From e5e1c8abb965e4100e28402194717f60a3c920ee Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Sat, 5 Sep 2026 02:59:59 +0800
Subject: [PATCH 01/31] feat(init): add guided and reviewable project setup

---
 Cargo.lock                               |  46 +-
 Cargo.toml                               |   2 +
 crates/tysel-cli/Cargo.toml              |   2 +
 crates/tysel-cli/src/check.rs            |  52 ++-
 crates/tysel-cli/src/init.rs             | 572 +++++++++++++++++++++--
 crates/tysel-cli/src/init/plan.rs        | 147 +++++-
 crates/tysel-cli/src/init/project.rs     | 129 +++++
 crates/tysel-cli/src/init/prompt.rs      | 325 ++++++++++++-
 crates/tysel-cli/src/init/templates.rs   |  45 +-
 crates/tysel-cli/src/init/transaction.rs |  56 ++-
 crates/tysel-cli/src/main.rs             |  52 ++-
 crates/tysel-cli/tests/dev_check.rs      | 179 +++++++
 12 files changed, 1520 insertions(+), 87 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index de6b945..a316255 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -434,6 +434,18 @@ dependencies = [
  "zmij",
 ]
 
+[[package]]
+name = "console"
+version = "0.16.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fe5f465a4f6fee88fad41b85d990f84c835335e85b5d9e6e63e0d06d28cba7c"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "unicode-width",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "const-oid"
 version = "0.10.2"
@@ -703,6 +715,16 @@ version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"
 
+[[package]]
+name = "dialoguer"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25f104b501bf2364e78d0d3974cbc774f738f5865306ed128e1e0d7499c0ad96"
+dependencies = [
+ "console",
+ "shell-words",
+]
+
 [[package]]
 name = "digest"
 version = "0.10.7"
@@ -783,6 +805,12 @@ version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
 
+[[package]]
+name = "encode_unicode"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
+
 [[package]]
 name = "encoding_rs"
 version = "0.8.35"
@@ -805,7 +833,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -2931,7 +2959,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.12.1",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3028,7 +3056,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b55fb86dfd3a2f5f76ea78310a88f96c4ea21a3031f8d212443d56123fd0521"
 dependencies = [
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3139,6 +3167,12 @@ dependencies = [
  "digest 0.11.3",
 ]
 
+[[package]]
+name = "shell-words"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
+
 [[package]]
 name = "shlex"
 version = "2.0.1"
@@ -3331,7 +3365,7 @@ dependencies = [
  "getrandom 0.4.3",
  "once_cell",
  "rustix 1.1.4",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3751,6 +3785,8 @@ version = "0.2.0"
 dependencies = [
  "anyhow",
  "clap",
+ "dialoguer",
+ "json-strip-comments",
  "libc",
  "notify",
  "reqwest",
@@ -4637,7 +4673,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index c65b460..6101d2d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -46,6 +46,8 @@ thiserror = "2"
 serde = { version = "1", features = ["derive"] }
 toml = "0.8"
 clap = { version = "4", features = ["derive"] }
+dialoguer = { version = "0.12", default-features = false }
+json-strip-comments = "3.1.2"
 tracing = "0.1"
 tokio = { version = "1", features = ["rt-multi-thread", "sync", "time", "macros", "net", "io-util", "process", "signal"] }
 # Candidate QuickJS-NG 0.16.2 adapter. Keep the immutable revision until the
diff --git a/crates/tysel-cli/Cargo.toml b/crates/tysel-cli/Cargo.toml
index 3b22c20..ffcf009 100644
--- a/crates/tysel-cli/Cargo.toml
+++ b/crates/tysel-cli/Cargo.toml
@@ -18,6 +18,8 @@ path = "src/main.rs"
 [dependencies]
 anyhow.workspace = true
 clap.workspace = true
+dialoguer.workspace = true
+json-strip-comments.workspace = true
 tokio.workspace = true
 tysel-distribution.workspace = true
 tysel-manifest.workspace = true
diff --git a/crates/tysel-cli/src/check.rs b/crates/tysel-cli/src/check.rs
index 0245df7..5864338 100644
--- a/crates/tysel-cli/src/check.rs
+++ b/crates/tysel-cli/src/check.rs
@@ -5,6 +5,14 @@ use anyhow::{Context, Result, anyhow};
 use tysel_manifest::Manifest;
 
 pub fn run(manifest_path: &Path) -> Result<()> {
+    run_with_options(manifest_path, false)
+}
+
+pub(crate) fn run_requiring_types(manifest_path: &Path) -> Result<()> {
+    run_with_options(manifest_path, true)
+}
+
+fn run_with_options(manifest_path: &Path, require_types: bool) -> Result<()> {
     let manifest = Manifest::from_path(manifest_path)
         .with_context(|| format!("failed to read {}", manifest_path.display()))?;
     let root = manifest_path.parent().unwrap_or(Path::new("."));
@@ -33,9 +41,15 @@ pub fn run(manifest_path: &Path) -> Result<()> {
         Typecheck::Skipped(reason) => println!("  types     skipped ({reason})"),
         Typecheck::Failed(_) => println!("  types     fail"),
     }
-    if let Typecheck::Failed(output) = types {
-        eprint!("{output}");
-        return Err(anyhow!("TypeScript check failed"));
+    match types {
+        Typecheck::Failed(output) => {
+            eprint!("{output}");
+            return Err(anyhow!("TypeScript check failed"));
+        }
+        Typecheck::Skipped(reason) if require_types => {
+            return Err(anyhow!("TypeScript check was skipped: {reason}"));
+        }
+        Typecheck::Ok | Typecheck::Skipped(_) => {}
     }
     if !is_component {
         let specifiers = crate::node_scan::scan_file(&entry)?;
@@ -99,3 +113,35 @@ fn find_tsc(start: &Path) -> Option<PathBuf> {
     }
     None
 }
+
+#[cfg(test)]
+mod tests {
+    use std::fs;
+
+    use super::*;
+
+    #[test]
+    fn strict_check_rejects_a_skipped_typecheck() {
+        let root = std::env::temp_dir().join(format!(
+            "tysel-strict-check-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
+        ));
+        fs::create_dir_all(root.join("src")).unwrap();
+        fs::write(
+            root.join("tysel.toml"),
+            "[app]\nname = \"strict-check\"\nentry = \"src/index.ts\"\n",
+        )
+        .unwrap();
+        fs::write(
+            root.join("src/index.ts"),
+            "export default { fetch() { return new Response('ok'); } };\n",
+        )
+        .unwrap();
+        fs::write(root.join("tsconfig.json"), "{}\n").unwrap();
+
+        let error = run_requiring_types(&root.join("tysel.toml")).unwrap_err();
+        assert!(error.to_string().contains("TypeScript check was skipped"));
+        fs::remove_dir_all(root).unwrap();
+    }
+}
diff --git a/crates/tysel-cli/src/init.rs b/crates/tysel-cli/src/init.rs
index 3a31ec4..19af678 100644
--- a/crates/tysel-cli/src/init.rs
+++ b/crates/tysel-cli/src/init.rs
@@ -1,5 +1,6 @@
 use std::io::IsTerminal;
 use std::path::{Path, PathBuf};
+use std::process::Command;
 
 use anyhow::{Context, Result};
 use tysel_manifest::ManifestFormat;
@@ -10,7 +11,7 @@ mod prompt;
 mod templates;
 mod transaction;
 
-use prompt::{configure, prompt_yes_no};
+use prompt::{configure, configure_tty, confirm_tty};
 use transaction::ProjectTransaction;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -29,15 +30,86 @@ pub enum Template {
     Minimal,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PackageManager {
+    Npm,
+    Pnpm,
+    Yarn,
+    Bun,
+}
+
+impl PackageManager {
+    fn detect(root: &Path) -> Self {
+        let mut cursor = if root.is_dir() { Some(root) } else { root.parent() };
+        while let Some(directory) = cursor {
+            for (lockfile, manager) in [
+                ("pnpm-lock.yaml", Self::Pnpm),
+                ("bun.lock", Self::Bun),
+                ("bun.lockb", Self::Bun),
+                ("yarn.lock", Self::Yarn),
+                ("package-lock.json", Self::Npm),
+            ] {
+                if directory.join(lockfile).is_file() {
+                    return manager;
+                }
+            }
+            cursor = directory.parent();
+        }
+        Self::Npm
+    }
+
+    fn command(self) -> &'static str {
+        match self {
+            Self::Npm => "npm",
+            Self::Pnpm => "pnpm",
+            Self::Yarn => "yarn",
+            Self::Bun => "bun",
+        }
+    }
+
+    fn is_available(self) -> bool {
+        let Some(path) = std::env::var_os("PATH") else {
+            return false;
+        };
+        std::env::split_paths(&path)
+            .any(|directory| command_is_executable(&directory, self.command()))
+    }
+}
+
+#[cfg(unix)]
+fn command_is_executable(directory: &Path, command: &str) -> bool {
+    use std::os::unix::fs::PermissionsExt;
+
+    std::fs::metadata(directory.join(command))
+        .is_ok_and(|metadata| metadata.is_file() && metadata.permissions().mode() & 0o111 != 0)
+}
+
+#[cfg(windows)]
+fn command_is_executable(directory: &Path, command: &str) -> bool {
+    ["exe", "cmd", "bat", "com"]
+        .iter()
+        .any(|extension| directory.join(command).with_extension(extension).is_file())
+}
+
+#[cfg(not(any(unix, windows)))]
+fn command_is_executable(directory: &Path, command: &str) -> bool {
+    directory.join(command).is_file()
+}
+
 pub struct Request {
-    pub root: PathBuf,
+    pub root: Option<PathBuf>,
     pub template: Option<Template>,
     pub manifest_format: Option<ManifestFormat>,
     pub entry: Option<PathBuf>,
     pub package_json: Option<PackageJsonMode>,
     pub add_scripts: bool,
+    pub package_manager: Option<PackageManager>,
+    pub install: Option<bool>,
+    pub verify: Option<bool>,
     pub include_tests: Option<bool>,
     pub dry_run: bool,
+    pub json: bool,
+    pub diff: bool,
     pub yes: bool,
     pub no_interactive: bool,
 }
@@ -49,8 +121,13 @@ struct Options {
     entry: Option<PathBuf>,
     package_json: PackageJsonMode,
     add_scripts: bool,
+    package_manager: PackageManager,
+    install: bool,
+    verify: bool,
     include_tests: bool,
     dry_run: bool,
+    json: bool,
+    diff: bool,
 }
 
 pub fn run(request: Request) -> Result<()> {
@@ -60,9 +137,13 @@ pub fn run(request: Request) -> Result<()> {
         && std::io::stdin().is_terminal()
         && std::io::stdout().is_terminal();
     let (options, confirm) = if interactive {
-        let stdin = std::io::stdin();
-        let stdout = std::io::stdout();
-        configure(request, &mut stdin.lock(), &mut stdout.lock())?
+        if std::env::var("TERM").is_ok_and(|term| term == "dumb") {
+            let stdin = std::io::stdin();
+            let stdout = std::io::stdout();
+            configure(request, &mut stdin.lock(), &mut stdout.lock())?
+        } else {
+            configure_tty(request)?
+        }
     } else {
         (options_from_request(request), false)
     };
@@ -70,34 +151,35 @@ pub fn run(request: Request) -> Result<()> {
 }
 
 fn options_from_request(request: Request) -> Options {
+    let root = request.root.unwrap_or_else(|| PathBuf::from("."));
     Options {
-        root: request.root,
+        package_manager: request.package_manager.unwrap_or_else(|| PackageManager::detect(&root)),
+        root,
         template: request.template.unwrap_or(Template::Http),
         manifest_format: request.manifest_format.unwrap_or(ManifestFormat::Toml),
         entry: request.entry,
         package_json: request.package_json.unwrap_or(PackageJsonMode::Auto),
         add_scripts: request.add_scripts,
+        install: request.install.unwrap_or(false),
+        verify: request.verify.unwrap_or(false),
         include_tests: request.include_tests.unwrap_or(true),
         dry_run: request.dry_run,
+        json: request.json,
+        diff: request.diff,
     }
 }
 
 fn run_options(options: Options, confirm: bool) -> Result<()> {
     let plan = plan::build(options)?;
-    if plan.dry_run || confirm {
-        print_plan(
-            &plan.root,
-            &plan.files,
-            plan.package_exists,
-            plan.package_update.is_some(),
-            plan.entry_existed,
-            &plan.entry,
-        );
+    if plan.dry_run && plan.json {
+        print_plan_json(&plan)?;
+    } else if plan.dry_run || confirm {
+        print_plan(&plan);
     }
     if plan.dry_run {
         return Ok(());
     }
-    if confirm && !confirm_plan()? {
+    if confirm && !confirm_tty("Create this project?", true)? {
         println!("cancelled; no files were changed");
         return Ok(());
     }
@@ -119,44 +201,230 @@ fn run_options(options: Options, confirm: bool) -> Result<()> {
             .replace(&path, &original, contents.as_bytes())
             .with_context(|| format!("update {}", path.display()))?;
     }
+    if let Some((path, original, contents)) = plan.gitignore_update {
+        transaction
+            .replace(&path, &original, contents.as_bytes())
+            .with_context(|| format!("update {}", path.display()))?;
+    }
     transaction.commit();
 
     println!("created {} in {}", plan.name, plan.root.display());
+    if plan.install {
+        install_dependencies(&plan.root, plan.package_manager)?;
+    }
+    if plan.verify {
+        println!("validating generated project...");
+        let manifest = plan.root.join(plan.manifest_name);
+        let result = if plan.create_package {
+            crate::check::run_requiring_types(&manifest)
+        } else {
+            crate::check::run(&manifest)
+        };
+        result.with_context(
+            || "project files were created, but generated project validation failed",
+        )?;
+    }
+    let root = shell_arg(&plan.root);
+    println!("next:");
+    println!("  cd {root}");
+    if plan.create_package && !plan.install {
+        println!("  {} install", plan.package_manager.command());
+    }
+    if !plan.verify {
+        println!("  tysel check");
+    }
     if plan.include_tests {
-        println!("next: cd {} && tysel check && tysel test", plan.root.display());
-    } else {
-        println!("next: cd {} && tysel check", plan.root.display());
+        println!("  tysel test");
     }
     Ok(())
 }
 
-fn print_plan(
-    root: &Path,
-    files: &[(PathBuf, String)],
-    package_exists: bool,
-    package_update: bool,
-    entry_existed: bool,
-    entry: &Path,
-) {
-    println!("\nTysel init plan for {}", root.display());
-    for (relative, _) in files {
+fn print_plan(plan: &plan::InitPlan) {
+    println!("\nTysel init plan");
+    println!("  Project   {}", plan.root.display());
+    println!("  Mode      {}", if plan.adopting { "Adopt" } else { "Create" });
+    println!("  Template  {}", plan.template.label());
+    println!(
+        "  Manifest  {}",
+        match plan.manifest_format {
+            ManifestFormat::Toml => "TOML",
+            ManifestFormat::Json => "JSON",
+        }
+    );
+    println!(
+        "  Entry     {} ({})",
+        plan.entry.display(),
+        if plan.entry_existed { "reuse" } else { "create" }
+    );
+    println!("  Package   {}", plan.package_action);
+    if plan.create_package {
+        println!(
+            "  Install   {} install ({})",
+            plan.package_manager.command(),
+            if plan.install { "run" } else { "skip" }
+        );
+    }
+    println!("  Verify    {}", if plan.verify { "run" } else { "skip" });
+    println!("  Tests     {}", if plan.include_tests { "create" } else { "skip" });
+    println!("\nChanges");
+    for (relative, _) in &plan.files {
         println!("  create {}", relative.display());
     }
-    if package_exists && !package_update {
+    if plan.package_exists && plan.package_update.is_none() {
         println!("  preserve package.json");
     }
-    if package_update {
-        println!("  update package.json scripts");
+    for (path, changes) in &plan.update_summaries {
+        let path = path.strip_prefix(&plan.root).unwrap_or(path);
+        println!("  update {}", path.display());
+        for change in changes {
+            println!("    {change}");
+        }
+    }
+    if plan.entry_existed {
+        println!("  reuse {}", plan.entry.display());
+    }
+    if plan.diff {
+        println!("\nDiff");
+        for (relative, contents) in &plan.files {
+            print_full_diff(relative, None, contents);
+        }
+        if let Some((path, original, contents)) = &plan.package_update {
+            let relative = path.strip_prefix(&plan.root).unwrap_or(path);
+            print_full_diff(relative, Some(&String::from_utf8_lossy(original)), contents);
+        }
+        if let Some((path, original, contents)) = &plan.gitignore_update {
+            let relative = path.strip_prefix(&plan.root).unwrap_or(path);
+            print_full_diff(relative, Some(&String::from_utf8_lossy(original)), contents);
+        }
+    }
+}
+
+fn print_plan_json(plan: &plan::InitPlan) -> Result<()> {
+    let mut changes = plan
+        .files
+        .iter()
+        .map(|(path, contents)| {
+            serde_json::json!({
+                "operation": "create",
+                "path": path.display().to_string(),
+                "before": null,
+                "after": contents,
+            })
+        })
+        .collect::<Vec<_>>();
+    for (path, original, contents, summary) in [
+        plan.package_update.as_ref().map(|(path, original, contents)| {
+            (path, original, contents, plan.update_summary(path))
+        }),
+        plan.gitignore_update.as_ref().map(|(path, original, contents)| {
+            (path, original, contents, plan.update_summary(path))
+        }),
+    ]
+    .into_iter()
+    .flatten()
+    {
+        let path = path.strip_prefix(&plan.root).unwrap_or(path);
+        changes.push(serde_json::json!({
+            "operation": "update",
+            "path": path.display().to_string(),
+            "before": String::from_utf8_lossy(original),
+            "after": contents,
+            "summary": summary,
+        }));
+    }
+    if plan.package_exists && plan.package_update.is_none() {
+        changes.push(serde_json::json!({
+            "operation": "preserve",
+            "path": "package.json",
+        }));
+    }
+    if plan.entry_existed {
+        changes.push(serde_json::json!({
+            "operation": "reuse",
+            "path": plan.entry.display().to_string(),
+        }));
+    }
+    let output = serde_json::json!({
+        "schemaVersion": 1,
+        "project": plan.root.display().to_string(),
+        "mode": if plan.adopting { "adopt" } else { "create" },
+        "template": plan.template.key(),
+        "manifestFormat": match plan.manifest_format {
+            ManifestFormat::Toml => "toml",
+            ManifestFormat::Json => "json",
+        },
+        "entry": {
+            "path": plan.entry.display().to_string(),
+            "operation": if plan.entry_existed { "reuse" } else { "create" },
+        },
+        "package": {
+            "action": plan.package_action,
+            "manager": plan.package_manager.command(),
+            "install": plan.install,
+        },
+        "verify": plan.verify,
+        "tests": plan.include_tests,
+        "changes": changes,
+    });
+    println!("{}", serde_json::to_string_pretty(&output)?);
+    Ok(())
+}
+
+fn print_full_diff(path: &Path, before: Option<&str>, after: &str) {
+    let before = before.unwrap_or("");
+    let before_lines = diff_lines(before);
+    let after_lines = diff_lines(after);
+    if before_lines.is_empty() {
+        println!("--- /dev/null");
+    } else {
+        println!("--- a/{}", path.display());
+    }
+    println!("+++ b/{}", path.display());
+    println!(
+        "@@ -{},{} +{},{} @@",
+        if before_lines.is_empty() { 0 } else { 1 },
+        before_lines.len(),
+        if after_lines.is_empty() { 0 } else { 1 },
+        after_lines.len()
+    );
+    for line in before_lines {
+        println!("-{line}");
+    }
+    for line in after_lines {
+        println!("+{line}");
     }
-    if entry_existed {
-        println!("  reuse {}", entry.display());
+}
+
+fn diff_lines(contents: &str) -> Vec<&str> {
+    contents.split_terminator('\n').collect()
+}
+
+fn install_dependencies(root: &Path, manager: PackageManager) -> Result<()> {
+    println!("installing dependencies with {}...", manager.command());
+    let status = Command::new(manager.command())
+        .arg("install")
+        .current_dir(root)
+        .status()
+        .with_context(|| {
+            format!("project files were created, but {} could not be started", manager.command())
+        })?;
+    if !status.success() {
+        return Err(anyhow::anyhow!(
+            "project files were created, but {} install exited with {status}",
+            manager.command()
+        ));
     }
+    println!("installed dependencies");
+    Ok(())
 }
 
-fn confirm_plan() -> Result<bool> {
-    let stdin = std::io::stdin();
-    let stdout = std::io::stdout();
-    prompt_yes_no(&mut stdin.lock(), &mut stdout.lock(), "Create this project?", true)
+fn shell_arg(path: &Path) -> String {
+    let value = path.display().to_string();
+    if value.chars().all(|ch| ch.is_ascii_alphanumeric() || matches!(ch, '/' | '.' | '_' | '-')) {
+        value
+    } else {
+        format!("'{}'", value.replace('\'', "'\\''"))
+    }
 }
 
 #[cfg(test)]
@@ -166,7 +434,11 @@ mod tests {
 
     use tysel_manifest::Manifest;
 
-    use super::project::{is_application_name, normalize_entry};
+    use super::project::{
+        ensure_generated_entry_extension, ensure_tsconfig_files, gitignore_with_entries,
+        is_application_name, normalize_entry,
+    };
+    use super::prompt::prompt_yes_no;
     use super::templates::{
         generated_package_json, generated_tsconfig, manifest, tysel_env_import,
     };
@@ -174,14 +446,19 @@ mod tests {
 
     fn request(root: PathBuf) -> Request {
         Request {
-            root,
+            root: Some(root),
             template: None,
             manifest_format: None,
             entry: None,
             package_json: None,
             add_scripts: false,
+            package_manager: None,
+            install: None,
+            verify: None,
             include_tests: None,
             dry_run: false,
+            json: false,
+            diff: false,
             yes: false,
             no_interactive: false,
         }
@@ -220,6 +497,26 @@ mod tests {
         fs::remove_dir_all(root).unwrap();
     }
 
+    #[test]
+    fn transaction_rolls_back_an_atomic_replacement() {
+        let root = std::env::temp_dir().join(format!(
+            "tysel-init-replace-rollback-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
+        ));
+        fs::create_dir_all(&root).unwrap();
+        let path = root.join("package.json");
+        fs::write(&path, b"original").unwrap();
+        {
+            let mut transaction = ProjectTransaction::default();
+            transaction.replace(&path, b"original", b"replacement").unwrap();
+            assert_eq!(fs::read(&path).unwrap(), b"replacement");
+        }
+        assert_eq!(fs::read(&path).unwrap(), b"original");
+        assert_eq!(fs::read_dir(&root).unwrap().count(), 1);
+        fs::remove_dir_all(root).unwrap();
+    }
+
     #[test]
     fn generated_project_pins_matching_public_type_packages() {
         let package: serde_json::Value =
@@ -234,7 +531,13 @@ mod tests {
                 .unwrap();
         assert_eq!(mcp_package["devDependencies"]["@tysel/sdk"], expected);
         let tsconfig: serde_json::Value = serde_json::from_str(
-            &generated_tsconfig(Path::new("src/index.ts"), false, true).unwrap(),
+            &generated_tsconfig(
+                Path::new("src/index.ts"),
+                true,
+                Some(Path::new("tests/app.test.ts")),
+                true,
+            )
+            .unwrap(),
         )
         .unwrap();
         assert_eq!(
@@ -292,22 +595,133 @@ mod tests {
     #[test]
     fn interactive_quick_start_uses_reproducible_defaults() {
         let root = PathBuf::from("quick-start");
-        let mut input = Cursor::new(b"\n");
+        let mut input = Cursor::new(b"\n\n");
         let mut output = Vec::new();
         let (options, confirm) = configure(request(root.clone()), &mut input, &mut output).unwrap();
         assert_eq!(options.root, root);
         assert_eq!(options.template, Template::Http);
         assert_eq!(options.manifest_format, ManifestFormat::Toml);
         assert_eq!(options.package_json, PackageJsonMode::Auto);
+        assert_eq!(options.package_manager, PackageManager::detect(&root));
+        assert!(!options.install);
         assert!(options.entry.is_none());
         assert!(confirm);
         assert!(String::from_utf8(output).unwrap().contains("Quick start"));
     }
 
+    #[test]
+    fn interactive_init_without_a_path_prompts_for_a_project_directory() {
+        let mut input = Cursor::new(b"\nnew-service\n\n\n");
+        let mut output = Vec::new();
+        let (options, confirm) =
+            configure(request_without_root(), &mut input, &mut output).unwrap();
+        assert_eq!(options.root, Path::new("new-service"));
+        assert!(confirm);
+        assert!(String::from_utf8(output).unwrap().contains("Project directory"));
+    }
+
+    #[test]
+    fn interactive_init_can_adopt_the_current_directory() {
+        let mut input = Cursor::new(b"2\n\n\n");
+        let mut output = Vec::new();
+        let (options, _) = configure(request_without_root(), &mut input, &mut output).unwrap();
+        assert_eq!(options.root, Path::new("."));
+        assert!(String::from_utf8(output).unwrap().contains("Add Tysel"));
+    }
+
+    #[test]
+    fn package_manager_detection_uses_the_nearest_lockfile() {
+        let root = std::env::temp_dir().join(format!(
+            "tysel-init-package-manager-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
+        ));
+        fs::create_dir_all(root.join("apps/service")).unwrap();
+        fs::write(root.join("pnpm-lock.yaml"), "lockfileVersion: '9.0'\n").unwrap();
+        assert_eq!(PackageManager::detect(&root.join("apps/service")), PackageManager::Pnpm);
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn existing_tysel_tsconfig_must_cover_required_files() {
+        let root = std::env::temp_dir().join(format!(
+            "tysel-init-tsconfig-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
+        ));
+        fs::create_dir_all(&root).unwrap();
+        let config = root.join("tsconfig.tysel.json");
+        fs::write(&config, "{\n  // Tysel files\n  \"files\": [\"./src/tysel.ts\",],\n}\n")
+            .unwrap();
+        assert!(ensure_tsconfig_files(&config, &[Path::new("src/tysel.ts")]).is_ok());
+        let error = ensure_tsconfig_files(
+            &config,
+            &[Path::new("src/tysel.ts"), Path::new("tests/tysel.test.ts")],
+        )
+        .unwrap_err();
+        assert!(error.to_string().contains("tests/tysel.test.ts"));
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn new_project_destination_validation_rejects_nonempty_directories() {
+        let root = std::env::temp_dir().join(format!(
+            "tysel-init-destination-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
+        ));
+        fs::create_dir_all(&root).unwrap();
+        fs::write(root.join("existing.txt"), "keep").unwrap();
+        let error = super::project::validate_new_project_root(root.to_str().unwrap()).unwrap_err();
+        assert!(error.to_string().contains("not empty"));
+        assert_eq!(
+            super::project::validate_new_project_root("  trimmed-project  ").unwrap(),
+            Path::new("trimmed-project")
+        );
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn line_prompt_retries_an_invalid_entry_in_place() {
+        let root = PathBuf::from("entry-validation");
+        let mut input = Cursor::new(b"src/app.js\nsrc/app.ts\n");
+        let mut output = Vec::new();
+        let entry = super::prompt::prompt_text_validated(
+            &mut input,
+            &mut output,
+            "Application entry",
+            "src/index.ts",
+            |value| super::project::validate_entry_input(&root, value),
+        )
+        .unwrap();
+        assert_eq!(entry, Path::new("src/app.ts"));
+        assert!(String::from_utf8(output).unwrap().contains("must use a TypeScript extension"));
+    }
+
+    #[test]
+    fn gitignore_merge_adds_only_missing_tysel_entries() {
+        let root = std::env::temp_dir().join(format!(
+            "tysel-init-gitignore-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
+        ));
+        fs::create_dir_all(&root).unwrap();
+        let path = root.join(".gitignore");
+        fs::write(&path, "node_modules/\ncustom/\n").unwrap();
+        let (_, merged) = gitignore_with_entries(&path, templates::GITIGNORE).unwrap().unwrap();
+        assert_eq!(merged.matches("node_modules/").count(), 1);
+        assert!(merged.contains("custom/\n\n# Tysel\n"));
+        assert!(merged.contains("data/\n"));
+        assert!(merged.contains(".tysel/\n"));
+        fs::write(&path, &merged).unwrap();
+        assert!(gitignore_with_entries(&path, templates::GITIGNORE).unwrap().is_none());
+        fs::remove_dir_all(root).unwrap();
+    }
+
     #[test]
     fn interactive_customize_maps_every_answer_to_options() {
         let root = PathBuf::from("custom-start");
-        let mut input = Cursor::new(b"2\n3\n2\n2\nsrc/custom.ts\nno\n");
+        let mut input = Cursor::new(b"2\n3\n2\n2\nsrc/custom.ts\nno\nno\n");
         let mut output = Vec::new();
         let (options, _) = configure(request(root), &mut input, &mut output).unwrap();
         assert_eq!(options.template, Template::Mcp);
@@ -315,13 +729,14 @@ mod tests {
         assert_eq!(options.package_json, PackageJsonMode::None);
         assert_eq!(options.entry, Some(PathBuf::from("src/custom.ts")));
         assert!(!options.include_tests);
+        assert!(!options.verify);
     }
 
     #[test]
     fn explicit_choices_seed_the_interactive_flow_instead_of_disabling_it() {
         let mut request = request(PathBuf::from("partial-start"));
         request.template = Some(Template::Mcp);
-        let mut input = Cursor::new(b"2\n2\nsrc/tool.ts\nyes\n");
+        let mut input = Cursor::new(b"2\n2\nsrc/tool.ts\nyes\nno\n");
         let mut output = Vec::new();
         let (options, confirm) = configure(request, &mut input, &mut output).unwrap();
         assert_eq!(options.template, Template::Mcp);
@@ -380,15 +795,50 @@ mod tests {
     }
 
     #[test]
-    fn existing_projects_get_an_isolated_typecheck_config() {
+    fn dependency_free_projects_get_an_isolated_typecheck_config() {
         let config: serde_json::Value = serde_json::from_str(
-            &generated_tsconfig(Path::new("src/tysel.ts"), true, true).unwrap(),
+            &generated_tsconfig(
+                Path::new("src/tysel.ts"),
+                false,
+                Some(Path::new("tests/tysel.test.ts")),
+                false,
+            )
+            .unwrap(),
         )
         .unwrap();
         assert_eq!(config["files"], serde_json::json!(["src/tysel.ts"]));
         assert_eq!(config["compilerOptions"]["types"], serde_json::json!([]));
     }
 
+    #[test]
+    fn an_existing_javascript_entry_gets_a_compatible_typecheck_config() {
+        let config: serde_json::Value = serde_json::from_str(
+            &generated_tsconfig(Path::new("src/server.js"), false, None, false).unwrap(),
+        )
+        .unwrap();
+        assert_eq!(config["compilerOptions"]["allowJs"], true);
+        assert_eq!(config["compilerOptions"]["checkJs"], false);
+    }
+
+    #[test]
+    fn adopted_typed_projects_typecheck_the_generated_test() {
+        let config: serde_json::Value = serde_json::from_str(
+            &generated_tsconfig(
+                Path::new("src/tysel.ts"),
+                true,
+                Some(Path::new("tests/tysel.test.ts")),
+                true,
+            )
+            .unwrap(),
+        )
+        .unwrap();
+        assert_eq!(config["files"], serde_json::json!(["src/tysel.ts", "tests/tysel.test.ts"]));
+        assert_eq!(
+            config["compilerOptions"]["types"],
+            serde_json::json!(["@tysel/types", "@tysel/test"])
+        );
+    }
+
     #[test]
     fn no_tests_removes_test_dependencies_and_task_steps() {
         let package: serde_json::Value =
@@ -411,6 +861,9 @@ mod tests {
         );
         assert!(normalize_entry(Path::new("../outside.ts")).is_err());
         assert!(normalize_entry(Path::new("src/bad\nname.ts")).is_err());
+        assert!(ensure_generated_entry_extension(Path::new("src/index.ts")).is_ok());
+        assert!(ensure_generated_entry_extension(Path::new("src/index.mts")).is_ok());
+        assert!(ensure_generated_entry_extension(Path::new("src/index.js")).is_err());
 
         let rendered = manifest(
             "app",
@@ -427,4 +880,31 @@ mod tests {
                 .unwrap_err();
         assert!(wasm.to_string().contains("Wasm Components require a manual manifest"));
     }
+
+    #[test]
+    fn next_step_paths_are_shell_safe() {
+        assert_eq!(shell_arg(Path::new("my-app")), "my-app");
+        assert_eq!(shell_arg(Path::new("parent dir/my-app")), "'parent dir/my-app'");
+        assert_eq!(shell_arg(Path::new("it's/app")), "'it'\\''s/app'");
+    }
+
+    fn request_without_root() -> Request {
+        Request {
+            root: None,
+            template: None,
+            manifest_format: None,
+            entry: None,
+            package_json: None,
+            add_scripts: false,
+            package_manager: None,
+            install: None,
+            verify: None,
+            include_tests: None,
+            dry_run: false,
+            json: false,
+            diff: false,
+            yes: false,
+            no_interactive: false,
+        }
+    }
 }
diff --git a/crates/tysel-cli/src/init/plan.rs b/crates/tysel-cli/src/init/plan.rs
index 0bea83c..2162e4f 100644
--- a/crates/tysel-cli/src/init/plan.rs
+++ b/crates/tysel-cli/src/init/plan.rs
@@ -1,17 +1,18 @@
 use std::fs;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use anyhow::{Result, anyhow};
 use tysel_manifest::{Manifest, ManifestFormat};
 
 use super::project::{
-    application_name, ensure_safe_destination, is_application_name, normalize_entry,
+    application_name, ensure_generated_entry_extension, ensure_safe_destination,
+    ensure_tsconfig_files, gitignore_with_entries, is_application_name, normalize_entry,
     package_declares_dependency, package_with_tysel_scripts,
 };
 use super::templates::{
     GITIGNORE, generated_package_json, generated_tsconfig, manifest, tysel_env_import,
 };
-use super::{Options, PackageJsonMode};
+use super::{Options, PackageJsonMode, PackageManager, Template};
 
 pub(super) struct InitPlan {
     pub(super) root: PathBuf,
@@ -19,10 +20,32 @@ pub(super) struct InitPlan {
     pub(super) files: Vec<(PathBuf, String)>,
     pub(super) package_exists: bool,
     pub(super) package_update: Option<(PathBuf, Vec<u8>, String)>,
+    pub(super) gitignore_update: Option<(PathBuf, Vec<u8>, String)>,
     pub(super) entry_existed: bool,
     pub(super) entry: PathBuf,
     pub(super) include_tests: bool,
     pub(super) dry_run: bool,
+    pub(super) json: bool,
+    pub(super) diff: bool,
+    pub(super) create_package: bool,
+    pub(super) adopting: bool,
+    pub(super) template: Template,
+    pub(super) manifest_format: ManifestFormat,
+    pub(super) package_action: &'static str,
+    pub(super) package_manager: PackageManager,
+    pub(super) install: bool,
+    pub(super) verify: bool,
+    pub(super) manifest_name: &'static str,
+    pub(super) update_summaries: Vec<(PathBuf, Vec<String>)>,
+}
+
+impl InitPlan {
+    pub(super) fn update_summary(&self, path: &Path) -> &[String] {
+        self.update_summaries
+            .iter()
+            .find(|(candidate, _)| candidate == path)
+            .map_or(&[], |(_, summary)| summary)
+    }
 }
 
 pub(super) fn build(options: Options) -> Result<InitPlan> {
@@ -58,10 +81,28 @@ pub(super) fn build(options: Options) -> Result<InitPlan> {
         }
         PackageJsonMode::Reuse | PackageJsonMode::None => false,
     };
+    if options.install && !create_package {
+        return Err(anyhow!(
+            "--install requires init to create package.json; use --package-json auto or create"
+        ));
+    }
+    if options.install && !options.dry_run && !options.package_manager.is_available() {
+        return Err(anyhow!(
+            "{} was not found on PATH; install it or choose another --package-manager",
+            options.package_manager.command()
+        ));
+    }
+    if options.verify && create_package && !options.install {
+        return Err(anyhow!(
+            "--verify requires --install when init creates package.json so type checking is not skipped"
+        ));
+    }
     let has_public_types =
         create_package || package_declares_dependency(&package_path, "@tysel/types");
     let has_runtime_sdk =
         create_package || package_declares_dependency(&package_path, "@tysel/sdk");
+    let has_test_types =
+        create_package || package_declares_dependency(&package_path, "@tysel/test");
     let typed_entry =
         has_public_types && (!options.template.needs_runtime_sdk() || has_runtime_sdk);
     let package_update = if options.add_scripts && package_exists {
@@ -86,6 +127,9 @@ pub(super) fn build(options: Options) -> Result<InitPlan> {
     let entry = normalize_entry(&entry)?;
     let env_import = tysel_env_import(&entry);
     let entry_existed = root.join(&entry).is_file();
+    if !entry_existed {
+        ensure_generated_entry_extension(&entry)?;
+    }
     let manifest_name = match options.manifest_format {
         ManifestFormat::Toml => "tysel.toml",
         ManifestFormat::Json => "tysel.json",
@@ -113,18 +157,32 @@ pub(super) fn build(options: Options) -> Result<InitPlan> {
             generated_package_json(&name, options.include_tests, options.template)?,
         ));
     }
+    let test_path = if existing_js_project {
+        PathBuf::from("tests/tysel.test.ts")
+    } else {
+        PathBuf::from("tests/app.test.ts")
+    };
     let tsconfig_path = if existing_js_project {
         PathBuf::from("tsconfig.tysel.json")
     } else {
         PathBuf::from("tsconfig.json")
     };
-    if !root.join(&tsconfig_path).exists() {
+    let existing_tsconfig = root.join(&tsconfig_path);
+    if existing_tsconfig.is_file() && tsconfig_path.as_path() == Path::new("tsconfig.tysel.json") {
+        let mut required = vec![entry.as_path()];
+        if options.include_tests && has_test_types {
+            required.push(test_path.as_path());
+        }
+        ensure_tsconfig_files(&existing_tsconfig, &required)?;
+    }
+    if !existing_tsconfig.exists() {
         files.push((
             tsconfig_path,
             generated_tsconfig(
                 &entry,
-                existing_js_project || !create_package,
-                options.include_tests,
+                typed_entry,
+                options.include_tests.then_some(test_path.as_path()),
+                has_test_types,
             )?,
         ));
     }
@@ -136,18 +194,21 @@ pub(super) fn build(options: Options) -> Result<InitPlan> {
     {
         files.push((PathBuf::from("tysel-env.d.ts"), contents));
     }
-    let test_path = if existing_js_project {
-        PathBuf::from("tests/tysel.test.ts")
-    } else {
-        PathBuf::from("tests/app.test.ts")
-    };
     if options.include_tests && !root.join(&test_path).exists() {
         files.push((test_path, options.template.test_source(&entry)));
     }
     files.push((PathBuf::from(manifest_name), manifest_contents));
-    if !root.join(".gitignore").exists() {
+    let gitignore_path = root.join(".gitignore");
+    let gitignore_update = if gitignore_path.is_file() {
+        if fs::symlink_metadata(&gitignore_path)?.file_type().is_symlink() {
+            return Err(anyhow!("refusing to modify symlinked {}", gitignore_path.display()));
+        }
+        gitignore_with_entries(&gitignore_path, GITIGNORE)?
+            .map(|(original, contents)| (gitignore_path, original, contents))
+    } else {
         files.push((PathBuf::from(".gitignore"), GITIGNORE.to_owned()));
-    }
+        None
+    };
 
     for (relative, _) in &files {
         ensure_safe_destination(&root, &root.join(relative))?;
@@ -162,15 +223,75 @@ pub(super) fn build(options: Options) -> Result<InitPlan> {
         return Err(anyhow!("refusing to overwrite existing files: {}", paths.join(", ")));
     }
 
+    let package_action = if create_package {
+        "create package.json"
+    } else if package_update.is_some() {
+        "update package.json scripts"
+    } else if package_exists {
+        "preserve package.json"
+    } else {
+        "none"
+    };
+    let mut update_summaries = Vec::new();
+    if let Some((path, original, contents)) = &package_update {
+        update_summaries.push((path.clone(), summarize_package_update(original, contents)));
+    }
+    if let Some((path, original, contents)) = &gitignore_update {
+        update_summaries.push((path.clone(), summarize_gitignore_update(original, contents)));
+    }
     Ok(InitPlan {
         root,
         name,
         files,
         package_exists,
         package_update,
+        gitignore_update,
         entry_existed,
         entry,
         include_tests: options.include_tests,
         dry_run: options.dry_run,
+        json: options.json,
+        diff: options.diff,
+        create_package,
+        adopting: existing_js_project || entry_existed,
+        template: options.template,
+        manifest_format: options.manifest_format,
+        package_action,
+        package_manager: options.package_manager,
+        install: options.install,
+        verify: options.verify,
+        manifest_name,
+        update_summaries,
     })
 }
+
+fn summarize_package_update(original: &[u8], contents: &str) -> Vec<String> {
+    let Ok(before) = serde_json::from_slice::<serde_json::Value>(original) else {
+        return Vec::new();
+    };
+    let Ok(after) = serde_json::from_str::<serde_json::Value>(contents) else {
+        return Vec::new();
+    };
+    let Some(scripts) = after.get("scripts").and_then(serde_json::Value::as_object) else {
+        return Vec::new();
+    };
+    let mut changes = scripts
+        .iter()
+        .filter(|(name, value)| before["scripts"].get(*name) != Some(*value))
+        .map(|(name, value)| format!("+ scripts.{name} = {value}"))
+        .collect::<Vec<_>>();
+    changes.push("~ package.json is reserialized with normalized formatting".into());
+    changes
+}
+
+fn summarize_gitignore_update(original: &[u8], contents: &str) -> Vec<String> {
+    let before = String::from_utf8_lossy(original);
+    let before = before.lines().map(str::trim).collect::<Vec<_>>();
+    contents
+        .lines()
+        .map(str::trim)
+        .filter(|line| !line.is_empty() && !line.starts_with('#'))
+        .filter(|line| !before.contains(line))
+        .map(|line| format!("+ {line}"))
+        .collect()
+}
diff --git a/crates/tysel-cli/src/init/project.rs b/crates/tysel-cli/src/init/project.rs
index 118d7e9..b51679b 100644
--- a/crates/tysel-cli/src/init/project.rs
+++ b/crates/tysel-cli/src/init/project.rs
@@ -19,6 +19,51 @@ pub(super) fn application_name(root: &Path) -> Result<String> {
         .ok_or_else(|| anyhow!("cannot derive an application name from {}", root.display()))
 }
 
+pub(super) fn validate_new_project_root(input: &str) -> Result<PathBuf> {
+    let input = input.trim();
+    if input.is_empty() {
+        return Err(anyhow!("project directory cannot be empty"));
+    }
+    if input.chars().any(char::is_control) {
+        return Err(anyhow!("project directory cannot contain control characters"));
+    }
+    let root = PathBuf::from(input);
+    if root == Path::new(".") {
+        return Err(anyhow!("choose 'Add Tysel to the current directory' to use ."));
+    }
+    if root.exists() {
+        if !root.is_dir() {
+            return Err(anyhow!("project destination is not a directory"));
+        }
+        if fs::read_dir(&root).with_context(|| format!("read {}", root.display()))?.next().is_some()
+        {
+            return Err(anyhow!(
+                "project destination is not empty; choose the current-directory adoption flow or another path"
+            ));
+        }
+    }
+    let name = application_name(&root)?;
+    if !is_application_name(&name) {
+        return Err(anyhow!(
+            "project name must start with a letter or digit and use only letters, digits, '-', '_' or '.'"
+        ));
+    }
+    Ok(root)
+}
+
+pub(super) fn validate_entry_input(root: &Path, input: &str) -> Result<PathBuf> {
+    let entry = normalize_entry(Path::new(input.trim()))?;
+    let destination = root.join(&entry);
+    if destination.exists() && !destination.is_file() {
+        return Err(anyhow!("entry is not a file: {}", destination.display()));
+    }
+    if !destination.is_file() {
+        ensure_generated_entry_extension(&entry)?;
+    }
+    ensure_safe_destination(root, &destination)?;
+    Ok(entry)
+}
+
 pub(super) fn normalize_entry(entry: &Path) -> Result<PathBuf> {
     let raw = entry.to_str().ok_or_else(|| anyhow!("entry must be valid UTF-8"))?;
     if raw.chars().any(char::is_control) {
@@ -47,6 +92,51 @@ pub(super) fn normalize_entry(entry: &Path) -> Result<PathBuf> {
     Ok(normalized)
 }
 
+pub(super) fn ensure_generated_entry_extension(entry: &Path) -> Result<()> {
+    let extension = entry.extension().and_then(|value| value.to_str());
+    if matches!(extension, Some("ts" | "tsx" | "mts")) {
+        return Ok(());
+    }
+    Err(anyhow!(
+        "generated application entry must use a TypeScript extension (.ts, .tsx, or .mts): {}",
+        entry.display()
+    ))
+}
+
+pub(super) fn ensure_tsconfig_files(path: &Path, required: &[&Path]) -> Result<()> {
+    let bytes = fs::read(path).with_context(|| format!("read {}", path.display()))?;
+    let mut source =
+        String::from_utf8(bytes).with_context(|| format!("{} must be UTF-8", path.display()))?;
+    json_strip_comments::strip(&mut source)
+        .with_context(|| format!("invalid {}", path.display()))?;
+    let config: serde_json::Value =
+        serde_json::from_str(&source).with_context(|| format!("invalid {}", path.display()))?;
+    let Some(files) = config.get("files") else {
+        return Ok(());
+    };
+    let files =
+        files.as_array().ok_or_else(|| anyhow!("files in {} must be an array", path.display()))?;
+    let files = files
+        .iter()
+        .filter_map(serde_json::Value::as_str)
+        .map(normalize_config_path)
+        .collect::<Vec<_>>();
+    for required in required {
+        let required = normalize_config_path(&required.to_string_lossy());
+        if !files.iter().any(|candidate| candidate == &required) {
+            return Err(anyhow!(
+                "{} does not include {required}; add it to files or remove the config and rerun init",
+                path.display()
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn normalize_config_path(path: &str) -> String {
+    path.replace('\\', "/").trim_start_matches("./").to_owned()
+}
+
 pub(super) fn ensure_safe_destination(root: &Path, destination: &Path) -> Result<()> {
     if !root.exists() {
         return Ok(());
@@ -134,6 +224,45 @@ pub(super) fn package_with_tysel_scripts(
     Ok(Some((bytes, rendered)))
 }
 
+pub(super) fn gitignore_with_entries(
+    path: &Path,
+    desired: &str,
+) -> Result<Option<(Vec<u8>, String)>> {
+    let bytes = fs::read(path).with_context(|| format!("read {}", path.display()))?;
+    let original =
+        std::str::from_utf8(&bytes).with_context(|| format!("{} must be UTF-8", path.display()))?;
+    let normalized =
+        original.lines().map(|line| normalize_ignore_pattern(line.trim())).collect::<Vec<_>>();
+    let missing = desired
+        .lines()
+        .filter(|entry| {
+            let entry = normalize_ignore_pattern(entry);
+            !normalized.iter().any(|existing| existing == &entry)
+        })
+        .collect::<Vec<_>>();
+    if missing.is_empty() {
+        return Ok(None);
+    }
+
+    let mut contents = original.to_owned();
+    if !contents.is_empty() && !contents.ends_with('\n') {
+        contents.push('\n');
+    }
+    if !contents.is_empty() && !contents.ends_with("\n\n") {
+        contents.push('\n');
+    }
+    contents.push_str("# Tysel\n");
+    for entry in missing {
+        contents.push_str(entry);
+        contents.push('\n');
+    }
+    Ok(Some((bytes, contents)))
+}
+
+fn normalize_ignore_pattern(pattern: &str) -> &str {
+    pattern.trim_start_matches('/').trim_start_matches("./")
+}
+
 pub(super) fn is_application_name(name: &str) -> bool {
     let mut chars = name.chars();
     chars.next().is_some_and(|ch| ch.is_ascii_alphanumeric())
diff --git a/crates/tysel-cli/src/init/prompt.rs b/crates/tysel-cli/src/init/prompt.rs
index 906b838..0ec157a 100644
--- a/crates/tysel-cli/src/init/prompt.rs
+++ b/crates/tysel-cli/src/init/prompt.rs
@@ -2,21 +2,258 @@ use std::io::{BufRead, Write};
 use std::path::PathBuf;
 
 use anyhow::{Result, anyhow};
+use dialoguer::{Confirm, Input, Select, console::Term};
 use tysel_manifest::ManifestFormat;
 
-use super::{Options, PackageJsonMode, Request, Template, options_from_request};
+use super::project::{validate_entry_input, validate_new_project_root};
+use super::{Options, PackageJsonMode, PackageManager, Request, Template, options_from_request};
+
+pub(super) fn configure_tty(mut request: Request) -> Result<(Options, bool)> {
+    let term = Term::stdout();
+    term.write_line("Create a Tysel application")?;
+    term.write_line("")?;
+    if request.root.is_none() {
+        request.root = Some(
+            if select_tty(
+                &term,
+                "What would you like to do?",
+                &["Create a new project", "Add Tysel to the current directory"],
+                0,
+            )? == 0
+            {
+                validate_new_project_root(
+                    &Input::<String>::new()
+                        .with_prompt("Project directory")
+                        .default("my-tysel-app".into())
+                        .validate_with(|value: &String| {
+                            validate_new_project_root(value)
+                                .map(|_| ())
+                                .map_err(|error| error.to_string())
+                        })
+                        .interact_text_on(&term)?,
+                )?
+            } else {
+                PathBuf::from(".")
+            },
+        );
+    }
+
+    let customize = request.template.is_some()
+        || request.manifest_format.is_some()
+        || request.entry.is_some()
+        || request.package_json.is_some()
+        || request.add_scripts
+        || request.package_manager.is_some()
+        || request.install.is_some()
+        || request.verify.is_some()
+        || request.include_tests.is_some()
+        || select_tty(
+            &term,
+            "How would you like to start?",
+            &["Quick start (recommended)", "Customize"],
+            0,
+        )? == 1;
+    let template_explicit = request.template.is_some();
+    let format_explicit = request.manifest_format.is_some();
+    let entry_explicit = request.entry.is_some();
+    let package_explicit = request.package_json.is_some() || request.add_scripts;
+    let package_manager_explicit = request.package_manager.is_some();
+    let install_explicit = request.install.is_some();
+    let verify_explicit = request.verify.is_some();
+    let tests_explicit = request.include_tests.is_some();
+    let mut options = options_from_request(request);
+
+    if customize && !template_explicit {
+        options.template = match select_tty(
+            &term,
+            "Application template",
+            &["HTTP service", "Queue worker", "MCP tool", "Minimal"],
+            0,
+        )? {
+            0 => Template::Http,
+            1 => Template::Worker,
+            2 => Template::Mcp,
+            _ => Template::Minimal,
+        };
+    }
+    if customize && !format_explicit {
+        options.manifest_format =
+            match select_tty(&term, "Manifest format", &["TOML (recommended)", "JSON"], 0)? {
+                0 => ManifestFormat::Toml,
+                _ => ManifestFormat::Json,
+            };
+    }
+    if customize && !package_explicit {
+        let package_exists = options.root.join("package.json").is_file();
+        if package_exists {
+            match select_tty(
+                &term,
+                "JavaScript ecosystem integration",
+                &[
+                    "Reuse package.json",
+                    "Reuse package.json and add tysel:* scripts",
+                    "Leave package.json untouched",
+                ],
+                0,
+            )? {
+                0 => options.package_json = PackageJsonMode::Reuse,
+                1 => {
+                    options.package_json = PackageJsonMode::Reuse;
+                    options.add_scripts = true;
+                }
+                _ => options.package_json = PackageJsonMode::None,
+            }
+        } else {
+            options.package_json = match select_tty(
+                &term,
+                "JavaScript ecosystem integration",
+                &["Create package.json", "No package.json"],
+                0,
+            )? {
+                0 => PackageJsonMode::Create,
+                _ => PackageJsonMode::None,
+            };
+        }
+    }
+    if customize && !entry_explicit {
+        let default_entry = if options.root.join("package.json").is_file() {
+            "src/tysel.ts"
+        } else {
+            "src/index.ts"
+        };
+        let root = options.root.clone();
+        options.entry = Some(validate_entry_input(
+            &options.root,
+            &Input::<String>::new()
+                .with_prompt("Application entry")
+                .default(default_entry.into())
+                .validate_with(move |value: &String| {
+                    validate_entry_input(&root, value)
+                        .map(|_| ())
+                        .map_err(|error| error.to_string())
+                })
+                .interact_text_on(&term)?,
+        )?);
+    }
+    if customize && !tests_explicit {
+        options.include_tests = confirm_on(&term, "Include tests?", true)?;
+    }
+    let creates_package = !options.root.join("package.json").is_file()
+        && matches!(options.package_json, PackageJsonMode::Auto | PackageJsonMode::Create);
+    if creates_package {
+        if customize && !package_manager_explicit {
+            options.package_manager = match select_tty(
+                &term,
+                "Package manager",
+                &["npm", "pnpm", "yarn", "bun"],
+                package_manager_index(options.package_manager),
+            )? {
+                0 => PackageManager::Npm,
+                1 => PackageManager::Pnpm,
+                2 => PackageManager::Yarn,
+                _ => PackageManager::Bun,
+            };
+        }
+        if !install_explicit {
+            options.install = confirm_on(&term, "Install dependencies now?", false)?;
+        }
+        while options.install && !options.package_manager.is_available() {
+            term.write_line(&format!(
+                "{} was not found on PATH; choose an installed package manager.",
+                options.package_manager.command()
+            ))?;
+            let selection = select_tty(
+                &term,
+                "Package manager",
+                &["npm", "pnpm", "yarn", "bun", "Continue without installing"],
+                package_manager_index(options.package_manager),
+            )?;
+            if selection == 4 {
+                options.install = false;
+                break;
+            }
+            options.package_manager = match selection {
+                0 => PackageManager::Npm,
+                1 => PackageManager::Pnpm,
+                2 => PackageManager::Yarn,
+                _ => PackageManager::Bun,
+            };
+        }
+    }
+    if !verify_explicit
+        && (options.install || matches!(options.package_json, PackageJsonMode::None))
+    {
+        options.verify = confirm_on(&term, "Validate the generated project?", true)?;
+    }
+    Ok((options, true))
+}
+
+pub(super) fn confirm_tty(prompt: &str, default: bool) -> Result<bool> {
+    confirm_on(&Term::stdout(), prompt, default)
+}
+
+fn select_tty(term: &Term, prompt: &str, choices: &[&str], default: usize) -> Result<usize> {
+    Select::new()
+        .with_prompt(prompt)
+        .items(choices)
+        .default(default)
+        .interact_on_opt(term)?
+        .ok_or_else(|| anyhow!("cancelled; no files were changed"))
+}
+
+fn confirm_on(term: &Term, prompt: &str, default: bool) -> Result<bool> {
+    Confirm::new()
+        .with_prompt(prompt)
+        .default(default)
+        .interact_on_opt(term)?
+        .ok_or_else(|| anyhow!("cancelled; no files were changed"))
+}
+
+fn package_manager_index(manager: PackageManager) -> usize {
+    match manager {
+        PackageManager::Npm => 0,
+        PackageManager::Pnpm => 1,
+        PackageManager::Yarn => 2,
+        PackageManager::Bun => 3,
+    }
+}
 
 pub(super) fn configure<R: BufRead, W: Write>(
-    request: Request,
+    mut request: Request,
     input: &mut R,
     output: &mut W,
 ) -> Result<(Options, bool)> {
     writeln!(output, "Create a Tysel application\n")?;
+    if request.root.is_none() {
+        request.root = Some(
+            if prompt_select(
+                input,
+                output,
+                "What would you like to do?",
+                &["Create a new project", "Add Tysel to the current directory"],
+                0,
+            )? == 0
+            {
+                prompt_text_validated(
+                    input,
+                    output,
+                    "Project directory",
+                    "my-tysel-app",
+                    validate_new_project_root,
+                )?
+            } else {
+                PathBuf::from(".")
+            },
+        );
+    }
     let customize = request.template.is_some()
         || request.manifest_format.is_some()
         || request.entry.is_some()
         || request.package_json.is_some()
         || request.add_scripts
+        || request.package_manager.is_some()
+        || request.install.is_some()
+        || request.verify.is_some()
         || request.include_tests.is_some()
         || prompt_select(
             input,
@@ -29,6 +266,9 @@ pub(super) fn configure<R: BufRead, W: Write>(
     let format_explicit = request.manifest_format.is_some();
     let entry_explicit = request.entry.is_some();
     let package_explicit = request.package_json.is_some() || request.add_scripts;
+    let package_manager_explicit = request.package_manager.is_some();
+    let install_explicit = request.install.is_some();
+    let verify_explicit = request.verify.is_some();
     let tests_explicit = request.include_tests.is_some();
     let mut options = options_from_request(request);
     if customize && !template_explicit {
@@ -94,12 +334,68 @@ pub(super) fn configure<R: BufRead, W: Write>(
     if customize && !entry_explicit {
         let package_exists = options.root.join("package.json").is_file();
         let default_entry = if package_exists { "src/tysel.ts" } else { "src/index.ts" };
-        options.entry =
-            Some(PathBuf::from(prompt_text(input, output, "Application entry", default_entry)?));
+        let root = options.root.clone();
+        options.entry = Some(prompt_text_validated(
+            input,
+            output,
+            "Application entry",
+            default_entry,
+            |value| validate_entry_input(&root, value),
+        )?);
     }
     if customize && !tests_explicit {
         options.include_tests = prompt_yes_no(input, output, "Include tests?", true)?;
     }
+    let creates_package = !options.root.join("package.json").is_file()
+        && matches!(options.package_json, PackageJsonMode::Auto | PackageJsonMode::Create);
+    if creates_package {
+        if customize && !package_manager_explicit {
+            options.package_manager = match prompt_select(
+                input,
+                output,
+                "Package manager",
+                &["npm", "pnpm", "yarn", "bun"],
+                package_manager_index(options.package_manager),
+            )? {
+                0 => PackageManager::Npm,
+                1 => PackageManager::Pnpm,
+                2 => PackageManager::Yarn,
+                _ => PackageManager::Bun,
+            };
+        }
+        if !install_explicit {
+            options.install = prompt_yes_no(input, output, "Install dependencies now?", false)?;
+        }
+        while options.install && !options.package_manager.is_available() {
+            writeln!(
+                output,
+                "{} was not found on PATH; choose an installed package manager.",
+                options.package_manager.command()
+            )?;
+            let selection = prompt_select(
+                input,
+                output,
+                "Package manager",
+                &["npm", "pnpm", "yarn", "bun", "Continue without installing"],
+                package_manager_index(options.package_manager),
+            )?;
+            if selection == 4 {
+                options.install = false;
+                break;
+            }
+            options.package_manager = match selection {
+                0 => PackageManager::Npm,
+                1 => PackageManager::Pnpm,
+                2 => PackageManager::Yarn,
+                _ => PackageManager::Bun,
+            };
+        }
+    }
+    if !verify_explicit
+        && (options.install || matches!(options.package_json, PackageJsonMode::None))
+    {
+        options.verify = prompt_yes_no(input, output, "Validate the generated project?", true)?;
+    }
     Ok((options, true))
 }
 
@@ -143,6 +439,27 @@ fn prompt_text<R: BufRead, W: Write>(
     Ok(if value.is_empty() { default.to_owned() } else { value })
 }
 
+pub(super) fn prompt_text_validated<R, W, T, F>(
+    input: &mut R,
+    output: &mut W,
+    prompt: &str,
+    default: &str,
+    validate: F,
+) -> Result<T>
+where
+    R: BufRead,
+    W: Write,
+    F: Fn(&str) -> Result<T>,
+{
+    loop {
+        let value = prompt_text(input, output, prompt, default)?;
+        match validate(&value) {
+            Ok(value) => return Ok(value),
+            Err(error) => writeln!(output, "{error}")?,
+        }
+    }
+}
+
 pub(super) fn prompt_yes_no<R: BufRead, W: Write>(
     input: &mut R,
     output: &mut W,
diff --git a/crates/tysel-cli/src/init/templates.rs b/crates/tysel-cli/src/init/templates.rs
index f600f98..2a7bcce 100644
--- a/crates/tysel-cli/src/init/templates.rs
+++ b/crates/tysel-cli/src/init/templates.rs
@@ -181,6 +181,24 @@ struct TemplateSpec {
 }
 
 impl Template {
+    pub(super) fn key(self) -> &'static str {
+        match self {
+            Self::Http => "http",
+            Self::Worker => "worker",
+            Self::Mcp => "mcp",
+            Self::Minimal => "minimal",
+        }
+    }
+
+    pub(super) fn label(self) -> &'static str {
+        match self {
+            Self::Http => "HTTP service",
+            Self::Worker => "Queue worker",
+            Self::Mcp => "MCP tool",
+            Self::Minimal => "Minimal",
+        }
+    }
+
     fn spec(self) -> TemplateSpec {
         match self {
             Self::Http => TemplateSpec {
@@ -284,22 +302,33 @@ pub(super) fn generated_package_json(
 
 pub(super) fn generated_tsconfig(
     entry: &Path,
-    isolated: bool,
-    include_tests: bool,
+    has_public_types: bool,
+    test_path: Option<&Path>,
+    has_test_types: bool,
 ) -> Result<String> {
     let mut config: serde_json::Value = serde_json::from_str(TSCONFIG)?;
     let entry = entry.to_string_lossy().replace('\\', "/");
+    if matches!(
+        Path::new(&entry).extension().and_then(|value| value.to_str()),
+        Some("js" | "mjs" | "cjs")
+    ) {
+        config["compilerOptions"]["allowJs"] = serde_json::Value::Bool(true);
+        config["compilerOptions"]["checkJs"] = serde_json::Value::Bool(false);
+    }
     let mut files = vec![serde_json::Value::String(entry)];
-    if include_tests && !isolated {
-        files.push(serde_json::Value::String("tests/app.test.ts".into()));
+    if let Some(test_path) = test_path.filter(|_| has_test_types) {
+        files.push(serde_json::Value::String(test_path.to_string_lossy().replace('\\', "/")));
     }
     config.as_object_mut().expect("tsconfig template").remove("include");
     config["files"] = serde_json::Value::Array(files);
-    if isolated {
-        config["compilerOptions"]["types"] = serde_json::json!([]);
-    } else if !include_tests {
-        config["compilerOptions"]["types"] = serde_json::json!(["@tysel/types"]);
+    let mut types = Vec::new();
+    if has_public_types {
+        types.push("@tysel/types");
+    }
+    if test_path.is_some() && has_test_types {
+        types.push("@tysel/test");
     }
+    config["compilerOptions"]["types"] = serde_json::json!(types);
     let mut rendered = serde_json::to_string_pretty(&config)?;
     rendered.push('\n');
     Ok(rendered)
diff --git a/crates/tysel-cli/src/init/transaction.rs b/crates/tysel-cli/src/init/transaction.rs
index d4de1e9..a8aaac7 100644
--- a/crates/tysel-cli/src/init/transaction.rs
+++ b/crates/tysel-cli/src/init/transaction.rs
@@ -1,6 +1,11 @@
 use std::fs;
 use std::io::Write;
 use std::path::{Path, PathBuf};
+#[cfg(unix)]
+use std::sync::atomic::{AtomicU64, Ordering};
+
+#[cfg(unix)]
+static TEMP_FILE_SEQUENCE: AtomicU64 = AtomicU64::new(0);
 
 #[derive(Default)]
 pub(super) struct ProjectTransaction {
@@ -44,9 +49,16 @@ impl ProjectTransaction {
                 path.display()
             )));
         }
+        #[cfg(unix)]
+        replace_contents(path, expected, contents)?;
+        #[cfg(not(unix))]
+        if let Err(error) = replace_contents(path, expected, contents) {
+            #[cfg(not(unix))]
+            let _ = fs::write(path, &original);
+            return Err(error);
+        }
         self.modified_files.push((path.to_path_buf(), original));
-        let mut file = fs::OpenOptions::new().write(true).truncate(true).open(path)?;
-        file.write_all(contents)
+        Ok(())
     }
 
     pub(super) fn commit(mut self) {
@@ -54,6 +66,46 @@ impl ProjectTransaction {
     }
 }
 
+#[cfg(unix)]
+fn replace_contents(path: &Path, expected: &[u8], contents: &[u8]) -> std::io::Result<()> {
+    let parent = path.parent().unwrap_or_else(|| Path::new("."));
+    let mut name = path.file_name().unwrap_or_else(|| std::ffi::OsStr::new("file")).to_os_string();
+    name.push(format!(
+        ".tysel-init-{}-{}",
+        std::process::id(),
+        TEMP_FILE_SEQUENCE.fetch_add(1, Ordering::Relaxed)
+    ));
+    let temporary = parent.join(name);
+    let result = (|| {
+        let permissions = fs::metadata(path)?.permissions();
+        let mut file = fs::OpenOptions::new().write(true).create_new(true).open(&temporary)?;
+        fs::set_permissions(&temporary, permissions)?;
+        file.write_all(contents)?;
+        file.sync_all()?;
+        if fs::read(path)? != expected {
+            return Err(std::io::Error::other(format!(
+                "{} changed while init was running",
+                path.display()
+            )));
+        }
+        fs::rename(&temporary, path)?;
+        if let Ok(directory) = fs::File::open(parent) {
+            let _ = directory.sync_all();
+        }
+        Ok(())
+    })();
+    if result.is_err() {
+        let _ = fs::remove_file(temporary);
+    }
+    result
+}
+
+#[cfg(not(unix))]
+fn replace_contents(path: &Path, _expected: &[u8], contents: &[u8]) -> std::io::Result<()> {
+    let mut file = fs::OpenOptions::new().write(true).truncate(true).open(path)?;
+    file.write_all(contents)
+}
+
 impl Drop for ProjectTransaction {
     fn drop(&mut self) {
         if self.committed {
diff --git a/crates/tysel-cli/src/main.rs b/crates/tysel-cli/src/main.rs
index fb2cb80..e4cf71e 100644
--- a/crates/tysel-cli/src/main.rs
+++ b/crates/tysel-cli/src/main.rs
@@ -69,6 +69,14 @@ enum PackageJsonArg {
     None,
 }
 
+#[derive(Clone, Copy, ValueEnum)]
+enum PackageManagerArg {
+    Npm,
+    Pnpm,
+    Yarn,
+    Bun,
+}
+
 #[derive(Clone, Copy, ValueEnum)]
 enum InitTemplateArg {
     Http,
@@ -114,8 +122,8 @@ enum ConfigCommand {
 enum Commands {
     /// Create a new Tysel application.
     Init {
-        #[arg(default_value = ".")]
-        path: PathBuf,
+        /// Project directory; omit it in a terminal to choose interactively.
+        path: Option<PathBuf>,
         /// Select the generated application template.
         #[arg(long, value_enum)]
         template: Option<InitTemplateArg>,
@@ -131,12 +139,27 @@ enum Commands {
         /// Add namespaced Tysel scripts to a reused package.json.
         #[arg(long)]
         add_scripts: bool,
+        /// Select the package manager used for dependency installation instructions.
+        #[arg(long, value_enum)]
+        package_manager: Option<PackageManagerArg>,
+        /// Install generated package dependencies after creating the project.
+        #[arg(long)]
+        install: bool,
+        /// Run `tysel check` after creation and optional dependency installation.
+        #[arg(long)]
+        verify: bool,
         /// Do not generate an application test.
         #[arg(long)]
         no_tests: bool,
         /// Print the planned file changes without writing them.
         #[arg(long)]
         dry_run: bool,
+        /// Serialize a dry-run plan as JSON, including before/after file contents.
+        #[arg(long, requires = "dry_run")]
+        json: bool,
+        /// Include full unified file diffs in a human-readable dry run.
+        #[arg(long, requires = "dry_run", conflicts_with = "json")]
+        diff: bool,
         /// Accept recommended defaults and never prompt.
         #[arg(short = 'y', long)]
         yes: bool,
@@ -496,15 +519,22 @@ fn run(cli: Cli) -> Result<ExitCode> {
             entry,
             package_json,
             add_scripts,
+            package_manager,
+            install,
+            verify,
             no_tests,
             dry_run,
+            json,
+            diff,
             yes,
             no_interactive,
         } => {
-            let path = match project_dir.as_deref() {
-                Some(base) if path == Path::new(".") => base.to_path_buf(),
-                Some(base) if path.is_relative() => base.join(path),
-                _ => path,
+            let path = match (path, project_dir.as_deref()) {
+                (Some(path), Some(base)) if path == Path::new(".") => Some(base.to_path_buf()),
+                (Some(path), Some(base)) if path.is_relative() => Some(base.join(path)),
+                (Some(path), _) => Some(path),
+                (None, Some(base)) => Some(base.to_path_buf()),
+                (None, None) => None,
             };
             init::run(init::Request {
                 root: path,
@@ -523,8 +553,18 @@ fn run(cli: Cli) -> Result<ExitCode> {
                     PackageJsonArg::None => init::PackageJsonMode::None,
                 }),
                 add_scripts,
+                package_manager: package_manager.map(|value| match value {
+                    PackageManagerArg::Npm => init::PackageManager::Npm,
+                    PackageManagerArg::Pnpm => init::PackageManager::Pnpm,
+                    PackageManagerArg::Yarn => init::PackageManager::Yarn,
+                    PackageManagerArg::Bun => init::PackageManager::Bun,
+                }),
+                install: install.then_some(true),
+                verify: verify.then_some(true),
                 include_tests: no_tests.then_some(false),
                 dry_run,
+                json,
+                diff,
                 yes,
                 no_interactive,
             })
diff --git a/crates/tysel-cli/tests/dev_check.rs b/crates/tysel-cli/tests/dev_check.rs
index c36f82b..02f0e1a 100644
--- a/crates/tysel-cli/tests/dev_check.rs
+++ b/crates/tysel-cli/tests/dev_check.rs
@@ -426,6 +426,169 @@ fn init_can_create_a_package_free_json_project() {
     assert!(String::from_utf8_lossy(&task.stdout).contains("task verify completed"));
 }
 
+#[test]
+fn init_rejects_a_javascript_extension_for_a_generated_typescript_entry() {
+    let dir = temp_app("init-js-extension");
+    let _ = fs::remove_dir_all(&dir);
+    let output = Command::new(cli_exe())
+        .args(["init", dir.to_str().unwrap(), "--entry", "src/app.js", "--yes"])
+        .output()
+        .unwrap();
+    assert!(!output.status.success());
+    assert!(String::from_utf8_lossy(&output.stderr).contains("must use a TypeScript extension"));
+    assert!(!dir.exists(), "init must fail before creating the project directory");
+}
+
+#[test]
+fn init_dry_run_prints_a_reviewable_project_summary() {
+    let dir = temp_app("init-plan-summary");
+    let _ = fs::remove_dir_all(&dir);
+    let output = Command::new(cli_exe())
+        .args(["init", dir.to_str().unwrap(), "--dry-run"])
+        .output()
+        .unwrap();
+    assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("Mode      Create"), "{stdout}");
+    assert!(stdout.contains("Template  HTTP service"), "{stdout}");
+    assert!(stdout.contains("Entry     src/index.ts (create)"), "{stdout}");
+    assert!(stdout.contains("Package   create package.json"), "{stdout}");
+    assert!(stdout.contains("Install   npm install (skip)"), "{stdout}");
+    assert!(!dir.exists());
+}
+
+#[test]
+fn init_dry_run_json_contains_machine_readable_file_contents() {
+    let dir = temp_app("init-plan-json");
+    let _ = fs::remove_dir_all(&dir);
+    let output = Command::new(cli_exe())
+        .args(["init", dir.to_str().unwrap(), "--dry-run", "--json"])
+        .output()
+        .unwrap();
+    assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
+    let plan: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+    assert_eq!(plan["schemaVersion"], 1);
+    assert_eq!(plan["mode"], "create");
+    assert_eq!(plan["package"]["manager"], "npm");
+    assert!(
+        plan["changes"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|change| change["path"] == "package.json" && change["after"].is_string())
+    );
+    assert!(!dir.exists());
+}
+
+#[test]
+fn init_dry_run_install_does_not_require_the_package_manager_on_path() {
+    let dir = temp_app("init-plan-missing-manager");
+    let _ = fs::remove_dir_all(&dir);
+    let empty_path = temp_app("init-empty-path");
+    let output = Command::new(cli_exe())
+        .env("PATH", &empty_path)
+        .args(["init", dir.to_str().unwrap(), "--package-manager", "npm", "--install", "--dry-run"])
+        .output()
+        .unwrap();
+    assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
+    assert!(String::from_utf8_lossy(&output.stdout).contains("npm install (run)"));
+    assert!(!dir.exists());
+}
+
+#[test]
+fn init_rejects_install_without_a_generated_package() {
+    let dir = temp_app("init-install-without-package");
+    let _ = fs::remove_dir_all(&dir);
+    let output = Command::new(cli_exe())
+        .args(["init", dir.to_str().unwrap(), "--package-json", "none", "--install", "--yes"])
+        .output()
+        .unwrap();
+    assert!(!output.status.success());
+    assert!(String::from_utf8_lossy(&output.stderr).contains("--install requires"));
+    assert!(!dir.exists());
+}
+
+#[test]
+fn init_rejects_verify_for_an_uninstalled_generated_package() {
+    let dir = temp_app("init-verify-without-install");
+    let _ = fs::remove_dir_all(&dir);
+    let output = Command::new(cli_exe())
+        .args(["init", dir.to_str().unwrap(), "--verify", "--yes"])
+        .output()
+        .unwrap();
+    assert!(!output.status.success());
+    assert!(String::from_utf8_lossy(&output.stderr).contains("--verify requires --install"));
+    assert!(!dir.exists());
+}
+
+#[test]
+fn init_can_verify_a_package_free_project_after_creation() {
+    let dir = temp_app("init-package-free-verify");
+    let _ = fs::remove_dir_all(&dir);
+    let output = Command::new(cli_exe())
+        .args(["init", dir.to_str().unwrap(), "--package-json", "none", "--verify", "--yes"])
+        .output()
+        .unwrap();
+    assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
+    assert!(String::from_utf8_lossy(&output.stdout).contains("validating generated project"));
+    assert!(dir.join("tysel.toml").is_file());
+}
+
+#[test]
+fn init_dry_run_summarizes_existing_file_updates() {
+    let dir = temp_app("init-update-summary");
+    fs::write(dir.join("package.json"), r#"{"name":"existing"}"#).unwrap();
+    fs::write(dir.join(".gitignore"), "custom/\nnode_modules/\n").unwrap();
+    let output = Command::new(cli_exe())
+        .args(["init", dir.to_str().unwrap(), "--add-scripts", "--dry-run"])
+        .output()
+        .unwrap();
+    assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("update package.json"), "{stdout}");
+    assert!(stdout.contains("+ scripts.tysel:dev = \"tysel dev\""), "{stdout}");
+    assert!(stdout.contains("update .gitignore"), "{stdout}");
+    assert!(stdout.contains("+ .tysel/"), "{stdout}");
+    assert_eq!(fs::read_to_string(dir.join("package.json")).unwrap(), r#"{"name":"existing"}"#);
+}
+
+#[test]
+fn init_dry_run_diff_exposes_complete_existing_file_changes() {
+    let dir = temp_app("init-update-diff");
+    fs::write(
+        dir.join("package.json"),
+        "{\n    \"name\": \"existing\",\n    \"private\": true\n}\n",
+    )
+    .unwrap();
+    let output = Command::new(cli_exe())
+        .args(["init", dir.to_str().unwrap(), "--add-scripts", "--dry-run", "--diff"])
+        .output()
+        .unwrap();
+    assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("--- a/package.json"), "{stdout}");
+    assert!(stdout.contains("-    \"name\": \"existing\""), "{stdout}");
+    assert!(stdout.contains("+  \"name\": \"existing\""), "{stdout}");
+    assert!(stdout.contains("+    \"tysel:dev\": \"tysel dev\""), "{stdout}");
+}
+
+#[test]
+fn init_rejects_a_stale_existing_tysel_tsconfig_before_writing() {
+    let dir = temp_app("init-stale-tsconfig");
+    fs::write(
+        dir.join("package.json"),
+        r#"{"devDependencies":{"@tysel/types":"0.2.0","@tysel/test":"0.2.0"}}"#,
+    )
+    .unwrap();
+    fs::write(dir.join("tsconfig.tysel.json"), r#"{"files":["src/old.ts"]}"#).unwrap();
+    let output =
+        Command::new(cli_exe()).args(["init", dir.to_str().unwrap(), "--yes"]).output().unwrap();
+    assert!(!output.status.success());
+    assert!(String::from_utf8_lossy(&output.stderr).contains("does not include src/tysel.ts"));
+    assert!(!dir.join("tysel.toml").exists());
+    assert!(!dir.join("src").exists());
+}
+
 #[test]
 fn types_generates_and_checks_manifest_scoped_capabilities() {
     let dir = temp_app("types-environment");
@@ -614,6 +777,22 @@ fn init_can_add_namespaced_scripts_without_replacing_node_scripts() {
     assert_eq!(updated["scripts"]["tysel:build"], "tysel build --release");
 }
 
+#[test]
+fn init_merges_tysel_entries_into_an_existing_gitignore() {
+    let dir = temp_app("init-existing-gitignore");
+    fs::write(dir.join(".gitignore"), "custom/\nnode_modules/\n").unwrap();
+    let output = Command::new(cli_exe())
+        .args(["init", dir.to_str().unwrap(), "--package-json", "none", "--yes"])
+        .output()
+        .unwrap();
+    assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
+    let gitignore = fs::read_to_string(dir.join(".gitignore")).unwrap();
+    assert!(gitignore.starts_with("custom/\nnode_modules/\n"));
+    assert_eq!(gitignore.matches("node_modules/").count(), 1);
+    assert!(gitignore.contains("# Tysel\n"));
+    assert!(gitignore.contains(".tysel/\n"));
+}
+
 #[test]
 fn project_discovery_walks_up_and_config_reports_the_context() {
     let dir = temp_app("project-discovery");

From 3309eb71beedd8d42024504d94a0c3ed19f31132 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Sat, 5 Sep 2026 03:00:16 +0800
Subject: [PATCH 02/31] docs(init): document guided setup and dry-run output

---
 docs/concepts/projects-and-configuration.md   | 44 +++++++++++++++++--
 docs/reference/cli/project.md                 | 34 ++++++++++++--
 .../concepts/projects-and-configuration.mdx   | 44 +++++++++++++++++--
 website/content/reference/cli/project.mdx     | 34 ++++++++++++--
 4 files changed, 140 insertions(+), 16 deletions(-)

diff --git a/docs/concepts/projects-and-configuration.md b/docs/concepts/projects-and-configuration.md
index 43a1a9b..41022d8 100644
--- a/docs/concepts/projects-and-configuration.md
+++ b/docs/concepts/projects-and-configuration.md
@@ -107,10 +107,38 @@ relative runtime paths resolve from the process working directory.
 In a terminal, `tysel init` offers a recommended quick start and an optional
 customized flow:
 
+```sh
+tysel init
+```
+
+When no path is supplied, the interactive flow first asks whether to create a
+new project or add Tysel to the current directory. New projects then ask for a
+destination. Supply a path to skip those questions:
+
 ```sh
 tysel init my-service
 ```
 
+Use the arrow keys and Enter to choose options. Basic terminals without cursor
+control use numbered choices instead.
+
+For generated packages, `init` detects the nearest npm, pnpm, Yarn, or Bun
+lockfile and offers to install dependencies. Automation can choose explicitly:
+
+```sh
+tysel init my-service --package-manager pnpm --install --yes
+```
+
+Add `--verify` to run `tysel check` after installation. In the interactive
+flow, verification is offered when installation is selected, defaults to yes,
+and runs only after installation succeeds. Generated packages require the
+TypeScript portion of the check to run rather than report `skipped`.
+Package-free projects can be verified immediately:
+
+```sh
+tysel init job --package-json none --verify --yes
+```
+
 The customized flow selects independent dimensions:
 
 - HTTP service, Queue worker, MCP tool, or minimal template;
@@ -133,10 +161,16 @@ tysel init worker \
   --yes
 ```
 
-Use `--dry-run` to print the complete change plan without writing. `init`
-checks every destination first, preserves existing source and configuration,
-rejects symlinked mutation targets, and rolls back its writes if a later
-operation fails.
+Use `--dry-run` to print the complete change plan without writing. Add `--diff`
+for full unified file contents, or `--json` for a machine-readable plan whose
+changes include `before` and `after` values. Dry runs do not require the
+selected package manager to be installed.
+
+`init` checks every destination first, preserves existing source and
+configuration, merges missing Tysel entries into an existing `.gitignore`,
+and rejects symlinked mutation targets. File writes are rolled back if project
+creation fails before completion. A later package installation or validation
+failure leaves the created project available for inspection and retry.
 
 When adopting an existing JavaScript or TypeScript project, Tysel defaults to
 `src/tysel.ts` and `tsconfig.tysel.json`. It preserves `package.json` unless
@@ -144,6 +178,8 @@ When adopting an existing JavaScript or TypeScript project, Tysel defaults to
 
 ```sh
 tysel init . --dry-run
+tysel init . --dry-run --diff
+tysel init . --dry-run --json
 tysel init . --add-scripts
 ```
 
diff --git a/docs/reference/cli/project.md b/docs/reference/cli/project.md
index 6a241a6..e44ae59 100644
--- a/docs/reference/cli/project.md
+++ b/docs/reference/cli/project.md
@@ -8,23 +8,44 @@ Create a project or safely add Tysel files to an existing directory.
 tysel init [PATH] [OPTIONS]
 ```
 
-`PATH` defaults to `.`. With global `-C`, a relative path is resolved from the
-selected base directory.
+When `PATH` is omitted in an interactive terminal, `init` asks for a project
+directory and suggests `my-tysel-app`. In non-interactive use it defaults to
+`.`. With global `-C`, a relative path is resolved from the selected base
+directory.
 
 | Option | Accepted values | Behavior |
 | --- | --- | --- |
 | `--template` | `http`, `worker`, `mcp`, `minimal` | Select generated application content. |
 | `--manifest-format` | `toml`, `json` | Select only the manifest serialization; both use the same schema and combine with every other option. |
-| `--entry <path>` | Project-relative non-Wasm path | Override the generated JavaScript application entry. `.wasm` is rejected because `init` does not yet generate Component projects. |
+| `--entry <path>` | Project-relative path | Reuse an existing JavaScript or TypeScript entry. A newly generated entry must use `.ts`, `.tsx`, or `.mts`; `.wasm` is rejected because `init` does not yet generate Component projects. |
 | `--package-json` | `auto`, `create`, `reuse`, `none` | Control only the optional npm sidecar. `auto` reuses an existing file or creates one; `create` requires no existing file; `reuse` requires one; `none` leaves it absent or untouched. |
 | `--add-scripts` | Flag | Add Tysel scripts to a reused `package.json`. |
+| `--package-manager` | `npm`, `pnpm`, `yarn`, `bun` | Select the install command shown or run for a generated package. The nearest lockfile is used when omitted. |
+| `--install` | Flag | Run the selected package manager after project files are created. Requires `init` to create `package.json`. |
+| `--verify` | Flag | Run `tysel check` after creation and optional installation. A newly generated package requires `--install` so TypeScript is not skipped. |
 | `--no-tests` | Flag | Do not create the starter test, test dependency/script, or `test` step in the generated `verify` task. |
 | `--dry-run` | Flag | Print the plan without writing files. |
+| `--json` | Flag | Serialize a dry-run plan, including before/after file contents, as JSON. Requires `--dry-run`. |
+| `--diff` | Flag | Include full unified file diffs in human-readable dry-run output. Requires `--dry-run`. |
 | `-y, --yes` | Flag | Accept the proposed plan. |
-| `--no-interactive` | Flag | Fail instead of prompting when input is required. |
+| `--no-interactive` | Flag | Disable prompts and use documented defaults for omitted choices. |
 
 `init` does not overwrite existing files silently. Use `--dry-run` in existing
 repositories and review the adoption plan before accepting it.
+An existing `.gitignore` is extended only with missing Tysel-generated paths;
+its other entries are preserved.
+
+With no path, the first interactive choice explicitly separates creating a new
+project from adding Tysel to the current directory. Other choices support the
+arrow keys and Enter. Terminals without cursor control fall back to numbered
+choices.
+Project destinations and entry paths are validated at their prompts so invalid
+values can be corrected before the rest of the wizard runs.
+
+For adopted projects, the default plan reports the individual package scripts
+and ignore patterns that will be added. `--diff` exposes exact content changes,
+including formatting changes from rewriting `package.json`; `--json` provides
+the same before/after contents for automation.
 
 Template, manifest format, entry, package integration, and tests are
 independent choices. A `package.json` is not required to run, test, or build an
@@ -32,6 +53,10 @@ application that has no npm dependencies. Fresh projects receive
 `tsconfig.json`; projects that
 already have JavaScript or TypeScript configuration receive a separate
 `tsconfig.tysel.json` when needed.
+If that Tysel-specific config already has an explicit `files` list, `init`
+requires it to include the selected entry and any generated typed test.
+Comments and trailing commas accepted by TypeScript configuration files are
+supported during this validation.
 
 For a Wasm Component, start from the published Rust or Go Component starter and
 its version-matched manifest; follow the
@@ -41,6 +66,7 @@ its version-matched manifest; follow the
 ```sh
 tysel init api --template http --manifest-format toml --yes
 tysel init . --package-json reuse --add-scripts --dry-run
+tysel init . --package-json reuse --add-scripts --dry-run --diff
 tysel init worker --template worker --manifest-format json --package-json none --yes
 tysel init tool --template mcp --package-json none --no-tests --yes
 ```
diff --git a/website/content/docs/concepts/projects-and-configuration.mdx b/website/content/docs/concepts/projects-and-configuration.mdx
index 1e2b4d2..3475c07 100644
--- a/website/content/docs/concepts/projects-and-configuration.mdx
+++ b/website/content/docs/concepts/projects-and-configuration.mdx
@@ -110,10 +110,38 @@ relative runtime paths resolve from the process working directory.
 In a terminal, `tysel init` offers a recommended quick start and an optional
 customized flow:
 
+```sh
+tysel init
+```
+
+When no path is supplied, the interactive flow first asks whether to create a
+new project or add Tysel to the current directory. New projects then ask for a
+destination. Supply a path to skip those questions:
+
 ```sh
 tysel init my-service
 ```
 
+Use the arrow keys and Enter to choose options. Basic terminals without cursor
+control use numbered choices instead.
+
+For generated packages, `init` detects the nearest npm, pnpm, Yarn, or Bun
+lockfile and offers to install dependencies. Automation can choose explicitly:
+
+```sh
+tysel init my-service --package-manager pnpm --install --yes
+```
+
+Add `--verify` to run `tysel check` after installation. In the interactive
+flow, verification is offered when installation is selected, defaults to yes,
+and runs only after installation succeeds. Generated packages require the
+TypeScript portion of the check to run rather than report `skipped`.
+Package-free projects can be verified immediately:
+
+```sh
+tysel init job --package-json none --verify --yes
+```
+
 The customized flow selects independent dimensions:
 
 - HTTP service, Queue worker, MCP tool, or minimal template;
@@ -136,10 +164,16 @@ tysel init worker \
   --yes
 ```
 
-Use `--dry-run` to print the complete change plan without writing. `init`
-checks every destination first, preserves existing source and configuration,
-rejects symlinked mutation targets, and rolls back its writes if a later
-operation fails.
+Use `--dry-run` to print the complete change plan without writing. Add `--diff`
+for full unified file contents, or `--json` for a machine-readable plan whose
+changes include `before` and `after` values. Dry runs do not require the
+selected package manager to be installed.
+
+`init` checks every destination first, preserves existing source and
+configuration, merges missing Tysel entries into an existing `.gitignore`,
+and rejects symlinked mutation targets. File writes are rolled back if project
+creation fails before completion. A later package installation or validation
+failure leaves the created project available for inspection and retry.
 
 When adopting an existing JavaScript or TypeScript project, Tysel defaults to
 `src/tysel.ts` and `tsconfig.tysel.json`. It preserves `package.json` unless
@@ -147,6 +181,8 @@ When adopting an existing JavaScript or TypeScript project, Tysel defaults to
 
 ```sh
 tysel init . --dry-run
+tysel init . --dry-run --diff
+tysel init . --dry-run --json
 tysel init . --add-scripts
 ```
 
diff --git a/website/content/reference/cli/project.mdx b/website/content/reference/cli/project.mdx
index 79f526d..1c89e2c 100644
--- a/website/content/reference/cli/project.mdx
+++ b/website/content/reference/cli/project.mdx
@@ -11,23 +11,44 @@ Create a project or safely add Tysel files to an existing directory.
 tysel init [PATH] [OPTIONS]
 ```
 
-`PATH` defaults to `.`. With global `-C`, a relative path is resolved from the
-selected base directory.
+When `PATH` is omitted in an interactive terminal, `init` asks for a project
+directory and suggests `my-tysel-app`. In non-interactive use it defaults to
+`.`. With global `-C`, a relative path is resolved from the selected base
+directory.
 
 | Option | Accepted values | Behavior |
 | --- | --- | --- |
 | `--template` | `http`, `worker`, `mcp`, `minimal` | Select generated application content. |
 | `--manifest-format` | `toml`, `json` | Select only the manifest serialization; both use the same schema and combine with every other option. |
-| <code>{"--entry <path>"}</code> | Project-relative non-Wasm path | Override the generated JavaScript application entry. `.wasm` is rejected because `init` does not yet generate Component projects. |
+| <code>{"--entry <path>"}</code> | Project-relative path | Reuse an existing JavaScript or TypeScript entry. A newly generated entry must use `.ts`, `.tsx`, or `.mts`; `.wasm` is rejected because `init` does not yet generate Component projects. |
 | `--package-json` | `auto`, `create`, `reuse`, `none` | Control only the optional npm sidecar. `auto` reuses an existing file or creates one; `create` requires no existing file; `reuse` requires one; `none` leaves it absent or untouched. |
 | `--add-scripts` | Flag | Add Tysel scripts to a reused `package.json`. |
+| `--package-manager` | `npm`, `pnpm`, `yarn`, `bun` | Select the install command shown or run for a generated package. The nearest lockfile is used when omitted. |
+| `--install` | Flag | Run the selected package manager after project files are created. Requires `init` to create `package.json`. |
+| `--verify` | Flag | Run `tysel check` after creation and optional installation. A newly generated package requires `--install` so TypeScript is not skipped. |
 | `--no-tests` | Flag | Do not create the starter test, test dependency/script, or `test` step in the generated `verify` task. |
 | `--dry-run` | Flag | Print the plan without writing files. |
+| `--json` | Flag | Serialize a dry-run plan, including before/after file contents, as JSON. Requires `--dry-run`. |
+| `--diff` | Flag | Include full unified file diffs in human-readable dry-run output. Requires `--dry-run`. |
 | `-y, --yes` | Flag | Accept the proposed plan. |
-| `--no-interactive` | Flag | Fail instead of prompting when input is required. |
+| `--no-interactive` | Flag | Disable prompts and use documented defaults for omitted choices. |
 
 `init` does not overwrite existing files silently. Use `--dry-run` in existing
 repositories and review the adoption plan before accepting it.
+An existing `.gitignore` is extended only with missing Tysel-generated paths;
+its other entries are preserved.
+
+With no path, the first interactive choice explicitly separates creating a new
+project from adding Tysel to the current directory. Other choices support the
+arrow keys and Enter. Terminals without cursor control fall back to numbered
+choices.
+Project destinations and entry paths are validated at their prompts so invalid
+values can be corrected before the rest of the wizard runs.
+
+For adopted projects, the default plan reports the individual package scripts
+and ignore patterns that will be added. `--diff` exposes exact content changes,
+including formatting changes from rewriting `package.json`; `--json` provides
+the same before/after contents for automation.
 
 Template, manifest format, entry, package integration, and tests are
 independent choices. A `package.json` is not required to run, test, or build an
@@ -35,6 +56,10 @@ application that has no npm dependencies. Fresh projects receive
 `tsconfig.json`; projects that
 already have JavaScript or TypeScript configuration receive a separate
 `tsconfig.tysel.json` when needed.
+If that Tysel-specific config already has an explicit `files` list, `init`
+requires it to include the selected entry and any generated typed test.
+Comments and trailing commas accepted by TypeScript configuration files are
+supported during this validation.
 
 For a Wasm Component, start from the published Rust or Go Component starter and
 its version-matched manifest; follow the
@@ -44,6 +69,7 @@ its version-matched manifest; follow the
 ```sh
 tysel init api --template http --manifest-format toml --yes
 tysel init . --package-json reuse --add-scripts --dry-run
+tysel init . --package-json reuse --add-scripts --dry-run --diff
 tysel init worker --template worker --manifest-format json --package-json none --yes
 tysel init tool --template mcp --package-json none --no-tests --yes
 ```

From 26ae2c5acb1fa0e805b989f74117e13a3b12b5f9 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Sat, 5 Sep 2026 03:00:54 +0800
Subject: [PATCH 03/31] docs(brand): add GitHub organization avatar

---
 brand/README.md                   |   5 +++++
 brand/github/tysel-org-avatar.png | Bin 0 -> 38372 bytes
 brand/github/tysel-org-avatar.svg |   9 +++++++++
 3 files changed, 14 insertions(+)
 create mode 100644 brand/github/tysel-org-avatar.png
 create mode 100644 brand/github/tysel-org-avatar.svg

diff --git a/brand/README.md b/brand/README.md
index abb6a33..85a6b81 100644
--- a/brand/README.md
+++ b/brand/README.md
@@ -46,6 +46,11 @@ The secondary `ty` mark is a direct crop of the same outlined wordmark. It is re
 
 ## GitHub surfaces
 
+[`github/tysel-org-avatar.png`](./github/tysel-org-avatar.png) is the upload-ready
+1024×1024 organization profile picture. It keeps the original `ty` mark inside a
+circle-safe area, using Tysel Blue on a solid Runtime Mist field. The editable
+[`SVG source`](./github/tysel-org-avatar.svg) is included alongside it.
+
 [`github/tysel-github-banner.png`](./github/tysel-github-banner.png) is the
 upload-ready 1280×640 social preview. Its editable
 [`SVG source`](./github/tysel-github-banner.svg) is included for future size
diff --git a/brand/github/tysel-org-avatar.png b/brand/github/tysel-org-avatar.png
new file mode 100644
index 0000000000000000000000000000000000000000..d30419ecd376522f58fb47f020a20b8bfda82575
GIT binary patch
literal 38372
zcmeFZbzIZy|31ErAtO{8l$r{Hw1FTwl@cYC4oMZ16e+1~N(mC8lt?I2(v9Q<2}Mez
z8w8|5I$z&=<DBz3zW@6D|2u#9aKJ0>c*ga-p4Yu+8fr?1sg6^@V6em2l;v;1U`X&0
z2}2zM|6w@<o`V12k8UYlfn~R_PlF#M?&@8;r>Y9$2cJ<exc`094RG+&aqtfYLnI>p
z{tXhANcMl9iGN&TYUG8%FtBU#m$lsBbAw+V8Fg2)u0K8YUj7yt#bL%XH{Z$MVuvGk
zD|L-Odutot5nMd?3JR3CUOpxm?)656U!S|lt#K!dfp^09<?qR<_jA0@4!4}-xk-QR
z+1L&9Uuq^Z*WUXaYOCdFshsN2ennXDXkFUk#0{FfF`FBD${ROw83%(SkSJO-=HSBx
z1JjE3%8pC_{vG(^$VVI!hyUxEzb~ez4TCA88_Sgcd<Hk{`5%v@MTg;VNDSg~m%^V<
zMZ-;L{(jcM2=GWGH;f*YFHHaUcn<zf3A6a~9Vl)z8XkrTbAIvX@Reb#WdE8CxEl?J
zQ{s?MGK2p7H3mUo{qr3NN|Z8;oA%Ca?mwqV53B$49kj|A3<8Zu&z}5qnqe@}L;tss
z#DQZF2znSLQlEwLk7<IXJp1Q6kpC^^AExo&QvPGD|5@c9UiP1Z|LrLM#mYZZ!hdP!
zZ%6qr?fjWt|I6Ti1DOB7(4Uy^KV12D4E+zH{|C{Dw(wu9{4ZAiSA+kJq=>fg{~1?`
zJ|jAi0;;e-ZfQ<GHQ-%D%u~YVre1W+v8K1&3jf5H9|{;mqVS9FY6vlg&E*D{O$sd3
z@VZDcZqj>m^v-50G&DQyq^JH5XYhmvb_o9O5uyHLApR+jNgw_rbN(@||9G)KOyfU_
z@gGL=KZ@~h=7bbW|DzcHag_i6QjDT5i=SSqA@+VKAlj*Smqobz<o2fZSLf$S@bfOb
z(rzOS*Q<^1nuwpJtI5cTj3rxe8slUbza5gV`ZZ)HZLM-^(rwcNs+&z>9`{C^qRh;8
zsgc_i!O~=8oMIZEq$l5BA0A@fpB(NpHV^)A5@UJ_|0URXNg9rrppy0;pxjs}YRb~G
z{X&(QMLs_7+HUz<DvT4`?5*ep?LFuzY3=vtl#b`Wme^@<L~eIvxGB8!QTk+?zvjnR
zNwf&0A`9O}w_H+*F6F^aVtf(Tvm&Uhb;a<s&p){bKPefGK~Wr4f&CD8V9<XDv_VcQ
z=?;_P0j34fYi}Zh(mG>GqmwS@Hn{TW{L|r|M-WIVhA<f4bDdA5M<zZ-=w?U5+bYt!
zQk9N!71z2BJ9mpd{-HRs`E0tcQ2Q$7dtw{r%B!`5Hq1}%rC&FBl@ULE(xdU@vd}l0
zSNL}RiqSz=-Wohv3Z%=5&}Pu%MZ<GLJ~JE)ns5(sJrZtHKVF0&zX6HRmf+q^O{qd6
zIPDimMfxxp>$BEo(v@f#I9JX0pvQtTRi3@{uk_5@)ulob!eGA|zK9{eGJ;WS8s0t_
zH5?&sm+2P~p+@HZj@p@ib9=VaVIzASnxQY)TU7Pi+u=B75ao8?QW8`<)1M6vkQPQ5
zk&$ttu*EPajymPaHnZr;d;1T3!i76nMzb~)Viw@Qt`}}k4yuD56@q_WmQO`|39gd&
zH?vT21%nGD!mKxq^aCSdrEjr481r3xS9np+nTG1Qs*?UVhj|0nnP*Bu$Rq60G>aA1
z+gPC|$uGW8g0>TjBgbhHX_Z7hu<b1*?Pe;o{wrMNm(s{sUBuFAx)<+uUf}5Qa;Slp
z+!ozt2oPjRkmUhH#0w#1cQPyujYjVxwouXg385DH$?W2L)q)S!Xj%0z2vgH@;(q~z
z7)-|9W4IR@A-Fu9kVl+F?9vj)hP?Y%A!)&g%ZVspBPX>Yu8~LqdRm9m9*D~!i9zZK
z#aCUBiApla8&HnYo5FLq!F5g+Ia8!bnsVbkHu^^E4;R1`uQ;tlA`-Aw?2?g?{WN0}
zxeFA^L*I8fu>>>#?O9s?YU_ES1oaQK`G;Ruq!X=IY!}!VIw~7YvomyVuiD7Dh>rCJ
z7_+E|F2ey?BSKkd&?K_g9EJSNlKX=j+wo52!d^9>{seuaI%venUFV@AUWosRtlD+t
z$;^sLh%*|wKC`qjoa1L$(xvi2RV;~$UGD7p2XqU(m_$=B_$PQKb<!kX3od1P(2w|1
zufwezpJ&X)PD9!=M|C#dUVUk{IP~n3oue2WkxZ=&d!?3rg_J+q1mTv2;sWt!*XrqC
zM!(B@Y<L429%#rwn$v~B0*I3(J@^6t$W;SXGM2{$QiEAgj?vk2?%$$&eH9ET5cFV_
z8gUjp^D{e#?J3f(i_w-oek3IQ_<Q!{>tcCo2;H1)Kc&z)k(>U}UaRd|J(UfskmP3-
zHef1$_csa3h~8uK3E0UCxEHj86>5ZU;m+LcvS!=Z!nf_B|6{MLS_J>1%XLQ85x7d8
zV*0?TwQ=5*@%zssY0<gqI3yuO+W4=o=Qf>#j)$B|_O!0)-DC#40loPR$8K#ths`A|
zw-wb6NPq_afs%$B4Hu=23i`|bj1jI2g|#Ka+k~#B`bSTx-^f+7>l{w~G|FFEy9!aY
zX<su%f<>oW8c-pv4XT1x^zM$YZ;m2E?)y6zs?RN6+^fD}>rBUb8*IGORi3|$^)~RH
zQ~fkPp2$dp`dhN$b&<cn@M?|*i-SO+qd$%O%@hV}?AE-0;A{H$jKTB${k9FoJW?>n
zna!s=^A59J25QM?Qk3BxP|y$Ui+FS3#eomC`AG;sS#4x_T&?uGD#DGHRbeDY*5l&W
z`30eygjI+>Pg?=a3&#8g&2;r(%uZ48=rUW@=X|EyPymi+(EDejmfO5o2XuW*=P-T%
zJlHWwi}s*QGd+c|Fx7%9sf6(Bwd}1}T7FGe7DA$a@`GS0kXmyPg8LA?z4J{?>u_Zc
zMw;OrHgTPrN{{(bY6r{vh=x%0D4nQ46z%_5IC<Y-tDT8w-kS<C+$iuyu9mF1@(_+#
zs&bc@eUswyZPd>b;2r+&&K<x$ya~A=*=9ry3mH|RLAVlGxVGcgz^)C?+J{##d^<Te
zOi^45aWLkkaNN;{B4(TU_V}VAwNjVnGxT0hwVg(L^iUvh`{WoPE`k2|Ph1-607i}Y
z65^!h7bNYbN~>v?wdD{j!kJDRp}(e7y0y+MO{aF4O{sC6`0yNGM)~~YNVzMc%*J2d
zFGDW7BaraZy~fS)D*U|C#rMx<d_O)ehm@FTgHMPi0&~Qf3iBRN_{GdiW_H%6ba!<K
zLv+<^0n7HitB}nh90eS)26jKqey;EhDJ07aj0kR6U1hji%PD8)A1f}z_UxR5h#0@&
zPPK)9=uwduo8g#wq$fqU@SWo~NIN>l;<l8?P__Hr&u&?XKZMzPf6MWg)0kC|j*TGL
z<NAxnCp1`q36#mJNRbR3(~P_^ovlycx5?%?#Wc2|Uo;JQUHSMN^AqHe7Zl1X2m5-P
z+(76&Z02}*e!tg5e%`I(t;DrB=}R2OUY$z*mj{j1(HG&vb$JT%9tYQ7MdtIsGBPHe
z#kt@3I*<3;>t1zndapEqNP!wSxUx>Q<$%~(eJlGQQXmh}>rL<9a=riMA&%@Vk6Yd}
zv`pbuvGZ)S!vX|bxmyOxrq*E8S;0nsNjqrHm>wg9IZzH3-$_?qZEs0|?6GwXe!s|)
z@yKo3rMLl#@aunB%P7(YDe=aT-?a!NtBJrhD6avehMrUJy^z~1Ak_|kjUf3Nj(|f9
zdzUkF$`)36V2bYux61CyJvL7Wh$f3yh2-vSW51pFei1<i!WGTu3G)MkG1b7&J$F5d
zs6-0VO()ZLKT1_^^_lPYx)UJ4Z*bMr4L;ml+yC+9L4y5tm2eIx8%AIGxhFtw39JOy
zDIspr0AL$vgKVAy+c?BrI`@17-+Zfdw6{R5^r3~AZ+2I4C<DU@b{R?S{&i~!IARvq
zcvq~O-@#KGZ;mu@^^eBdd$u*bD5O(}1A(fq*grrr5?GaOzo$`vr1EhkQw)5#o$SfS
z1H+<aH6rLQK8+RIJJJD-hc4~*#%!{s`yx^Q69mnWo;_@eS-l&|RCOG~U%t?Wu%F$N
zTj0CTf&T;saY+0Tuvy~ji6#;{GcpFJheABq!m{$Bpw$k8(nk%uP&Aq6_O~0+acehE
zOtRi*!-FU49!;9${A>Bp_*8YN(eKF-_=SfL9|0fw)*hCp<mx>HcE|$kkRQlDtcuMt
zf9((f5ecWc(bdCt0}7QYlv9TiLdstlDB%biz*?{7eSCJXB&=GAo#)6*H40LU7p)pg
zPf3Z3Gu*pZKW6v7iw-UN3M{yWjorz=7MzI)r2ran9)4OTHoq-WZA5vLtLNy+$<o*R
zT#uXzg9%pP;YnK`WB=MkO|;a?-Y&~M`0AI=o+i>rGzWtrxl88T*nykhB@wkC4bs?8
zsr@xa41Pr@w)(JgS7}p}Ao(-Nlt+WjP)e#Q6iV8dKeGtUY18=)Q)AU~caW)o4{<J2
zMelRj+Y~;>aDrhx=Hq|**D$V+bZuCVc4c)|Wjo(oK?)n`9TAX)l-PQv7rp_Xxwt3S
z2fNRTXD0@6j27}>pW3Q%9kA_^2YnIdT(0s{tu0`Vt^tK1ghuf2Qw;nEX@Qni-t>zs
z?5Ts;j6q(g)SH#TaY!0PYgG)KwqQKN^&mG%;%&HaY7J){+R0N!4#{}-90Bg5;~*5s
zrDJ;Uo*?^vsRxo6(}J19U{+3U&LO0Mf955^X`}LcT)54Xnl?eQ&;TWE9aX5#HZVd_
zvAY{kJL8}#+8en0rp0?;k|1v;K18%Uu{TmKnG2hS4C%Gq@q>`SgzhE$cQ84XBptfH
zqJ0qV=+kQD_bbr#C>w~&y3o?HyaPHKyU%6qSr~+gC$8TE{-A%>Z+oqC;i1Di{1<fw
zoW*Nz?LnzW$sjKNLIE}LK3-l`$o`(wS|Gt5n7a4usQrNvVki+AgF-MtGCsIuIRCfJ
z0B%~g3jh)vHkDRQ#DjMnruiUz0Nx}~n;Lrld=nk@UEzmeD=)rPzq0MGuTe^YrjBOF
zBVJG`!{m>%HXm4`DvMQ7CZ)am^MZY1q*@Eq<T4Ll>-CKhJqz$p=5o6*;xRC+pF$s`
z4-6|&1ix5qLVa|>kY$KPCs?G+=^>A_$GvKQy{lH>h8N(5I*{EM$3JNOb;D77>zl*F
z{<kVcfEN#K+78Py%kH)<K+B5CO{kwDqA}PPD%==TR{Y#%-14F1pYgKuKG?mSgu_=y
z<LQwu3+&Xq>MgG{G{v-?B;%G+<z%RvA~|#!aPSAs>+sDLxde`pBT-$dreAJ_T3szR
z1*k0#pf&{%F&TL>j1Xj0Z+2>J8uu?uJe+EIjl_KZG*Do9ayJ#~4GA!maPKf4T;|*5
zf_BE+sc&6*i)ir^c~$beCPDhXe@<2Ye)VsRO&hEO62~oHz#pQ%@M|OZa7cJIais|a
z#8A(X8#-SOZ!9>=p@(vhneuG%Xu0q2I{s2?Tn^9}iO{XDIne=~dj9-09iI*;H1tf8
ziAWryfY{kk_j4VNOG|U<JaV$lARNZ}IYX^ma{9!Om5^YIOB81xSS!^1V}IZ*d30Fi
zr?mhRbUy_lDFzWGa&6)Bas7h#=E2Wh{(ONi;?bk#!C$#ox&|_;+?|O~o;O~~rjC55
ztmwGipg~3{(}zW#rI`$i(Wggk$cbPR`C1qaZ(Bvpasj)hXYQ%=IO)0h;#9Ud7ozw6
zVU}{sI*$w20ibgm{|Gj^;#2!M1Uaw_Mw(1F;zp<Gm_BS5#639GW->3-1lxZ4p<O%D
z<ujWg2=&3ik#u|pVE$HS6QubkBS6M-5-<BuNXfr=mEd0|8}`8IT59<kG|_a=`7>)i
zhg5ydrwtIS&R*=3Po#m{Kl`eoLyG!Zr*kbD+$7ego$jt>l*-}ltMsWuxk`4*d$ilB
zjmnFUbIRoBTz!t0bZuFH&eki$qF(W!;Tn;J?j)Z+hp!`Vg7Mcb7L3hhZi-Yn9LFRW
zwVQNFibUoex^FksTB~P~bQ}2<=rQ@O>T?jCPa~bM%y8c9t1&L3J~82|5ZN!Kbk6Rc
zjuR~s^8=SSk8obtlWX~9#e{bRapCJj9cp4+(Bc!7l48!Ugh`Jvm;U^=SxWZ9ayBwb
zYP3GMQ#Qv%KL#<?((IF$mv=5hiv^B&0jyP?nYQ@^NDpAk-yG6-ZXKUI^s(c}u-DX6
zi})1nR}sxW^_c4Uf0bl*EP!zI5r-KE5#l(PIR~-cz~2~YY@g2cDj)W&lRf^1gUiFG
z*e(IYEjI0kb=kMaM=Ob>fmx0k;w*U8XU4;}q*v7-PoJ)@=`DzaGah=Q`Dq>ANSR+_
zZg4#W$_T^Oet?!Jfa!l;M&NzG+~}!_vjOl#JL7%pdVf&9TZAG61l|t1cp9zZ`x5aR
zizT&Li`^I9Iy<zfzBTV`=_Xf~QGPy&hSOf>E+i!oDi#SRt8*3mW!P;hf6lj08bYN;
zABa<q+*HT6%6aIt`iWO`_O@1T44vPr9yRNdL3mNRvHW0p8ARGUN<{BM_eHYja^Wdq
z4O~gV27E4TU$l01KR)u_F|kGdP(yQq`0Zx?mWQ-$PYApE_CD85In$|P8-qXVPB%w!
zOz5RUiV>~N{m`9LY^@B+s-WsE3YZlknmkKSHTGP^&Vu|H)k9aPeyww9F2)Ns7V>?&
z%gfn<XP~^>7<yvK&*U~9yd1VSutId?(`dLUJF&*XI3lR2@4-K_uexlUf3FWatCZ&2
ze*;>azqM9?-F%whs@;IuLz)8`Cg9BRzAMCxmyC)&Vo0^39H9(*{#o}+bBIHxk5`k*
zUPXU+BRMi0T&m1JAbFj5X$)aukYThoG{sb2aHRIm=TFn^g+)aR(}#8AhT5K{d{1>*
z<UG1qVX=)(zN~Qx-v~DABz3?fX<(PYz%JJDE4h~%*bUqHCwM!??>e|o3_CB6spuIC
zR~w7j37c*}&0ZBMXa%r-j7iz8#Py?Xc@sl9zR&dBo!fK&qx!3x6u*+|_4AkM73EFh
z0SLcoeZd!oXGK=5Jv%|wM}jrU)N?&&IYYc=njcOtk!h9wIG5}R%T^Jwjf=`mzW|fr
z$4<pPTN;92k8^Kx3&eZ}Y3rK5$rLCF!isTsVGkRi?>t=m;~{OWSsuG-9Cky6MyHDP
znp+Jg84Yg~`eSIo4QJ&qvyrTU9?!sgujZ9Wn6~+_dh$_Dr<%1{fQ~G*C&WNm$1WMi
zZ<x4XjNnyMfvq|&v*UjNZ@I+<-v(?2-iQ32Wkbz$#}IdeG}0gvY+L-4ZNa`=6>TNh
z|DNh$kew71gHT!`Aar=q6p{c6Kck-BD_B|>w&?>0MJdnC2^OQWJCTYLmp5;d-GCsD
zfNFa5QU-u|IgC}nB4Bt%@(|9rBmE_z$vtZZt6P0V5xM#1-j6dsZLjxtF4Z2L*Ncs^
zDOZaR@40btQ&P>88mzt$u7XrkH8V#?vr=2Ox)-opztSzMHfm{!-U!en&;)Oe{T}jo
zIU45*Frdge19|ijaGS(fA`{8z-x6xZY<!C{+y&rD-)wob24}N)zQoL|dUV@tV@b5p
zQUMT6zaZ_`7ixCN3&)H-n&qD59r5W3ABR~yS1li;)D^xC`^+5sGBw4*I(!|N!V8?M
z6dn0hP13?2$Ahrtu<+(Ctn-)s?b(vS^OIb%g)N@e>5e(2?ss{lADd(S96QBx<_Y*O
zOI?PbO3MDJjkphz#d{8HB`<Mls+pr>OK8xOpO)&TfY&f{bwCzD%BYp~^Up;1z?{y3
zIW;2QT_VjXn9#~*sj8*<(V&Dem&Ww^yYC`aMcj8)l!o8cyaae@_(@|EG8|M@%HAj#
zY2{6j%*@{qn{_9PArnV>jMj<A+l35vMkc`@RMW*L_cnNItGrU6RM{h|2?QNrRECs~
z<A?w)oG#bHrQ&UsM+t|W_c)oQAf3UC-M5}%p{s(UZbKm-AMZrV6H9Aa!1Q3=<J$#^
znUBxJbR+)R(x|`pQ=KYLteC-}wgk;%x`0LS`)%s{Mv@0E8XcWM`Th)`6YdSHy(Yfs
zA}yE*Su`r%u892-%VpMhakDSmklvN$3Xa~JDIR5%H;#fw+kniK8xht`teMeg@aHY>
zUD?pWgrdmvEvCA<*rjxxt-QDI3k_7+?qfS2x_$KSfK0lU0L>N)V!TbtxEOJG%4((!
zEz5vLaQPl`cB!}ik#5;FSm*;Hr@R1lDw=xD^QynzuQskbk3_A4pz|wvjC5o{*}&B7
zQ|z=J1@O#HrTT4X#$w5lI^XNM3*eZby9_1_=-fPD?ZoPyxTW&sYEIbLi((O0Q>PY-
zi>5j$eto}NAo?M+CW!f4vsBfpuU`&|wnqi<QUWJ(NHD+=QBYtp`s029%$#Od*Cfl2
zS3OfMhyS99_eXk8+1#U7wf8G$WFCJHPc{~gKZW@>^@$k+McL;|u>684A+j{#i}y^m
zEQd2DYyDGeV(nk=4-)|mY8BJ~zvjpENy}g~@{5!p$6@B|hh%+pSeU*<&CGdp+H63^
z{NU-P=Yh>NJ5?wWo&5{d4Yd&8Esz&KOTdJU3lCKWmS$!;)f8FJW#kU0se!B*z6_cV
zL>keCd;Br!4aQ)>CJoLWc><`?E9(tOM))9>$l93)ADutgTHr(F;;C|~?EoEe1uR%%
z6tEx>rq%<<o{e#-=(5h)N<CNq$@Caz>*m?LYR{GC2N(9R=Q(od(7C_?#n`^M#gmMb
zg_VtsI%rCeEZ`wpBB*LNtuQjODMu@q4HRwFCxThPD$9daW?&Z~JssWz8)GMnDz|KR
zl?+J|5RfFcA4<f9%K4f+GTcMhV`f^^&h23Zc)_OR8iN}vpIH(e9Y@GPELKS!8**=A
zn>V?9a%-$TNp17@Yx3#4zT-iyd+XJLv)(gcq+C4RwCJ|$0N+IgP95BN9l)DjnkAkP
ztExhp#0rh*eUtb#9WiI!)4mM6f~tLAzs&x*Js@%tb}PjDtIg$C6|BF!a02fLPhx3$
zH<TZ5vkhh69;&gYoIoIu?o^x8?Jw(I5+ef!FlP%g45Mvtzp$up@>AhwO|pF^?(V=C
zIiAN3XZn@9_ABTn?aGpKbMN>#9)lxfKn`%vcMB&jBWjn3SkK{x1GS)%xf|QmE-50?
zv{Qy%5KG8_C3y<8K{;^_cq-^Z^n}$@|NXw0^XE@^tjyCz0k^1Yu(*aubo(i5E#Yn>
zIoC5i?~!063=GvDmw=YhkX9h&4R4XK%4yjyFVam%Q|sz2Y_k}$jUM)0$@{t&Ww(um
zbh5esFm4#$84(n8k<7^d)-uDeR|)gNaEWYXny67#1%13sLF<*9RZm~-tgK?MHD3N^
zbR9=<2d2ArI-cl<#7U~Xd2>WlQ^w@?9bbfrr&+N3&E0!?j670q9}~PKiR_u-#;1va
z%Q!+4!aJ}cbJUt>zUbU%gt<943FohZIMo3D$LV*2-OU!VB9oY@YdLaFJ0J?=qf7s@
zgsaSYxipF5H+)+qld4#EdDZ(yGjcK^5k=SBTMgxlJ#sR@-c285pZ*_vKa4!cj8aET
z$>LSwt6W<tI!}%mPU&80_zj)3q7Xj6vt+*w5p3*08SW1}<tU^2fu{r`PxCfBNiSua
z*4n5jn%U|%G<Z=xoy)Twb3XIU4vKcO5`?5hg<VoON7<an&6OyxV=@*tB=~pk)`=Jw
z?#p32KVAQp0&y+c!F~Z^4=)YS(r*o|Lqwb4<^gg1<!Dj&F2ixnwjATzl)W))oLi`Y
zvLa@?VdJJ$(d6gc4rB7Jz3l?tL(hGF-9sR~nU*?!>Qb2yT?U5VN7k27IEwVq<jQ4+
zXB#ZUBdyL8c5{W&8(STJgae*gyKN7Nst`oOm-78`4%pBHge8k0*{_!$3Y!GU8be>-
z^^Qz>b>Xbp26S_G;D5K*kZNvN4mf4T&ceW{<AB!}n|+K-8eH&ciqfAnyY%1~ubP^_
zZGXjWuFiJin`oC9CP0JWz%Ma~ps8;NR#fIlQ1zC(n6&o~;nK)S7VKVA=hCkidyM7*
zh0_oTVqGBmv;OiAHll6t-5i<Qz45Fl{eb{}?%VdtRCz4i?KwB#c9lIp4oY7-R+9%P
z)7HaUmysxGkcdTT4_+6BDBrl@bJf3W@w?1BI*{^KH2~PPi&mlpB|T`bQM?E2`ercL
zGJA<#Uy@hSoX*X)Iz})xuQT?Ves>I(gc1>Pt%({0q*Nz02qQ!^hG77H{F+tUi^yRB
zI%cxvo6kZzj`Ia-fLJkMr^x1VNA(O0j#yjQ4$W6pAoHgoB~_?3ND}~x3ea&`qW2Ra
zEj=L-A>|Tcm@36*@TuGIkf`+1ttOhl(Y4>@D?g@VM5P1@q7%}>!5D$iY=ngpB7zq<
z;wqJ(U>}Wxa@iHT0zWUeE}f=jZ0+oXYw9$#rO*Eih93qT%WhZgL5CRd1ia;z&g!a%
zJ!9FZ=u18C^W3rQ^`JTJuxRYM^?73wI+_v*fx0I=NojsRp*oYEl9q_zpOcZ?QuN(F
zZb^6SQTg7Nm&BF=;K`nNFZ)hIPhT@V+?!rlg<_6@&P=ZM>3<1N8x>5=E+fz^jc=&#
z$8DIoXsFCW6ifn>?%+yN>qd?`8g9ycV7Tnae2(%G`whc#cD_evYQPK58&_EEK_d^g
zhRzPgZDBvJLY_Ax6mbN5FgWkpQ4vx|G?l=A`I0vx?poW+^sswvHe+;Ja|gC+z0;|i
zF}lC!QXN&EjmCEjS}3HZ^3YR{X$!&;py>&#CB;V6Pi~O!)WR+?b}V>DHn$XR{89%T
z!~UDVDi!)X5?z4)`)DKn4f2SW1e44BZ*^<6H>X&}ui8RBkvCTDwSPpMAGDPZVb9ya
z-mLn{gBh`eFW!2NBrRXqOQLX4&#3U2De0ygJNqbIU8&I-?OAB2gMZ<}`N3&OQ!@o(
z;my2*Kmy<i8~<x)d?0wlTHFsjt}wDbU$oSr-cmIDb?J9<M6ONIXPq0qAem!FKl6hS
zB>)D=`qwg&uP-Lh?5wN))O+_%k#2MBQG!j$@ADwPz8y13h&e{hg$0c5^7jX5aP;x-
zgOiu2-$+>=!?e7=%3^tp(B+iH(*c#}@UI8Xl|W!*)|pNq%m6SWN>B1DpgCBv6e4Sk
zar!kTY;15OE@T`gj__Pf<EYwlcTS3uF$pIaiNlE}Qt{`&X8p~baP#C^w#pMr@O0UR
zzFz;MlA{@HvLkkk2`f_t$S;aH?o~AS-d<o#p{ZZfREX?HF2&ymECXrv^hBu>QQc-=
z3u#O(#FTjKY&5$B0NwxPS~(Ook;REf2j&#EjcUV^Vut+4w}Bh1EAdsd{g<h2g?dpA
zrwXW9GNIwdl+3C5eG?KT^Djf!z!6&F#z%jhEq7<ZNIAUdF0&lS$&8-b_b6SgGCVA|
z-?P8hv2Xm2us&}wnmY~g1ZD)nz;;<2Y!@SUZmy|C&J!yNewXB(>kHRe_EL5>tRfY6
zjo<H9TUPHSM2l*tc|I1SSJnkp|6tE7$Yw|sqoBjg52p>QoF@V|Jxu_p%(Tqk$5vkJ
zZSC2swt2Wl2V@z4ovp<`L4vZe_KW5{IOAt2jl8S{yA4heWZ%46sb_Cy0L#e<Y=kNV
z{W^85=J!OWGTIho<-+lt4WgfD<N~}vPPU=H+Z<~>I(l_>5Ib7t?kon1B@-VL=?|Mw
zZvh}^MzhtxDuO~u7O|Q@jE7WA5?zBRhyIJ!p418p1xq4TqSPZS{2dVXMcM+e4PDEe
zdx$f{JJ`Lvh|vjOL!Q4<$+4m>@yLW}vu)=|dS^Jz<F_~Wb#p3!;cd-4;KrbVGDY;r
zfhm1LPzSBU`Jzj6#zZ73M?Q9Rq{cbyZ9g!%C(N&iHavbo*6yCh*)kQLKLIk*k#=*b
zHa*um3hVeNkv%;CV6D+fRW8q{$jGbxE~rz%$v5reV-q-vP#Xa2oASXI75&T~F%XxW
z_Lm8IM|Jp}K5XwPlUwp#*a=ZS2i)4t)eOM;0l9#e(KJ1{>?bI`!>ZFkG$dkCNxZK@
z^|GP=txpU9lPt1oi7pv`a2%b>oQ6amZ-&G0jvyy|UDIJBrE&gTEOe)*#QtRaP(#Oj
zQ<QE^pFvr}@L***F^vcDqA82-RC(+s5GlnEpy)|cF|H(TQ`j5A$45h(x*V&Pt&*c(
zBb+SZ5>$D8bfu4`^xPn?4k#n|Ngw5VAuuwR-8B*%S7D4^RNGriGd4XldKY$PqjLKN
zOHIuakVZcPrs6$F^kI&xYa~3P!qfw(XU`@4@P0(#P*T2*^~Z*SX6%QKX`djLjyVs(
z_PAJaYQ9K4D+;_8k*)}?@Fo>XJP3dWGe7T5sMrta9afKj?|Q_zYtjE`#~?H^aaN<Q
zyZ2@yu!R$V-a{ILIN_#W+fAGfkZ9n~KRRz_lR2WoSe=g9U>O}uTKW#?;{_=8NKlQ5
zkzQlfhSv(qkt_hMFM>93&#Q)m<K1Wze4JE6ZF`dD7W0QfJozo7L%FYhefP&xC|wo@
zu7TF8qeqK|fz*vL5<X2zi%HaidWS?M#{zhaO2fKna6mRx>MoWg8!931Sh-i!U0;hQ
zTZbB%w9P=v50ti|jIpsKBP1*#Qq@%buO*QCQG6S1=`ZQNvd$aPP!}X%<}4O5RNviN
zrvPZ=pg?9iWli9_&84%T$o-3C<y4EyXLIvC;b!ct(gXvt8kfSwys!JPzrG8gcdyz2
zTf~4~x&kuz-#7?!A3;4hjB?i!2>b3o_9~pCGvvcsQT4Lo#l7JwuGzcNS8*67zzb-n
zWsth4;Vcp^Hj*~|_mr0SDQc3h1J=`SKhNzbXJKt~?6jb3n&XYN5B>36m0HqDIE*&&
z&Mz5JME?zEj()>Vy|Qu-u5}5;DKq0U+Z|giy1%<M!5{N7r+?$|@2fBvJ`DuvcU1oM
zL`%o0AS}zLo_K(<)ttjIZtKnS^_8xR53?WL+2~(>WN{(~L=$39taohYpplIgT54C)
zH0u_I7<Dh94YDS=f}{Fg_-lux4tLvbLnJhe|3F?bn<j~vA;pM0<n;{=PnuyFhoLB9
z$uu#!K<2PA`Ct>U1VxRM-5{~meCl@oqgRB#07#X49lxyJR~pUR!5v1gJnC+Y-8UH|
z^jCUFSL|d@L!AnsvHu5&fYt~ncmSbT<<4oMc&HK?dAx#V#PjJ+mq6rMnG!cON0Aga
zE5Mk`fe^-epuS5q$3L2~Iiz<NWsr5R1*T^>>mv{qTitLu!osqkOg&-Ut1>3E8+05L
z0YW|QT13)90C~pb)LzPx?sKZD&4uzJfUQ=#zL<Q>2L+S$!u}y9nuw|l&z*V7a%dxK
z;tJw_bZ-8Hp-KkO3dv+zxUAWynYGd!OCDB3Ns)Xw3@-3GcB3DHe=$<SVXlF#<++@3
z&;++RJyM$6>=cO2de#K9f$8m*_NE>Bn;Fms6Vl><uMzzhhR-GpfLzFS^=1UYm%7<N
z0Qz}NYM``TW{i;Jga>_~+#T%n3_qv>O+e1@PBu~^<uoeBo{x{Di7j~3!+}FLMgW`w
zZR1H#Q=mL>6@-QbfBIGeg@9Qh)oBcx0^G??%XA=B_zjXZ=tpse)JC?yzY9x&j!ID}
zR=2J~?S~_Pi9H0<sO#mAIY8Xp4!?gmMHjM+VD3FO9(aGWnML@5y=JYn#ceHp(5Lb#
z8D3X4dX?iyN&APY2ycWewq-k-s@5wb&GPL8)t8WF!`oR<#TM}2n)&`_sV;|rut@Kw
zH>YH-i|d|%Bc1}Xgl2N$0Wk%jHPQ$*Pmq|mgjmL^fxYCdiKew-n%ryGk6onHeI*ii
zNrvNY`2~>Q5!IlZxO;LGBE>T_0-w~7Qd?{rLYBtQsH%6U%|}*?3A#BW<6wGj&ZB7+
zx=Ay59fw&aPLM4FPnzJWkf@m0`mQpe%HF{&8#EENoV~%x5{G5;${h_|Y&p~|=Gdo-
z79ytWv8)o(=*U32X@Y&A(sW@Q8CP1nEr;E6FWC#7tq#4cz08$7)R6*()=U{AkSZX1
z@KG9w9fVsGe5mYeAR*e~Ei=iH&Y5+RlS;7fbfo~9V}<?jUX=6F$eo_@Zh&y>jII$Q
z#n5dno*eKPup+s5B2vvgHgZUUN4ipL{4UJdq(<Y48+E$5_fTfs6;mb^9A*Jb?Bh%R
zFw(@H3j>5I<$gkiRb`~c*B$tZ@q&+acP7Ne|LfF{({>?}5a446gnHayYT=36S4mcN
zh|X=Xa^cmO7sJzmvA#D*@6ERyRgkw>>i4e#lQrKR^$Z1aWX1Lbm-Z=Mnr(0nXVjAc
zi4bUrr2)Yri8`TYl(0Nc`1;Pc;VvwTr+P2PoB%2_-!e&HA)w7^s&{GQpjv-IKG|w;
zNJDhludd`lDP7`Wm^h8)TM=+EUrr6Ea`Ztkx74URxVQqjz7U7%T{RE=O)h-ffO6i&
zE2N{`)n3SRBW?@28~W<1|LIyHxkplG(XtY$DmN+D1NW~XCo;Z#>>riL)#LB5&2(CF
z;Z~+pp+&m-ngk$*bTDTE*&R^dn3lxAgRuD+G^vO!IO*$JI@Jj0*SAa>c&PX4PfX6L
z_3p_{E?EI6Ap-)ld!ifB4w0zOCv&a4-6R~H_#-E|J3}PB(yH7((ctnaru?~7eZ_}F
z0bq0mfKl`{$ck3p3kO-zms;<ThQz~GDj=y8llD3e$-+#qmB$x`?KkG0@&+-0yCe*G
z7|<GTz~CMhs~p_*5%oq=jN|k?d34YO+PAPgAzj2skMn1wN_JMq4PO-;)rSi^Rjb5w
zF$jh@!+dt0DCGgdO`=PJ;+ngAkyX;j|7f>!Uk2JQda~V*NR7_s#O^2fCxfD!4`AR#
zBm1I*rGE=TI}gn73EOf?vd)0@EU`fPJyF^(VUBuNF}Mox)xNt40{aQjApTq8gy}>y
zgs1|dft^Cbg&nk%spa+xbzF+Px}&@{O_sN+?Q<%GrSETJjbD8QbmtwS1%A>#h--dy
z(XWqF_rAb!PEdO;D^%>jfJN-PZEn6yU+S|?fuclm6cNbZz~maQ-aK~TSx7)*s$dpw
zDtv2#8N3j=`RkMZPAbUuUMOeWzdK2oL^TALb1TPiQIp)@-G;fEx{0>w&#vqvptug>
zfd9G~PtbE^3ORhKX+;O1(Jg8>mKT46Ow0+y__&3c*{5^3D-PmkR!5(zZO&wD%377Q
zSU!8EdVC>yfLwN34T|z<iqpm;QLp$wd+22GhXW9k23#|V>WC}$IT+z}7l=*xb?xxo
zZD`450YL75cWE#{M6q$?hHvGL4W^4lCxoTQVA&SwW_G6P;)F8i?VBl(5)1v|lNeK?
ziugp^0I6Mw{J<ztVs#ADyRVylr(wSC{P6zHqE2n7TyfJq<+7?%N~tv=aYK^4GAO5b
z3>k8l(HcYRObUSC>7(VOVs-pa{hEK^N{zc7H5TJ&4@!Zj=0j)SOeAHzfZ+!K+H~aA
zMib4PmQTkN2zHnDcV5=%yjyifT&EKPRP(hO$=pLSXNSBRJb%B65kE|oo=vL^ydB-!
zHVfooNYoE~Q!}6d$RB5E@?UT%XAr*q-16d;-iK-Ls*;paYcq1(`;B}nL5yhBC8+0n
z$^a^X=vFFp(X(nwEf;xK_|!*Y?YnB8Qgr5&SG(8}ou$<qIiZkP_IhsLB(Cx`@mBCc
z6ZPZ+v%Q7PFK7&9kKs=ij;NpwFk{Bh*t(tgzMBL19>9W$S0}kE<1qAKU#|J+^AhWb
z#Al$wd&SksD(l%$$Z~m$j<34jB0<ex*LXSdBe6C_Yxv+2?kS}4AE@VEp^4QY$c?6y
z-$g!@y1nfy+5j5v+9(s3Q0^r@RlrqzPt%si0eKDp2I!0fQ9I*_T-$y(iO1htek%0X
zX-y86&o9lFbb7(6+f*@y8N+_2r{e2nAkS@xvIAmc(c?H7mJ6Jp1i8Tar&SYr$tiL9
zNqQ6KaQw5v{g?c<L%0$^C()yv{i<Lg9)|Zs?#eec+&pvO8}xYf^4XV`mK+osr}uAV
zl--4Ccim2TDCius&qZpz<10Xr_#LiwgtWhD7}Ez21it}@qj7o<fLSx!tX+%Eg`wNj
zC3aa6y`Ar8Uq_=xOQ)f0q3}4~HhEx#rxmpmh*l1|P(VJR61-7h3B*DVwhCY^2`0it
z3F*2n?{-Gz`YmgTeSTH?CC#jB?LSzE)}(xEWNDOCD1L9E@y>VxQpU;zFUQvl!CAuR
zt<8f1K!Y*NALmN_kID>aCuC)r0RpsxMH)=(U#ue4M@?A;M(w2!nnJq2U4)S$Uk8}f
zYv!AKr1ldxkmvG=&vobIfG*NksnEp?wv5ry+TR--e7a)seZV3L3WiQMFwhB|z@SCo
za=rhz92z48e0r{{y=(Wm&|Ao|>ae5NuTQ9c$ua+O`ApagopW+>Z1<Zk5EWcW0Kq(;
zoU$X%3r!nL7<<<N`%0r2Lv(l$wwU_U(`iGTL%T`C`-7z9CZ8kIu<J48nJ3H5|1RS^
zqVl-l@K^2UImIt|Ez3HfhB51CW?<ES!Z>r<o^sc76_B^<261Q$1NZ&8y!8Ysvahq~
z*33K@?MxfVA)ni~=L7v0VubzsR0{eMJQg0w_IqV2DB(45^~YzMQy}aE@L}Y^Nlc;>
zxb*uM?Sn5H3uK6%wKKkWZ{6`Bp<3YM^SiLS3t~&<3p^X$nyL3{RtxPDe<E^fk@NuQ
zDD(A{k%Z^XEImcm((ISM?}?=-ok6gOWcs+2myU074%qwKSDo>WxqL=XEDbP*$C1|<
z04lf!ay7TC_yHK+1lfk&Oh-qHQ*ObBO+3&r5e!lP1<l~_uB$81ylz0hKX(G3`ga9}
zV&rp}StWTQzNT8Jtnn^PA#$(Zc(Z>RKruFQB<g|*$Y@(<yRMRq?uKc9@v_61&+wf{
zruAf<hf1rr_4u>r@;zs6g-%1x&tAEJ>NODLX+HOb0}<>CK<WalqGOc}SpTM`twl26
zvl*kQ34M2+Pffc6C1*{0Quw`VM-g$nVL(2MIf?I51@Ed5Z2JNgd~K@RkwoC<_zHUU
z%VVPG0*e+ny;wvhvFwS{&|Ue(DM>ZgsOB50Ti$2XjZ{JDN)#nURJennr12KhFTy17
zLnL)(uJ#+K6D~!h^Au76)bR5=;>1oCkg*I4R5LA$Bap9w?7i(r;|x#?Auj@vY7a8?
zvWSr2wuYvTM3lkSL9ui_>bFpVU{G1-%jQ>GKN&ipS!Qv74ooG$u8$53fTk4QfI2hV
zfJ|c+w%)r*#04#J`{|1>t=~6Q?YRgIlt&H!crBo-Q&V7hO6*Is7uB0fKv|NYMeJ<B
z5kpKD&;eycuyL6@uqW51?P6(_8-95?572MSnC0(s-C<L&0p4v2G(bICx%f>`-H<q6
zK$&PbBYzOp7gWf2ne$|ch;@|@pgAbLE*%B`8FPbAJ<(gtwm(u8O88(>TNDl4?JA(r
zX(*>If>r*ZKQgUJiIZ%w4=d)95M=^Tk@Y8Y_mMNXg@xyS##L9&FORzb;qqFE`nKT-
zgeB+*5NS!4Cm9+D<U7#A3pgiuoH%uJa-FgSO&uL>cpxZ{oeE%IpVjT{%r7;ICt)2x
zeCC$;Q1B)ium<dwMZm{H!A48xwGsKKSNuy$X5MU(5q%C3hXqZ!aQH8NRVPBzcOJhw
z>qJ3c_HbuCZ)v$91>$9Nyv_4}q%is>-v1~db13(QDqoI{eEOnQW_Vw2Wpk;j@aJar
zxhE1pCw%%eIEYbe02tTLr+{8cU9ivx%s-iGU=K7HwUz<}3TP7Fz>KO2=@l>CTWOgu
za+nHPY(Do+OnlMj`MEcpmvI;)kbxf7UA0DCP&EA}qWvy(Vz6BHjy%_Ub~cIOz1;Dg
zb4qQ81HZ0!mpVS)Y=#+n?^NS$s?@80f7O%l>;c@qHb}@A4kDVQ<+0_~xQc%$cl%vv
zU#MKB!m#4uZ|bJq*^~`&6Ad5lUrX`~XtkjHloGr$_6SensM%<csP}v$LhgY#yDbqs
zsOO=v2o1!FvbHBwi6kiF#3~+}JuLRi$~Ji!Wl-A;vnr7q9rGPs$V#|XB-C>6vl}tF
z{3Ab7p^bK!bEEv4r2TL<5@6{kYvntu)6)wvQ)||)g9f|A-a>oQr>LHR(!ArGaxT)A
z?aSV4oq2!<0d)C%rY8b9M%?rB!UhV7>xf9$XRaDScy9h!t>W&BuQ|T`#lijzyeTUJ
z8rNjVB?s*@%v^qhQ(nB53+neepypc#@a_lbq9>llf4_lnW>}i!-w!A%uTHFZ{77uy
z?*XVIBjG>4el#=7Isw$-<xZxxif(UHanq2DzBH)pPJ-QdhBOeTd?jQ`38<Rd&M4JO
z>&n+hI@D8Z=Q3p^14FiNSwBwXkC&PC$<WP$xKOqML9TPG)Lh<H+Yqgj9RSTIz(WpG
zzPF<dAnMeL16J)?BLrj}RwM5(6liK%nAx=)vQkjmBnt7nvi2ElSVV;V#rho?IU+@|
zE?uioO@uZm5Waz@oK;flNBz)48zRt@v{;ykNjNM(PGzgaf!H6ycCPUp$)^EWX3bkc
z8n`;$hp&K&Py_cl2Sygtr^Vpz*Dq5D?g&lH_j}K?V&DI^9UToNhK(V_&y2FF!po8H
z9+*R=$x!PZi~XlZ*`K~B$@mR`OcV~gH_IfF#iJpBk2yB`e3mx1RgTLh%aLRIeQ+%G
zo%2rL5IqBYp}L^Bp`2gu;<X(pFJZ3QQ9CJobfx)gw45~%rg;KM2Ie>z%>B>$B9vMu
zMJ<x@R0b%rRtu`#Fa8qBwkLii=JI7vAn^eu)~pxIU`nX&jO_6fps4W6mqgJ9fU{8O
zb<}+>{Bi1Uui+X&zwTBidpcBmoK94_g`ha1<}2fII(+64Q{24e1FT%PR{Q$t&X3kn
z(~xRlY85zUPyzA;3B?16)^%7hEb!-qnycS$Xa|ZRr@bbjVp~6UDHhIrc&Jqt#v-ie
zr|HDr;v!zf&Q>6pWn~E@ue8-*h`VRMUqKWx<x-k@UD<$kht+2~^n{vKM{HbG3zhN^
z-Pu`wsp{hKW-Dvm#LijP1|?r{M6(Deza|^>j#AS80!Q=`<#=^Lf$2jK$l0Vjk2K^d
z8L0TkENt@Iuu)}6Ak%5M>Wjlt;_dbzn#<)oy^y(UOtWIB_dS%2Q_j>5gWKNP!|@6^
ze((tJB}J}Nr0>(z0y5wua^@fMxl)F(`>o9g*7~f44MD-z<Qh&i;)dhH2H|c3eRBPK
z!>iD{hzNBY<~FiID(Cw9!k3uC<Sui$L-}fEO(A5vGxhb=>6w})g+*Ar&4a?^_C1fo
zkM3HhZ)|jaRY{dvN!hTj{V^Ut1n5nR0g@c_@0J$d4O9PPFyCHg?IkW~GcE011Y0^G
z`!>VqOZAkKwzto}cAniSa@bhtD{C>T%%|7!+&7sDpJK4DILn#OAOg+^040be=mebt
z$hZasFsdY>%#k@|0(Qqf4yD2B@SZ&3c64yz-RAo`v%A~r`yfVe4clyBi5e?fH&E3s
z)zs*Mh69nSKW}xdZf_h~GjrQ@8^7Ij{ej;D6-J3i_atxhQRiwb8#e(=>b+;e=U%e3
zb%_%9E||C?mBgrdVCNvo8u-q3*AJC<AAx>y$?dK!R#{aMifzY7!Aajq*TNc3<6m~`
z-P08k3yY(*E}+2dq%!=m`@xkc;p6~pz}5>QhB*Y%JF9$C5%F|Pm@Pu$?AbOU;Sl)|
zb*ww{{zSDCKZbjhFZmcXQ0~s`E}8Lq?tQ1&r)J6b!MxQzZL$d@y~W&eC>WrX)CfM+
z&fM`JzKY=IdXjC(Qu<3&d0U$bzd7zt%ROdYpNl~$g>E-H#4KocI`3{eMaOYat0!!0
z8EDaf3p^Ot=l3oNxbKxsLkgFmTMKUnA?({FVvlc^-}KOd+A$G@7azVr4!VQqzS_91
zT!cCxHxZ-CnWrkphP1oSiit6|=!x96V$C)(ri5lpWW4sLK&h8NrC~MkjH$}9)eUGa
z7eCTdmoLzx+lYb>E@j~p7*jXAI5*6%A!ww<a*zzZ-;UkU)SJmRSqBUHgrg&t>!-Z?
zuRB5Vh^$z!Oknp!MPq<ClvRGDS$r@0*k^%y>jG{9b|ZAb7n+4U*)3KI&nS_ESW>Rr
z@y#!^ZZc7VR>n!UPI@$LB@R20bo9j``m_=p4{R-DSR|`8l5BT5G&Ej>((U)>_#@S&
z7v>>A5RA_0H>8LOWv8!ME>=BTYAFX&LT1-Jkn-ig?(e@bQos?yK)kwIqu}0Oy(Qi>
zTD_IC=+`Pct46(K^`21k4v9HM7ORoU%$-LcNYqq|rhy2PXr9fBF-7A`hKngjFs5Rq
zn=NrJn_T-lJA-l?HE~iG&t+V0JoI4f(^Jh>bu8<z(<}@D$|K*7UCRupc?&8*c_2on
z)yG`$$8;cz?YWKu7V>6CVd=fSt+|4UC6m2cu3BilmD7(4`wC@s>p4p^!s?d9%bBMB
zMWDpcA~;9F@ObhH0j}t8hrw#{n=*qDt$p-%7W2U_i^Th2mo~68P!r@S=eg&+K^fXd
z{l@t?X5J$D0fo(e)PtXEu`s+h`CQodoL9484-7`;OL)s08ZTY<wjvxKh_<EQ1V=YK
z_NM><5|xu<m@LB%xz*B#9rv-n&9E^aOQX-8V-nS-??3)5jlAU>s9c?K7eZk8uYj50
zKZ-v@YgL6i25SyoZj$*Xd*L27Uz6+z$7`BYwPv5%!SRV95BqaBZalB_OwT#RtoN%0
z0kXdY=5?{!2skl+CDLJ?M8gM@@4g!7sTTmg&b_oQ<^AKQyneYk0Q`r06Xwo#?9~mt
zy{b8yRI6!*-3Z8@3*Kh45AmP-^)a6-PK{UE{RgGo-j9WSeUE);!ZL2DWZ&GQSM^zO
z)z*UA40bCj^h(s%rx+n*evA?)u|UlIh;yBY-EoV6f%8yARe;4{tDCIyPn`bv$#`e=
zBQ`}k@z7Q>+si?$@49pAoOebnjoW<Da_%Fgjn<as+@u}e9jMsW;zap9M@PXMs(ZU@
zO_WdPp6(jBLZ3i$t#SPnk?^$yXW6c;PhFFe_Ur+N$O>yKcX}!Is`nqc0w~|@?Y$>5
z-?*R9DFR=*a;H1{+0sMT$$DSv$i)hcW$kaoqmiVu(`aU3yLu<zav+Zjik?5uJOmDO
z?KX?M1ll`9`_CAxzm;KQdHOt9Fy@sE_bYD~zTef<K?U?M1%!Z<IDT)CN3nN^>F-%<
z!Y*zsgOkCRDA_%+{HfuLFUv6NpN9P*N5xMu=Q~<0O<!ro8lY%IfbM*BegMEF17dow
zGqk7FIt_Ry@AI0+ssbr#&X8ynZ%_Be@<GK!X>jzosenk@t$`M2n(J<1JjNC|Bu<ui
zG4HzuLWKHG6HFTQS<qpGK;+n8B%N(g?g!al31t6xJu6DQBJ~{)*o_?p^CXMRN6n0l
z_h8>zBC)rwo)=sDfP#Z!;q8YT|EjToj6OfEUv9Te7WTqd;StK_Ojul1*gW~jWwZ{^
z;<5u>hD~7*48IA2|5(s7W;&}(0<V&1fR&Adb7nh$hZiI(iWUYwJteZ}9gsDLd@!Km
zwZJmp`lzjlw#A=H0CI_SRNGD&mFMoVR?o+dbGWkloG<g>4ELAzPEhX!5|5!=(T)M!
zD`R8J{h_Ks|A2Ujcy8J}OtFvUer7Z5)RCL{ss%gP{I}f?5&!zi1RCKmuYgAHmq6hL
z&K)qbWEEta{CGV$M*MaF`zk=o79?f50yiLbvP;qcR_oCk3GjklTw6Yg*CRi|`G(44
z-L0S2+VhqTz(HpeZzq5%UYk(;Gl{A!0R#%9+M7Z;5T%4q193PQ29;lmPlpR6P6g~<
z6p&d2!X2R9GiAhgn<Sumvzviw{7?t_*mJmTg{&AMS>iE}Wxr{t`FXZ69a`f(2>CC{
zz5<<KDj~f?R({oInH%3oz7FC7#S!HZ1<n-i*Or=Jxoa|k@RJcpGBjWxPEykL7>#_p
z-vqnJ@|z#;Mh++=R(l8f2fZ=p_c^Zd4FIYF69NqDk~x1MQJA-0DMl2t{%GDWG*Und
z<88)^&Za)DXL|M7U<EW#iK;)gaJ?SqC>W3$0Y3DJ77ej!^{rX|5J|!P`9zr4lH(go
z_B`bxCKpIu?Dw`R?*9%*g6O%w<ll>5d<gm_4^cfdq9GFRdjf6NzufPDG-)bj8PH)b
z!93N%0zqmM#SeO%t{JV>d^-3Obj04#HinqQ0-ljEPdSUOx0;Q33_ZbMU=0jr7Yyci
zffhX+oMqeXO^6{EMaMKz%Ad&f+HsTc9yo1t6L~66@tgBT;u0y!je?NrSMrD#jyOg2
zW_p24bi8sPAkdCiBbeB7GZy<j-L>txU2Sovg9GLcnwr93jXsL<`@q0CSt8A`TXB@G
zw&$Zik>Xds;oqy@0N3L1e>Ky3F#+i747*>MXXg;*86&Ay`zb2m=pGD@owB!M8+i}~
z@@Np@#}7RRW*}xzPT~NobgIQ2ICvg-N8L7m91MKL1~C*Wh4j!kP@fiI2)G4~C-c>Q
zZ&bY70jbCA4>$JAFcQDj1$<G&Y!)c}-BG)BCeh?=PwO<1?^r;Oz(%F`F07s61N`te
z`Z_5WxBfny#tZ_EV4~i<X7CWE1@IWEK{oD)edUB6uLT}7Na`EPcii3-g(?k>=`^hO
z?Nx`|>;S?|b7F~jmcLIPeHNd$FrZcdqo*!gxTpxs^d@I8<-PYD$AIui#`&v6&;{w&
z3OLZ*=7v3B7H#Hf)56Q`_S*DR_J_Vtsn@N3EdZjHrdccJaCvjE!<tM}3RJ!Q;jE4q
zH#j<iKaJYF-{-?OLxw+u0y)YTyD{vM43}vqM@&-^Ij1n=A5F8%Z^q4=YKhS;7zik>
zJOiA=FkZlME$7HJ5*+TI0S#{Eme=un0)8TnOpPf}f~;7abqp0~WnsR8wLPO`GE6Cd
zI?R@DeG#I#2bX7NZa$HlOsFb34OAB|4UMM|h^JKSQWrUjtH<VN672xiz!4M?-tX*4
z@^yYXBF1Hx{`FLzXOo{t^a(*f79Nr~)fJ4K+pm7{oOnn_6m+Nv4t5KGK}6%{<Z;lZ
z++#5(XbOawU?e!R2;Z#Ax=DD@_T$;YbT08wfyq;i`zPTDF`~fcX6}Uu3_pV6sG4u}
zvbYU@q)NqF!7)Tm<wd$9Sn1B^Ex!~P5v{3^{f3TMps5u&IUG#4q*-+K?GHLcGyUdK
zC`q?QASe1zTV~pfY6m&9AeohW!1ejzie{ecYdS#NeIN9R-_u!Ea%)K8b<1L9_u{H8
zt`hpl)t<g&26H=oqp#-F^w}`ose*@2V?NW+<H!8|fMfZ;_Od+hk|kD_Erj!YvP2od
ziWYwuS?ro>jonT^YRk6d<_^Q#u-o=e+Rni42m{IxV}kI`U$6Ul5-5mh8!sYv%dxIX
zJynCZaQwTS*T8XBUxgi4n(@i_VXB@zsDyJLv^)OA!~3Fkq4~j`&^wkfTuZ4R%C;p3
zADIbrntS-cJ?8X1Y+CD{E*kgaDldj0PTx~4HDT6K$q(aW$$JqFp|^Op?k5L_bD1Xj
z1iK_-xKGYMNoFMrGNa7(JA1YV!E91L{&DSw>(ra$1$oUOgST(5RZaaqlb%+k6*uK2
zr#?EplJ#gvQ&@1lZD+C}-<A!KgR6)Mv;K~bE9LD?#g;)wAba(kX7I%ps|W;cb&{VR
zovVl^qevOsKBZ~x8IcMi+1141#m`0El84d$UYZY#owbjh++rv?vv&a$RUddps<S(1
z{M%{K4sbjL*8r`Q3nPoK3*ZlbBh<*!JcIaUFd2|;nam*|muV(P!o=(oM;WYwFdtce
z@X8g9w2c*C7?8FW0;IegGc!01IeYrvanEYKjkOOM?8_0)Ou&&212h_Db@`?03ydbx
zWiC44DE5wQU=e%}&<?qnlKy8;DTEH`jWTPySm~O`FllP;pEBt^bc_{_C}N?7{iyN<
zx#l)vg3EtnP`p3;TC5QMI2C)<P->}|jp6zU!#z0<Y8tR%e$*(~@gdWWQ*HA2^2M0o
zlB&)Y1qP4**WQ=EQ@ut1AE%?Fh-4^<uA&q&D?$_9jHwVpX)@0lJGfm5;oek|v8&8u
z=JA{|6-6>TI3mgH7!Qu~{;c=gz0ddi!{;yfJoP+1Pbd4l-)pb6_G`WN+G{U%dY`$w
zt15&k#Vc~j$AyFt9kH+?(I!?LydJ`yAD($@Ut+c-kH|5xKs^^uvbq=IH%Xn@Q76Mq
zIU4vk+g`OvXf^}=9z>025<@@!9*mT{?oR=n6k}o05c9gVmCGbi!#jeerC!VxZE2Au
zFakM{gRGpw_g?EA6ui`WN=WtRx?yXl03QpUV<#6*J}oBYbdm#pWU;>K$R=~2v9pvE
z$7+J@{=DITLQ22yM3Ag=1+qI_GrE_lB`p`P#ZZ7w;U&4aaD_=9Q_d%S#J9Ee(;G-7
zG6Rg;D!X;33(7i-$u|NPr>-^rt-?@$Q*26LE4-?K`|@KtRweKu+ow<N!@|sD-MUmQ
zy)AdoYwIST!UuEembu?~uzEZvU76u;{<awIE(RL2v*9epzNz2|wh{(Xdl%EG{Q_G!
zm4gdYB;_X`vfKBzhc!v@G%FNViN<s;xHo)5M4_JqY%VLS18{?j;i?aCfiKw>eB$XJ
zv_^*`RBqeK-l#e7g_9+fr7*drrr8xyh`N|FHiR7}4ufeQQ%zXmHYfX2<1Jo;Ck2Pr
zg<nK&ZNeXTY8*-qV$G>=l<=wAh736MN;-e}+iZ%s>BUJF{O{m{znAffYKS}|b13OF
zq^egP=Hv6rc-m+#gy-M+B7Um=it*KN>!;NmnBLxW<e3rTG;c<RCIaV=ir~&~&w<}8
zGe#IFOch3kEFJF!1-O5g;4V!ff15~^rmK+d=8_e<^!T*ww%StGIFGsE35MWThGCiD
z{)U0BEN}JwZ(r*3rDi?*5Y>1@bMP4+e0KLpYLz3wLdt3piMFGo*T(+e^kla^oxu0`
z&X_Zz{L2p)+tU)OK1~@^zrm0E=7fEXc<`8t*<Pmqo8{VERaNxXZcqT}&r63g0jv)a
zmUg8Q{FauL8aR|r>?+&IA@itntNDz4K<6T(NX+kZ(a6wW5$xWQq9h0}<TTJtGGEb2
zJV8S8m|R=<GRa?!IMXI*y~f$}#JK$G<}T&HD&I93b*JE5mvAB1(?*E!&gLd`1H{R~
zLOwBD2|%*SZcbde>9<r6J6uAv>m2zwPSF(2jnVKv(fsaA1UdaGrCzqLtW0mR>L2yz
z4wOUaL8ZBg2G04qAPF*|-|!>HKQ33fNf8lChlusH_~72zd$AVh2stET#&4oBkK^#1
zNK1OIA`9Mu51hJe?T20fS;ML!B82`uRk8k#T7k^Hsh3Ho1IPlb_hzOWAYaN55OtAM
zy#F&vB#kdz_B@`jM|{w7u)e7MPuRX14N6Aq)~m0L#tw-J$Co^iJ^D`<w@DEBdKgR2
z>GU%F!#faCrOA%>;b0cRS1{(+*i1NU4q`nKueVpC`69CmxvlN@vt~ZuEj0*#q)+Nh
zW;*#>joNy)&4i}x<U~$vsOw2Kp!je=Dm`e@g@LTWrog$#wz(&_Mj{%mBPHwkk%o_6
zb06Il1j_dBOsgiJ<JYY{7_C#QPaHxnb<A}B)bjfB4N2B2LVp`jmZ1hN@4_K{0NHr_
z2scX?Uss0Ij5?ip12|)RsFT01%=2i<*!50==0SspcKCpcHl24=1VfuNEbf)nAQNpe
zqL9I`0l-i3X!ipZ#F7V&h=ny7>DIfoNY)uwyPnv`98Xs!`rWc$w11%y#mdRcLgue_
z{>_MCnfB3vSyU$EOh<BK=q#WTLs<5PwwXYhL<x#c({=01Ep=7P&Gpt))5lu-jtf!O
zbCU6UTFs-*i{;r|l9sB-682v-z7y4P`4EZB5{!&G{lN`~nzjIknG~lvn4VTr*TmVC
z277ORTHOd8YC>y8EmefniSNBXPq-}hF0nmLWnshhw#@_u=~a$Mq9LpS4Pg=>Nk%uX
zHL#X@ctJ(?;bO|2&C4X_#2b1TNtuUAoYYah_$LdeOU^YF4&}c!%Jwiu)s}A@l{_es
zrenmCiQE}6M*G)nVqpnT0-8zCJeucVCOyDh>Up<L-_}HnpNR`;2o2gqLaOSNC+?1N
z+fmHpS)Yg2$+O<{m>%q{cU(k@yuHCS3HAF$a00;@4zL~v4+gFTIre$AeHtV#O<vf$
z-r7Tdx1+g!**{M}pGkGg5gUyEY8&W8oPUh$DEuyz=VGliFgc4ncc;j2<w|=SfJ<uZ
zmjQmf=irwa&&|f%hjI@%`+urSztlvlX=veW4kQkR6wtm$jSj_)Y}(V|7Uk^_s1>Fl
z*VnrrcF32XMqlwj>!1QF!Qz$73?7j$Hv(f~9L=lzZJnieKYwmC1o;{zle4oS!ihqv
z&nLDjpY^G9dg7XRv+23xWRJDWTiOMZ>qLuc!7i=H3zZh>U;AdVnAE<3mq5lAAttqF
zT53Wm-UHUgO!mp%4&gqhu$Xr`{QSm4W2r55ZTj(HsR<T7V>I(hufDprt~sL@hoA?^
z+c*49-M!)2X1@8^rB0Haw%yfL^m4DGk<HH9M`jnbT3$=0nJNbA#x@3gPK@i>lXML9
zY9TgAs+X>rJqZ8K5Ic6fC#1h(?ZH}8!@Z$e*QZ)r7;j6XBOk0uhb6AxIBao<Z=Zcz
zHiO{*%Ea#a{13;cDtls;mN#2ENvU;6d#*O=FE>$D7^S8&p}GG3-;j>+4|L7pS%lWp
zD+|x>ln}w0WWE@Mv+N{1wAtuCG;>RNcHGQc;$6OVlgs4Fh*!0jU$vL&665RO1b?J-
zLkQ0im$~mN4VO}lB)mgUt%R&k+8=Mwdm3%hm-osGTD*x`N{JQccfS%=<x^qI*R@n!
zOB^Jv-ZvPTX-YOt@M$bUGWwD)MtmMelG_U<(Y3A*Yh6t}R}5(A2%+)P)@J{?e&7Cl
zN$K2OVca>}PY1Tu{qyI@;VpOgtY=HTZXe_eJHj7#cwY;jy0mmpv1)1V_I<{oxh=?~
z-=kyQtkTTXK7MI+hZ(*R-~OSsp)FNIma)vU;*COUAw&79Z(mg|i;JeDoRGOTaOXr_
zSO1L$620uqoMnlp2l0I}Cz9*7)+xU<#}=n_)zVt`b^_dB4|IWLSD$W20f0*@)hKhb
zAU3Kg8FMZyZh8=^-!N<Y8`x5aX&Ggd?fU|VL$<G=B6uT|SnwQDi*-Rg6Lih?np@dt
z!CrM<r=m0cyr|h{33%CU%g3;tUxMfNQheoL8v`RhvhG`dsgFb@-;pq}xHbGl+y8$2
z6P=oi&(Wu_!^$l|K?y?AUuTod-G&6I?kl7N-Moi}W)XJzcj#@kSqX?$nHqjrzXbx@
zW3547s*0fWKFi%L^$ta@KyFkJlB=$a2ry4+V4mw{I7~vW^P;n}HK|{B86K=4zlqkX
zJ;#65?u4%>kVh7LE-Zse_FAl@6e8(Q)(BzC2q$$TbL+3!ym+k$`T~hJT=93{M&cs4
zv};Y<(Nk|UQ!@BBa{t70Nv0*Ko<nBHk=8Zx>P*|2%CFiOz3hV}>#~iawlO8H9qRUr
zNO2_xWJ?~eu=?L9enb5MRI-Y|=qj^Vmo>#E4!fcmqNfazIsc|NoDvYsqdaF6jO-8}
zy#i_xAO+y881)jsUBPrl+x*7D#LZ43in_#m#XM`v+i<<@Zf+1AEa1gHi%oa2D;XNu
zaEtS#pgQAQk7;<1RWN@kb2a_vvPz8;`3O3|Dho#E&-G%(VO)1h$o%(LsToSZubK;O
ztHn@qSiY4FH{K~TyitLnz)hz`w$xh^8{QzcUvoTm%s<f<`=_!3E%wsz02b0Q75?`|
z<(KI;Mzp$5e&?_fy=ZHnSClrAt^26}-ujn?2JWu`b2K1A`0xtU5<V%Uuj-ORo0oq#
zkB^Gt9$7&g(VrPOKxipivvx;6prIiw><F#FQu$(qi{R`mm|MT$(_{4`!Tbvs;90M^
zXD!F&n=>{P)XB#9m>BnHG{MaAv!AZ~P^Xy?bLKv(x)W?Lp)UumH(Ed{aC<Rmb#zNh
zwJTArdwv`u00nuZEj<-^<5DqJr)>>f<?-(B9~=5KBj_bsL?HCw2J2gIB;^!a3<sZ^
zU0ZEYL96&YxB*e$T&mybC@LW}yV6o607nX6kkAsF*EO-R6Sd!J_z=Ov8R4KJtH+>w
znW0{J%th{ok)ug|virQh>zJk3!Er{P-@N<6nh=(+HQ)h7=<d1oVnY!bc<OqS9F5A%
zyn<x*Cc1=YnlX62Cmc8t;pp5c2wYZs;n6N>y>QVGzHv8%d<l?ToxW*w9kwvJFMfD*
z>DK-DTxHDor1Zb&`7M5=86mBev^0#h8Lem9N7XCmQ7daw5$o?oHt@j5=d5lVH7mM^
z*-s;>6%Sp6SK<*K@kxeKc`N^mzJ!xJ`FA3<k!t}Bk)Sq%t04U?Gi$32>0jd2S0Rw@
zK$s?Rsy3sfmqL4xv}qs8Bt0w*0}4@ehY;7kc|+rFtktW}F40z6NCMj0pW~Bbs*2%u
zSrs&bnJY^CjxAe*-{A!ZDK`u@USJ9r+p}whc~zK}>*Hg#9G~t!+1BULrQ=>9wI03K
z;uJas4Gr8e{MlG^EkP|DABtd%QN&%9xFjdMrc~CF8AEx0T0ElC!$(1XaW6X4v?K`U
zf9T2_z@}}$8rYT^JxoGqA<*7RUFeA3a_(vEw~^m+DsCrJm&g2<GzCzcc({uTEswdi
zAz3=+!Ow=w5jazba$%I7L{gT#v*%xeXGoTmFHlYURnaSDR{)bPrwi6^6qU-dKUHDw
z@L#;_H>RCB6vY2rF5>K%1bd&$s16h>Es#R1WW+$IEF%awriWWLaG8VGYdqcUfj)z@
z^dUz1ey=!_!(qNWMM17DgyOV3hLm$vp+Lq9+sn&ITOVS2fE|zO+N7cCQnnl|+$k<3
zS*zuZRIbHmLZd!%=XSY*V9__UlAD|f>pYi_275Bta9$Wxp{nudt5@yfx9kg3V#bGb
zSC(~sSdo^_1rqEkRlV%bH*5x!QarJ+jru_|^19(j8RE&u5`bL;Yq!+E86f*!V%VQ`
zCaLc*vrYZvijvujgz4Jm_^Q&oqh}|(TLt?{oM!4ev#U(AiA0nz1TP5#9rI!Y-`Ns*
zr<w6t{{AVe4!n~u#a>5$ZNb08DgjF80@;D}OZ4qMgRv;cpB$eBpmB8e_g>V?U+PKG
z?LWnZ5yiYB6=hSawt7eVqr~cbuef;Kim1y{z02k<hY-0IsU7?LnPG3<=^<_Ul6Cpk
zd^BHg#P4Jrnc?R$jX13?_$!~xg?r8#iv$3`i4blK4Ov-@LW^h#zB%2kQqz&@#3d)8
zZ)a(_<9+743GU6*u-vA)HnFgY6n(t}(z3X<^MO;jAK1(L_1rf{)^(jD8%U8#3NQDy
zWXJg*tyVMkyY_JBi1@0weom#k<-W<mMCI%6s!2uML}gh>dL#%{dTJG)62vZBqnMt>
z2t^C|G#mrxqSi0=H}j@;L?>1Xt0-nj_HqXL;myL5%^k}+QjwJtNho8|l>TeUq^>oR
z%7?8w)OG7coDph#SV#!B*iCDJWL?bky)Z+&`8j)R5y10@Sy8-vuqAbmx;_sess;rH
zI82nTV55%^8r{|)-Qx9zO!e(Dch~eLembHw1BnLc^?E=A_koZLSB;_a><n2=Phr(+
zR|j|LQt!u7#@vmf3)sf%ZXB#S7fFTv|Gtpyj30S+bYO9sqo%4m6AKG-Fx|$I54isX
zw;@bd+9?)0PC+YNcJ%2708b8x8~=q)D&v3^M}UM!jfpF}eP4GtXzufILJ|5^t4}B#
zZ=yiX1q3o9@4<CUN4CD<fdqw{jKauU|FPODsEvI9Ykb^z|9jiBouzY)M3)}Y*oE+q
zR;WObr^5%d#`Z#1bz{{l;z!>5@2K{yRvcD<N;e4Q5CD%=#v7wLf->+dmM;NfFW;9F
z1}?@elkQgpA)P@#>tI}32uxlqToz8e;7gGK3b^`V+ss9-?y>^@8L!|VWV}@}8I(?5
zg#|gGR0ug0RDb|z{n|J?fhJW#wr)c@a=bUAY;QjdI`iHem_IfusTuFtcbuofb9q9Q
z)mj_?AW#ALS|{6&G4$uq_}LC8pP6{O;6$JUrJUC6*_=K7F#&6r5e{)qKINGh22V9?
zCY!7T6mruGG*%Lj!C<}{u3ujv9@EMB;DA;Fz}Sx2T5Q~Eff=Q1l>MY8oa9{3wOQMa
z_RX9CsLKj#`M0?;>`J&xzds2nT~^CvcBNWtUI4LLK`hM)8#`1i133_@J?r{Il|l^?
z{R?tNI3d!a<rQ*9)Mr0T%vK6Gn)fCS>|SoCIM{k|#oOaPfysOzcw@9VWOaM@dCb_~
z!A5^a^@{wb3{x~SR;R1<`LdmXCMNAiP}j$gyc;Y5*agoa>6PU#Yl^Rrq`@f<xCp?l
zK~JXuWGmsPTzQ){*l#JgZhbns?$6*6wD##u^egj8l7gRR92m5GfchM29Fa0G<CCZ(
zFAN4>Eq`vP<5!tc-(O}3b4!DBh@`JmGRps25nR25swSirp|fN81`02@KuyrZo*ttp
z>_Z2;GOJaQVS=%EU`gd0;Ta;?8}S&A$p^23L=sLU=<Oa%V^>*HahHn~HY>g+cV_p~
zYiEw0&F$Lly3GPh$LaEdEsF|%V1@-a*R%2|=Sf`c56{2;K%HjV<;Noi4kkfhOysd2
z(8tQSf53~A%BmbFpUUejJ%rcjrziVtT1mx=1Ad^}JX0{a?Hkodbh+(0Jh&@Bv$*J4
zl+Vvs9QjVvn@2_+zoKI0oq%EEajO3|-2{>l=sBP+s5BsdsfUK9fKgNc4Tq}<u%aJs
z?sR5Hv#wfV&P~~EE-feBL@5az7|^<br9Mw($DkiT(l|USX?hkJ>I7(m52TijH*(4Z
z2{CXElQY}VBLz%^J%Q_M;=>PwUq(81jWCUdN3dR2T>EjeQt&8jRJ+b#<B>I5Yoz4a
z+&iPB+u3sFs4$?kn;R(yg6lSuO(LFK+ATB5yv7T|o@!+>tM^q9yP|ohaAYgIMh?0`
zVR9ZrYjFzA0aYaZH?`ZZ8c$C&h)*%Pvg{tBBzqh<X-3;NQB1$v@e#NW0Xg3d@W$5^
zb_*l5f9NxVzs|!U2Hg9AxejbWrH8zW7Ot>-y(oqO)h4u8J6cpmNs2;pD8gL61e*I?
zEx@}mQK(pPZjx-H4f-mXOi|ac3n!hDutipS#ev~PJZl`@V02o+f6|jGC%8;i?_z|!
zMAsAB0a)q>t{b71u7nH;FlNTRl>XsyzAhV|87HSlu}%p#N`LmCp@w`OL=zn;ltINr
zKd%yCJ4&NPO4n9XUzk%LR$^VX*eWk*;ASPbs2KQFfVIBl5RLB_n-#kcM<w<O@LNvm
z7iKIs(%~TnS}aI;d%j&gz!w~p@;I}TKOAzn8;_5^)+ucM!>Q)s5ZxaO6C%gpcSex~
z3>-Gv27!C=1yUSiBeo0_yt~Eh{NqO%X7JlE=;g;s%(O2Lz-+`k3W#noNA>2Bso)>O
zAO0R&<rsK`0t9R}@BzI=p8_znc#79!5qOj0kbQ3OpD>>XXPBPT3!~kpeX7{~;fMUQ
z(#^B?EHK*7!R1WQ*!0q*=5U{L&1F^kz{-ob$#&<3hu9oEz;W7(-0F3)32{3^*{y)X
z&1cYKE8dH`_G7qw)1^$mpj6b80rz0%rFq9j8x`H)3|PB8&qhIL4)wB4!f}zhu|5j%
zf!DDx-w(R?m`S2xhA1cOWyzCLleP#VFSv^jEasGzt~`&qqDsMf!v&D(5Tb_*if(Nf
zDrp42Mznsb{N4YI{lMfU<T;5~2ZhgPC^P(rV>7l1Dg!(HrCr_Q!OvGtBX4qZ`I*<W
zrclv#8!n3l`k*_+4(Vj<b{qFLK&9FwNvin@v3z|grgSF0Kt`_3q3q!pCTRz}{K~{5
z8s>L~FsTD0j_&!8o2E@~QLL@wUz^Wp4Oc|Fo3)#eNd^jz39qn8t+K+Th&9Dd*VmRT
zDku8g^8HELYenl-R!q=OS~+0nxR9(GIwyh508w0hBjsnf6NGr*>6q|X$Ak!rT;(My
zmI`LOY!1tVwt4qH)WaVeleuxjiw;Abqd!j2mOMYzJCuB`{r*}A5nJkxLl@d*i1?RO
z>?|-Bk^qsjLO({a2SN_B&wJFq&vimaN1sAlPQi?}iYlW^P83iRT{An`?R&n4msB|@
zI#$}80AOHl9eaksH#bmI&F!|(0u8Jy4Hyl%xWif%(EOwCqTi7JR8dsxR4+~6CKry6
z&|C*lhJD6nn2ukv0RW4IUy%PqR39S0OMkbrUg614E!}XN%^<;^cAZNbou&v6c~H8b
z#Gkn$>^<TBsrg<o<&p8m$WW9W4~W!Y?3jjzlgjEV1FH`?;+5S?yT{aJd7(b7kknWu
zi<b9u34}uiLO!Ax3;PPZfXBLmO5gLEwCUIGFWxlww30xx8x}2P>t_soFq+YB0E(_j
z*^M$xw#Ry)=;VT|@#m0iu2<;Nfxminx1tv%(~?)!a5&!6zn?vI`KNJ*=5F-v1l!|l
zFy(tUSV2D;NsWMsX|A3Rg(>Iw7dNXgM%bC0Gr|L{SQaDcDlFF9i*5GkP^)klY9eZK
zF0nfAOZbtTpAC>Ax1Jdwf*~@0p6A#IINy1=aNi4zH*QyR2^gYLFZ$Ym^u1N_Eh<bX
zJ&d}2{(>~77{0CauD9ntD_%i$K=%MkG0K1E^?z%vC4G-%^V>jSg}PTIeQ4|GoN@le
z`m?CnpFz&xGInwbABOq5OY_alm#cVyyg#mZI+bf^MXctju<UJ>_N04GB|M6WnU=7e
zvOzroa5IQ-q9G!2j=v?yoq;uFHx-?I4>|0D#P~2vhTmbLMV~({Y<~Gp!qrf>QPY~g
z-2ai2i${&@<TqT4z-~dRWz=(H7YMu_ve{MXk{H@PAUuyY9$FcV9*!oNOH4P>?77(>
z?W(?}Lt8A+en6F!R=WFMG~ohCnD$U<p_y88&ze$fkzb&GadKh#Mw{5S#qbxD9~)BI
z0Tr=`YWTNBlijwbERb5gC6Kqb<)kqI-@+St&T7_g#e-(D@2WF{?s`<Jdg<Ocof0y1
z_WjDr^q>XNmgMc`nU_o&;pp!!FX|qXHX2G?wjm0c*?mG4@x=gE-5EhUIMamnAsJX#
z_v{px!9$kO8A#ODy2hQT+L@}y7g@L4TRd!SY%ZV9{1o#{*;g@i?E?3{tjAOGf6no&
zx}IB~Q&Z><A4|8qe@(S|!NWU^SSE^O#;?yu3XP5!Pe|UD$Fx3(rmk|ezi-7piIB(_
zT+05C<x&>joK^ePu=aw>_$e3MX<DhQ*HQg*hi2mS&gLqYSDVFMpiaQ0x(vwD=J1S&
z)BA^(vBVWna20|%Ym(4?MQzk;(#kYayE7Bx9uGMNSN+JAN0|ZS!F0*86+J(B|Ah)n
zui!6ZfRJNZ=w1T_kpKR-2mbfhSQh**J)mLcmmYqti(mNg3nx(|_!TcU5b>8De(B-=
zXH38R;g>)B@`qo0hF@Iy7gzqpm49*N|NC5-DI5`2y)fc9a0dr}em|#oHs`d}AO8bW
C9^_>J

literal 0
HcmV?d00001

diff --git a/brand/github/tysel-org-avatar.svg b/brand/github/tysel-org-avatar.svg
new file mode 100644
index 0000000..326805b
--- /dev/null
+++ b/brand/github/tysel-org-avatar.svg
@@ -0,0 +1,9 @@
+<svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg" role="img" aria-labelledby="title desc">
+  <title id="title">Tysel organization avatar</title>
+  <desc id="desc">The Tysel Blue ty mark centered on a Runtime Mist field.</desc>
+  <rect width="1024" height="1024" fill="#F1F3F7"/>
+  <g fill="#5B5CE2" transform="translate(154 37) scale(8.2)">
+    <path d="M30.39 79.95 Q22.72 79.95 19.03 76.73 Q15.35 73.52 15.35 66.13 L15.35 42.39 L8.95 42.39 L8.95 32.94 L15.35 32.94 L15.35 21.7 L28.02 21.7 L28.02 32.94 L36.45 32.94 L36.45 42.39 L28.02 42.39 L28.02 64.76 Q28.02 67.98 29.45 69.24 Q30.88 70.49 33.74 70.49 Q34.58 70.49 35.22 70.43 Q35.87 70.36 36.45 70.3 L36.45 79.47 Q35.39 79.64 33.87 79.79 Q32.34 79.95 30.39 79.95 Z"/>
+    <path d="M42.54 94.17 Q40.71 94.17 38.99 94 Q37.28 93.82 36.16 93.63 L36.16 84.31 Q36.82 84.44 37.9 84.58 Q38.97 84.71 40.37 84.71 Q43.18 84.71 44.83 83.78 Q46.47 82.85 47.29 80.53 L47.82 79.02 L31.56 32.94 L45.33 32.94 L55.73 71.46 L54.08 68.95 L56.42 68.95 L54.74 71.46 L65.14 32.94 L78.38 32.94 L62.58 79.84 Q60.78 85.25 58.05 88.39 Q55.32 91.53 51.5 92.85 Q47.67 94.17 42.54 94.17 Z"/>
+  </g>
+</svg>

From 4da5038ce8fe40d2170d65cc3877e3503de56c3b Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Sat, 5 Sep 2026 14:02:12 +0800
Subject: [PATCH 04/31] feat(dev): synchronize manifest types and expose source
 diagnostics

---
 Cargo.lock                                    |   1 +
 crates/tysel-build/src/bundle.rs              |  75 +++++++-
 crates/tysel-build/src/diagnostic.rs          |  29 +++
 crates/tysel-build/src/lib.rs                 |  42 ++++
 .../tysel-build/src/runtime-components.json   |  34 +++-
 crates/tysel-cli/src/build.rs                 |   5 +
 crates/tysel-cli/src/check.rs                 |  13 +-
 crates/tysel-cli/src/dev.rs                   |  26 ++-
 crates/tysel-cli/src/init/plan.rs             |   6 +
 crates/tysel-cli/src/init/project.rs          |  14 +-
 crates/tysel-cli/src/init/templates.rs        |   7 +-
 crates/tysel-cli/src/main.rs                  |  18 +-
 crates/tysel-cli/src/typegen.rs               |  70 ++++++-
 crates/tysel-cli/tests/dev_check.rs           | 125 ++++++++++++
 crates/tysel-manifest/Cargo.toml              |   3 +-
 .../schema/tysel-manifest-v1.schema.json      |   6 +-
 crates/tysel-manifest/src/diagnostic.rs       | 130 +++++++++++++
 crates/tysel-manifest/src/lib.rs              | 179 ++++++++++++------
 docs/concepts/projects-and-configuration.md   |  33 ++++
 docs/reference/cli/development.md             |  12 ++
 docs/reference/errors-and-output.md           |  19 ++
 packages/tysel-types/README.md                |   4 +-
 22 files changed, 757 insertions(+), 94 deletions(-)
 create mode 100644 crates/tysel-manifest/src/diagnostic.rs

diff --git a/Cargo.lock b/Cargo.lock
index a316255..fce4691 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3933,6 +3933,7 @@ dependencies = [
  "serde_json",
  "thiserror",
  "toml",
+ "toml_edit",
 ]
 
 [[package]]
diff --git a/crates/tysel-build/src/bundle.rs b/crates/tysel-build/src/bundle.rs
index 00b7ac1..a6b4717 100644
--- a/crates/tysel-build/src/bundle.rs
+++ b/crates/tysel-build/src/bundle.rs
@@ -116,7 +116,7 @@ pub fn bundle(entry: &Path) -> Result<(Vec<u8>, Vec<u8>)> {
 
         let mut resolved = HashMap::new();
         for specifier in &analysis.specifiers {
-            let resolved_path = resolve_specifier(&resolver, &path, specifier)?;
+            let resolved_path = resolve_specifier(&resolver, &path, specifier, &source)?;
             resolved.insert(specifier.clone(), module_id(&resolved_path));
             pending.push_back(resolved_path);
         }
@@ -158,6 +158,7 @@ struct OrigPos {
 struct Analysis {
     has_module_syntax: bool,
     specifiers: Vec<String>,
+    specifier_spans: HashMap<String, Span>,
     dynamic_imports: Vec<Span>,
 }
 
@@ -174,13 +175,37 @@ fn analyze_source(path: &Path, source: &str) -> Result<Analysis> {
         )));
     }
     let mut specifiers = Vec::new();
+    let mut specifier_spans = HashMap::new();
     let mut seen = HashSet::new();
+    let mut type_only_statements = HashMap::new();
+    for (start, is_type) in parsed
+        .module_record
+        .import_entries
+        .iter()
+        .map(|entry| (entry.statement_span.start, entry.is_type))
+        .chain(
+            parsed
+                .module_record
+                .indirect_export_entries
+                .iter()
+                .map(|entry| (entry.statement_span.start, entry.is_type)),
+        )
+    {
+        type_only_statements
+            .entry(start)
+            .and_modify(|all: &mut bool| *all &= is_type)
+            .or_insert(is_type);
+    }
     for (specifier, requests) in parsed.module_record.requested_modules.iter() {
-        if requests.iter().all(|request| request.is_type) {
+        let Some(request) = requests.iter().find(|request| {
+            !request.is_type
+                && type_only_statements.get(&request.statement_span.start) != Some(&true)
+        }) else {
             continue;
-        }
+        };
         let specifier = specifier.as_str().to_string();
         if seen.insert(specifier.clone()) {
+            specifier_spans.insert(specifier.clone(), request.span);
             specifiers.push(specifier);
         }
     }
@@ -198,12 +223,14 @@ fn analyze_source(path: &Path, source: &str) -> Result<Analysis> {
         let Some(literal) = call.common_js_require() else { continue };
         let specifier = literal.value.as_str().to_owned();
         if seen.insert(specifier.clone()) {
+            specifier_spans.insert(specifier.clone(), literal.span);
             specifiers.push(specifier);
         }
     }
     Ok(Analysis {
         has_module_syntax: parsed.module_record.has_module_syntax,
         specifiers,
+        specifier_spans,
         dynamic_imports: parsed
             .module_record
             .dynamic_imports
@@ -441,15 +468,45 @@ fn collect_binding(pattern: &BindingPattern<'_>, names: &mut Vec<String>) {
     }
 }
 
-fn resolve_specifier(resolver: &Resolver, importer: &Path, specifier: &str) -> Result<PathBuf> {
+fn resolve_specifier(
+    resolver: &Resolver,
+    importer: &Path,
+    specifier: &str,
+    source: &str,
+) -> Result<PathBuf> {
     let directory = importer.parent().unwrap_or(importer);
     match resolver.resolve(directory, specifier) {
-        Ok(resolution) => canonicalize_existing(&resolution.full_path()),
-        Err(ResolveError::Builtin { resolved, .. }) => {
-            Err(anyhow!("Node builtin '{resolved}' is not available in Tysel"))
+        Ok(resolution) if !specifier.starts_with("node:") => {
+            canonicalize_existing(&resolution.full_path())
         }
-        Err(err) => {
-            Err(anyhow!("cannot resolve '{}' from {}: {err}", specifier, importer.display()))
+        result => {
+            let (code, message) = match result {
+                Err(ResolveError::Builtin { resolved, .. }) => (
+                    "TYSEL_NODE_BUILTIN_UNSUPPORTED",
+                    format!("Node builtin '{resolved}' is not available in Tysel"),
+                ),
+                _ if specifier.starts_with("node:") => (
+                    "TYSEL_NODE_BUILTIN_UNSUPPORTED",
+                    format!("Node builtin '{specifier}' is not available in Tysel"),
+                ),
+                Err(error) => (
+                    "TYSEL_IMPORT_UNRESOLVED",
+                    format!("cannot resolve '{specifier}' from {}: {error}", importer.display()),
+                ),
+                Ok(_) => unreachable!(),
+            };
+            // Analyze the original source only on failure: successful builds do
+            // not pay for a second parse just to retain diagnostic positions.
+            let original = analyze_source(importer, source)?;
+            let span = original.specifier_spans.get(specifier).copied();
+            Err(anyhow!(crate::BuildDiagnostics::new(vec![crate::BuildDiagnostic::at_source(
+                code,
+                "resolve",
+                message,
+                importer,
+                source,
+                span.map(|span| span.start as usize..span.end as usize),
+            )])))
         }
     }
 }
diff --git a/crates/tysel-build/src/diagnostic.rs b/crates/tysel-build/src/diagnostic.rs
index 01e6422..609d1d4 100644
--- a/crates/tysel-build/src/diagnostic.rs
+++ b/crates/tysel-build/src/diagnostic.rs
@@ -18,6 +18,35 @@ pub struct BuildDiagnostic {
     pub end: Option<DiagnosticPosition>,
 }
 
+impl BuildDiagnostic {
+    /// Create a diagnostic from an original-source byte range, if one exists.
+    pub fn at_source(
+        code: impl Into<String>,
+        phase: impl Into<String>,
+        message: impl Into<String>,
+        path: &Path,
+        source: &str,
+        range: Option<std::ops::Range<usize>>,
+    ) -> Self {
+        let index = LineIndex::new(source);
+        let positions = range.map(|range| {
+            (
+                index.position(source, range.start.min(source.len()) as u32),
+                index.position(source, range.end.min(source.len()) as u32),
+            )
+        });
+        Self {
+            code: code.into(),
+            message: message.into(),
+            severity: DiagnosticSeverity::Error,
+            phase: phase.into(),
+            file: path.to_string_lossy().into_owned(),
+            start: positions.map(|(start, _)| start),
+            end: positions.map(|(_, end)| end),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
 #[serde(rename_all = "lowercase")]
 pub enum DiagnosticSeverity {
diff --git a/crates/tysel-build/src/lib.rs b/crates/tysel-build/src/lib.rs
index 8336fbd..ba2a5c7 100644
--- a/crates/tysel-build/src/lib.rs
+++ b/crates/tysel-build/src/lib.rs
@@ -693,6 +693,48 @@ export default {
         assert!(!js.contains("module.exports = {"));
     }
 
+    #[test]
+    fn nested_import_errors_use_original_typescript_ranges() {
+        let dir = std::env::temp_dir()
+            .join(format!("tysel-nested-import-diagnostic-{}", std::process::id()));
+        fs::create_dir_all(dir.join("src")).unwrap();
+        let entry = dir.join("src/index.ts");
+        fs::write(&entry, "export { default } from './nested.js';\n").unwrap();
+        let nested = dir.join("src/nested.ts");
+        for specifier in ["node:fs", "node:future_builtin", "./missing.js"] {
+            // Type erasure changes the generated line/column before this import.
+            let source = format!(
+                "type Name = string;\nconst name: Name = '王😀'; import '{specifier}';\nexport default name;\n"
+            );
+            fs::write(&nested, &source).unwrap();
+            let error = read_bundle(&entry).unwrap_err();
+            let diagnostics = error.downcast_ref::<BuildDiagnostics>().unwrap();
+            let diagnostic = &diagnostics.diagnostics()[0];
+            assert_eq!(
+                diagnostic.code,
+                if specifier.starts_with("node:") {
+                    "TYSEL_NODE_BUILTIN_UNSUPPORTED"
+                } else {
+                    "TYSEL_IMPORT_UNRESOLVED"
+                }
+            );
+            assert_eq!(Path::new(&diagnostic.file), fs::canonicalize(&nested).unwrap());
+            let start = diagnostic.start.unwrap();
+            let end = diagnostic.end.unwrap();
+            assert_eq!(start.line, 2);
+            let selected = &source[start.byte_offset as usize..end.byte_offset as usize];
+            assert!(selected.contains(specifier), "{selected:?}");
+            let line_start = source.find('\n').unwrap() + 1;
+            assert_eq!(
+                start.column as usize,
+                source[line_start..start.byte_offset as usize].chars().count() + 1
+            );
+        }
+        fs::write(&nested, "import type { Stats } from 'node:fs';\nimport { type Missing } from './not-installed.js';\nexport default {};\n").unwrap();
+        assert!(read_bundle(&entry).is_ok(), "erased imports must not be resolved");
+        fs::remove_dir_all(dir).unwrap();
+    }
+
     #[test]
     fn node_builtins_are_rejected() {
         let dir = std::env::temp_dir().join(format!("tysel-build-fs-{}", std::process::id()));
diff --git a/crates/tysel-build/src/runtime-components.json b/crates/tysel-build/src/runtime-components.json
index 3f2d027..370f459 100644
--- a/crates/tysel-build/src/runtime-components.json
+++ b/crates/tysel-build/src/runtime-components.json
@@ -1,6 +1,6 @@
 {
   "inventory_version": 1,
-  "cargo_lock_sha256": "1f7d8b76e2f5e4330473ff013afae3520afafec95f30ec42185bcf76fe6a99dd",
+  "cargo_lock_sha256": "124d6184ae5fe5b7fd53af46018f884b1448c5affa8fd1247f3bbb1452ba6d80",
   "roots": [
     "tysel-cli",
     "tysel-isolate",
@@ -391,6 +391,14 @@
       "source": "registry+https://github.com/rust-lang/crates.io-index",
       "checksum": "79fcda08c33bb58b97008b2cdada6622500e949e060f5913361763121abd2416"
     },
+    {
+      "name": "console",
+      "version": "0.16.4",
+      "license": "MIT",
+      "purl": "pkg:cargo/console@0.16.4",
+      "source": "registry+https://github.com/rust-lang/crates.io-index",
+      "checksum": "4fe5f465a4f6fee88fad41b85d990f84c835335e85b5d9e6e63e0d06d28cba7c"
+    },
     {
       "name": "const-oid",
       "version": "0.10.2",
@@ -615,6 +623,14 @@
       "source": "registry+https://github.com/rust-lang/crates.io-index",
       "checksum": "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"
     },
+    {
+      "name": "dialoguer",
+      "version": "0.12.0",
+      "license": "MIT",
+      "purl": "pkg:cargo/dialoguer@0.12.0",
+      "source": "registry+https://github.com/rust-lang/crates.io-index",
+      "checksum": "25f104b501bf2364e78d0d3974cbc774f738f5865306ed128e1e0d7499c0ad96"
+    },
     {
       "name": "digest",
       "version": "0.10.7",
@@ -687,6 +703,14 @@
       "source": "registry+https://github.com/rust-lang/crates.io-index",
       "checksum": "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
     },
+    {
+      "name": "encode_unicode",
+      "version": "1.0.0",
+      "license": "Apache-2.0 OR MIT",
+      "purl": "pkg:cargo/encode_unicode@1.0.0",
+      "source": "registry+https://github.com/rust-lang/crates.io-index",
+      "checksum": "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
+    },
     {
       "name": "encoding_rs",
       "version": "0.8.35",
@@ -2460,6 +2484,14 @@
       "source": "registry+https://github.com/rust-lang/crates.io-index",
       "checksum": "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
     },
+    {
+      "name": "shell-words",
+      "version": "1.1.1",
+      "license": "MIT OR Apache-2.0",
+      "purl": "pkg:cargo/shell-words@1.1.1",
+      "source": "registry+https://github.com/rust-lang/crates.io-index",
+      "checksum": "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
+    },
     {
       "name": "shlex",
       "version": "2.0.1",
diff --git a/crates/tysel-cli/src/build.rs b/crates/tysel-cli/src/build.rs
index f100b21..a4c9825 100644
--- a/crates/tysel-cli/src/build.rs
+++ b/crates/tysel-cli/src/build.rs
@@ -98,6 +98,11 @@ pub fn run(manifest_path: PathBuf, options: Options) -> Result<()> {
     println!("{payload_label:<16} {}", format_bytes(payload_bytes as u64));
     println!("Capabilities     {}", capability_summary(&manifest));
     println!("Runtime          {}", manifest.app.profile);
+    if manifest.app.profile == "isolated" {
+        println!(
+            "Worker           matching tysel-worker required beside executable (or TYSEL_WORKER)"
+        );
+    }
     println!("Executable       {}", format_bytes(executable));
     println!("Target           {}", target.canonical());
     println!("Output           {}", output.display());
diff --git a/crates/tysel-cli/src/check.rs b/crates/tysel-cli/src/check.rs
index 5864338..e45f160 100644
--- a/crates/tysel-cli/src/check.rs
+++ b/crates/tysel-cli/src/check.rs
@@ -52,16 +52,9 @@ fn run_with_options(manifest_path: &Path, require_types: bool) -> Result<()> {
         Typecheck::Ok | Typecheck::Skipped(_) => {}
     }
     if !is_component {
-        let specifiers = crate::node_scan::scan_file(&entry)?;
-        if specifiers.is_empty() {
-            println!("  node      ok");
-        } else {
-            println!("  node      fail");
-            for specifier in &specifiers {
-                eprintln!("unsupported Node builtin '{specifier}'");
-            }
-            return Err(anyhow!("Node builtins are not available in Tysel"));
-        }
+        // The build resolver validates runtime imports across the entire graph.
+        // Re-scanning raw TS here would incorrectly reject erased type imports.
+        println!("  node      ok");
     }
     Ok(())
 }
diff --git a/crates/tysel-cli/src/dev.rs b/crates/tysel-cli/src/dev.rs
index b2b1313..d7f05d5 100644
--- a/crates/tysel-cli/src/dev.rs
+++ b/crates/tysel-cli/src/dev.rs
@@ -214,7 +214,7 @@ async fn serve(
     reload: bool,
     error_format: ErrorFormat,
 ) -> Result<()> {
-    let loaded = load(&manifest_path, entry.as_deref())?;
+    let loaded = load_for_serve(&manifest_path, entry.as_deref(), reload)?;
     let pool = SharedPool::with_server_limits(
         loaded.isolate,
         loaded.max_request_bytes,
@@ -252,7 +252,7 @@ async fn serve(
                 }
                 _ = wait_change(&mut changes.rx) => {
                     diagnostic_generation = diagnostic_generation.saturating_add(1);
-                    match load(&manifest_path, entry.as_deref()) {
+                    match load_for_serve(&manifest_path, entry.as_deref(), true) {
                     Ok(next) => {
                         task_generation = task_generation.saturating_add(1);
                         match start_task_service(next.task.clone(), task_generation).await {
@@ -456,9 +456,27 @@ fn listen_announcement(bound: std::net::SocketAddr) -> String {
     format!("tysel listen {bound}\ntysel url http://{bound}\n")
 }
 
+fn load_for_serve(manifest_path: &Path, entry: Option<&Path>, sync_types: bool) -> Result<Loaded> {
+    let manifest = Manifest::from_path(manifest_path)
+        .with_context(|| format!("failed to read {}", manifest_path.display()))?;
+    if sync_types {
+        crate::typegen::sync(
+            manifest_path.parent().unwrap_or(Path::new(".")),
+            &manifest,
+            None,
+            false,
+        )?;
+    }
+    load_manifest(manifest_path, entry, manifest)
+}
+
 fn load(manifest_path: &Path, entry: Option<&Path>) -> Result<Loaded> {
     let manifest = Manifest::from_path(manifest_path)
         .with_context(|| format!("failed to read {}", manifest_path.display()))?;
+    load_manifest(manifest_path, entry, manifest)
+}
+
+fn load_manifest(manifest_path: &Path, entry: Option<&Path>, manifest: Manifest) -> Result<Loaded> {
     let root = manifest_path.parent().unwrap_or(Path::new("."));
     let entry = match entry {
         Some(path) => path.to_path_buf(),
@@ -701,6 +719,9 @@ fn relevant(event: notify::Result<Event>) -> bool {
 }
 
 fn is_watched(path: &Path) -> bool {
+    if path.file_name().and_then(|name| name.to_str()) == Some("tysel-env.d.ts") {
+        return false;
+    }
     if ignored(path) {
         return false;
     }
@@ -743,6 +764,7 @@ mod tests {
     fn watches_dotenv_and_source_but_not_ignored_paths() {
         assert!(is_watched(Path::new("/app/.env")));
         assert!(is_watched(Path::new("/app/src/index.ts")));
+        assert!(!is_watched(Path::new("/app/tysel-env.d.ts")));
         assert!(is_watched(Path::new("/app/tysel.toml")));
         assert!(!is_watched(Path::new("/app/README.md")));
         assert!(!is_watched(Path::new("/app/node_modules/pkg/.env")));
diff --git a/crates/tysel-cli/src/init/plan.rs b/crates/tysel-cli/src/init/plan.rs
index 2162e4f..ffe9f16 100644
--- a/crates/tysel-cli/src/init/plan.rs
+++ b/crates/tysel-cli/src/init/plan.rs
@@ -198,6 +198,12 @@ pub(super) fn build(options: Options) -> Result<InitPlan> {
         files.push((test_path, options.template.test_source(&entry)));
     }
     files.push((PathBuf::from(manifest_name), manifest_contents));
+    if options.manifest_format == ManifestFormat::Toml {
+        files.push((
+            PathBuf::from(".tysel/manifest.schema.json"),
+            tysel_manifest::JSON_SCHEMA.to_owned(),
+        ));
+    }
     let gitignore_path = root.join(".gitignore");
     let gitignore_update = if gitignore_path.is_file() {
         if fs::symlink_metadata(&gitignore_path)?.file_type().is_symlink() {
diff --git a/crates/tysel-cli/src/init/project.rs b/crates/tysel-cli/src/init/project.rs
index b51679b..fb23c66 100644
--- a/crates/tysel-cli/src/init/project.rs
+++ b/crates/tysel-cli/src/init/project.rs
@@ -233,14 +233,21 @@ pub(super) fn gitignore_with_entries(
         std::str::from_utf8(&bytes).with_context(|| format!("{} must be UTF-8", path.display()))?;
     let normalized =
         original.lines().map(|line| normalize_ignore_pattern(line.trim())).collect::<Vec<_>>();
-    let missing = desired
+    // Negation rules are order-sensitive. Keep the schema exception block at
+    // the end so an existing `.tysel/` rule cannot hide the shared schema.
+    let (unordered, ordered) = desired
+        .split_once("!.tysel/\n")
+        .map(|(head, tail)| (head, format!("!.tysel/\n{tail}")))
+        .unwrap_or((desired, String::new()));
+    let append_ordered = !ordered.is_empty() && !original.trim_end().ends_with(ordered.trim_end());
+    let missing = unordered
         .lines()
         .filter(|entry| {
             let entry = normalize_ignore_pattern(entry);
             !normalized.iter().any(|existing| existing == &entry)
         })
         .collect::<Vec<_>>();
-    if missing.is_empty() {
+    if missing.is_empty() && !append_ordered {
         return Ok(None);
     }
 
@@ -256,6 +263,9 @@ pub(super) fn gitignore_with_entries(
         contents.push_str(entry);
         contents.push('\n');
     }
+    if append_ordered {
+        contents.push_str(&ordered);
+    }
     Ok(Some((bytes, contents)))
 }
 
diff --git a/crates/tysel-cli/src/init/templates.rs b/crates/tysel-cli/src/init/templates.rs
index 2a7bcce..2806f70 100644
--- a/crates/tysel-cli/src/init/templates.rs
+++ b/crates/tysel-cli/src/init/templates.rs
@@ -40,7 +40,8 @@ pub(super) const PACKAGE_JSON: &str = r#"{
 }
 "#;
 
-pub(super) const GITIGNORE: &str = "node_modules/\ndist/\ndata/\n.tysel/\n";
+pub(super) const GITIGNORE: &str =
+    "node_modules/\ndist/\ndata/\n!.tysel/\n.tysel/*\n!.tysel/manifest.schema.json\n";
 
 const HTTP_TYPED: &str = r#"import type { TyselApp } from "@tysel/types";
 import type { TyselEnv } from "__TYSEL_ENV_IMPORT__";
@@ -401,7 +402,9 @@ steps = [["build", "--release"]]
         })
         .collect::<Vec<_>>()
         .join("\n");
-    Ok(format!("{rendered}\n"))
+    let schema =
+        if format == ManifestFormat::Toml { "#:schema .tysel/manifest.schema.json\n" } else { "" };
+    Ok(format!("{schema}{rendered}\n"))
 }
 
 #[cfg(test)]
diff --git a/crates/tysel-cli/src/main.rs b/crates/tysel-cli/src/main.rs
index e4cf71e..8c172da 100644
--- a/crates/tysel-cli/src/main.rs
+++ b/crates/tysel-cli/src/main.rs
@@ -653,8 +653,22 @@ fn run(cli: Cli) -> Result<ExitCode> {
 
 pub(crate) fn structured_diagnostics(
     error: &anyhow::Error,
-) -> Option<&tysel_build::BuildDiagnostics> {
-    error.chain().find_map(|cause| cause.downcast_ref())
+) -> Option<tysel_build::BuildDiagnostics> {
+    error.chain().find_map(|cause| {
+        if let Some(build) = cause.downcast_ref::<tysel_build::BuildDiagnostics>() {
+            return Some(build.clone());
+        }
+        let manifest = cause.downcast_ref::<tysel_manifest::ManifestError>()?;
+        let tysel_manifest::ManifestError::Located(source) = manifest else { return None };
+        Some(tysel_build::BuildDiagnostics::new(vec![tysel_build::BuildDiagnostic::at_source(
+            source.code,
+            "manifest",
+            source.error.to_string(),
+            &source.file,
+            &source.source_text,
+            source.range.clone(),
+        )]))
+    })
 }
 
 fn switch_to_selected_dir(path: Option<&Path>) -> Result<()> {
diff --git a/crates/tysel-cli/src/typegen.rs b/crates/tysel-cli/src/typegen.rs
index 81b1570..db1bb66 100644
--- a/crates/tysel-cli/src/typegen.rs
+++ b/crates/tysel-cli/src/typegen.rs
@@ -9,8 +9,28 @@ use crate::project::ProjectContext;
 const GENERATED_HEADER: &str = "// Generated by `tysel types`. Do not edit.\n";
 
 pub fn run(context: &ProjectContext, output: Option<&Path>, check: bool) -> Result<()> {
+    let changed = sync(&context.root, &context.manifest, output, check)?;
     let path = resolve_output_path(&context.root, output)?;
-    let rendered = render(&context.manifest)?;
+    let action = if check {
+        "types ok"
+    } else if changed {
+        "wrote"
+    } else {
+        "unchanged"
+    };
+    println!("{action} {}", display_path(&path, &context.root).display());
+    Ok(())
+}
+
+/// Synchronize only tool-owned output. Returns whether a file was written.
+pub(crate) fn sync(
+    root: &Path,
+    manifest: &Manifest,
+    output: Option<&Path>,
+    check: bool,
+) -> Result<bool> {
+    let path = resolve_output_path(root, output)?;
+    let rendered = render(manifest)?;
 
     if fs::symlink_metadata(&path).is_ok_and(|metadata| metadata.file_type().is_symlink()) {
         return Err(anyhow!("refusing to use symlinked generated types {}", path.display()));
@@ -21,13 +41,15 @@ pub fn run(context: &ProjectContext, output: Option<&Path>, check: bool) -> Resu
         if current != rendered {
             return Err(anyhow!("generated types are out of date: run `tysel types`"));
         }
-        println!("types ok {}", display_path(&path, &context.root).display());
-        return Ok(());
+        return Ok(false);
     }
 
     if path.is_file() {
         let current = fs::read_to_string(&path)
             .with_context(|| format!("read existing generated types {}", path.display()))?;
+        if current == rendered {
+            return Ok(false);
+        }
         if !current.starts_with(GENERATED_HEADER) {
             return Err(anyhow!(
                 "refusing to replace non-generated file {}; choose --output",
@@ -35,13 +57,12 @@ pub fn run(context: &ProjectContext, output: Option<&Path>, check: bool) -> Resu
             ));
         }
     }
-    let parent = path.parent().unwrap_or(&context.root);
+    let parent = path.parent().unwrap_or(root);
     fs::create_dir_all(parent)
         .with_context(|| format!("create generated types directory {}", parent.display()))?;
     fs::write(&path, rendered)
         .with_context(|| format!("write generated types {}", path.display()))?;
-    println!("wrote {}", display_path(&path, &context.root).display());
-    Ok(())
+    Ok(true)
 }
 
 fn resolve_output_path(root: &Path, output: Option<&Path>) -> Result<PathBuf> {
@@ -208,6 +229,43 @@ profile = "{profile}"
         .unwrap()
     }
 
+    #[test]
+    fn sync_updates_only_changed_owned_output_and_check_never_writes() {
+        let root = std::env::temp_dir().join(format!(
+            "tysel-typegen-sync-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
+        ));
+        fs::create_dir_all(&root).unwrap();
+        let mut manifest = manifest("service");
+        assert!(sync(&root, &manifest, None, true).is_err());
+        assert!(!root.join("tysel-env.d.ts").exists());
+        assert!(sync(&root, &manifest, None, false).unwrap());
+        let path = root.join("tysel-env.d.ts");
+        let modified = fs::metadata(&path).unwrap().modified().unwrap();
+        assert!(!sync(&root, &manifest, None, false).unwrap());
+        assert_eq!(fs::metadata(&path).unwrap().modified().unwrap(), modified);
+        let before = fs::read_to_string(&path).unwrap();
+        manifest.permissions.secrets = vec!["TOKEN".into()];
+        assert!(sync(&root, &manifest, None, true).is_err());
+        assert_eq!(fs::read_to_string(&path).unwrap(), before);
+        assert!(sync(&root, &manifest, None, false).unwrap());
+        assert!(fs::read_to_string(&path).unwrap().contains("TOKEN"));
+        fs::write(&path, "// user declaration").unwrap();
+        assert!(sync(&root, &manifest, None, false).is_err());
+        assert_eq!(fs::read_to_string(&path).unwrap(), "// user declaration");
+        #[cfg(unix)]
+        {
+            fs::remove_file(&path).unwrap();
+            let other = root.join("other.d.ts");
+            fs::write(&other, &before).unwrap();
+            std::os::unix::fs::symlink(&other, &path).unwrap();
+            assert!(sync(&root, &manifest, None, false).is_err());
+            assert_eq!(fs::read_to_string(&other).unwrap(), before);
+        }
+        fs::remove_dir_all(root).unwrap();
+    }
+
     #[test]
     fn generated_runtime_tracks_manifest_capabilities() {
         let mut manifest = manifest("service");
diff --git a/crates/tysel-cli/tests/dev_check.rs b/crates/tysel-cli/tests/dev_check.rs
index 02f0e1a..c52d984 100644
--- a/crates/tysel-cli/tests/dev_check.rs
+++ b/crates/tysel-cli/tests/dev_check.rs
@@ -352,6 +352,15 @@ fn init_writes_a_hello_service_skeleton() {
     assert!(source.contains("import type { TyselEnv } from \"../tysel-env.js\""));
     assert!(source.contains("} satisfies TyselApp<TyselEnv>;"));
     assert!(dir.join("tysel-env.d.ts").is_file());
+    assert_eq!(
+        fs::read_to_string(dir.join(".tysel/manifest.schema.json")).unwrap(),
+        tysel_manifest::JSON_SCHEMA
+    );
+    assert!(
+        fs::read_to_string(dir.join("tysel.toml"))
+            .unwrap()
+            .starts_with("#:schema .tysel/manifest.schema.json\n")
+    );
     let tsconfig: serde_json::Value =
         serde_json::from_slice(&fs::read(dir.join("tsconfig.json")).unwrap()).unwrap();
     assert_eq!(
@@ -793,6 +802,37 @@ fn init_merges_tysel_entries_into_an_existing_gitignore() {
     assert!(gitignore.contains(".tysel/\n"));
 }
 
+#[test]
+fn init_keeps_the_schema_trackable_but_ignores_runtime_state() {
+    for (index, existing) in
+        ["", ".tysel/\n", "!.tysel/\n!.tysel/manifest.schema.json\n.tysel/\n"].iter().enumerate()
+    {
+        let dir = temp_app(&format!("init-schema-git-{index}"));
+        fs::write(dir.join(".gitignore"), existing).unwrap();
+        let output = Command::new(cli_exe())
+            .args(["init", dir.to_str().unwrap(), "--package-json", "none", "--yes"])
+            .output()
+            .unwrap();
+        assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
+        assert!(Command::new("git").args(["init", "-q"]).arg(&dir).status().unwrap().success());
+        fs::write(dir.join(".tysel/local-cache"), "local state").unwrap();
+        let ignored = |path: &str| {
+            Command::new("git")
+                .current_dir(&dir)
+                .args(["check-ignore", "-q", path])
+                .status()
+                .unwrap()
+        };
+        assert_eq!(
+            ignored(".tysel/manifest.schema.json").code(),
+            Some(1),
+            "schema hidden for {existing:?}"
+        );
+        assert_eq!(ignored(".tysel/local-cache").code(), Some(0));
+        fs::remove_dir_all(dir).unwrap();
+    }
+}
+
 #[test]
 fn project_discovery_walks_up_and_config_reports_the_context() {
     let dir = temp_app("project-discovery");
@@ -1562,6 +1602,91 @@ fn dev_reloads_source_but_ignores_node_modules() {
     let _ = child.wait();
 }
 
+#[test]
+fn check_ignores_erased_imports_and_locates_nested_runtime_imports() {
+    let dir = temp_app("check-import-diagnostics");
+    write_js_app(&dir, "export { default } from './nested.js';\n");
+    // write_js_app uses src/index.js; .js specifiers resolve to .ts sources.
+    let nested = dir.join("src/nested.ts");
+    fs::write(&nested, "import { type Stats } from 'node:fs';\nexport default {};\n").unwrap();
+    let invoke = || {
+        Command::new(cli_exe())
+            .args(["--error-format", "json", "check", "--manifest"])
+            .arg(dir.join("tysel.toml"))
+            .output()
+            .unwrap()
+    };
+    let output = invoke();
+    assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
+    fs::write(&nested, "import 'node:fs';\nexport default {};\n").unwrap();
+    let output = invoke();
+    assert!(!output.status.success());
+    let output: serde_json::Value = serde_json::from_slice(&output.stderr).unwrap();
+    assert_eq!(output["diagnostics"][0]["code"], "TYSEL_NODE_BUILTIN_UNSUPPORTED");
+    assert!(output["diagnostics"][0]["file"].as_str().unwrap().ends_with("src/nested.ts"));
+    assert_eq!(output["diagnostics"][0]["start"]["line"], 1);
+}
+
+#[test]
+fn dev_syncs_types_preserves_them_on_manifest_errors_and_recovers() {
+    let dir = temp_app("dev-type-sync");
+    fs::create_dir_all(dir.join("src")).unwrap();
+    let manifest_path = dir.join("tysel.toml");
+    let valid =
+        "[app]\nname = 'type-sync'\nentry = 'src/index.ts'\n[server]\nlisten = '127.0.0.1:0'\n";
+    fs::write(&manifest_path, valid).unwrap();
+    fs::write(
+        dir.join("src/index.ts"),
+        "export default { fetch() { return new Response('ok'); } };\n",
+    )
+    .unwrap();
+    let mut child = ManagedChild::spawn(
+        Command::new(cli_exe())
+            .args(["--error-format", "json", "dev", "--manifest"])
+            .arg(&manifest_path)
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped()),
+        "dev type sync",
+    );
+    let (addr, log) = wait_listen(&mut child, Duration::from_secs(8));
+    wait_log(&log, "\"generation\":0", Duration::from_secs(5));
+    let path = dir.join("tysel-env.d.ts");
+    let original = fs::read_to_string(&path).unwrap();
+    assert!(!original.contains("TOKEN"));
+    fs::write(&manifest_path, format!("{valid}\n[permissions]\nsecrets = ['TOKEN']\n")).unwrap();
+    wait_log(&log, "\"generation\":1", Duration::from_secs(5));
+    let generated = fs::read_to_string(&path).unwrap();
+    assert!(generated.contains("TOKEN"));
+    let invalid = valid.replace("listen =", "workers = 0\nlisten =");
+    fs::write(&manifest_path, &invalid).unwrap();
+    wait_log(&log, "TYSEL_MANIFEST_INVALID", Duration::from_secs(5));
+    assert_eq!(fs::read_to_string(&path).unwrap(), generated);
+    assert!(http_get(&addr).contains("ok"));
+    let cli = Command::new(cli_exe())
+        .args(["--error-format", "json", "check", "--manifest"])
+        .arg(&manifest_path)
+        .output()
+        .unwrap();
+    assert!(!cli.status.success());
+    let cli: serde_json::Value = serde_json::from_slice(&cli.stderr).unwrap();
+    let event: serde_json::Value = log
+        .lock()
+        .unwrap()
+        .lines()
+        .filter_map(|line| serde_json::from_str::<serde_json::Value>(line).ok())
+        .find(|event| event["diagnostics"][0]["code"] == "TYSEL_MANIFEST_INVALID")
+        .unwrap();
+    assert_eq!(cli["diagnostics"], event["diagnostics"]);
+    assert_eq!(event["diagnostics"][0]["start"]["line"], 5);
+    fs::write(&manifest_path, valid).unwrap();
+    wait_log(&log, "\"generation\":3", Duration::from_secs(5));
+    assert_eq!(fs::read_to_string(&path).unwrap(), original);
+    // Generated output must not cause a second reload or overwrite editor changes.
+    thread::sleep(Duration::from_millis(300));
+    assert!(!log.lock().unwrap().contains("\"generation\":4"));
+    assert!(http_get(&addr).contains("ok"));
+}
+
 #[test]
 fn dev_json_diagnostics_are_replaced_after_a_successful_reload() {
     let dir = temp_app("dev-json-diagnostics");
diff --git a/crates/tysel-manifest/Cargo.toml b/crates/tysel-manifest/Cargo.toml
index f3c69cd..103e09c 100644
--- a/crates/tysel-manifest/Cargo.toml
+++ b/crates/tysel-manifest/Cargo.toml
@@ -13,6 +13,7 @@ workspace = true
 
 [dependencies]
 serde.workspace = true
-serde_json.workspace = true
+serde_json = { workspace = true, features = ["raw_value"] }
 thiserror.workspace = true
 toml.workspace = true
+toml_edit = "0.22"
diff --git a/crates/tysel-manifest/schema/tysel-manifest-v1.schema.json b/crates/tysel-manifest/schema/tysel-manifest-v1.schema.json
index e3ff51e..e28b203 100644
--- a/crates/tysel-manifest/schema/tysel-manifest-v1.schema.json
+++ b/crates/tysel-manifest/schema/tysel-manifest-v1.schema.json
@@ -6,22 +6,25 @@
   "additionalProperties": false,
   "required": ["app"],
   "properties": {
-    "schema_version": { "type": "integer", "const": 1, "default": 1 },
+    "schema_version": { "type": "integer", "const": 1, "default": 1, "description": "Manifest contract version supported by this toolchain." },
     "app": {
       "type": "object",
       "additionalProperties": false,
       "required": ["name", "entry"],
       "properties": {
         "name": {
+          "description": "Application identity used in packaging and diagnostics.",
           "type": "string",
           "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]*$"
         },
         "entry": {
+          "description": "Application entry relative to the project root. Component profiles require a .wasm file.",
           "type": "string",
           "minLength": 1,
           "pattern": "^(?![A-Za-z]:)(?!/)(?!\\.(?:/\\.)*/?$)(?!.*(?:^|/)\\.\\.(?:/|$))[^\\\\\\u0000-\\u001F]+$"
         },
         "profile": {
+          "description": "Execution model: trusted service, isolated worker, or experimental Wasm Component.",
           "type": "string",
           "enum": ["service", "isolated", "component"],
           "default": "service"
@@ -81,6 +84,7 @@
       ]
     },
     "permissions": {
+      "description": "Explicit host-resource grants. Resources are denied unless granted; types do not replace runtime enforcement.",
       "type": "object",
       "additionalProperties": false,
       "properties": {
diff --git a/crates/tysel-manifest/src/diagnostic.rs b/crates/tysel-manifest/src/diagnostic.rs
new file mode 100644
index 0000000..8e9147a
--- /dev/null
+++ b/crates/tysel-manifest/src/diagnostic.rs
@@ -0,0 +1,130 @@
+use std::collections::BTreeMap;
+use std::ops::Range;
+use std::path::{Path, PathBuf};
+
+use crate::{ManifestError, ManifestFormat};
+
+/// A manifest failure tied to the exact source snapshot that was validated.
+#[derive(Debug, thiserror::Error)]
+#[error("{error}")]
+pub struct ManifestSourceError {
+    pub file: PathBuf,
+    pub source_text: String,
+    pub code: &'static str,
+    pub range: Option<Range<usize>>,
+    #[source]
+    pub error: ManifestError,
+}
+
+impl ManifestSourceError {
+    pub(crate) fn new(
+        path: &Path,
+        raw: String,
+        format: ManifestFormat,
+        error: ManifestError,
+    ) -> Self {
+        let (code, range) = match &error {
+            ManifestError::Toml(error) => ("TYSEL_MANIFEST_PARSE_ERROR", error.span()),
+            ManifestError::Json(error) => {
+                // serde_json reports a one-based byte column; retain an insertion
+                // point rather than claiming a whole token is invalid.
+                let line_start = raw
+                    .split_inclusive('\n')
+                    .take(error.line().saturating_sub(1))
+                    .map(str::len)
+                    .sum::<usize>();
+                let offset = (line_start + error.column().saturating_sub(1)).min(raw.len());
+                ("TYSEL_MANIFEST_PARSE_ERROR", (error.line() > 0).then_some(offset..offset))
+            }
+            ManifestError::Field { field, .. } => {
+                ("TYSEL_MANIFEST_INVALID", field_range(&raw, format, field))
+            }
+            _ => ("TYSEL_MANIFEST_INVALID", None),
+        };
+        Self { file: path.to_path_buf(), source_text: raw, code, range, error }
+    }
+}
+
+fn field_range(raw: &str, format: ManifestFormat, field: &[String]) -> Option<Range<usize>> {
+    match format {
+        ManifestFormat::Toml => {
+            // ImDocument retains parser spans; DocumentMut would discard them.
+            let document = toml_edit::ImDocument::parse(raw).ok()?;
+            let mut item = document.as_item();
+            for part in field {
+                item = item.get(part.as_str())?;
+            }
+            item.span()
+        }
+        ManifestFormat::Json => {
+            // Borrow RawValue slices to locate nested values without searching
+            // for key text (which may also occur in strings or other objects).
+            let mut value = raw;
+            for part in field {
+                let object: BTreeMap<String, &serde_json::value::RawValue> =
+                    serde_json::from_str(value).ok()?;
+                value = object.get(part)?.get();
+            }
+            let offset = value.as_ptr() as usize - raw.as_ptr() as usize;
+            Some(offset..offset + value.len())
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::Manifest;
+
+    #[test]
+    fn semantic_ranges_identify_nested_values_in_both_formats() {
+        let cases = [
+            (
+                ManifestFormat::Toml,
+                "# 王😀 workers = 0\n[app]\nname = 'test'\nentry = 'index.ts'\n[server]\nworkers = 0\n",
+            ),
+            (
+                ManifestFormat::Toml,
+                "app = { name = 'test', entry = 'index.ts' }\nserver.workers = 0\n",
+            ),
+            (
+                ManifestFormat::Json,
+                r#"{"app":{"name":"test","entry":"workers-王😀.ts"},"server":{"workers":0}}"#,
+            ),
+        ];
+        for (format, raw) in cases {
+            let error = Manifest::parse_with_format(raw, format).unwrap_err();
+            let diagnostic =
+                ManifestSourceError::new(Path::new("manifest"), raw.to_owned(), format, error);
+            assert_eq!(diagnostic.code, "TYSEL_MANIFEST_INVALID");
+            assert_eq!(&raw[diagnostic.range.unwrap()], "0");
+        }
+    }
+
+    #[test]
+    fn absent_default_field_has_no_invented_location() {
+        for (format, raw) in [
+            (ManifestFormat::Toml, "[app]\nname = 'test'\nentry = 'main.wasm'\n"),
+            (ManifestFormat::Json, r#"{"app":{"name":"test","entry":"main.wasm"}}"#),
+        ] {
+            // Explicit field identities also work when the field is absent.
+            let error =
+                ManifestError::invalid_field(&["app", "profile"], "profile required".into());
+            let diagnostic =
+                ManifestSourceError::new(Path::new("manifest"), raw.to_owned(), format, error);
+            assert_eq!(diagnostic.range, None);
+        }
+    }
+
+    #[test]
+    fn syntax_failures_have_a_stable_parse_code() {
+        for (format, raw) in [(ManifestFormat::Toml, "[app"), (ManifestFormat::Json, "{\n  ")] {
+            let error = Manifest::parse_with_format(raw, format).unwrap_err();
+            let diagnostic =
+                ManifestSourceError::new(Path::new("manifest"), raw.to_owned(), format, error);
+            assert_eq!(diagnostic.code, "TYSEL_MANIFEST_PARSE_ERROR");
+            let range = diagnostic.range.unwrap();
+            assert!(range.start <= range.end && range.end <= raw.len());
+        }
+    }
+}
diff --git a/crates/tysel-manifest/src/lib.rs b/crates/tysel-manifest/src/lib.rs
index b505443..530bab7 100644
--- a/crates/tysel-manifest/src/lib.rs
+++ b/crates/tysel-manifest/src/lib.rs
@@ -10,6 +10,9 @@ use std::path::{Path, PathBuf};
 
 use serde::{Deserialize, Serialize};
 
+mod diagnostic;
+pub use diagnostic::ManifestSourceError;
+
 pub const MAX_FILESYSTEM_ROOTS_PER_OPERATION: usize = 64;
 pub const JSON_SCHEMA: &str = include_str!("../schema/tysel-manifest-v1.schema.json");
 
@@ -27,6 +30,16 @@ pub enum ManifestError {
     UnsupportedFormat(PathBuf),
     #[error("{0}")]
     Invalid(String),
+    #[error("{message}")]
+    Field { field: Vec<String>, message: String },
+    #[error(transparent)]
+    Located(Box<ManifestSourceError>),
+}
+
+impl ManifestError {
+    fn invalid_field(field: &[&str], message: String) -> Self {
+        Self::Field { field: field.iter().map(|part| (*part).to_owned()).collect(), message }
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -253,7 +266,9 @@ impl Manifest {
         let path = path.as_ref();
         let format = ManifestFormat::from_path(path)?;
         let raw = fs::read_to_string(path)?;
-        Self::parse_with_format(&raw, format)
+        Self::parse_with_format(&raw, format).map_err(|error| {
+            ManifestError::Located(Box::new(ManifestSourceError::new(path, raw, format, error)))
+        })
     }
 
     /// Parse a TOML manifest. Kept for callers embedding existing TOML fixtures.
@@ -353,10 +368,12 @@ impl Manifest {
         let is_component =
             entry.extension().and_then(|extension| extension.to_str()) == Some("wasm");
         match (self.app.profile.as_str(), is_component) {
-            ("component", false) => Err(ManifestError::Invalid(
+            ("component", false) => Err(ManifestError::invalid_field(
+                &["app", "entry"],
                 "app.profile = \"component\" requires a .wasm entry".into(),
             )),
-            (profile, true) if profile != "component" => Err(ManifestError::Invalid(
+            (profile, true) if profile != "component" => Err(ManifestError::invalid_field(
+                &["app", "entry"],
                 ".wasm entry requires app.profile = \"component\"".into(),
             )),
             _ => Ok(()),
@@ -365,48 +382,63 @@ impl Manifest {
 
     fn validate(&self) -> Result<(), ManifestError> {
         if self.schema_version != 1 {
-            return Err(ManifestError::Invalid(format!(
-                "unsupported schema_version {}; expected 1",
-                self.schema_version
-            )));
+            return Err(ManifestError::invalid_field(
+                &["schema_version"],
+                format!("unsupported schema_version {}; expected 1", self.schema_version),
+            ));
         }
         if self.app.name.trim().is_empty() {
-            return Err(ManifestError::Invalid("app.name must be non-empty".into()));
+            return Err(ManifestError::invalid_field(
+                &["app", "name"],
+                "app.name must be non-empty".into(),
+            ));
         }
         if !is_app_name(&self.app.name) {
-            return Err(ManifestError::Invalid(
+            return Err(ManifestError::invalid_field(&["app", "name"],
                 "app.name must start with a letter or digit and contain only letters, digits, '-', '_' or '.'"
                     .into(),
             ));
         }
         if self.app.entry.trim().is_empty() {
-            return Err(ManifestError::Invalid("app.entry must be non-empty".into()));
+            return Err(ManifestError::invalid_field(
+                &["app", "entry"],
+                "app.entry must be non-empty".into(),
+            ));
         }
         validate_entry(&self.app.entry)?;
         if !self.server.http1 && !self.server.http2 {
-            return Err(ManifestError::Invalid(
+            return Err(ManifestError::invalid_field(
+                &["server", "http1"],
                 "server must enable at least one of http1 or http2".into(),
             ));
         }
         if self.server.websocket && !self.server.http1 {
-            return Err(ManifestError::Invalid(
+            return Err(ManifestError::invalid_field(
+                &["server", "websocket"],
                 "server.websocket requires server.http1 because WebSocket upgrades use HTTP/1.1"
                     .into(),
             ));
         }
         if !(1..=64).contains(&self.server.workers) {
-            return Err(ManifestError::Invalid("server.workers must be between 1 and 64".into()));
+            return Err(ManifestError::invalid_field(
+                &["server", "workers"],
+                "server.workers must be between 1 and 64".into(),
+            ));
         }
         if self.server.workers > 1 && self.app.profile != "service" {
-            return Err(ManifestError::Invalid(
+            return Err(ManifestError::invalid_field(
+                &["server", "workers"],
                 "server.workers greater than 1 requires app.profile = \"service\"".into(),
             ));
         }
         if !matches!(self.app.profile.as_str(), "service" | "isolated" | "component") {
-            return Err(ManifestError::Invalid(format!(
-                "unsupported app profile {:?}; expected service, isolated, or component",
-                self.app.profile
-            )));
+            return Err(ManifestError::invalid_field(
+                &["app", "profile"],
+                format!(
+                    "unsupported app profile {:?}; expected service, isolated, or component",
+                    self.app.profile
+                ),
+            ));
         }
         self.validate_entry_profile(Path::new(&self.app.entry))?;
         validate_string_set("permissions.fetch", &self.permissions.fetch)?;
@@ -420,33 +452,43 @@ impl Manifest {
                 .filter(|root| !root.is_empty())
                 .collect::<std::collections::BTreeSet<_>>();
             if unique.len() != roots.len() {
-                return Err(ManifestError::Invalid(format!(
-                    "{operation} roots must be non-empty and unique"
-                )));
+                return Err(ManifestError::invalid_field(
+                    &["permissions", operation],
+                    format!("{operation} roots must be non-empty and unique"),
+                ));
             }
             if unique.len() > MAX_FILESYSTEM_ROOTS_PER_OPERATION {
-                return Err(ManifestError::Invalid(format!(
-                    "{operation} declares more than {MAX_FILESYSTEM_ROOTS_PER_OPERATION} roots"
-                )));
+                return Err(ManifestError::invalid_field(
+                    &["permissions", operation],
+                    format!(
+                        "{operation} declares more than {MAX_FILESYSTEM_ROOTS_PER_OPERATION} roots"
+                    ),
+                ));
             }
         }
         if self.permissions.postgres.len() > 1 {
-            return Err(ManifestError::Invalid(
+            return Err(ManifestError::invalid_field(
+                &["permissions", "postgres"],
                 "this runtime supports exactly one Postgres connection; declare at most one grant"
                     .into(),
             ));
         }
         for item in &self.permissions.postgres {
-            parse_postgres_grant(item).map_err(ManifestError::Invalid)?;
+            parse_postgres_grant(item).map_err(|message| {
+                ManifestError::invalid_field(&["permissions", "postgres"], message)
+            })?;
         }
         if self.permissions.redis.len() > 1 {
-            return Err(ManifestError::Invalid(
+            return Err(ManifestError::invalid_field(
+                &["permissions", "redis"],
                 "this runtime supports exactly one Redis connection; declare at most one grant"
                     .into(),
             ));
         }
         for item in &self.permissions.redis {
-            parse_redis_grant(item).map_err(ManifestError::Invalid)?;
+            parse_redis_grant(item).map_err(|message| {
+                ManifestError::invalid_field(&["permissions", "redis"], message)
+            })?;
         }
         self.validate_tasks()?;
         Ok(())
@@ -455,41 +497,53 @@ impl Manifest {
     fn validate_tasks(&self) -> Result<(), ManifestError> {
         for (name, task) in &self.tasks {
             if !is_task_name(name) {
-                return Err(ManifestError::Invalid(format!(
-                    "invalid task name {name:?}; start with a letter or digit, then use letters, digits, '-', '_' or ':'"
-                )));
+                return Err(ManifestError::invalid_field(
+                    &["tasks", name],
+                    format!(
+                        "invalid task name {name:?}; start with a letter or digit, then use letters, digits, '-', '_' or ':'"
+                    ),
+                ));
             }
             if task.depends.is_empty() && task.steps.is_empty() {
-                return Err(ManifestError::Invalid(format!(
-                    "task {name:?} must declare depends or steps"
-                )));
+                return Err(ManifestError::invalid_field(
+                    &["tasks", name],
+                    format!("task {name:?} must declare depends or steps"),
+                ));
             }
             let mut dependencies = BTreeSet::new();
             for dependency in &task.depends {
                 if !self.tasks.contains_key(dependency) {
-                    return Err(ManifestError::Invalid(format!(
-                        "task {name:?} depends on unknown task {dependency:?}"
-                    )));
+                    return Err(ManifestError::invalid_field(
+                        &["tasks", name],
+                        format!("task {name:?} depends on unknown task {dependency:?}"),
+                    ));
                 }
                 if !dependencies.insert(dependency) {
-                    return Err(ManifestError::Invalid(format!(
-                        "task {name:?} contains duplicate dependency {dependency:?}"
-                    )));
+                    return Err(ManifestError::invalid_field(
+                        &["tasks", name],
+                        format!("task {name:?} contains duplicate dependency {dependency:?}"),
+                    ));
                 }
             }
             for (index, step) in task.steps.iter().enumerate() {
                 if step.is_empty() || step.iter().any(|argument| argument.is_empty()) {
-                    return Err(ManifestError::Invalid(format!(
-                        "task {name:?} step {} must contain non-empty arguments",
-                        index + 1
-                    )));
+                    return Err(ManifestError::invalid_field(
+                        &["tasks", name],
+                        format!(
+                            "task {name:?} step {} must contain non-empty arguments",
+                            index + 1
+                        ),
+                    ));
                 }
                 if !is_task_command(&step[0]) {
-                    return Err(ManifestError::Invalid(format!(
-                        "task {name:?} step {} uses unsupported Tysel command {:?}",
-                        index + 1,
-                        step[0]
-                    )));
+                    return Err(ManifestError::invalid_field(
+                        &["tasks", name],
+                        format!(
+                            "task {name:?} step {} uses unsupported Tysel command {:?}",
+                            index + 1,
+                            step[0]
+                        ),
+                    ));
                 }
                 if step[1..].iter().any(|argument| {
                     matches!(
@@ -500,10 +554,13 @@ impl Manifest {
                         || argument.starts_with("--project=")
                         || argument.starts_with("--project-dir=")
                 }) {
-                    return Err(ManifestError::Invalid(format!(
-                        "task {name:?} step {} cannot override its project selection",
-                        index + 1
-                    )));
+                    return Err(ManifestError::invalid_field(
+                        &["tasks", name],
+                        format!(
+                            "task {name:?} step {} cannot override its project selection",
+                            index + 1
+                        ),
+                    ));
                 }
             }
         }
@@ -524,7 +581,10 @@ fn validate_string_set(name: &str, values: &[String]) -> Result<(), ManifestErro
         .filter(|value| !value.is_empty())
         .collect::<BTreeSet<_>>();
     if unique.len() != values.len() {
-        return Err(ManifestError::Invalid(format!("{name} values must be non-empty and unique")));
+        return Err(ManifestError::invalid_field(
+            &name.split('.').collect::<Vec<_>>(),
+            format!("{name} values must be non-empty and unique"),
+        ));
     }
     Ok(())
 }
@@ -537,7 +597,8 @@ fn is_app_name(name: &str) -> bool {
 
 fn validate_entry(entry: &str) -> Result<(), ManifestError> {
     if entry.chars().any(char::is_control) || entry.contains('\\') {
-        return Err(ManifestError::Invalid(
+        return Err(ManifestError::invalid_field(
+            &["app", "entry"],
             "app.entry must use '/' separators and contain no control characters".into(),
         ));
     }
@@ -559,7 +620,8 @@ fn validate_entry(entry: &str) -> Result<(), ManifestError> {
         })
         || !has_normal_component
     {
-        return Err(ManifestError::Invalid(
+        return Err(ManifestError::invalid_field(
+            &["app", "entry"],
             "app.entry must be a project-relative path without '..'".into(),
         ));
     }
@@ -598,7 +660,10 @@ fn visit_task<'a>(
         return Ok(());
     }
     if !visiting.insert(name) {
-        return Err(ManifestError::Invalid(format!("task dependency cycle includes {name:?}")));
+        return Err(ManifestError::invalid_field(
+            &["tasks", name, "depends"],
+            format!("task dependency cycle includes {name:?}"),
+        ));
     }
     for dependency in &tasks[name].depends {
         visit_task(dependency, tasks, visiting, visited)?;
diff --git a/docs/concepts/projects-and-configuration.md b/docs/concepts/projects-and-configuration.md
index 41022d8..5d0626f 100644
--- a/docs/concepts/projects-and-configuration.md
+++ b/docs/concepts/projects-and-configuration.md
@@ -236,6 +236,39 @@ root manifest that would make discovery ambiguous.
 `tysel config schema` prints the bundled Draft 2020-12 JSON Schema for editor,
 CI, and tooling integration. The runtime validator remains authoritative.
 
+New TOML projects include `.tysel/manifest.schema.json` and this header in
+`tysel.toml`:
+
+```toml
+#:schema .tysel/manifest.schema.json
+```
+
+A Taplo-enabled editor uses the local schema for field completion and schema
+validation without downloading it. Keep the schema in version control. For an
+existing project, export the installed toolchain's schema and add the header:
+
+```sh
+mkdir -p .tysel
+tysel config schema > .tysel/manifest.schema.json
+```
+
+New projects keep this schema visible to Git while ignoring other `.tysel`
+contents. If an existing project ignores `.tysel/`, append these ordered rules
+to `.gitignore` so the schema is available to other developers after checkout:
+
+```gitignore
+!.tysel/
+.tysel/*
+!.tysel/manifest.schema.json
+```
+
+Re-export after upgrading the toolchain. JSON projects can associate this schema
+through their editor's JSON schema settings; do not add a `$schema` property to
+`tysel.json`, because the manifest rejects unknown fields. Schema feedback does
+not replace `tysel check`: grant syntax and task dependency checks also use
+runtime validation rules.
+
+
 ## Reproducible project tasks
 
 The manifest can compose Tysel commands without shell-specific quoting or a
diff --git a/docs/reference/cli/development.md b/docs/reference/cli/development.md
index 439c5c1..2349a45 100644
--- a/docs/reference/cli/development.md
+++ b/docs/reference/cli/development.md
@@ -88,6 +88,18 @@ successful rebuild. An explicit `ENTRY` overrides `app.entry` for this run.
 Development mode can read `.env`, but only declared secrets and named Postgres
 and Redis connections become visible through their host capabilities.
 
+At startup and on reload, dev validates the manifest and synchronizes the default
+`tysel-env.d.ts` before building the application. Identical output is not written,
+and generated declaration changes do not trigger another reload. A rejected
+manifest preserves the previous declaration and running application. A valid
+manifest can update types even if the subsequent source build fails.
+
+Dev refuses to overwrite a user-owned declaration or follow an output symlink.
+Custom `tysel types --output` destinations remain manually managed. Use
+`tysel types --check` in CI; it never updates files. `tysel run` and `tysel check`
+also leave generated types unchanged.
+
+
 `tysel dev` rejects a `.wasm` Component entry. Components are one-shot tasks;
 use `tysel run` and provide one JSON value on stdin.
 
diff --git a/docs/reference/errors-and-output.md b/docs/reference/errors-and-output.md
index b1f7de3..cedfbe0 100644
--- a/docs/reference/errors-and-output.md
+++ b/docs/reference/errors-and-output.md
@@ -47,6 +47,25 @@ Fatal errors are one JSON object on stderr. Build failures also include a
 diagnostic, not as a stable programmatic discriminator. The process exits with
 status `1` for this fatal path.
 
+Individual static diagnostics use these stable codes:
+
+| Code | Meaning |
+| --- | --- |
+| `TYSEL_MANIFEST_PARSE_ERROR` | TOML/JSON syntax or deserialization failed. |
+| `TYSEL_MANIFEST_INVALID` | A manifest semantic rule failed. |
+| `TYSEL_NODE_BUILTIN_UNSUPPORTED` | A runtime import requests a Node builtin. |
+| `TYSEL_IMPORT_UNRESOLVED` | A runtime import cannot be resolved. |
+
+Manifest diagnostics use phase `manifest`; import diagnostics use `resolve`.
+Manifest validation reports the first failure, with its field range when
+available. Missing fields may have no range, and parser errors may point to an
+insertion point or enclosing table. Import diagnostics cover modules reached by
+the build resolver, including dependencies, and refer to original TypeScript
+source rather than emitted JavaScript. Erased type-only imports are excluded.
+TypeScript typecheck output itself remains compiler text, not this structured
+protocol.
+
+
 ## Development diagnostic stream
 
 `tysel --error-format json dev` writes one JSON object per diagnostic update to
diff --git a/packages/tysel-types/README.md b/packages/tysel-types/README.md
index 93d846c..56c9b4e 100644
--- a/packages/tysel-types/README.md
+++ b/packages/tysel-types/README.md
@@ -26,7 +26,9 @@ export default {
 } satisfies TyselApp<TyselEnv>;
 ```
 
-Run `tysel types` after changing manifest permissions. The package exports
+`tysel dev` synchronizes `tysel-env.d.ts` at startup and on reload after valid
+manifest changes. Outside dev, run `tysel types` after changing permissions;
+use `tysel types --check` in CI to detect stale declarations without writing files. The package exports
 application, task, capability, WebSocket, and durable-execution types, including
 `TyselApp`, `RequestContext`, `DurableContext`, and `TyselRuntime`. It also
 declares `globalThis.tysel`; underscored native bindings remain private.

From f613f0b463d151f7e6fd194dde02285617164416 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Sat, 5 Sep 2026 14:02:22 +0800
Subject: [PATCH 05/31] test: verify editor feedback and packaged example
 workflows

---
 tests/editor/README.md                        |  55 ++++
 tests/editor/evidence/vscode-2026-09-05.json  |  56 ++++
 tests/editor/extension.cjs                    |   2 +
 tests/editor/package.json                     |  10 +
 tests/editor/run.py                           |  81 ++++++
 tests/editor/test.cjs                         | 211 +++++++++++++++
 tests/workflows/README.md                     |  33 +++
 .../workflows/evidence/macos-2026-09-05.json  |  47 ++++
 tests/workflows/run.py                        | 246 ++++++++++++++++++
 9 files changed, 741 insertions(+)
 create mode 100644 tests/editor/README.md
 create mode 100644 tests/editor/evidence/vscode-2026-09-05.json
 create mode 100644 tests/editor/extension.cjs
 create mode 100644 tests/editor/package.json
 create mode 100644 tests/editor/run.py
 create mode 100644 tests/editor/test.cjs
 create mode 100644 tests/workflows/README.md
 create mode 100644 tests/workflows/evidence/macos-2026-09-05.json
 create mode 100644 tests/workflows/run.py

diff --git a/tests/editor/README.md b/tests/editor/README.md
new file mode 100644
index 0000000..e3fbdad
--- /dev/null
+++ b/tests/editor/README.md
@@ -0,0 +1,55 @@
+# Editor feedback smoke test
+
+This is a test-only VS Code extension host fixture, not an installable Tysel
+extension or LSP. It validates real editor providers against a generated project:
+
+- Local TOML schema completion and validation, with online catalogs disabled.
+- TypeScript capability completion and navigation to generated declarations.
+- Live type updates when saved manifest permissions change.
+- Invalid-manifest preservation and recovery.
+- Mapping dev JSON snapshots into VS Code diagnostics, including Unicode ranges,
+  canonical-path mapping for symlinked workspaces, replacement across files, stale
+  generations, and clearing after repair.
+- The generated schema is visible to Git while runtime state stays ignored.
+
+## Run
+
+Build the CLI and declarations first:
+
+```sh
+cargo build --offline -p tysel-cli
+pnpm --filter @tysel/types build
+```
+
+Supply a VS Code executable and a locally installed Even Better TOML extension:
+
+```sh
+python3 tests/editor/run.py \
+  --code '/Applications/Visual Studio Code.app/Contents/MacOS/Code' \
+  --toml-extension "$HOME/.vscode/extensions/tamasfe.even-better-toml-0.21.2" \
+  --output /tmp/tysel-editor-verification.json
+```
+
+The runner creates a temporary project, profile, and extension directory, then
+launches a separate test window. It copies only the selected TOML extension and
+uses VS Code's bundled TypeScript provider. It does not install dependencies,
+change the user's editor settings, or modify another project. GUI and local
+TCP/Unix socket access must be available. A 180-second timeout bounds the run.
+Reports and editor logs stay in the printed temporary directory for inspection.
+The JSON report also retains any TypeScript server errors seen in the editor log;
+passing the assertions alone does not imply the editor log was error-free.
+
+## Interpretation
+
+The diagnostic adapter lives only in `test.cjs`. It proves the saved-file event
+contract can feed the editor API, including error navigation; it is not a shipped
+Problems integration. It serializes event application and clears previous-file
+errors when a newer snapshot arrives. Runtime occurrence events are separate.
+
+The suite intentionally uses VS Code's bundled TypeScript provider and symlinks
+the built local `@tysel/types` declarations. It does not prove npm publication,
+TypeScript 7 native-extension support, unsaved-buffer Tysel analysis, multi-root
+workspace routing, process restart handling, or every JSON Schema keyword. A
+production adapter still needs those lifecycle and UX decisions, including
+how to avoid duplicate TOML/Tysel manifest errors and how to label stale errors
+when unsaved contents diverge from the snapshot on disk.
diff --git a/tests/editor/evidence/vscode-2026-09-05.json b/tests/editor/evidence/vscode-2026-09-05.json
new file mode 100644
index 0000000..09afcce
--- /dev/null
+++ b/tests/editor/evidence/vscode-2026-09-05.json
@@ -0,0 +1,56 @@
+{
+  "timestamp": "2026-09-05T05:47:03.036Z",
+  "vscode": "1.136.1",
+  "cases": [
+    {
+      "name": "TOML schema supplies profile completion without online catalogs",
+      "passed": true,
+      "milliseconds": 309
+    },
+    {
+      "name": "TypeScript offers declared capabilities and resolves generated types",
+      "passed": true,
+      "milliseconds": 297
+    },
+    {
+      "name": "Saved permission grants refresh TypeScript completion without restarting the service",
+      "passed": true,
+      "milliseconds": 485
+    },
+    {
+      "name": "Invalid manifest is shown by both TOML and Tysel providers and preserves types",
+      "passed": true,
+      "milliseconds": 161
+    },
+    {
+      "name": "Repairing and revoking grants clears manifest diagnostics and removes capabilities",
+      "passed": true,
+      "milliseconds": 485
+    },
+    {
+      "name": "Nested import errors convert UTF-8 offsets into correct editor UTF-16 ranges",
+      "passed": true,
+      "milliseconds": 188
+    },
+    {
+      "name": "Snapshots replace old-file errors and stale generations cannot restore them",
+      "passed": true,
+      "milliseconds": 386
+    }
+  ],
+  "scope": "Real VS Code providers and a test-only saved-document diagnostic adapter; no production extension installed.",
+  "typescriptExtension": "10.0.0",
+  "bundledTypeScript": "6.0.3",
+  "tomlExtension": "0.21.2",
+  "passed": true,
+  "generations": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6
+  ],
+  "editorWarnings": []
+}
diff --git a/tests/editor/extension.cjs b/tests/editor/extension.cjs
new file mode 100644
index 0000000..4abbfb7
--- /dev/null
+++ b/tests/editor/extension.cjs
@@ -0,0 +1,2 @@
+// Extension-host fixture only; this does not install a production extension.
+exports.activate = () => {};
diff --git a/tests/editor/package.json b/tests/editor/package.json
new file mode 100644
index 0000000..a91fe0b
--- /dev/null
+++ b/tests/editor/package.json
@@ -0,0 +1,10 @@
+{
+  "name": "tysel-editor-smoke",
+  "publisher": "tysel-test",
+  "displayName": "Tysel editor verification (test only)",
+  "version": "0.0.0",
+  "engines": { "vscode": "^1.90.0" },
+  "main": "./extension.cjs",
+  "activationEvents": [],
+  "private": true
+}
diff --git a/tests/editor/run.py b/tests/editor/run.py
new file mode 100644
index 0000000..115be21
--- /dev/null
+++ b/tests/editor/run.py
@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""Run real VS Code providers in a disposable profile. No npm install required."""
+import argparse
+import json
+import os
+from pathlib import Path
+import shutil
+import signal
+import subprocess
+import tempfile
+
+repo = Path(__file__).resolve().parents[2]
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument("--code", required=True, help="VS Code executable (not a running user profile)")
+parser.add_argument("--toml-extension", required=True, type=Path, help="Installed Even Better TOML extension directory")
+parser.add_argument("--output", type=Path, help="Optional JSON evidence destination")
+args = parser.parse_args()
+root = Path(tempfile.mkdtemp(prefix="tysel-editor-smoke-"))
+project = root / "project"
+cli = repo / "target/debug/tysel"
+if not cli.is_file() or not (repo / "packages/tysel-types/dist/index.d.ts").is_file():
+    parser.error("Build tysel-cli and @tysel/types first; see README.md")
+subprocess.run([str(cli), "init", str(project), "--yes", "--no-tests"], check=True, capture_output=True)
+subprocess.run(["git", "init", "-q", str(project)], check=True)
+ignored = subprocess.run(["git", "-C", str(project), "check-ignore", "-q", ".tysel/manifest.schema.json"])
+if ignored.returncode != 1:
+    raise RuntimeError("The generated editor schema is ignored by Git")
+# Resolve the built declarations locally; this tests workspace output, not npm publication.
+(project / "node_modules/@tysel").mkdir(parents=True)
+(project / "node_modules/@tysel/types").symlink_to(repo / "packages/tysel-types", target_is_directory=True)
+(project / "input").mkdir()
+manifest = project / "tysel.toml"
+manifest.write_text(manifest.read_text().replace('127.0.0.1:3000', '127.0.0.1:0'))
+profile = root / "user-data/User"
+profile.mkdir(parents=True)
+(profile / "settings.json").write_text(json.dumps({
+    "telemetry.telemetryLevel": "off", "update.mode": "none",
+    "extensions.autoUpdate": False, "extensions.autoCheckUpdates": False,
+    "extensions.ignoreRecommendations": True, "security.workspace.trust.enabled": False,
+    "workbench.startupEditor": "none", "chat.disableAIFeatures": True,
+    "evenBetterToml.schema.catalogs": [], "files.autoSave": "off",
+}))
+extensions = root / "extensions"
+extensions.mkdir()
+# Copy only the explicitly selected extension, leaving the normal profile untouched.
+shutil.copytree(args.toml_extension.resolve(), extensions / args.toml_extension.name)
+report = root / "report.json"
+env = os.environ.copy()
+env.pop("ELECTRON_RUN_AS_NODE", None)
+env.update(TYSEL_EDITOR_CLI=str(cli), TYSEL_EDITOR_REPORT=str(report))
+command = [args.code, "--new-window", "--skip-welcome", "--skip-release-notes",
+           "--disable-workspace-trust", "--user-data-dir=" + str(root / "user-data"),
+           "--extensions-dir=" + str(extensions),
+           "--extensionDevelopmentPath=" + str(Path(__file__).parent.resolve()),
+           "--extensionTestsPath=" + str(Path(__file__).with_name("test.cjs")), str(project)]
+print(f"Isolated editor evidence: {root}", flush=True)
+with (root / "editor.log").open("w") as log:
+    child = subprocess.Popen(command, env=env, stdout=log, stderr=subprocess.STDOUT, start_new_session=True)
+    try:
+        code = child.wait(timeout=180)
+    except subprocess.TimeoutExpired:
+        os.killpg(child.pid, signal.SIGTERM)
+        try:
+            child.wait(timeout=10)
+        except subprocess.TimeoutExpired:
+            os.killpg(child.pid, signal.SIGKILL)
+            child.wait()
+        raise RuntimeError(f"Editor verification timed out; inspect {root / 'editor.log'}")
+if report.exists():
+    evidence = json.loads(report.read_text())
+    warnings = [line for line in (root / "editor.log").read_text(errors="replace").splitlines()
+                if "TypeScript Server Error" in line or line.startswith("Could not find source file:")]
+    evidence["editorWarnings"] = list(dict.fromkeys(warnings))
+    report.write_text(json.dumps(evidence, indent=2) + "\n")
+    print(report.read_text())
+    if args.output:
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(report, args.output)
+else:
+    raise RuntimeError(f"Editor did not write a report; inspect {root / 'editor.log'}")
+raise SystemExit(code)
diff --git a/tests/editor/test.cjs b/tests/editor/test.cjs
new file mode 100644
index 0000000..bf90306
--- /dev/null
+++ b/tests/editor/test.cjs
@@ -0,0 +1,211 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+const readline = require('node:readline');
+const vscode = require('vscode');
+
+const pause = ms => new Promise(resolve => setTimeout(resolve, ms));
+async function until(description, read, accept = Boolean) {
+  const deadline = Date.now() + 25000;
+  let last;
+  while (Date.now() < deadline) {
+    last = await read();
+    if (accept(last)) return last;
+    await pause(150);
+  }
+  throw new Error(`${description}: timed out; last=${JSON.stringify(last)}`);
+}
+async function replace(document, text, save = true) {
+  const edit = new vscode.WorkspaceEdit();
+  edit.replace(document.uri, new vscode.Range(document.positionAt(0), document.positionAt(document.getText().length)), text);
+  assert(await vscode.workspace.applyEdit(edit));
+  if (save) assert(await document.save());
+}
+async function completions(document, marker) {
+  const offset = document.getText().indexOf(marker);
+  assert(offset >= 0, `missing completion marker ${marker}`);
+  const result = await vscode.commands.executeCommand('vscode.executeCompletionItemProvider',
+    document.uri, document.positionAt(offset + marker.length));
+  return (result?.items || []).map(item => typeof item.label === 'string' ? item.label : item.label.label);
+}
+
+// A deliberately small saved-document adapter. It exercises the existing event
+// contract through the real DiagnosticsCollection API, not a replacement LSP.
+async function diagnosticAdapter() {
+  const workspace = vscode.workspace.workspaceFolders[0].uri;
+  const canonicalRoot = await fs.realpath(workspace.fsPath);
+  const collection = vscode.languages.createDiagnosticCollection('tysel-editor-smoke');
+  let generation = -1;
+  const events = [];
+  let queue = Promise.resolve();
+  async function apply(event) {
+    if (event.event !== 'diagnostics' || event.schemaVersion !== 1 || event.generation <= generation) return;
+    const grouped = new Map();
+    for (const diagnostic of event.diagnostics) {
+      if (!diagnostic.file) continue;
+      const relative = path.relative(canonicalRoot, diagnostic.file);
+      const uri = !relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative)
+        ? vscode.Uri.file(path.join(workspace.fsPath, relative)) : vscode.Uri.file(diagnostic.file);
+      const document = await vscode.workspace.openTextDocument(uri);
+      const position = value => {
+        if (!value) return new vscode.Position(0, 0); // file-level fallback only
+        if (Number.isInteger(value.byteOffset)) {
+          return document.positionAt(Buffer.from(document.getText()).subarray(0, value.byteOffset).toString('utf8').length);
+        }
+        const line = value.line - 1;
+        const character = Array.from(document.lineAt(line).text).slice(0, value.column - 1).join('').length;
+        return new vscode.Position(line, character);
+      };
+      const item = new vscode.Diagnostic(new vscode.Range(position(diagnostic.start), position(diagnostic.end)),
+        diagnostic.message, diagnostic.severity === 'warning' ? vscode.DiagnosticSeverity.Warning : vscode.DiagnosticSeverity.Error);
+      item.code = diagnostic.code;
+      item.source = 'Tysel smoke';
+      const key = uri.toString();
+      if (!grouped.has(key)) grouped.set(key, [uri, []]);
+      grouped.get(key)[1].push(item);
+    }
+    collection.clear();
+    collection.set([...grouped.values()]);
+    generation = event.generation;
+    events.push(event);
+  }
+  return {
+    collection, events,
+    get generation() { return generation; },
+    accept(event) { queue = queue.then(() => apply(event)); return queue; },
+    flush() { return queue; },
+  };
+}
+
+exports.run = async function run() {
+  const root = vscode.workspace.workspaceFolders[0].uri.fsPath;
+  const report = { timestamp: new Date().toISOString(), vscode: vscode.version, cases: [], scope: 'Real VS Code providers and a test-only saved-document diagnostic adapter; no production extension installed.' };
+  const adapter = await diagnosticAdapter();
+  let child;
+  let streamError;
+  const test = async (name, operation) => {
+    const started = Date.now();
+    await operation();
+    report.cases.push({ name, passed: true, milliseconds: Date.now() - started });
+  };
+  const nextSnapshot = async operation => {
+    const before = adapter.generation;
+    await operation();
+    await until('dev diagnostic snapshot', () => {
+      if (streamError) throw streamError;
+      return adapter.generation > before;
+    });
+  };
+  try {
+    const ts = vscode.extensions.getExtension('vscode.typescript-language-features');
+    const toml = vscode.extensions.getExtension('tamasfe.even-better-toml');
+    assert(ts && toml, 'Required editor extensions were not discovered');
+    report.typescriptExtension = ts.packageJSON.version;
+    report.bundledTypeScript = JSON.parse(await fs.readFile(path.join(vscode.env.appRoot, 'extensions/node_modules/typescript/package.json'), 'utf8')).version;
+    report.tomlExtension = toml.packageJSON.version;
+    await ts.activate();
+    await toml.activate();
+    const manifest = await vscode.workspace.openTextDocument(path.join(root, 'tysel.toml'));
+    const baseManifest = manifest.getText();
+    const source = await vscode.workspace.openTextDocument(path.join(root, 'src/index.ts'));
+    const baseSource = `import type { TyselApp } from '@tysel/types';
+import type { TyselEnv } from '../tysel-env.js';
+export default {
+  async fetch(_request, runtime) {
+    runtime.sqlite;
+    return new Response('ok');
+  }
+} satisfies TyselApp<TyselEnv>;
+`;
+    await replace(source, baseSource);
+    await fs.writeFile(path.join(root, 'src/nested.ts'), `const label = '王😀'; import 'node:fs'; export default {};\n`);
+    await fs.writeFile(path.join(root, 'src/other.ts'), `import 'node:path'; export default {};\n`);
+    await test('TOML schema supplies profile completion without online catalogs', async () => {
+      await vscode.window.showTextDocument(manifest);
+      await replace(manifest, baseManifest.replace('profile = "service"', 'profile = ""'), false);
+      const labels = await until('TOML completion', () => completions(manifest, 'profile = "'),
+        items => items.some(item => item.includes('isolated')));
+      assert(labels.some(item => item.includes('component')));
+      await replace(manifest, baseManifest);
+    });
+    await test('TypeScript offers declared capabilities and resolves generated types', async () => {
+      await vscode.window.showTextDocument(source);
+      const labels = await until('runtime completion', () => completions(source, 'runtime.'), items => items.includes('sqlite'));
+      assert(!labels.includes('fs') && !labels.includes('secrets'));
+      const position = source.positionAt(source.getText().indexOf('TyselEnv') + 2);
+      const definitions = await vscode.commands.executeCommand('vscode.executeDefinitionProvider', source.uri, position);
+      assert(definitions.some(item => (item.targetUri || item.uri).fsPath.endsWith('tysel-env.d.ts')));
+    });
+    child = spawn(process.env.TYSEL_EDITOR_CLI, ['--error-format', 'json', 'dev'], { cwd: root, stdio: ['ignore', 'pipe', 'pipe'] });
+    const logs = [];
+    child.stdout.on('data', data => logs.push(data.toString()));
+    const lines = readline.createInterface({ input: child.stderr });
+    lines.on('line', line => {
+      logs.push(line);
+      try { adapter.accept(JSON.parse(line)).catch(error => { streamError = error; }); } catch { /* human log */ }
+    });
+    child.on('error', error => { streamError = error; });
+    child.on('exit', (code, signal) => { if (code !== null && code !== 0) streamError = new Error(`dev exited ${code}: ${logs.join('\n')}`); });
+    await until('dev startup', () => { if (streamError) throw streamError; return adapter.generation >= 0; });
+    await test('Saved permission grants refresh TypeScript completion without restarting the service', async () => {
+      await nextSnapshot(() => replace(manifest, baseManifest.replace('fs_read = []', 'fs_read = ["./input"]').replace('secrets = []', 'secrets = ["TOKEN"]')));
+      assert.equal(adapter.events.at(-1).diagnostics.length, 0, JSON.stringify(adapter.events.at(-1)));
+      await until('new capabilities', () => completions(source, 'runtime.'), items => items.includes('fs') && items.includes('secrets'));
+      assert((await fs.readFile(path.join(root, 'tysel-env.d.ts'), 'utf8')).includes('TOKEN'));
+    });
+    await test('Invalid manifest is shown by both TOML and Tysel providers and preserves types', async () => {
+      const oldTypes = await fs.readFile(path.join(root, 'tysel-env.d.ts'), 'utf8');
+      await nextSnapshot(() => replace(manifest, manifest.getText().replace('workers = 1', 'workers = 0')));
+      const item = adapter.collection.get(manifest.uri)?.[0];
+      assert.equal(item?.code, 'TYSEL_MANIFEST_INVALID');
+      assert.equal(manifest.getText(item.range), '0');
+      await until('TOML schema diagnostic', () => vscode.languages.getDiagnostics(manifest.uri),
+        diagnostics => diagnostics.some(item => item.source !== 'Tysel smoke' && item.message.includes('minimum')));
+      assert.equal(await fs.readFile(path.join(root, 'tysel-env.d.ts'), 'utf8'), oldTypes);
+    });
+    await test('Repairing and revoking grants clears manifest diagnostics and removes capabilities', async () => {
+      await nextSnapshot(() => replace(manifest, baseManifest));
+      assert(!adapter.collection.get(manifest.uri)?.length);
+      await until('revoked capabilities', () => completions(source, 'runtime.'), items => items.includes('sqlite') && !items.includes('fs') && !items.includes('secrets'));
+      await until('TOML diagnostics cleared', () => vscode.languages.getDiagnostics(manifest.uri), items => !items.length);
+    });
+    await test('Nested import errors convert UTF-8 offsets into correct editor UTF-16 ranges', async () => {
+      await nextSnapshot(() => replace(source, `export { default } from './nested.js';\n`));
+      const document = await vscode.workspace.openTextDocument(path.join(root, 'src/nested.ts'));
+      const item = adapter.collection.get(document.uri)?.[0];
+      assert.equal(item?.code, 'TYSEL_NODE_BUILTIN_UNSUPPORTED');
+      assert(document.getText(item.range).includes('node:fs'));
+      assert.equal(item.range.start.character, document.getText().indexOf("'node:fs'") + (document.getText(item.range).startsWith("'") ? 0 : 1));
+      await vscode.window.showTextDocument(document, { selection: item.range });
+      assert.equal(vscode.window.activeTextEditor.document.uri.toString(), document.uri.toString());
+    });
+    await test('Snapshots replace old-file errors and stale generations cannot restore them', async () => {
+      await vscode.window.showTextDocument(source);
+      const previous = adapter.events.at(-1);
+      await nextSnapshot(() => replace(source, `export { default } from './other.js';\n`));
+      assert(!adapter.collection.get(vscode.Uri.file(path.join(root, 'src/nested.ts')))?.length);
+      assert.equal(adapter.collection.get(vscode.Uri.file(path.join(root, 'src/other.ts')))?.[0].code, 'TYSEL_NODE_BUILTIN_UNSUPPORTED');
+      await adapter.accept(previous);
+      assert(!adapter.collection.get(vscode.Uri.file(path.join(root, 'src/nested.ts')))?.length);
+      await nextSnapshot(() => replace(source, baseSource));
+      assert(!vscode.languages.getDiagnostics().some(([, items]) => items.some(item => item.source === 'Tysel smoke')));
+    });
+    report.passed = true;
+    report.generations = adapter.events.map(event => event.generation);
+  } catch (error) {
+    report.passed = false;
+    report.error = error.stack;
+    report.lastDevEvent = adapter.events.at(-1);
+    throw error;
+  } finally {
+    if (child && child.exitCode === null) {
+      child.kill('SIGINT');
+      await Promise.race([new Promise(resolve => child.once('exit', resolve)), pause(2000)]);
+      if (child.exitCode === null && child.signalCode === null) child.kill('SIGKILL');
+    }
+    await adapter.flush().catch(() => {});
+    adapter.collection.dispose();
+    await fs.writeFile(process.env.TYSEL_EDITOR_REPORT, JSON.stringify(report, null, 2) + '\n');
+  }
+};
diff --git a/tests/workflows/README.md b/tests/workflows/README.md
new file mode 100644
index 0000000..f694447
--- /dev/null
+++ b/tests/workflows/README.md
@@ -0,0 +1,33 @@
+# Real-example workflow acceptance
+
+Run the repository's hello service, isolated plugin, and durable agent through
+permission edits, invalid configuration, source errors, recovery, typecheck,
+build, and execution from a deployment directory without source or npm packages.
+The durable artifact is restarted twice to check one LLM effect and one save.
+
+Prerequisites: Python 3, Node.js, the installed workspace TypeScript compiler,
+built `@tysel/types` declarations, and current local native tools:
+
+```sh
+cargo build --offline -p tysel-cli -p tysel-runtime -p tysel-isolate \
+  --bin tysel --bin tysel-service --bin tysel-worker
+pnpm --filter @tysel/types build
+python3 tests/workflows/run.py --output /tmp/tysel-workflow-verification.json
+```
+
+The runner creates temporary projects with `tysel init`, then uses the actual
+example source and manifests. It keeps the generated standalone tsconfig and
+links local type declarations and TypeScript instead of fetching packages. It
+uses ephemeral local ports and a fake local LLM endpoint with a test credential;
+no paid provider is contacted. The original example data remains untouched.
+Each server is stopped when its case finishes or fails. The printed fixture
+location and JSON report are retained for inspection.
+
+The isolated deployment case first verifies that omitting `tysel-worker` fails
+clearly, then copies the matching worker beside the executable and verifies
+network and filesystem denial. This is not a single-file isolation claim.
+
+The acceptance run uses debug artifacts on the current host. It does not certify
+release signing, cross-platform packaging, Linux security enforcement, or live
+LLM provider compatibility. The editor extension test fixture remains separate
+in `tests/editor`; no production editor extension is installed or developed here.
diff --git a/tests/workflows/evidence/macos-2026-09-05.json b/tests/workflows/evidence/macos-2026-09-05.json
new file mode 100644
index 0000000..390e048
--- /dev/null
+++ b/tests/workflows/evidence/macos-2026-09-05.json
@@ -0,0 +1,47 @@
+{
+  "timestamp": "2026-09-05T06:00:37.700948+00:00",
+  "platform": "Darwin",
+  "architecture": "arm64",
+  "scope": "Local debug tools/artifacts; fake local LLM; no release or Linux isolation claim",
+  "projects": [
+    {
+      "example": "hello-service",
+      "passed": true,
+      "stages": [
+        "dev permission change refreshes types",
+        "invalid manifest preserves service and types; CLI/dev diagnostics agree",
+        "source error is located and cleared after repair",
+        "pinned TypeScript check and read-only generated-type check pass",
+        "native development artifact builds with typecheck enabled",
+        "artifact runs without source, manifest, or npm dependencies"
+      ]
+    },
+    {
+      "example": "isolated-plugin",
+      "passed": true,
+      "stages": [
+        "dev permission change refreshes types",
+        "invalid manifest preserves service and types; CLI/dev diagnostics agree",
+        "source error is located and cleared after repair",
+        "isolated dev denies network and filesystem probes",
+        "pinned TypeScript check and read-only generated-type check pass",
+        "native development artifact builds with typecheck enabled",
+        "isolated deployment requires matching worker companion; missing worker fails clearly",
+        "artifact runs without source, manifest, or npm dependencies"
+      ]
+    },
+    {
+      "example": "durable-agent",
+      "passed": true,
+      "stages": [
+        "dev permission change refreshes types",
+        "invalid manifest preserves service and types; CLI/dev diagnostics agree",
+        "source error is located and cleared after repair",
+        "pinned TypeScript check and read-only generated-type check pass",
+        "native development artifact builds with typecheck enabled",
+        "artifact runs without source, manifest, or npm dependencies",
+        "two artifact restarts preserve durable state: one LLM call and one final save"
+      ]
+    }
+  ]
+}
diff --git a/tests/workflows/run.py b/tests/workflows/run.py
new file mode 100644
index 0000000..32f29d6
--- /dev/null
+++ b/tests/workflows/run.py
@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+"""Validate real example workflows against locally built tools, without external services."""
+import argparse
+import contextlib
+from datetime import datetime, timezone
+import http.client
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+import json
+import os
+from pathlib import Path
+import re
+import shutil
+import subprocess
+import tempfile
+import threading
+import time
+
+REPO = Path(__file__).resolve().parents[2]
+CLI = REPO / "target/debug/tysel"
+SERVICE = REPO / "target/debug/tysel-service"
+WORKER = REPO / "target/debug/tysel-worker"
+
+
+def wait_for(read, accept=bool, timeout=15):
+    end = time.monotonic() + timeout
+    value = None
+    while time.monotonic() < end:
+        value = read()
+        if accept(value):
+            return value
+        time.sleep(.05)
+    raise AssertionError(f"Timed out; last value: {value}")
+
+
+class Running:
+    def __init__(self, command, root, env):
+        self.lines, self.events = [], []
+        self.child = subprocess.Popen([str(x) for x in command], cwd=root, env=env,
+                                      stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        def drain(pipe):
+            for line in pipe:
+                self.lines.append(line.rstrip())
+                try:
+                    event = json.loads(line)
+                    if isinstance(event, dict) and event.get("event") == "diagnostics":
+                        self.events.append(event)
+                except ValueError:
+                    pass
+        for pipe in [self.child.stdout, self.child.stderr]:
+            threading.Thread(target=drain, args=(pipe,), daemon=True).start()
+
+    def address(self):
+        def read():
+            for line in self.lines:
+                if line.startswith("tysel listen "):
+                    return line.split()[-1]
+            if self.child.poll() is not None:
+                raise AssertionError("Startup failed: " + "\n".join(self.lines))
+        return wait_for(read)
+
+    def close(self):
+        if self.child.poll() is None:
+            self.child.terminate()
+            try:
+                self.child.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.child.kill()
+                self.child.wait()
+
+    def request(self, route="/", method="GET", body=None):
+        connection = http.client.HTTPConnection(self.address(), timeout=10)
+        connection.request(method, route, None if body is None else json.dumps(body),
+                           {"Content-Type": "application/json"})
+        response = connection.getresponse()
+        data = json.loads(response.read())
+        status = response.status
+        connection.close()
+        return status, data
+
+    def edit(self, path, text):
+        generation = self.events[-1]["generation"]
+        path.write_text(text)
+        return wait_for(lambda: next((event for event in reversed(self.events)
+                                     if event["generation"] > generation), None))
+
+
+@contextlib.contextmanager
+def running(command, root, env):
+    server = Running(command, root, env)
+    try:
+        server.address()
+        yield server
+    finally:
+        server.close()
+
+
+class Provider(BaseHTTPRequestHandler):
+    calls = 0
+
+    def do_POST(self):
+        self.rfile.read(int(self.headers.get("Content-Length", "0")))
+        Provider.calls += 1
+        body = json.dumps({"id": "local-workflow-test", "output_text": "Account looks healthy",
+                           "usage": {"input_tokens": 4, "output_tokens": 3}}).encode()
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def log_message(self, *args):
+        pass
+
+
+def run_command(root, env, *args, success=True):
+    result = subprocess.run([str(CLI), *args], cwd=root, env=env, capture_output=True, text=True, timeout=60)
+    assert (result.returncode == 0) == success, result.stdout + result.stderr
+    return result
+
+
+def verify(name, base, env):
+    root = base / name
+    run_command(base, env, "init", str(root), "--yes", "--no-tests")
+    example = REPO / "examples" / name
+    shutil.copytree(example / "src", root / "src", dirs_exist_ok=True)
+    manifest = root / "tysel.toml"
+    original_manifest = (example / "tysel.toml").read_text().replace("127.0.0.1:3000", "127.0.0.1:0")
+    manifest.write_text(original_manifest)
+    # The generated tsconfig is standalone. Link only built workspace types and the pinned compiler.
+    (root / "node_modules/@tysel").mkdir(parents=True)
+    (root / "node_modules/@tysel/types").symlink_to(REPO / "packages/tysel-types", target_is_directory=True)
+    (root / "node_modules/typescript").symlink_to(REPO / "node_modules/typescript", target_is_directory=True)
+    (root / "data").mkdir()
+    (root / "data/example.txt").write_text("must remain inaccessible to isolated code")
+    source = root / "src/index.ts"
+    original_source = source.read_text()
+    stages = []
+    with running([CLI, "--error-format", "json", "dev"], root, env) as dev:
+        wait_for(lambda: dev.events)
+        assert dev.request()[0] == 200
+        declarations = root / "tysel-env.d.ts"
+        before = declarations.read_text()
+        modified = re.sub(r'secrets\s*=\s*\[[^\]]*\]', 'secrets = ["OPENAI_API_KEY", "WORKFLOW_TOKEN"]', original_manifest)
+        if modified == original_manifest:
+            modified = original_manifest.replace('[permissions]', '[permissions]\nsecrets = ["WORKFLOW_TOKEN"]')
+        assert dev.edit(manifest, modified)["diagnostics"] == []
+        assert "WORKFLOW_TOKEN" in declarations.read_text()
+        stages.append("dev permission change refreshes types")
+        invalid = modified.replace('[server]', '[server]\nworkers = 0')
+        last_valid = declarations.read_text()
+        error = dev.edit(manifest, invalid)["diagnostics"][0]
+        assert error["code"] == "TYSEL_MANIFEST_INVALID"
+        assert declarations.read_text() == last_valid
+        assert dev.request()[0] == 200
+        cli_error = json.loads(run_command(root, env, "--error-format", "json", "check", success=False).stderr)
+        assert cli_error["diagnostics"][0] == error
+        assert dev.edit(manifest, original_manifest)["diagnostics"] == []
+        assert declarations.read_text() == before
+        stages.append("invalid manifest preserves service and types; CLI/dev diagnostics agree")
+        bad_source = "import 'node:fs';\n" + original_source
+        error = dev.edit(source, bad_source)["diagnostics"][0]
+        assert error["code"] == "TYSEL_NODE_BUILTIN_UNSUPPORTED" and error["start"]["line"] == 1
+        assert dev.request()[0] == 200
+        assert dev.edit(source, original_source)["diagnostics"] == []
+        stages.append("source error is located and cleared after repair")
+        if name == "isolated-plugin":
+            for route in ["/probe/fetch", "/probe/filesystem"]:
+                status, data = dev.request(route)
+                assert status == 403 and data["denied"] is True
+            stages.append("isolated dev denies network and filesystem probes")
+    result = run_command(root, env, "check")
+    assert "types     ok" in result.stdout, result.stdout
+    run_command(root, env, "types", "--check")
+    stages.append("pinned TypeScript check and read-only generated-type check pass")
+    binary = root / "dist" / name
+    result = run_command(root, env, "build", "--stub", str(SERVICE), "--output", str(binary))
+    assert "Type check       passed" in result.stdout
+    if name == "isolated-plugin":
+        assert "matching tysel-worker required" in result.stdout
+    stages.append("native development artifact builds with typecheck enabled")
+    # Run from a deployment directory containing no TS source, node_modules, or manifest.
+    deploy = root / "deployment"
+    deploy.mkdir()
+    app = deploy / name
+    shutil.copy2(binary, app)
+    if name == "isolated-plugin":
+        missing = subprocess.run([str(app)], cwd=deploy, env=env, capture_output=True, text=True, timeout=15)
+        assert missing.returncode != 0 and "worker binary not found" in missing.stderr, missing.stderr
+        shutil.copy2(WORKER, deploy / "tysel-worker")
+        stages.append("isolated deployment requires matching worker companion; missing worker fails clearly")
+    with running([app], deploy, env) as packaged:
+        assert packaged.request()[0] == 200
+        if name == "isolated-plugin":
+            for route in ["/probe/fetch", "/probe/filesystem"]:
+                status, data = packaged.request(route)
+                assert status == 403 and data["denied"] is True
+        if name == "durable-agent":
+            initial_calls = Provider.calls
+            status, data = packaged.request("/runs", "POST", {"customerId": "acceptance-1"})
+            assert status == 202 and data["status"] == "awaiting_approval", data
+            run_id = data["runId"]
+    stages.append("artifact runs without source, manifest, or npm dependencies")
+    if name == "durable-agent":
+        with running([app], deploy, env) as restarted:
+            assert restarted.request("/runs/" + run_id)[1]["status"] == "awaiting_approval"
+            restarted.request("/runs/" + run_id + "/approval", "POST", {"approved": True})
+            completed = wait_for(lambda: restarted.request("/runs/" + run_id)[1], lambda row: row["status"] == "completed")
+            assert completed["saveCount"] == 1
+        with running([app], deploy, env) as restarted_again:
+            assert restarted_again.request("/runs/" + run_id)[1]["saveCount"] == 1
+        assert Provider.calls - initial_calls == 1
+        stages.append("two artifact restarts preserve durable state: one LLM call and one final save")
+    return {"example": name, "passed": True, "stages": stages}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    base = Path(tempfile.mkdtemp(prefix="tysel-workflows-")).resolve()
+    print(f"Workflow fixtures: {base}", flush=True)
+    env = {key: value for key, value in os.environ.items()
+           if not key.startswith(("TYSEL_", "OPENAI_"))}
+    provider = ThreadingHTTPServer(("127.0.0.1", 0), Provider)
+    threading.Thread(target=provider.serve_forever, daemon=True).start()
+    env.update(TYSEL_LLM_ENDPOINT=f"http://127.0.0.1:{provider.server_port}/v1/responses",
+               TYSEL_LLM_MODEL="workflow-test", OPENAI_API_KEY="local-test-key")
+    report = {"timestamp": datetime.now(timezone.utc).isoformat(), "platform": os.uname().sysname, "architecture": os.uname().machine, "scope": "Local debug tools/artifacts; fake local LLM; no release or Linux isolation claim", "projects": []}
+    try:
+        for name in ["hello-service", "isolated-plugin", "durable-agent"]:
+            try:
+                result = verify(name, base, env)
+            except Exception as error:
+                result = {"example": name, "passed": False, "error": str(error)}
+            report["projects"].append(result)
+            print(json.dumps(result), flush=True)
+    finally:
+        provider.shutdown()
+        provider.server_close()
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+        args.output.write_text(json.dumps(report, indent=2) + "\n")
+    return 0 if all(row["passed"] for row in report["projects"]) else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 685df934f124339161a17ca47dbb846fce417715 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Sat, 5 Sep 2026 14:02:22 +0800
Subject: [PATCH 06/31] docs: record workflow acceptance and isolated
 deployment requirements

---
 README.md                          |   2 +-
 docs/editor-iteration-plan.md      | 163 +++++++++++++++++++++++++++++
 docs/operations/deployment.md      |   8 +-
 examples/isolated-plugin/README.md |  16 +++
 mkdocs.yml                         |   1 +
 5 files changed, 188 insertions(+), 2 deletions(-)
 create mode 100644 docs/editor-iteration-plan.md

diff --git a/README.md b/README.md
index c4197f9..64f63ba 100644
--- a/README.md
+++ b/README.md
@@ -117,7 +117,7 @@ command.
 | Toolchain | Linux and macOS, x64 and arm64 |
 | Windows | WSL; no native Windows archive yet |
 | `service` profile | Trusted first-party application code |
-| `isolated` profile | Separate worker process; Linux is the production security gate |
+| `isolated` profile | Packaged apps also require matching `tysel-worker`; Linux is the production security gate |
 | `component` profile | Experimental Wasm Component tasks with restricted WASI |
 | Native runtime cross-compilation | Not provided; `build --target` instead packages with a verified same-version official runtime |
 
diff --git a/docs/editor-iteration-plan.md b/docs/editor-iteration-plan.md
new file mode 100644
index 0000000..fa7d428
--- /dev/null
+++ b/docs/editor-iteration-plan.md
@@ -0,0 +1,163 @@
+# Editor feedback iteration
+
+Status: Implemented and verified (2026-09-05)
+
+## Objective
+
+Keep generated runtime types synchronized during development and make Tysel's
+own static errors consumable by editors. Reuse TypeScript language services;
+an independent LSP is outside this iteration.
+
+## Delivery order
+
+1. Automatically synchronize `tysel-env.d.ts` at dev startup and reload after
+   successful manifest validation. Do not rewrite identical output, overwrite
+   user-owned files, follow output symlinks, or trigger a reload from generated
+   declaration changes. Invalid manifests preserve the last valid declaration.
+   `tysel types --check` remains read-only for CI.
+2. Reuse the structured diagnostic envelope for manifest and unsupported import
+   errors. Preserve stable codes and original-source locations when available;
+   do not invent a location for an absent field. Keep CLI and dev consistent.
+3. Diagnose unsupported runtime imports throughout the reachable module graph
+   using the build resolver, including imports in non-entry files. Preserve
+   TypeScript source positions and exclude erased type-only imports.
+4. Associate new TOML manifests with the existing JSON schema and document editor
+   setup and its limits. Verify schema/tool compatibility before recommending it.
+
+## Verification
+
+- Targeted type-generation tests cover changed/unchanged output, invalid
+  manifests, user files, and symlinks; watcher tests cover generated output.
+- Diagnostic tests cover stable codes, nested imports, type-only imports,
+  missing fields, and Unicode source positions.
+- Exercise CLI JSON failures and a live dev edit/error/recovery cycle.
+- Run formatting and relevant crate tests; document any unavailable checks.
+
+## Verification results
+
+- Relevant unit suites: 147 passed (manifest 24, build 39, supply-chain tool 6,
+  CLI 78). CLI development integration suite: 66 passed.
+- `cargo clippy --offline -p tysel-manifest -p tysel-build -p tysel-cli --lib
+  --bins -- -D warnings`, formatting, and diff whitespace checks passed.
+- Strict MkDocs build passed with output outside the repository.
+- Taplo CLI 0.9.0 accepted a valid manifest through the local schema directive
+  and rejected invalid workers, an unknown profile, and a Component/entry
+  mismatch. This validates schema consumption, not a visual editor UI audit.
+- Runtime inventory regenerated and verified (497 production components) after
+  the direct TOML span dependency changed Cargo.lock. Regeneration also included
+  existing interactive-init dependencies missing from the previous inventory.
+- Socket-based tests passed outside the restricted sandbox. The initial failures
+  were denied TCP/Unix socket operations; the new recovery test also had one
+  expected-line assertion corrected before the final successful run.
+
+## Delivered behavior and limits
+
+- Dev synchronizes the default output after manifest validation, before source
+  bundling. Source errors can therefore coexist with newly updated types; an
+  invalid manifest preserves the previous types. Custom output paths stay manual.
+- Manifest semantic diagnostics locate TOML and JSON values from the original
+  source snapshot. Parse errors keep the parser's position. Absent values have
+  no invented range. Validation still reports the first failure.
+- The existing bundler already traversed the module graph. This iteration adds
+  structured resolution failures and original-source ranges, removes redundant
+  entry scanning in check, and excludes erased type-only requests.
+- New TOML projects carry a local schema with no online dependency. Existing
+  projects and JSON editor associations have documented setup instructions.
+
+## Follow-up decision
+
+Keep the lightweight editor adapter as a test fixture. Productization is paused
+until real usage demonstrates a need. Consider a thin LSP only when unsaved-buffer
+analysis, cross-file configuration navigation, or multiple editor clients justify it. TypeScript inference and unrestricted
+permission-changing quick fixes remain outside the scope.
+
+
+## Editor-host follow-up (2026-09-05)
+
+The real VS Code extension-host smoke test passed all seven scenarios on VS Code
+1.136.1, its bundled TypeScript 6.0.3 provider, and Even Better TOML 0.21.2. The
+final run recorded no TypeScript server errors. The reproducible runner is
+`tests/editor/run.py`; evidence is saved in
+`tests/editor/evidence/vscode-2026-09-05.json`.
+
+Verified through editor APIs: offline schema completion, generated-type
+navigation, live capability completion changes, invalid-manifest preservation,
+repair and revocation, Unicode error navigation, cross-file diagnostic
+replacement, stale-generation rejection, and final clearing. The adapter is a
+test fixture, not a shipped extension. It maps canonical diagnostic paths back
+to workspace URIs, including macOS /var versus /private/var aliases.
+
+This validation found and fixed a delivery bug: the generated `.tysel/` ignore
+rule hid the shared schema from Git. Init now adds an ordered exception for
+`.tysel/manifest.schema.json`, preserving ignores for other runtime state. The
+merge logic keeps the exception effective even with existing, conflicting ignore
+rules. A Git-backed regression test covers new and adopted projects. All 21 init
+integration tests and the gitignore merge unit test passed, as did CLI Clippy,
+formatting, whitespace checks, and the strict documentation build.
+
+An earlier run exposed a TypeScript 6.0.3 refactor request error while rapidly
+removing the currently displayed module from the import graph. Returning to the
+entry editor before changing imports produced a clean final run; this does not
+claim to fix the TypeScript server edge case. The runner records such errors in
+its evidence rather than hiding them behind passing assertions.
+
+Decision: the current APIs are sufficient for a saved-file editor adapter. Before
+shipping it, specify process restart/reset behavior, dirty-buffer diagnostics,
+multi-root routing, and deduplication with TOML validation. TypeScript 7 native
+extension support and npm publication remain unverified by this smoke test.
+An independent LSP is still unnecessary for the validated scenarios.
+
+
+## Real-project acceptance and review (2026-09-05)
+
+All three repository examples completed the development-to-artifact workflow:
+
+| Example | Verified behavior |
+| --- | --- |
+| `hello-service` | Permission/type update, invalid manifest and import recovery, pinned TS 7.0.2 check, native build, HTTP response without source or npm dependencies. |
+| `isolated-plugin` | The same development checks, plus denied fetch/filesystem probes in dev and in the packaged deployment with the matching worker. |
+| `durable-agent` | The same development checks, plus two native-artifact restarts, retained approval state, exactly one local LLM effect, and one final save. |
+
+The runner initializes a disposable project, adopts the actual example manifest
+and source, keeps the standalone generated tsconfig, and links local workspace
+types and the pinned compiler. Deployment directories contain no source,
+manifest, or node_modules. These are macOS arm64 debug-artifact checks with a
+local fake LLM, not a release, external-provider, or Linux isolation certification.
+See `tests/workflows/README.md` and the evidence in
+`tests/workflows/evidence/macos-2026-09-05.json`.
+
+Review covered generated-file ownership and symlinks, unchanged-file writes,
+invalid-manifest preservation, type-only imports, original-source ranges,
+JSON/TOML field location, diagnostic envelope compatibility, Git rule ordering,
+and whether the test-only editor adapter is kept separate from runtime code.
+No blocking regression was found in the tested routes. Final relevant tests:
+147 unit tests plus 67 CLI integration tests passed (214 total); Clippy,
+formatting, diff whitespace, strict documentation build, and the 497-component
+runtime inventory check passed.
+
+### Findings ordered by practical impact
+
+1. **P1 — isolated deployment requires a companion worker.** Confirmed by running
+   the packaged app without one: startup fails with `worker binary not found`.
+   Copying the matching worker restores operation and preserves capability denial.
+   Build output, README, example instructions, and deployment documentation now
+   state the requirement. Automatic worker packaging/signing remains a separate
+   product decision; this iteration does not promise a single-file isolated app.
+2. **P2 — generated schema was ignored by Git.** Fixed and covered by Git-backed
+   tests for new projects and conflicting existing rules. Other runtime state
+   stays ignored.
+3. **P2 — canonical paths differ from editor workspace URIs.** The test adapter
+   now maps them; preserve this behavior if a production adapter is later built.
+
+There is no planned extension product work in this iteration. TS 7 native editor
+support, dirty-buffer analysis, multi-root behavior, and release/Linux gates are
+explicit verification gaps, not failures inferred from the passing local tests.
+
+### Change organization
+
+- Development feedback foundation: type synchronization, static diagnostics,
+  schema generation and Git handling, plus focused Rust regressions.
+- Acceptance fixtures: separate editor-host and real-project workflow tests with
+  reproducible commands and bounded evidence.
+- Delivery documentation: accurate isolated-worker requirements, validation
+  conclusions, and the decision to pause editor productization.
diff --git a/docs/operations/deployment.md b/docs/operations/deployment.md
index 84ff3e8..db35600 100644
--- a/docs/operations/deployment.md
+++ b/docs/operations/deployment.md
@@ -53,7 +53,13 @@ APP.licenses.json
 APP.evidence.json
 ```
 
-The runtime host needs only `APP`. Admission and rollback still depend on the
+For the `service` profile, the runtime host needs only `APP`. An `isolated`
+application also requires a matching-version, matching-platform `tysel-worker`
+beside the executable, or its path set through `TYSEL_WORKER`. The build command
+reports this requirement but does not copy the worker into the output directory.
+Keep the worker alongside the application in the deployment artifact set;
+copying only the isolated application will fail at startup with
+`worker binary not found`. Admission and rollback still depend on the
 complete immutable set. When using a container, record the mapping from the
 image digest to the admitted executable digest.
 
diff --git a/examples/isolated-plugin/README.md b/examples/isolated-plugin/README.md
index 787def4..00ba629 100644
--- a/examples/isolated-plugin/README.md
+++ b/examples/isolated-plugin/README.md
@@ -32,6 +32,22 @@ JSON document with `denied: true`. This is expected even though the resources
 appear under `[permissions]`: the effective authority is the intersection of
 the manifest, deployment policy, execution profile, and runtime support.
 
+## Run a packaged application
+
+`tysel build` creates the application executable. Deploy a matching toolchain's
+`tysel-worker` alongside it:
+
+```text
+dist/
+  isolated-plugin
+  tysel-worker
+```
+
+Alternatively, set `TYSEL_WORKER` to the matching worker's path. The build
+command reports this dependency but does not copy the worker automatically.
+The application does not need TypeScript source, the manifest, or `node_modules`
+at runtime, but the isolated profile does need this separate worker executable.
+
 ## Crash recovery
 
 On Unix, kill the worker child while leaving the `tysel` supervisor alive:
diff --git a/mkdocs.yml b/mkdocs.yml
index 6c750c8..208d273 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -14,6 +14,7 @@ validation:
 exclude_docs: |
   website-plan.md
   documentation-roadmap.md
+  editor-iteration-plan.md
 theme:
   name: readthedocs
 plugins:

From 48081e898ef2711beb23c2e55bfb7e933da8d5f6 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Sun, 6 Sep 2026 07:32:53 +0800
Subject: [PATCH 07/31] feat(website): add reviewed Chinese localization and
 SEO validation

---
 .github/scripts/check-version-sync.sh         |    4 +-
 .github/workflows/website.yml                 |    9 +
 docs/documentation-roadmap.md                 |    7 +
 docs/operations/production.md                 |    2 +-
 website/.gitignore                            |    7 +-
 website/README.md                             |   59 +
 .../{ => (site)}/(home)/benchmarks/page.tsx   |   60 +-
 .../app/(site)/(home)/blog/[slug]/page.tsx    |   16 +
 website/app/(site)/(home)/blog/page.tsx       |    3 +
 .../app/{ => (site)}/(home)/examples/page.tsx |   97 +-
 website/app/{ => (site)}/(home)/layout.tsx    |    0
 website/app/(site)/(home)/page.tsx            |    3 +
 .../{ => (site)}/docs/[[...slug]]/page.tsx    |    3 +-
 website/app/{ => (site)}/docs/layout.tsx      |    0
 website/app/(site)/layout.tsx                 |    5 +
 .../reference/[[...slug]]/page.tsx            |    5 +-
 website/app/{ => (site)}/reference/layout.tsx |    0
 website/app/{ => (site)}/template.tsx         |    0
 website/app/global.css                        |   12 +-
 website/app/opengraph-image.tsx               |   11 -
 website/app/opengraph-image/route.tsx         |    7 +
 website/app/sitemap.ts                        |   11 +-
 website/app/twitter-image.tsx                 |    2 -
 website/app/twitter-image/route.tsx           |    7 +
 .../benchmarks/admission-scoreboard.tsx       |   31 +-
 .../components/benchmarks/runtime-suites.tsx  |   18 +-
 .../page.tsx => components/blog/article.tsx}  |   72 +-
 website/components/blog/blog-table.tsx        |   10 +
 website/components/copy-button.tsx            |    5 +-
 website/components/header-chrome.ts           |    9 +
 website/components/home/artifact-demo.tsx     |    7 +-
 .../home/blog-index-page.tsx}                 |   31 +-
 website/components/home/five-minutes.tsx      |    8 +-
 .../home/home-page.tsx}                       |   79 +-
 website/components/home/install-panel.tsx     |    5 +-
 .../components/home/runtime-capabilities.tsx  |   41 +-
 website/components/language-switcher.tsx      |  121 +
 website/components/locale-original-link.tsx   |   25 +
 website/components/locale-provider.tsx        |   42 +
 .../site-document.tsx}                        |   23 +-
 website/components/site-footer.tsx            |   10 +-
 website/components/site-header.tsx            |   44 +-
 website/components/theme-toggle.tsx           |   10 +-
 .../concepts/projects-and-configuration.mdx   |   33 +
 .../content/docs/operations/deployment.mdx    |    8 +-
 .../content/docs/operations/production.mdx    |    2 +-
 website/content/reference/cli/development.mdx |   12 +
 .../content/reference/errors-and-output.mdx   |   19 +
 website/lib/blog.ts                           |   37 +-
 website/lib/i18n/catalog.ts                   |    8 +
 website/lib/i18n/config.ts                    |   12 +
 website/lib/i18n/content.ts                   |   25 +
 website/lib/i18n/messages.ts                  |   16 +
 website/lib/i18n/pages.ts                     |   23 +
 website/lib/i18n/routes/layout.tsx            |   11 +
 website/lib/i18n/routes/page.tsx              |   99 +
 website/lib/i18n/routes/search.ts             |   20 +
 website/lib/i18n/routing.ts                   |   27 +
 website/lib/i18n/seo.ts                       |    8 +
 website/lib/reading-time.d.mts                |    1 +
 website/lib/reading-time.mjs                  |   10 +
 website/lib/seo.ts                            |   46 +-
 website/locales/config.json                   |    7 +
 website/locales/en/messages.json              |  390 +++
 .../content/blog/capability-by-default.mdx    |  184 ++
 .../durable-execution-recovery-semantics.mdx  |  197 ++
 .../from-typescript-to-one-executable.mdx     |  231 ++
 .../zh-CN/content/blog/tysel-v0-1-1.mdx       |  147 +
 ...hy-tysel-is-not-another-nodejs-runtime.mdx |  142 +
 .../zh-CN/content/docs/capabilities/index.mdx |   25 +
 .../content/docs/compatibility/index.mdx      |   51 +
 .../docs/concepts/durable-execution.mdx       |   80 +
 .../docs/concepts/execution-profiles.mdx      |   59 +
 .../content/docs/concepts/how-tysel-works.mdx |   60 +
 .../zh-CN/content/docs/concepts/meta.json     |    9 +
 .../concepts/projects-and-configuration.mdx   |  234 ++
 .../zh-CN/content/docs/getting-started.mdx    |  125 +
 .../docs/guides/concurrency-backpressure.mdx  |   92 +
 .../content/docs/guides/container-image.mdx   |  252 ++
 .../zh-CN/content/docs/guides/cron-queue.mdx  |  104 +
 .../zh-CN/content/docs/guides/debugging.mdx   |   96 +
 .../zh-CN/content/docs/guides/examples.mdx    |   98 +
 .../zh-CN/content/docs/guides/filesystem.mdx  |  116 +
 .../zh-CN/content/docs/guides/index.mdx       |   51 +
 .../zh-CN/content/docs/guides/llm-gateway.mdx |   97 +
 .../zh-CN/content/docs/guides/meta.json       |   21 +
 .../content/docs/guides/observability.mdx     |  123 +
 .../zh-CN/content/docs/guides/postgresql.mdx  |  100 +
 .../zh-CN/content/docs/guides/redis.mdx       |   48 +
 .../docs/guides/reproducible-release.mdx      |  162 ++
 .../docs/guides/service-networking.mdx        |  136 +
 .../zh-CN/content/docs/guides/sqlite.mdx      |   93 +
 .../content/docs/guides/wasm-component-go.mdx |   92 +
 .../docs/guides/wasm-component-rust.mdx       |  102 +
 website/locales/zh-CN/content/docs/index.mdx  |   94 +
 .../locales/zh-CN/content/docs/install.mdx    |  179 ++
 website/locales/zh-CN/content/docs/meta.json  |   20 +
 .../docs/operations/component-tasks.mdx       |   50 +
 .../docs/operations/continuous-delivery.mdx   |   76 +
 .../content/docs/operations/deployment.mdx    |   61 +
 .../zh-CN/content/docs/operations/meta.json   |    9 +
 .../content/docs/operations/production.mdx    |  191 ++
 .../zh-CN/content/docs/performance/index.mdx  |   24 +
 .../zh-CN/content/docs/performance/redis.mdx  |   90 +
 .../zh-CN/content/docs/security/index.mdx     |   52 +
 .../zh-CN/content/reference/cli/delivery.mdx  |   84 +
 .../content/reference/cli/development.mdx     |   85 +
 .../zh-CN/content/reference/cli/evidence.mdx  |   42 +
 .../zh-CN/content/reference/cli/index.mdx     |   47 +
 .../content/reference/cli/installation.mdx    |   49 +
 .../zh-CN/content/reference/cli/meta.json     |   12 +
 .../zh-CN/content/reference/cli/project.mdx   |   72 +
 .../zh-CN/content/reference/cli/tasks.mdx     |   54 +
 .../zh-CN/content/reference/component/abi.mdx |   55 +
 .../reference/component/capabilities.mdx      |   69 +
 .../content/reference/component/go-sdk.mdx    |   53 +
 .../content/reference/component/index.mdx     |   60 +
 .../content/reference/component/runtime.mdx   |   64 +
 .../content/reference/component/rust-sdk.mdx  |   72 +
 .../zh-CN/content/reference/environment.mdx   |   75 +
 .../content/reference/errors-and-output.mdx   |  106 +
 .../locales/zh-CN/content/reference/index.mdx |   94 +
 .../reference/javascript/abortcontroller.mdx  |   25 +
 .../content/reference/javascript/crypto.mdx   |   26 +
 .../content/reference/javascript/event.mdx    |   26 +
 .../content/reference/javascript/fetch.mdx    |   27 +
 .../content/reference/javascript/headers.mdx  |   25 +
 .../content/reference/javascript/index.mdx    |   23 +
 .../content/reference/javascript/meta.json    |   16 +
 .../content/reference/javascript/request.mdx  |   28 +
 .../reference/javascript/textencoder.mdx      |   22 +
 .../content/reference/javascript/timers.mdx   |   25 +
 .../content/reference/javascript/url.mdx      |   27 +
 .../reference/javascript/websocket.mdx        |   28 +
 .../content/reference/limits-and-defaults.mdx |  104 +
 .../content/reference/manifest/app-server.mdx |   54 +
 .../manifest/durable-observability.mdx        |   44 +
 .../content/reference/manifest/index.mdx      |  308 +++
 .../content/reference/manifest/limits.mdx     |   37 +
 .../content/reference/manifest/meta.json      |   11 +
 .../reference/manifest/permissions.mdx        |   55 +
 .../content/reference/manifest/tasks.mdx      |   52 +
 .../locales/zh-CN/content/reference/meta.json |   16 +
 .../content/reference/runtime/application.mdx |  124 +
 .../reference/runtime/capabilities.mdx        |  107 +
 .../content/reference/runtime/durable.mdx     |   78 +
 .../zh-CN/content/reference/runtime/index.mdx |   42 +
 .../zh-CN/content/reference/runtime/meta.json |   11 +
 .../content/reference/runtime/testing.mdx     |   73 +
 .../zh-CN/content/reference/runtime/types.mdx |  119 +
 website/locales/zh-CN/glossary.json           |   34 +
 website/locales/zh-CN/manifest.json           | 2377 +++++++++++++++++
 website/locales/zh-CN/messages.json           |  390 +++
 website/package.json                          |   11 +-
 website/scripts/check-localized-html.py       |   85 +
 website/scripts/check-seo.py                  |   49 +
 website/scripts/i18n.mjs                      |  189 ++
 website/scripts/import-docs.mjs               |    3 +-
 website/scripts/navigation.mjs                |   14 +
 website/test/i18n-presentation.test.mjs       |   23 +
 website/test/i18n-routing.test.mjs            |   35 +
 website/test/i18n.test.mjs                    |   90 +
 162 files changed, 11492 insertions(+), 342 deletions(-)
 rename website/app/{ => (site)}/(home)/benchmarks/page.tsx (82%)
 create mode 100644 website/app/(site)/(home)/blog/[slug]/page.tsx
 create mode 100644 website/app/(site)/(home)/blog/page.tsx
 rename website/app/{ => (site)}/(home)/examples/page.tsx (79%)
 rename website/app/{ => (site)}/(home)/layout.tsx (100%)
 create mode 100644 website/app/(site)/(home)/page.tsx
 rename website/app/{ => (site)}/docs/[[...slug]]/page.tsx (96%)
 rename website/app/{ => (site)}/docs/layout.tsx (100%)
 create mode 100644 website/app/(site)/layout.tsx
 rename website/app/{ => (site)}/reference/[[...slug]]/page.tsx (97%)
 rename website/app/{ => (site)}/reference/layout.tsx (100%)
 rename website/app/{ => (site)}/template.tsx (100%)
 delete mode 100644 website/app/opengraph-image.tsx
 create mode 100644 website/app/opengraph-image/route.tsx
 delete mode 100644 website/app/twitter-image.tsx
 create mode 100644 website/app/twitter-image/route.tsx
 rename website/{app/(home)/blog/[slug]/page.tsx => components/blog/article.tsx} (78%)
 create mode 100644 website/components/blog/blog-table.tsx
 create mode 100644 website/components/header-chrome.ts
 rename website/{app/(home)/blog/page.tsx => components/home/blog-index-page.tsx} (87%)
 rename website/{app/(home)/page.tsx => components/home/home-page.tsx} (81%)
 create mode 100644 website/components/language-switcher.tsx
 create mode 100644 website/components/locale-original-link.tsx
 create mode 100644 website/components/locale-provider.tsx
 rename website/{app/layout.tsx => components/site-document.tsx} (70%)
 create mode 100644 website/lib/i18n/catalog.ts
 create mode 100644 website/lib/i18n/config.ts
 create mode 100644 website/lib/i18n/content.ts
 create mode 100644 website/lib/i18n/messages.ts
 create mode 100644 website/lib/i18n/pages.ts
 create mode 100644 website/lib/i18n/routes/layout.tsx
 create mode 100644 website/lib/i18n/routes/page.tsx
 create mode 100644 website/lib/i18n/routes/search.ts
 create mode 100644 website/lib/i18n/routing.ts
 create mode 100644 website/lib/i18n/seo.ts
 create mode 100644 website/lib/reading-time.d.mts
 create mode 100644 website/lib/reading-time.mjs
 create mode 100644 website/locales/config.json
 create mode 100644 website/locales/en/messages.json
 create mode 100644 website/locales/zh-CN/content/blog/capability-by-default.mdx
 create mode 100644 website/locales/zh-CN/content/blog/durable-execution-recovery-semantics.mdx
 create mode 100644 website/locales/zh-CN/content/blog/from-typescript-to-one-executable.mdx
 create mode 100644 website/locales/zh-CN/content/blog/tysel-v0-1-1.mdx
 create mode 100644 website/locales/zh-CN/content/blog/why-tysel-is-not-another-nodejs-runtime.mdx
 create mode 100644 website/locales/zh-CN/content/docs/capabilities/index.mdx
 create mode 100644 website/locales/zh-CN/content/docs/compatibility/index.mdx
 create mode 100644 website/locales/zh-CN/content/docs/concepts/durable-execution.mdx
 create mode 100644 website/locales/zh-CN/content/docs/concepts/execution-profiles.mdx
 create mode 100644 website/locales/zh-CN/content/docs/concepts/how-tysel-works.mdx
 create mode 100644 website/locales/zh-CN/content/docs/concepts/meta.json
 create mode 100644 website/locales/zh-CN/content/docs/concepts/projects-and-configuration.mdx
 create mode 100644 website/locales/zh-CN/content/docs/getting-started.mdx
 create mode 100644 website/locales/zh-CN/content/docs/guides/concurrency-backpressure.mdx
 create mode 100644 website/locales/zh-CN/content/docs/guides/container-image.mdx
 create mode 100644 website/locales/zh-CN/content/docs/guides/cron-queue.mdx
 create mode 100644 website/locales/zh-CN/content/docs/guides/debugging.mdx
 create mode 100644 website/locales/zh-CN/content/docs/guides/examples.mdx
 create mode 100644 website/locales/zh-CN/content/docs/guides/filesystem.mdx
 create mode 100644 website/locales/zh-CN/content/docs/guides/index.mdx
 create mode 100644 website/locales/zh-CN/content/docs/guides/llm-gateway.mdx
 create mode 100644 website/locales/zh-CN/content/docs/guides/meta.json
 create mode 100644 website/locales/zh-CN/content/docs/guides/observability.mdx
 create mode 100644 website/locales/zh-CN/content/docs/guides/postgresql.mdx
 create mode 100644 website/locales/zh-CN/content/docs/guides/redis.mdx
 create mode 100644 website/locales/zh-CN/content/docs/guides/reproducible-release.mdx
 create mode 100644 website/locales/zh-CN/content/docs/guides/service-networking.mdx
 create mode 100644 website/locales/zh-CN/content/docs/guides/sqlite.mdx
 create mode 100644 website/locales/zh-CN/content/docs/guides/wasm-component-go.mdx
 create mode 100644 website/locales/zh-CN/content/docs/guides/wasm-component-rust.mdx
 create mode 100644 website/locales/zh-CN/content/docs/index.mdx
 create mode 100644 website/locales/zh-CN/content/docs/install.mdx
 create mode 100644 website/locales/zh-CN/content/docs/meta.json
 create mode 100644 website/locales/zh-CN/content/docs/operations/component-tasks.mdx
 create mode 100644 website/locales/zh-CN/content/docs/operations/continuous-delivery.mdx
 create mode 100644 website/locales/zh-CN/content/docs/operations/deployment.mdx
 create mode 100644 website/locales/zh-CN/content/docs/operations/meta.json
 create mode 100644 website/locales/zh-CN/content/docs/operations/production.mdx
 create mode 100644 website/locales/zh-CN/content/docs/performance/index.mdx
 create mode 100644 website/locales/zh-CN/content/docs/performance/redis.mdx
 create mode 100644 website/locales/zh-CN/content/docs/security/index.mdx
 create mode 100644 website/locales/zh-CN/content/reference/cli/delivery.mdx
 create mode 100644 website/locales/zh-CN/content/reference/cli/development.mdx
 create mode 100644 website/locales/zh-CN/content/reference/cli/evidence.mdx
 create mode 100644 website/locales/zh-CN/content/reference/cli/index.mdx
 create mode 100644 website/locales/zh-CN/content/reference/cli/installation.mdx
 create mode 100644 website/locales/zh-CN/content/reference/cli/meta.json
 create mode 100644 website/locales/zh-CN/content/reference/cli/project.mdx
 create mode 100644 website/locales/zh-CN/content/reference/cli/tasks.mdx
 create mode 100644 website/locales/zh-CN/content/reference/component/abi.mdx
 create mode 100644 website/locales/zh-CN/content/reference/component/capabilities.mdx
 create mode 100644 website/locales/zh-CN/content/reference/component/go-sdk.mdx
 create mode 100644 website/locales/zh-CN/content/reference/component/index.mdx
 create mode 100644 website/locales/zh-CN/content/reference/component/runtime.mdx
 create mode 100644 website/locales/zh-CN/content/reference/component/rust-sdk.mdx
 create mode 100644 website/locales/zh-CN/content/reference/environment.mdx
 create mode 100644 website/locales/zh-CN/content/reference/errors-and-output.mdx
 create mode 100644 website/locales/zh-CN/content/reference/index.mdx
 create mode 100644 website/locales/zh-CN/content/reference/javascript/abortcontroller.mdx
 create mode 100644 website/locales/zh-CN/content/reference/javascript/crypto.mdx
 create mode 100644 website/locales/zh-CN/content/reference/javascript/event.mdx
 create mode 100644 website/locales/zh-CN/content/reference/javascript/fetch.mdx
 create mode 100644 website/locales/zh-CN/content/reference/javascript/headers.mdx
 create mode 100644 website/locales/zh-CN/content/reference/javascript/index.mdx
 create mode 100644 website/locales/zh-CN/content/reference/javascript/meta.json
 create mode 100644 website/locales/zh-CN/content/reference/javascript/request.mdx
 create mode 100644 website/locales/zh-CN/content/reference/javascript/textencoder.mdx
 create mode 100644 website/locales/zh-CN/content/reference/javascript/timers.mdx
 create mode 100644 website/locales/zh-CN/content/reference/javascript/url.mdx
 create mode 100644 website/locales/zh-CN/content/reference/javascript/websocket.mdx
 create mode 100644 website/locales/zh-CN/content/reference/limits-and-defaults.mdx
 create mode 100644 website/locales/zh-CN/content/reference/manifest/app-server.mdx
 create mode 100644 website/locales/zh-CN/content/reference/manifest/durable-observability.mdx
 create mode 100644 website/locales/zh-CN/content/reference/manifest/index.mdx
 create mode 100644 website/locales/zh-CN/content/reference/manifest/limits.mdx
 create mode 100644 website/locales/zh-CN/content/reference/manifest/meta.json
 create mode 100644 website/locales/zh-CN/content/reference/manifest/permissions.mdx
 create mode 100644 website/locales/zh-CN/content/reference/manifest/tasks.mdx
 create mode 100644 website/locales/zh-CN/content/reference/meta.json
 create mode 100644 website/locales/zh-CN/content/reference/runtime/application.mdx
 create mode 100644 website/locales/zh-CN/content/reference/runtime/capabilities.mdx
 create mode 100644 website/locales/zh-CN/content/reference/runtime/durable.mdx
 create mode 100644 website/locales/zh-CN/content/reference/runtime/index.mdx
 create mode 100644 website/locales/zh-CN/content/reference/runtime/meta.json
 create mode 100644 website/locales/zh-CN/content/reference/runtime/testing.mdx
 create mode 100644 website/locales/zh-CN/content/reference/runtime/types.mdx
 create mode 100644 website/locales/zh-CN/glossary.json
 create mode 100644 website/locales/zh-CN/manifest.json
 create mode 100644 website/locales/zh-CN/messages.json
 create mode 100644 website/scripts/check-localized-html.py
 create mode 100644 website/scripts/check-seo.py
 create mode 100644 website/scripts/i18n.mjs
 create mode 100644 website/scripts/navigation.mjs
 create mode 100644 website/test/i18n-presentation.test.mjs
 create mode 100644 website/test/i18n-routing.test.mjs
 create mode 100644 website/test/i18n.test.mjs

diff --git a/.github/scripts/check-version-sync.sh b/.github/scripts/check-version-sync.sh
index 4354026..0adac00 100755
--- a/.github/scripts/check-version-sync.sh
+++ b/.github/scripts/check-version-sync.sh
@@ -75,12 +75,12 @@ runtime_constant="$(extract_quoted_version runtime-js/bootstrap/index.ts \
   '.*runtimeJsVersion = "([0-9]+\.[0-9]+\.[0-9]+)";.*')"
 web_api_constant="$(extract_quoted_version runtime-js/web-api/index.ts \
   '.*webApiVersion = "([0-9]+\.[0-9]+\.[0-9]+)";.*')"
-website_version="$(extract_quoted_version 'website/app/(home)/page.tsx' \
+website_version="$(extract_quoted_version 'website/components/home/home-page.tsx' \
   '.*softwareVersion: "([0-9]+\.[0-9]+\.[0-9]+)",.*')"
 for version_entry in \
   "runtime-js/bootstrap/index.ts:${runtime_constant}" \
   "runtime-js/web-api/index.ts:${web_api_constant}" \
-  "website/app/(home)/page.tsx:${website_version}"; do
+  "website/components/home/home-page.tsx:${website_version}"; do
   version_file="${version_entry%%:*}"
   declared_version="${version_entry#*:}"
   if [[ "$declared_version" != "$version" ]]; then
diff --git a/.github/workflows/website.yml b/.github/workflows/website.yml
index c6d59ea..ee28a54 100644
--- a/.github/workflows/website.yml
+++ b/.github/workflows/website.yml
@@ -105,9 +105,18 @@ jobs:
       - name: Check benchmark evidence loader
         run: pnpm test:benchmarks
         working-directory: website
+      - name: Check localization contracts
+        run: pnpm test:i18n && pnpm i18n:check
+        working-directory: website
       - name: Build static website
         run: pnpm build
         working-directory: website
+      - name: Verify localized HTML and section links
+        run: python3 scripts/check-localized-html.py
+        working-directory: website
+      - name: Verify sitemap and multilingual SEO
+        run: python3 scripts/check-seo.py
+        working-directory: website
       - name: Verify generated documentation is committed
         run: |
           changes="$(git status --short --untracked-files=all -- website/content)"
diff --git a/docs/documentation-roadmap.md b/docs/documentation-roadmap.md
index c66051c..b2e8a98 100644
--- a/docs/documentation-roadmap.md
+++ b/docs/documentation-roadmap.md
@@ -352,6 +352,13 @@ The reader-facing P0 adoption backlog is now complete. The next tranche should
 proceed to the P1 image, observability, debugging, and reproducible-release
 walkthroughs while continuing to extend contract-derived reference checks.
 
+The website now also has a build-time localization pipeline. English remains the
+canonical source under `docs/`; reviewed translations live independently under
+`website/locales/<locale>/content/` and are invalidated when their source hash
+changes. The initial Simplified Chinese release set covers all UI messages and
+public content units and has completed technical review. See `website/README.md`
+for terminology, review, incremental import/export and publication rules.
+
 ## P1 operations-path update — 2026-08-26
 
 The first P1 operations tranche is implemented:
diff --git a/docs/operations/production.md b/docs/operations/production.md
index 97c1620..7d9326e 100644
--- a/docs/operations/production.md
+++ b/docs/operations/production.md
@@ -176,7 +176,7 @@ These manifest defaults are limits, not capacity promises:
 | In-flight requests | 1,000 |
 | Request body | 16 MiB |
 | Response body | 16 MiB |
-| PostgreSQL pool | 16 connections per process |
+| Application PostgreSQL pool | Up to 4 connections per process; separate from durable PostgreSQL storage |
 
 Load-test the exact release with production request bodies, task mix,
 capabilities, dependencies, and telemetry. Budget total database connections
diff --git a/website/.gitignore b/website/.gitignore
index 9e429e4..48b18b2 100644
--- a/website/.gitignore
+++ b/website/.gitignore
@@ -23,4 +23,9 @@ yarn-error.log*
 # others
 .env*.local
 .vercel
-next-env.d.ts
\ No newline at end of file
+next-env.d.ts
+# Prepared, reviewed translations (sources live in locales/)
+/content/translations/
+
+# Locale routes are emitted only when at least one target locale is published.
+/app/(localized)/
diff --git a/website/README.md b/website/README.md
index dd55aa7..76d070a 100644
--- a/website/README.md
+++ b/website/README.md
@@ -84,3 +84,62 @@ TYSEL_BENCHMARK_SAMPLE=1 pnpm dev
 ```
 
 The homepage follows bun.sh’s information density and developer-tool layout, using Tysel brand color, the official wordmark, and product copy from the docs. It does not publish unverified performance numbers.
+
+## Localization
+
+The website has build-time localization. English remains the source language and
+is published at unprefixed URLs. Simplified Chinese has a complete reviewed UI and
+content release set; publication is controlled by `locales/config.json`.
+Development and builds never call a translation model or service.
+
+After changing canonical files under the repository-level `docs/` directory,
+run `pnpm import:docs` before exporting translation work. Source changes invalidate
+the corresponding reviewed translation by hash; update and review that unit again
+instead of editing generated content. Run `pnpm i18n:check` before submitting any
+UI or documentation copy change.
+
+UI messages live in `locales/<locale>/messages.json`; document translations live
+in `locales/<locale>/content/{docs,reference,blog}/`. Keep UI keys stable and use
+`T` or `useLocale().t()` for new UI copy. Follow the locale's `glossary.json`.
+`manifest.json` records source and translation hashes plus review status.
+
+Translate outside the build using the model of your choice:
+
+```sh
+pnpm i18n:export --locale zh-CN --output /tmp/tysel-zh-CN-job.json
+# Return job units with a translation string; partial results are accepted.
+pnpm i18n:import --input /tmp/tysel-zh-CN-result.json
+# Review wording and technical meaning before marking the result reviewed.
+pnpm i18n:import --input /tmp/tysel-zh-CN-result.json --reviewed
+pnpm i18n:check
+```
+
+Imports default to draft. Preserve code blocks, URLs, placeholders, metadata,
+navigation IDs/order and heading counts/depths. Review technical qualifications,
+terminology and paragraph logic; blog translations should read naturally while
+preserving historical version context. Editing reviewed text requires another
+review. Published stale or draft translations fail the build.
+
+To add a language, register its BCP-47 code with `published: false`, create its
+message catalog and version-1 manifest (empty `messages` and `content` maps), then
+export, translate and review. Enable publication after all UI messages and the
+included documents are reviewed and current. Documents can be added gradually.
+
+English URLs remain unprefixed; Chinese uses `/zh-CN/`. Only existing translations
+receive localized URLs and language alternates. Links to untranslated pages fall
+back to English. `lib/i18n/pages.ts` controls availability, and each published
+language has its own search data. Never edit generated `app/(localized)` adapters
+or `content/translations/` content; preparation recreates them. Translated headings retain
+English anchor aliases.
+
+After building, verify the exported pages:
+
+```sh
+python3 scripts/check-localized-html.py
+python3 scripts/check-seo.py
+```
+
+CI runs both checks for section links, document roots, blog titles, sitemap pages,
+canonical URLs, reciprocal language alternates and structured data. These local
+checks do not establish search indexing or real-world performance; verify those
+after deployment with Search Console and performance measurements.
diff --git a/website/app/(home)/benchmarks/page.tsx b/website/app/(site)/(home)/benchmarks/page.tsx
similarity index 82%
rename from website/app/(home)/benchmarks/page.tsx
rename to website/app/(site)/(home)/benchmarks/page.tsx
index 83f4e37..5c9b35c 100644
--- a/website/app/(home)/benchmarks/page.tsx
+++ b/website/app/(site)/(home)/benchmarks/page.tsx
@@ -1,5 +1,7 @@
+import { alternates } from "@/lib/i18n/seo";
+import { T, SourceText } from "@/components/locale-provider";
 import type { Metadata } from "next";
-import Link from "next/link";
+import { SiteLink as Link } from "@/components/locale-provider";
 import { AdmissionScoreboard } from "@/components/benchmarks/admission-scoreboard";
 import { RuntimeSuites } from "@/components/benchmarks/runtime-suites";
 import { CopyButton } from "@/components/copy-button";
@@ -10,7 +12,7 @@ export const metadata: Metadata = {
   title: "Benchmarks",
   description:
     "CI release-admission gates for Tysel on fixed Linux runners — not a production performance SLA.",
-  alternates: { canonical: canonicalUrl("/benchmarks") },
+  alternates: alternates("/benchmarks"),
   openGraph: {
     url: canonicalUrl("/benchmarks"),
     images: [absoluteUrl("/opengraph-image")],
@@ -73,19 +75,19 @@ export default function BenchmarksPage() {
     <main className="mx-auto w-full max-w-6xl px-6 py-14 sm:py-16">
       <div className="max-w-2xl">
         <p className="text-xs font-medium uppercase tracking-[0.18em] text-fd-muted-foreground">
-          CI admission
+          <T id="ui.ci.admission" />
         </p>
         <h1 className="font-heading mt-2 text-4xl font-medium tracking-tighter text-balance sm:text-5xl">
-          {claim
+          <SourceText text={claim
             ? "Seven gates. CI measured."
             : sample
               ? "Seven gates. Sample layout."
-              : "Seven gates. Waiting on data."}
+              : "Seven gates. Waiting on data."} />
         </h1>
         <p className="mt-3 text-sm leading-6 text-fd-muted-foreground">
-          {sample
+          <SourceText text={sample
             ? "Illustrative layout only — not a published CI claim."
-            : "Fixed-runner regression gates. Not a production performance SLA."}
+            : "Fixed-runner regression gates. Not a production performance SLA."} />
         </p>
       </div>
 
@@ -102,16 +104,16 @@ export default function BenchmarksPage() {
         className="mt-3 flex flex-wrap items-center gap-x-4 gap-y-2 text-xs text-fd-muted-foreground"
       >
         <span className="font-mono text-[10px] uppercase tracking-[0.14em]">
-          Ladder
+          <T id="ui.ladder" />
         </span>
         {evidenceTiers.map((tier) => (
           <p key={tier.level} className="flex items-baseline gap-1.5">
             <span className="font-mono text-[10px] text-tysel-blue">
               {tier.level}
             </span>
-            <span className="text-fd-foreground">{tier.label}</span>
+            <span className="text-fd-foreground"><SourceText text={tier.label} /></span>
             <span className="font-mono text-[10px] uppercase tracking-[0.12em] text-fd-muted-foreground">
-              {tier.state}
+              <SourceText text={tier.state} />
             </span>
           </p>
         ))}
@@ -121,17 +123,15 @@ export default function BenchmarksPage() {
 
       <section className="mt-14 max-w-3xl">
         <h2 className="font-heading text-xl font-medium tracking-tight">
-          Reproduce locally
+          <T id="ui.reproduce.locally" />
         </h2>
         <p className="mt-2 text-sm leading-6 text-fd-muted-foreground">
-          Release mode, clean tree. Time gates admit on p50; suites may still
-          report p95/p99. Startup uses 2 warm-ups + 11 samples on a warm page
-          cache. Linux PSS is the memory result of record.
+          <T id="ui.release.mode.clean.tree.time.gates.admit.on" />
         </p>
 
         <div className="mt-5 overflow-hidden border border-fd-border bg-fd-muted/30">
           <div className="flex items-center justify-between border-b border-fd-border px-3 py-1.5 font-mono text-[11px] text-fd-muted-foreground">
-            <span>release evidence</span>
+            <span><T id="ui.release.evidence" /></span>
             <CopyButton value={benchCommand} />
           </div>
           <pre className="overflow-x-auto px-4 py-4 font-mono text-[12px] leading-5">
@@ -144,25 +144,25 @@ export default function BenchmarksPage() {
             href="/docs/performance"
             className="text-tysel-blue underline-offset-4 hover:underline"
           >
-            Performance documentation
+            <T id="ui.performance.documentation" />
           </Link>
           <Link
             href={`${githubUrl}/tree/main/benchmarks`}
             className="text-tysel-blue underline-offset-4 hover:underline"
           >
-            Benchmark source ↗
+            <T id="ui.benchmark.source" />
           </Link>
           <Link
             href="/benchmark-evidence/latest.json"
             className="text-tysel-blue underline-offset-4 hover:underline"
           >
-            Raw evidence JSON
+            <T id="ui.raw.evidence.json" />
           </Link>
           <Link
             href="/reference/cli/evidence"
             className="text-fd-muted-foreground underline-offset-4 hover:underline"
           >
-            Evidence reference
+            <T id="ui.evidence.reference" />
           </Link>
         </div>
       </section>
@@ -171,24 +171,22 @@ export default function BenchmarksPage() {
         <summary className="cursor-pointer list-none px-5 py-4 sm:flex sm:items-center sm:justify-between">
           <div>
             <h2 className="font-heading text-lg font-medium tracking-tight">
-              Cross-runtime publication contract
+              <T id="ui.cross.runtime.publication.contract" />
             </h2>
             <p className="mt-1 text-sm text-fd-muted-foreground">
-              Separate bar for public comparisons — not these CI gates.
+              <T id="ui.separate.bar.for.public.comparisons.not.these.ci" />
             </p>
           </div>
           <span className="mt-3 font-mono text-[11px] uppercase tracking-[0.12em] text-fd-muted-foreground group-open:hidden sm:mt-0">
-            Expand →
+            <T id="ui.expand" />
           </span>
           <span className="mt-3 hidden font-mono text-[11px] uppercase tracking-[0.12em] text-fd-muted-foreground group-open:inline sm:mt-0">
-            Collapse
+            <T id="ui.collapse" />
           </span>
         </summary>
         <div className="border-t border-fd-border px-5 py-5">
           <p className="max-w-2xl text-sm leading-6 text-fd-muted-foreground">
-            No cross-runtime winner is published yet. The matched Node.js, Bun,
-            Deno, and Tysel harness is public; results stay internal until these
-            steps complete on both architectures.
+            <T id="ui.no.cross.runtime.winner.is.published.yet.the" />
           </p>
           <div className="mt-5 border border-fd-border">
             {publicationSteps.map((step) => (
@@ -198,9 +196,9 @@ export default function BenchmarksPage() {
               >
                 <p className="font-mono text-xs text-tysel-blue">{step.n}</p>
                 <div>
-                  <h3 className="text-sm font-medium">{step.title}</h3>
+                  <h3 className="text-sm font-medium"><SourceText text={step.title} /></h3>
                   <p className="mt-1 text-sm leading-6 text-fd-muted-foreground">
-                    {step.body}
+                    <SourceText text={step.body} />
                   </p>
                 </div>
               </article>
@@ -211,19 +209,19 @@ export default function BenchmarksPage() {
               href={`${githubUrl}/tree/main/benchmarks/comparison`}
               className="text-sm text-tysel-blue underline-offset-4 hover:underline"
             >
-              Comparison protocol ↗
+              <T id="ui.comparison.protocol" />
             </Link>
           </div>
         </div>
       </details>
 
       <p className="mt-14 max-w-2xl text-sm leading-6 text-fd-muted-foreground">
-        Looking for the product story? Start on{" "}
+        <T id="ui.looking.for.the.product.story.start.on" />{" "}
         <Link
           href="/"
           className="text-fd-foreground underline-offset-4 hover:underline"
         >
-          Home
+          <T id="nav.home" />
         </Link>
         .
       </p>
diff --git a/website/app/(site)/(home)/blog/[slug]/page.tsx b/website/app/(site)/(home)/blog/[slug]/page.tsx
new file mode 100644
index 0000000..6d201ad
--- /dev/null
+++ b/website/app/(site)/(home)/blog/[slug]/page.tsx
@@ -0,0 +1,16 @@
+import { notFound } from "next/navigation";
+import { blog } from "@/lib/source";
+import BlogArticle, { blogMetadata } from "@/components/blog/article";
+import { alternates } from "@/lib/i18n/seo";
+export default async function Page(props: PageProps<"/blog/[slug]">) {
+  const page = blog.getPage([(await props.params).slug]);
+  if (!page) notFound();
+  return <BlogArticle page={page} />;
+}
+export function generateStaticParams() { return blog.getPages().map(page => ({ slug: page.slugs[0] })); }
+export async function generateMetadata(props: PageProps<"/blog/[slug]">) {
+  const page = blog.getPage([(await props.params).slug]);
+  if (!page) notFound();
+  const metadata = blogMetadata(page);
+  return { ...metadata, alternates: { ...metadata.alternates, ...alternates(page.url) } };
+}
diff --git a/website/app/(site)/(home)/blog/page.tsx b/website/app/(site)/(home)/blog/page.tsx
new file mode 100644
index 0000000..4619645
--- /dev/null
+++ b/website/app/(site)/(home)/blog/page.tsx
@@ -0,0 +1,3 @@
+import BlogIndexPage from "@/components/home/blog-index-page";
+export { metadata } from "@/components/home/blog-index-page";
+export default function Page() { return <BlogIndexPage />; }
diff --git a/website/app/(home)/examples/page.tsx b/website/app/(site)/(home)/examples/page.tsx
similarity index 79%
rename from website/app/(home)/examples/page.tsx
rename to website/app/(site)/(home)/examples/page.tsx
index 1287b1c..fd73c27 100644
--- a/website/app/(home)/examples/page.tsx
+++ b/website/app/(site)/(home)/examples/page.tsx
@@ -1,4 +1,6 @@
-import Link from "next/link";
+import { alternates } from "@/lib/i18n/seo";
+import { T, SourceText } from "@/components/locale-provider";
+import { SiteLink as Link } from "@/components/locale-provider";
 import type { Metadata } from "next";
 import { CopyButton } from "@/components/copy-button";
 import {
@@ -15,7 +17,7 @@ export const metadata: Metadata = {
   title: "Examples",
   description:
     "Runnable Tysel acceptance paths for services, durable agents, isolation, and Wasm Components.",
-  alternates: { canonical: canonicalUrl("/examples") },
+  alternates: alternates("/examples"),
   openGraph: {
     url: canonicalUrl("/examples"),
     images: [absoluteUrl("/opengraph-image")],
@@ -70,7 +72,7 @@ tysel dev`,
 function MetaLine({ example }: { example: Example }) {
   return (
     <p className="font-mono text-xs text-tysel-blue">
-      {statusLabel[example.status]} · {example.profile} · {example.capabilities}
+      <SourceText text={statusLabel[example.status]} /> · {example.profile} · <SourceText text={example.capabilities} />
     </p>
   );
 }
@@ -81,12 +83,12 @@ function ExampleRow({ example }: { example: Example }) {
   return (
     <div className="grid gap-3 border-b border-fd-border px-5 py-5 last:border-b-0 sm:grid-cols-[minmax(0,1fr)_minmax(0,1.1fr)] sm:gap-8">
       <div>
-        <h3 className="text-base font-medium">{example.name}</h3>
+        <h3 className="text-base font-medium"><SourceText text={example.name} /></h3>
         <div className="mt-1.5">
           <MetaLine example={example} />
         </div>
         <p className="mt-3 text-sm leading-6 text-fd-muted-foreground">
-          {example.purpose}
+          <SourceText text={example.purpose} />
         </p>
         <div className="mt-3 flex flex-wrap gap-x-4 gap-y-1 text-sm">
           <Link
@@ -95,27 +97,27 @@ function ExampleRow({ example }: { example: Example }) {
             rel={sourceExternal ? "noreferrer" : undefined}
             className="underline-offset-4 hover:underline"
           >
-            {example.sourceLabel ?? "Development source"}
+            <SourceText text={example.sourceLabel ?? "Development source"} />
           </Link>
           {example.docsHref ? (
             <Link
               href={example.docsHref}
               className="text-fd-muted-foreground underline-offset-4 hover:underline"
             >
-              Guide
+              <T id="ui.guide" />
             </Link>
           ) : null}
           <Link
             href={example.contractHref}
             className="text-fd-muted-foreground underline-offset-4 hover:underline"
           >
-            Contract
+            <T id="ui.contract" />
           </Link>
         </div>
       </div>
       <div className="overflow-hidden border border-fd-border bg-fd-muted/30">
         <div className="flex items-center justify-between border-b border-fd-border px-3 py-1.5 font-mono text-[11px] text-fd-muted-foreground">
-          <span>{example.runLabel ?? "after opening the example directory"}</span>
+          <span><SourceText text={example.runLabel ?? "after opening the example directory"} /></span>
           <CopyButton value={example.run} />
         </div>
         <pre className="overflow-x-auto px-3 py-3 font-mono text-[12px] leading-5">
@@ -130,33 +132,30 @@ export default function ExamplesPage() {
   return (
     <main className="mx-auto w-full max-w-6xl px-6 py-16">
       <p className="text-xs font-medium uppercase tracking-[0.18em] text-fd-muted-foreground">
-        Examples
+        <T id="nav.examples" />
       </p>
       <h1 className="font-heading mt-3 max-w-3xl text-4xl font-medium tracking-tighter text-balance">
-        Create a starter or open an exact example.
+        <T id="ui.create.a.starter.or.open.an.exact.example" />
       </h1>
       <p className="mt-4 max-w-2xl text-sm leading-6 text-fd-muted-foreground">
-        Use a built-in template when starting a new project. Use the
-        version-matched repository examples when you need a complete capability
-        walkthrough such as WebSocket, Postgres, Durable execution, or Wasm.
+        <T id="ui.use.a.built.in.template.when.starting.a" />
       </p>
 
       <section className="mt-10">
         <div className="flex items-end justify-between gap-6">
           <div>
             <h2 className="font-heading text-xl font-medium tracking-tight">
-              Start from a built-in template
+              <T id="ui.start.from.a.built.in.template" />
             </h2>
             <p className="mt-2 max-w-2xl text-sm leading-6 text-fd-muted-foreground">
-              These commands create the project before validating and running it.
-              Choose the closest application shape, then add explicit capabilities.
+              <T id="ui.these.commands.create.the.project.before.validating.and" />
             </p>
           </div>
           <Link
             href="/reference/cli/project#tysel-init"
             className="hidden shrink-0 text-sm text-tysel-blue underline-offset-4 hover:underline sm:block"
           >
-            Init reference
+            <T id="ui.init.reference" />
           </Link>
         </div>
         <div className="mt-5 grid gap-px bg-fd-border md:grid-cols-2">
@@ -164,9 +163,9 @@ export default function ExamplesPage() {
             <div key={template.name} className="bg-fd-background">
               <div className="flex items-start justify-between gap-4 border-b border-fd-border px-4 py-3">
                 <div>
-                  <h3 className="text-sm font-medium">{template.name}</h3>
+                  <h3 className="text-sm font-medium"><SourceText text={template.name} /></h3>
                   <p className="mt-1 text-xs leading-5 text-fd-muted-foreground">
-                    {template.description}
+                    <SourceText text={template.description} />
                   </p>
                 </div>
                 <CopyButton value={template.command} />
@@ -181,16 +180,14 @@ export default function ExamplesPage() {
 
       <section className="mt-14 max-w-3xl border border-fd-border">
         <div className="flex items-center justify-between border-b border-fd-border px-4 py-2 font-mono text-[11px] text-fd-muted-foreground">
-          <span>download version-matched examples</span>
+          <span><T id="ui.download.version.matched.examples" /></span>
           <CopyButton value={examplesDownload} />
         </div>
         <pre className="overflow-x-auto px-4 py-4 font-mono text-[12px] leading-5">
           <code>{examplesDownload}</code>
         </pre>
         <p className="border-t border-fd-border px-4 py-3 text-xs leading-5 text-fd-muted-foreground">
-          Replace <code>hello-service</code> with another directory listed below.
-          This downloads application source without a fork, repository clone,
-          or local Tysel build.
+          <T id="ui.replace" /> <code>hello-service</code> <T id="ui.with.another.directory.listed.below.this.downloads.application" />
         </p>
       </section>
 
@@ -198,17 +195,16 @@ export default function ExamplesPage() {
         <div className="border-b border-fd-border px-5 py-4 sm:flex sm:items-start sm:justify-between sm:gap-8">
           <div>
             <p className="text-xs font-medium uppercase tracking-[0.16em] text-fd-muted-foreground">
-              Start with the durable path
+              <T id="ui.start.with.the.durable.path" />
             </p>
             <h2 className="font-heading mt-2 text-2xl font-medium tracking-tight text-balance">
-              {featuredExample.name}
+              <SourceText text={featuredExample.name} />
             </h2>
             <div className="mt-2">
               <MetaLine example={featuredExample} />
             </div>
             <p className="mt-3 max-w-xl text-sm leading-6 text-fd-muted-foreground">
-              {featuredExample.purpose} Requires a real OpenAI-compatible
-              endpoint; see the README for{" "}
+              <SourceText text={featuredExample.purpose} /> <T id="ui.requires.a.real.openai.compatible.endpoint.see.the" />{" "}
               <code className="font-mono text-fd-foreground">demo.sh</code>.
             </p>
             <div className="mt-4 flex flex-wrap gap-x-4 gap-y-1 text-sm">
@@ -218,25 +214,25 @@ export default function ExamplesPage() {
                 rel="noreferrer"
                 className="underline-offset-4 hover:underline"
               >
-                Development source
+                <T id="ui.development.source" />
               </Link>
               <Link
                 href={featuredExample.docsHref!}
                 className="text-fd-muted-foreground underline-offset-4 hover:underline"
               >
-                Durable execution
+                <T id="ui.durable.execution" />
               </Link>
               <Link
                 href={featuredExample.contractHref}
                 className="text-fd-muted-foreground underline-offset-4 hover:underline"
               >
-                Durable API
+                <T id="ui.durable.api" />
               </Link>
             </div>
           </div>
           <div className="mt-6 w-full max-w-md overflow-hidden border border-fd-border bg-fd-muted/30 sm:mt-0">
             <div className="flex items-center justify-between border-b border-fd-border px-3 py-1.5 font-mono text-[11px] text-fd-muted-foreground">
-              <span>{featuredExample.runLabel ?? "after opening the example directory"}</span>
+              <span><SourceText text={featuredExample.runLabel ?? "after opening the example directory"} /></span>
               <CopyButton value={featuredExample.run} />
             </div>
             <pre className="overflow-x-auto px-3 py-3 font-mono text-[12px] leading-5">
@@ -260,19 +256,16 @@ export default function ExamplesPage() {
 
       <section className="mt-14 border border-fd-border px-5 py-5">
         <h2 className="text-sm font-medium uppercase tracking-[0.16em] text-fd-muted-foreground">
-          One installed toolchain
+          <T id="ui.one.installed.toolchain" />
         </h2>
         <p className="mt-2 max-w-2xl text-sm leading-6 text-fd-muted-foreground">
-          Install Tysel once, then use the same <code>tysel</code> command in
-          every example project. The managed installation already includes the
-          matching service runtime and isolated worker; no repository build or
-          worker-path override is required.
+          <T id="ui.install.tysel.once.then.use.the.same" /> <code>tysel</code> <T id="ui.command.in.every.example.project.the.managed.installation" />
         </p>
         <Link
           href="/docs/install"
           className="mt-3 inline-block text-sm text-tysel-blue underline-offset-4 hover:underline"
         >
-          Installation guide
+          <T id="ui.installation.guide" />
         </Link>
       </section>
 
@@ -280,17 +273,17 @@ export default function ExamplesPage() {
         {exampleSections.map((section) => (
           <section key={section.id} id={section.id}>
             <h2 className="font-heading text-xl font-medium tracking-tight">
-              {section.title}
+              <SourceText text={section.title} />
             </h2>
             <p className="mt-2 max-w-2xl text-sm leading-6 text-fd-muted-foreground">
-              {section.intent}
+              <SourceText text={section.intent} />
             </p>
             {section.note ? (
               <p className="mt-4 max-w-3xl border-l-2 border-tysel-blue pl-4 text-xs leading-5 text-fd-muted-foreground">
                 <span className="font-medium text-fd-foreground">
-                  Effective profile default.
+                  <T id="ui.effective.profile.default" />
                 </span>{" "}
-                {section.note}
+                <SourceText text={section.note} />
               </p>
             ) : null}
             <div className="mt-5 border border-fd-border">
@@ -306,11 +299,10 @@ export default function ExamplesPage() {
 
       <section className="mt-16" id="recipes">
         <h2 className="font-heading text-xl font-medium tracking-tight">
-          Supported, no dedicated tree yet
+          <T id="ui.supported.no.dedicated.tree.yet" />
         </h2>
         <p className="mt-2 max-w-2xl text-sm leading-6 text-fd-muted-foreground">
-          These APIs ship today. They are reference recipes — not missing
-          Node-style stdlib examples, and not end-to-end acceptance paths.
+          <T id="ui.these.apis.ship.today.they.are.reference.recipes" />
         </p>
         <div className="mt-5 grid gap-px bg-fd-border sm:grid-cols-2">
           {recipes.map((item) => (
@@ -319,12 +311,12 @@ export default function ExamplesPage() {
               href={item.href}
               className="bg-fd-background px-5 py-4 transition-colors hover:bg-fd-accent"
             >
-              <p className="font-medium">{item.name}</p>
+              <p className="font-medium"><SourceText text={item.name} /></p>
               <p className="mt-1 text-sm leading-6 text-fd-muted-foreground">
-                {item.purpose}
+                <SourceText text={item.purpose} />
               </p>
               <p className="mt-3 font-mono text-xs text-tysel-blue">
-                Recipe · contract only
+                <T id="ui.recipe.contract.only" />
               </p>
             </Link>
           ))}
@@ -332,20 +324,19 @@ export default function ExamplesPage() {
       </section>
 
       <p className="mt-14 max-w-2xl text-sm leading-6 text-fd-muted-foreground">
-        Shell, child processes, FFI, and dynamic libraries stay outside the
-        application contract. See the{" "}
+        <T id="ui.shell.child.processes.ffi.and.dynamic.libraries.stay" />{" "}
         <Link
           href="/docs/capabilities"
           className="text-fd-foreground underline-offset-4 hover:underline"
         >
-          capability matrix
+          <T id="ui.capability.matrix" />
         </Link>{" "}
-        and{" "}
+        <T id="ui.and.227" />{" "}
         <Link
           href="/docs/guides/examples"
           className="text-fd-foreground underline-offset-4 hover:underline"
         >
-          docs gallery
+          <T id="ui.docs.gallery" />
         </Link>
         .
       </p>
diff --git a/website/app/(home)/layout.tsx b/website/app/(site)/(home)/layout.tsx
similarity index 100%
rename from website/app/(home)/layout.tsx
rename to website/app/(site)/(home)/layout.tsx
diff --git a/website/app/(site)/(home)/page.tsx b/website/app/(site)/(home)/page.tsx
new file mode 100644
index 0000000..b7d5363
--- /dev/null
+++ b/website/app/(site)/(home)/page.tsx
@@ -0,0 +1,3 @@
+import HomePage from "@/components/home/home-page";
+export { metadata } from "@/components/home/home-page";
+export default function Page() { return <HomePage />; }
diff --git a/website/app/docs/[[...slug]]/page.tsx b/website/app/(site)/docs/[[...slug]]/page.tsx
similarity index 96%
rename from website/app/docs/[[...slug]]/page.tsx
rename to website/app/(site)/docs/[[...slug]]/page.tsx
index c315a84..ce05fde 100644
--- a/website/app/docs/[[...slug]]/page.tsx
+++ b/website/app/(site)/docs/[[...slug]]/page.tsx
@@ -1,3 +1,4 @@
+import { alternates } from "@/lib/i18n/seo";
 import {
   getPageImageUrl,
   getPageMarkdownUrl,
@@ -67,7 +68,7 @@ export async function generateMetadata(props: PageProps<'/docs/[[...slug]]'>): P
   return {
     title: page.data.title,
     description: page.data.description,
-    alternates: { canonical: canonicalUrl(page.url) },
+    alternates: alternates(page.url),
     openGraph: {
       url: canonicalUrl(page.url),
       siteName: 'Tysel',
diff --git a/website/app/docs/layout.tsx b/website/app/(site)/docs/layout.tsx
similarity index 100%
rename from website/app/docs/layout.tsx
rename to website/app/(site)/docs/layout.tsx
diff --git a/website/app/(site)/layout.tsx b/website/app/(site)/layout.tsx
new file mode 100644
index 0000000..e36e8ca
--- /dev/null
+++ b/website/app/(site)/layout.tsx
@@ -0,0 +1,5 @@
+import { SiteDocument, metadata } from "@/components/site-document";
+export { metadata };
+export default function Layout({ children }: { children: React.ReactNode }) {
+  return <SiteDocument locale="en">{children}</SiteDocument>;
+}
diff --git a/website/app/reference/[[...slug]]/page.tsx b/website/app/(site)/reference/[[...slug]]/page.tsx
similarity index 97%
rename from website/app/reference/[[...slug]]/page.tsx
rename to website/app/(site)/reference/[[...slug]]/page.tsx
index 870e596..40ce45e 100644
--- a/website/app/reference/[[...slug]]/page.tsx
+++ b/website/app/(site)/reference/[[...slug]]/page.tsx
@@ -1,10 +1,9 @@
+import { alternates } from "@/lib/i18n/seo";
 import {
-  getLLMText,
   getPageImageUrl,
   getPageMarkdownUrl,
   getPageSourcePath,
   referenceSource,
-  source,
 } from "@/lib/source";
 import {
   DocsBody,
@@ -102,7 +101,7 @@ export async function generateMetadata(props: ReferencePageProps): Promise<Metad
   return {
     title,
     description,
-    alternates: { canonical: canonicalUrl(page.url) },
+    alternates: alternates(page.url),
     openGraph: {
       url: canonicalUrl(page.url),
       siteName: "Tysel",
diff --git a/website/app/reference/layout.tsx b/website/app/(site)/reference/layout.tsx
similarity index 100%
rename from website/app/reference/layout.tsx
rename to website/app/(site)/reference/layout.tsx
diff --git a/website/app/template.tsx b/website/app/(site)/template.tsx
similarity index 100%
rename from website/app/template.tsx
rename to website/app/(site)/template.tsx
diff --git a/website/app/global.css b/website/app/global.css
index 509f991..24ab951 100644
--- a/website/app/global.css
+++ b/website/app/global.css
@@ -149,10 +149,16 @@ html > body[data-scroll-locked] {
   margin-inline: 0;
 }
 
-.blog-prose :where(table):not(:where([class~="not-prose"], [class~="not-prose"] *)) {
-  display: block;
+/* Fill the column when content is narrow; scroll instead of crushing wide tables. */
+.blog-prose .blog-table-scroll {
+  max-width: 100%;
   overflow-x: auto;
-  white-space: nowrap;
+  margin-block: 1.25em;
+}
+
+.blog-prose .blog-table-scroll > table {
+  width: 100%;
+  margin-block: 0;
 }
 
 @media (prefers-reduced-motion: reduce) {
diff --git a/website/app/opengraph-image.tsx b/website/app/opengraph-image.tsx
deleted file mode 100644
index 3485656..0000000
--- a/website/app/opengraph-image.tsx
+++ /dev/null
@@ -1,11 +0,0 @@
-import { ImageResponse } from "next/og";
-import { SocialCard } from "@/components/seo/social-card";
-
-export const dynamic = "force-static";
-export const alt = "Tysel — Write TypeScript. Ship a binary.";
-export const size = { width: 1200, height: 630 };
-export const contentType = "image/png";
-
-export default function OpenGraphImage() {
-  return new ImageResponse(<SocialCard />, size);
-}
diff --git a/website/app/opengraph-image/route.tsx b/website/app/opengraph-image/route.tsx
new file mode 100644
index 0000000..3498ecc
--- /dev/null
+++ b/website/app/opengraph-image/route.tsx
@@ -0,0 +1,7 @@
+import { ImageResponse } from "next/og";
+import { SocialCard } from "@/components/seo/social-card";
+
+export const dynamic = "force-static";
+export function GET() {
+  return new ImageResponse(<SocialCard />, { width: 1200, height: 630 });
+}
diff --git a/website/app/sitemap.ts b/website/app/sitemap.ts
index a939dbe..04c0e01 100644
--- a/website/app/sitemap.ts
+++ b/website/app/sitemap.ts
@@ -1,3 +1,7 @@
+import { publishedLocales, sourceLocale } from "@/lib/i18n/config";
+import { availablePaths } from "@/lib/i18n/pages";
+import { localePath } from "@/lib/i18n/routing";
+import { alternates } from "@/lib/i18n/seo";
 import type { MetadataRoute } from "next";
 import { getBlogPosts, getBlogUpdatedAt } from "@/lib/blog";
 import { referenceSource, source } from "@/lib/source";
@@ -26,5 +30,10 @@ export default function sitemap(): MetadataRoute.Sitemap {
     priority: 0.85,
   }));
 
-  return [...productPages, ...blogPages, ...contentPages];
+  const localizedPages = publishedLocales().filter((locale) => locale !== sourceLocale).flatMap((locale) =>
+    availablePaths(locale).map((pathname) => ({ url: canonicalUrl(localePath(pathname, locale)) })));
+  return [...productPages, ...blogPages, ...contentPages, ...localizedPages].map((page) => ({
+    ...page,
+    alternates: { languages: alternates(new URL(page.url).pathname.replace(/\/$/, "") || "/").languages },
+  }));
 }
diff --git a/website/app/twitter-image.tsx b/website/app/twitter-image.tsx
deleted file mode 100644
index 48a4cc2..0000000
--- a/website/app/twitter-image.tsx
+++ /dev/null
@@ -1,2 +0,0 @@
-export { alt, contentType, default, size } from "./opengraph-image";
-export const dynamic = "force-static";
diff --git a/website/app/twitter-image/route.tsx b/website/app/twitter-image/route.tsx
new file mode 100644
index 0000000..3498ecc
--- /dev/null
+++ b/website/app/twitter-image/route.tsx
@@ -0,0 +1,7 @@
+import { ImageResponse } from "next/og";
+import { SocialCard } from "@/components/seo/social-card";
+
+export const dynamic = "force-static";
+export function GET() {
+  return new ImageResponse(<SocialCard />, { width: 1200, height: 630 });
+}
diff --git a/website/components/benchmarks/admission-scoreboard.tsx b/website/components/benchmarks/admission-scoreboard.tsx
index d88bf78..bf005bb 100644
--- a/website/components/benchmarks/admission-scoreboard.tsx
+++ b/website/components/benchmarks/admission-scoreboard.tsx
@@ -1,6 +1,7 @@
 "use client";
 
-import Link from "next/link";
+import { T, SourceText } from "@/components/locale-provider";
+import { SiteLink as Link } from "@/components/locale-provider";
 import {
   formatGate,
   formatMeasured,
@@ -116,7 +117,7 @@ function MetricRow({
       <div className="min-w-0">
         <div className="flex items-baseline justify-between gap-3 sm:block">
           <p className="text-sm font-medium tracking-tight text-white/85">
-            {row.metric}
+            <SourceText text={row.metric} />
           </p>
           <p
             className={`font-mono text-[11px] tracking-[0.14em] sm:hidden ${
@@ -130,11 +131,11 @@ function MetricRow({
             }`}
             style={{ opacity: 0.35 + progress * 0.65 }}
           >
-            {status}
+            <SourceText text={status} />
           </p>
         </div>
         <p className="mt-1 max-w-md text-xs leading-5 text-white/40">
-          {row.detail}
+          <SourceText text={row.detail} />
         </p>
         <div className="mt-3 max-w-sm">
           <div className="flex items-baseline justify-between gap-3 font-mono text-[10px] uppercase tracking-[0.12em] text-white/35">
@@ -176,7 +177,7 @@ function MetricRow({
         }`}
         style={{ opacity: 0.35 + progress * 0.65 }}
       >
-        {status}
+        <SourceText text={status} />
       </p>
     </article>
   );
@@ -203,28 +204,28 @@ export function AdmissionScoreboard({
       <div className="grid gap-4 border-b border-white/10 px-5 py-5 sm:grid-cols-[minmax(0,1fr)_auto] sm:items-end sm:gap-6 sm:px-8 sm:py-6">
         <div>
           <p className="font-mono text-[10px] uppercase tracking-[0.16em] text-white/40">
-            CI admission · Linux x64
+            <T id="ui.ci.admission.linux.x64" />
           </p>
           {claim ? (
             <p className="font-heading mt-2 text-3xl tracking-tighter sm:text-4xl">
               <span className="text-tysel-lime">{shownPassed}</span>
               <span className="text-white/35">/{rows.length}</span>
               <span className="ml-2 text-xl text-white/65 sm:text-2xl">
-                clear
+                <T id="ui.clear" />
               </span>
             </p>
           ) : sample ? (
             <p className="font-heading mt-2 text-3xl tracking-tighter text-white/55 sm:text-4xl">
-              Sample layout
+              <T id="ui.sample.layout" />
             </p>
           ) : (
             <p className="font-heading mt-2 text-3xl tracking-tighter text-white/35 sm:text-4xl">
-              Waiting on CI
+              <T id="ui.waiting.on.ci" />
             </p>
           )}
           {sample ? (
             <p className="mt-1.5 font-mono text-[10px] uppercase tracking-[0.12em] text-white/30">
-              Not a CI claim
+              <T id="ui.not.a.ci.claim" />
             </p>
           ) : null}
         </div>
@@ -236,7 +237,7 @@ export function AdmissionScoreboard({
               {provenance.memoryKind.toUpperCase()}
             </p>
             {sample ? (
-              <p className="text-white/30">illustrative snapshot</p>
+              <p className="text-white/30"><T id="ui.illustrative.snapshot" /></p>
             ) : (
               <>
                 <p>
@@ -253,14 +254,14 @@ export function AdmissionScoreboard({
                         href={provenance.workflowRunUrl}
                         className="text-white/70 underline-offset-4 hover:text-white hover:underline"
                       >
-                        CI run
+                        <T id="ui.ci.run" />
                       </Link>
                     </>
                   ) : null}
                 </p>
                 {provenance.fetchedAt ? (
                   <p className="text-white/30">
-                    fetched {provenance.fetchedAt}
+                    <T id="ui.fetched" /> {provenance.fetchedAt}
                   </p>
                 ) : null}
               </>
@@ -268,7 +269,7 @@ export function AdmissionScoreboard({
           </div>
         ) : (
           <p className="max-w-xs font-mono text-[11px] leading-5 text-white/30 sm:text-right">
-            Gates stay public. Measured cells fill from{" "}
+            <T id="ui.gates.stay.public.measured.cells.fill.from" />{" "}
             <span className="text-white/50">benchmark-evidence-linux-x64</span>.
           </p>
         )}
@@ -287,7 +288,7 @@ export function AdmissionScoreboard({
       </div>
 
       <div className="border-t border-white/10 px-5 py-2.5 font-mono text-[10px] leading-5 text-white/30 sm:flex sm:justify-between sm:gap-6 sm:px-8">
-        <p>Admit on p50 · Linux PSS · regression budget, not capacity</p>
+        <p><T id="ui.admit.on.p50.linux.pss.regression.budget.not" /></p>
         {provenance && !sample ? (
           <p className="mt-1 truncate sm:mt-0 sm:max-w-md sm:text-right">
             {provenance.os} {provenance.arch}
diff --git a/website/components/benchmarks/runtime-suites.tsx b/website/components/benchmarks/runtime-suites.tsx
index 6b826d1..1761ce1 100644
--- a/website/components/benchmarks/runtime-suites.tsx
+++ b/website/components/benchmarks/runtime-suites.tsx
@@ -1,3 +1,4 @@
+import { T, SourceText } from "@/components/locale-provider";
 import { Fragment } from "react";
 import {
   formatMeasuredParts,
@@ -22,14 +23,13 @@ export function RuntimeSuites({ suites }: { suites: RuntimeSuite[] }) {
     <section className="mt-14">
       <div className="max-w-3xl">
         <p className="text-xs font-medium uppercase tracking-[0.18em] text-fd-muted-foreground">
-          Runtime microbenchmarks
+          <T id="ui.runtime.microbenchmarks" />
         </p>
         <h2 className="font-heading mt-2 text-xl font-medium tracking-tight">
-          Same run · not release gates
+          <T id="ui.same.run.not.release.gates" />
         </h2>
         <p className="mt-2 text-sm leading-6 text-fd-muted-foreground">
-          Observational only — they never fail a release and are not production
-          throughput claims. Values in ms.
+          <T id="ui.observational.only.they.never.fail.a.release.and" />
         </p>
       </div>
 
@@ -43,7 +43,7 @@ export function RuntimeSuites({ suites }: { suites: RuntimeSuite[] }) {
           </colgroup>
           <thead>
             <tr className="border-b border-fd-border font-mono text-[10px] uppercase tracking-[0.12em] text-fd-muted-foreground">
-              <th className="px-4 py-2.5 font-normal sm:px-5">Metric</th>
+              <th className="px-4 py-2.5 font-normal sm:px-5"><T id="ui.metric" /></th>
               <th className="px-2 py-2.5 text-right font-normal">p50</th>
               <th className="px-2 py-2.5 text-right font-normal">p95</th>
               <th className="px-4 py-2.5 text-right font-normal sm:pr-5">
@@ -57,9 +57,9 @@ export function RuntimeSuites({ suites }: { suites: RuntimeSuite[] }) {
                 <tr className="bg-fd-muted/25">
                   <td colSpan={4} className="px-4 py-2 sm:px-5">
                     <div className="flex flex-wrap items-baseline gap-x-3 gap-y-0.5">
-                      <span className="text-sm font-medium">{suite.title}</span>
+                      <span className="text-sm font-medium"><SourceText text={suite.title} /></span>
                       <span className="text-[11px] text-fd-muted-foreground">
-                        {suite.intent}
+                        <SourceText text={suite.intent} />
                       </span>
                     </div>
                   </td>
@@ -71,10 +71,10 @@ export function RuntimeSuites({ suites }: { suites: RuntimeSuite[] }) {
                   >
                     <td className="px-4 py-2 align-middle sm:px-5">
                       <p className="text-sm font-medium leading-5">
-                        {row.metric}
+                        <SourceText text={row.metric} />
                       </p>
                       <p className="mt-0.5 text-[11px] leading-4 text-fd-muted-foreground">
-                        {row.detail}
+                        <SourceText text={row.detail} />
                         {row.samples != null ? ` · n=${row.samples}` : null}
                       </p>
                     </td>
diff --git a/website/app/(home)/blog/[slug]/page.tsx b/website/components/blog/article.tsx
similarity index 78%
rename from website/app/(home)/blog/[slug]/page.tsx
rename to website/components/blog/article.tsx
index 0b54077..94867a0 100644
--- a/website/app/(home)/blog/[slug]/page.tsx
+++ b/website/components/blog/article.tsx
@@ -1,6 +1,8 @@
-import Link from "next/link";
+import { T } from "@/components/locale-provider";
+import { SiteLink as Link } from "@/components/locale-provider";
+import { LocaleOriginalLink } from "@/components/locale-original-link";
+import { BlogTable } from "@/components/blog/blog-table";
 import type { Metadata } from "next";
-import { notFound } from "next/navigation";
 import { BlogMobileToc } from "@/components/blog/mobile-toc";
 import { getMDXComponents } from "@/components/mdx";
 import { StructuredData } from "@/components/seo/structured-data";
@@ -11,19 +13,21 @@ import {
   getReadingMinutes,
 } from "@/lib/blog";
 import { createBlogPostingJsonLd } from "@/lib/seo";
-import { blog } from "@/lib/source";
+import type { BlogPage } from "@/lib/source";
+import type { MDXComponents } from "mdx/types";
+import { sourceLocale, type Locale } from "@/lib/i18n/config";
+import { getMessages } from "@/lib/i18n/messages";
 import { absoluteUrl, canonicalUrl, githubUrl } from "@/lib/shared";
 
-export default async function BlogPostPage(
-  props: PageProps<"/blog/[slug]">,
-) {
-  const params = await props.params;
-  const page = blog.getPage([params.slug]);
-  if (!page) notFound();
+function blogMdxComponents(components?: MDXComponents): MDXComponents {
+  return getMDXComponents({ ...components, table: BlogTable });
+}
 
+export default async function BlogArticle({ page, locale = sourceLocale, components, originalUrl }: { page: BlogPage; locale?: Locale; components?: MDXComponents; originalUrl?: string }) {
   const MDX = page.data.body;
-  const jsonLd = createBlogPostingJsonLd(page);
+  const jsonLd = createBlogPostingJsonLd(page, locale);
   const minutes = await getReadingMinutes(page);
+  const mdxComponents = blogMdxComponents(components);
 
   return (
     <>
@@ -38,14 +42,14 @@ export default async function BlogPostPage(
                   href="/blog"
                   className="transition-colors hover:text-fd-foreground"
                 >
-                  Blog
+                  <T id="nav.blog" />
                 </Link>
                 <span className="mx-2 text-fd-border">/</span>
-                <span className="text-fd-foreground">Post</span>
+                <span className="text-fd-foreground"><T id="ui.post" /></span>
               </nav>
 
               <p className="home-fade-up mt-8 font-mono text-xs text-tysel-blue">
-                {formatBlogDate(page)} · {minutes} min read · {page.data.author}
+                {formatBlogDate(page, locale)} · {minutes} <T id="ui.min.read" /> {page.data.author}
               </p>
 
               <h1 className="home-fade-up font-heading mt-4 text-3xl font-medium tracking-tighter text-balance sm:text-5xl sm:leading-[1.08]">
@@ -58,6 +62,12 @@ export default async function BlogPostPage(
                 </p>
               ) : null}
 
+              {originalUrl ? (
+                <p className="home-fade-up home-fade-up-delay mt-4">
+                  <LocaleOriginalLink href={originalUrl} label={getMessages(locale)["locale.original"]} />
+                </p>
+              ) : null}
+
               {page.data.tags && page.data.tags.length > 0 ? (
                 <ul className="home-fade-up home-fade-up-delay mt-6 flex flex-wrap gap-2">
                   {page.data.tags.map((tag) => (
@@ -92,7 +102,7 @@ export default async function BlogPostPage(
             <div className="min-w-0 lg:justify-self-end">
               <BlogMobileToc items={page.data.toc} />
               <div className="blog-prose prose min-w-0 max-w-[72ch]">
-                <MDX components={getMDXComponents()} />
+                <MDX components={mdxComponents} />
               </div>
             </div>
 
@@ -100,7 +110,7 @@ export default async function BlogPostPage(
               <div className="sticky top-[calc(var(--site-header-height)+1.5rem)] space-y-8">
                 <div>
                   <p className="text-xs font-medium uppercase tracking-[0.14em] text-fd-muted-foreground">
-                    On this page
+                    <T id="ui.on.this.page" />
                   </p>
                   <nav className="mt-3 space-y-2">
                     {page.data.toc
@@ -126,20 +136,20 @@ export default async function BlogPostPage(
                 href="/docs/getting-started"
                 className="bg-fd-background px-6 py-6 transition-colors hover:bg-fd-accent"
               >
-                <p className="font-mono text-xs text-tysel-blue">Next</p>
-                <p className="mt-2 text-sm font-medium">Get started →</p>
+                <p className="font-mono text-xs text-tysel-blue"><T id="ui.next" /></p>
+                <p className="mt-2 text-sm font-medium"><T id="ui.get.started" /></p>
                 <p className="mt-2 text-sm leading-6 text-fd-muted-foreground">
-                  Install the toolchain and ship a hello-service binary.
+                  <T id="ui.install.the.toolchain.and.ship.a.hello.service" />
                 </p>
               </Link>
               <Link
                 href="/docs"
                 className="bg-fd-background px-6 py-6 transition-colors hover:bg-fd-accent"
               >
-                <p className="font-mono text-xs text-tysel-blue">Docs</p>
-                <p className="mt-2 text-sm font-medium">Read the docs →</p>
+                <p className="font-mono text-xs text-tysel-blue"><T id="nav.docs" /></p>
+                <p className="mt-2 text-sm font-medium"><T id="ui.read.the.docs.186" /></p>
                 <p className="mt-2 text-sm leading-6 text-fd-muted-foreground">
-                  Concepts, capabilities, durable work, and operations.
+                  <T id="ui.concepts.capabilities.durable.work.and.operations" />
                 </p>
               </Link>
               <Link
@@ -148,10 +158,10 @@ export default async function BlogPostPage(
                 rel="noreferrer"
                 className="bg-fd-background px-6 py-6 transition-colors hover:bg-fd-accent"
               >
-                <p className="font-mono text-xs text-tysel-blue">Source</p>
+                <p className="font-mono text-xs text-tysel-blue"><T id="ui.source" /></p>
                 <p className="mt-2 text-sm font-medium">GitHub →</p>
                 <p className="mt-2 text-sm leading-6 text-fd-muted-foreground">
-                  Browse the runtime, examples, and release evidence.
+                  <T id="ui.browse.the.runtime.examples.and.release.evidence" />
                 </p>
               </Link>
             </div>
@@ -161,7 +171,7 @@ export default async function BlogPostPage(
                 href="/blog"
                 className="text-sm text-fd-muted-foreground transition-colors hover:text-fd-foreground"
               >
-                ← All posts
+                <T id="ui.all.posts.189" />
               </Link>
               <a
                 href="/rss.xml"
@@ -177,19 +187,7 @@ export default async function BlogPostPage(
   );
 }
 
-export function generateStaticParams() {
-  return blog.getPages().map((page) => ({
-    slug: page.slugs[0],
-  }));
-}
-
-export async function generateMetadata(
-  props: PageProps<"/blog/[slug]">,
-): Promise<Metadata> {
-  const params = await props.params;
-  const page = blog.getPage([params.slug]);
-  if (!page) notFound();
-
+export function blogMetadata(page: BlogPage): Metadata {
   const url = canonicalUrl(page.url);
   const published = getBlogDate(page).toISOString();
   const modified = getBlogUpdatedAt(page).toISOString();
diff --git a/website/components/blog/blog-table.tsx b/website/components/blog/blog-table.tsx
new file mode 100644
index 0000000..cf6f9d3
--- /dev/null
+++ b/website/components/blog/blog-table.tsx
@@ -0,0 +1,10 @@
+import type { ComponentProps } from "react";
+
+/** Keep table layout (`width: 100%`) while allowing wide multi-column tables to scroll. */
+export function BlogTable(props: ComponentProps<"table">) {
+  return (
+    <div className="blog-table-scroll">
+      <table {...props} />
+    </div>
+  );
+}
diff --git a/website/components/copy-button.tsx b/website/components/copy-button.tsx
index 5c5ff95..b57f3cf 100644
--- a/website/components/copy-button.tsx
+++ b/website/components/copy-button.tsx
@@ -1,5 +1,7 @@
 "use client";
 
+import { useLocale } from "@/components/locale-provider";
+
 import { Check, Copy } from "lucide-react";
 import { useState } from "react";
 
@@ -10,13 +12,14 @@ export function CopyButton({
   value: string;
   className?: string;
 }) {
+  const { t } = useLocale();
   const [copied, setCopied] = useState(false);
 
   return (
     <button
       type="button"
       className={`inline-flex size-8 items-center justify-center rounded-md text-fd-muted-foreground transition-colors hover:bg-fd-accent hover:text-fd-foreground ${className}`}
-      aria-label={copied ? "Copied" : "Copy"}
+      aria-label={t(copied ? "common.copied" : "common.copy")}
       onClick={async () => {
         await navigator.clipboard.writeText(value);
         setCopied(true);
diff --git a/website/components/header-chrome.ts b/website/components/header-chrome.ts
new file mode 100644
index 0000000..86355db
--- /dev/null
+++ b/website/components/header-chrome.ts
@@ -0,0 +1,9 @@
+/** Shared hit target + glyph weight for header utility controls. */
+export const headerIconButtonClass =
+  "inline-flex size-8 shrink-0 cursor-pointer items-center justify-center text-fd-muted-foreground transition-colors hover:bg-fd-accent hover:text-fd-foreground";
+
+/** Lucide / SVG glyph size inside the hit target. */
+export const headerIconClass = "size-4";
+
+/** Short locale labels (EN / 中) sized to match icon optical weight. */
+export const headerIconLabelClass = "font-mono text-sm leading-none font-medium";
diff --git a/website/components/home/artifact-demo.tsx b/website/components/home/artifact-demo.tsx
index f26bbc2..88c0e18 100644
--- a/website/components/home/artifact-demo.tsx
+++ b/website/components/home/artifact-demo.tsx
@@ -1,5 +1,6 @@
 "use client";
 
+import { SourceText } from "@/components/locale-provider";
 import { useEffect, useState } from "react";
 
 const frames = [
@@ -75,16 +76,16 @@ export function ArtifactDemo() {
                   : "text-white/55 hover:text-white"
               }`}
             >
-              {String(i + 1).padStart(2, "0")} {item.label}
+              {String(i + 1).padStart(2, "0")} <SourceText text={item.label} />
             </button>
           ))}
         </div>
         <span className="hidden font-mono text-[10px] tracking-wide text-white/40 sm:inline">
-          {paused ? "paused" : "replay"}
+          <SourceText text={paused ? "paused" : "replay"} />
         </span>
       </div>
       <div className="border-b border-white/10 px-4 py-2">
-        <p className="text-xs text-white/55">{frame.hint}</p>
+        <p className="text-xs text-white/55"><SourceText text={frame.hint} /></p>
       </div>
       <pre
         key={frame.id}
diff --git a/website/app/(home)/blog/page.tsx b/website/components/home/blog-index-page.tsx
similarity index 87%
rename from website/app/(home)/blog/page.tsx
rename to website/components/home/blog-index-page.tsx
index 4908431..448a4f1 100644
--- a/website/app/(home)/blog/page.tsx
+++ b/website/components/home/blog-index-page.tsx
@@ -1,4 +1,6 @@
-import Link from "next/link";
+import { sourceLocale, type Locale } from "@/lib/i18n/config";
+import { alternates } from "@/lib/i18n/seo";
+import { T, SiteLink as Link } from "@/components/locale-provider";
 import type { Metadata } from "next";
 import { StructuredData } from "@/components/seo/structured-data";
 import {
@@ -16,7 +18,7 @@ export const metadata: Metadata = {
   title: "Blog",
   description,
   alternates: {
-    canonical: canonicalUrl("/blog"),
+    ...alternates("/blog"),
     types: {
       "application/rss+xml": absoluteUrl("/rss.xml"),
     },
@@ -30,10 +32,10 @@ export const metadata: Metadata = {
   },
 };
 
-export default async function BlogIndexPage() {
-  const posts = getBlogPosts();
+export default async function BlogIndexPage({ locale = sourceLocale }: { locale?: Locale } = {}) {
+  const posts = getBlogPosts(locale);
   const [featured, ...rest] = posts;
-  const jsonLd = createBlogIndexJsonLd(posts);
+  const jsonLd = createBlogIndexJsonLd(posts, locale);
   const featuredMinutes = featured
     ? await getReadingMinutes(featured)
     : null;
@@ -50,25 +52,26 @@ export default async function BlogIndexPage() {
         <div className="home-grid pointer-events-none absolute inset-0" />
         <div className="relative mx-auto max-w-6xl px-6 pt-16 pb-14 sm:pt-20">
           <p className="home-fade-up text-xs font-medium uppercase tracking-[0.18em] text-fd-muted-foreground">
-            Blog
+            <T id="nav.blog" />
           </p>
           <h1 className="home-fade-up font-heading mt-3 max-w-3xl text-4xl font-medium tracking-tighter text-balance sm:text-5xl">
-            Notes on shipping TypeScript as a binary.
+            <T id="ui.notes.on.shipping.typescript.as.a.binary" />
           </h1>
           <p className="home-fade-up home-fade-up-delay mt-5 max-w-2xl text-base leading-7 text-fd-muted-foreground sm:text-lg">
-            {description}
+            <T id="blog.description" />
           </p>
           <div className="home-fade-up home-fade-up-delay mt-6">
             <a
               href="/rss.xml"
               className="font-mono text-xs text-tysel-blue transition-colors hover:text-fd-foreground"
             >
-              RSS feed →
+              <T id="ui.rss.feed" />
             </a>
           </div>
         </div>
       </section>
 
+
       {featured ? (
         <section className="border-b border-fd-border">
           <div className="mx-auto max-w-6xl px-6 py-12 sm:py-16">
@@ -90,8 +93,8 @@ export default async function BlogIndexPage() {
               ) : null}
               <div>
                 <p className="font-mono text-xs text-tysel-blue">
-                  Featured · {formatBlogDate(featured)} · {featuredMinutes}{" "}
-                  min read
+                  <T id="ui.featured" /> {formatBlogDate(featured, locale)} · {featuredMinutes}{" "}
+                  <T id="ui.min.read.194" />
                 </p>
                 <h2 className="font-heading mt-3 text-2xl font-medium tracking-tight text-balance transition-colors group-hover:text-tysel-blue sm:text-3xl">
                   {featured.data.title}
@@ -100,7 +103,7 @@ export default async function BlogIndexPage() {
                   {featured.data.description}
                 </p>
                 <span className="mt-6 inline-flex text-sm font-medium text-fd-foreground">
-                  Read the post →
+                  <T id="ui.read.the.post" />
                 </span>
               </div>
             </Link>
@@ -112,7 +115,7 @@ export default async function BlogIndexPage() {
         <section>
           <div className="mx-auto max-w-6xl px-6 py-12 sm:py-16">
             <p className="text-xs font-medium uppercase tracking-[0.18em] text-fd-muted-foreground">
-              Earlier
+              <T id="ui.earlier" />
             </p>
             <ul className="mt-6 divide-y divide-fd-border border-y border-fd-border">
               {restWithMinutes.map(({ post, minutes }) => (
@@ -140,7 +143,7 @@ export default async function BlogIndexPage() {
                     {/* Text */}
                     <div className="min-w-0 flex-1 py-0.5">
                       <p className="font-mono text-xs text-fd-muted-foreground">
-                        {formatBlogDate(post)} · {minutes} min read
+                        {formatBlogDate(post, locale)} · {minutes} <T id="ui.min.read.194" />
                       </p>
                       <h2 className="mt-2 text-base font-medium tracking-tight leading-snug transition-colors group-hover:text-tysel-blue sm:text-lg">
                         {post.data.title}
diff --git a/website/components/home/five-minutes.tsx b/website/components/home/five-minutes.tsx
index 623b07c..2c52bfc 100644
--- a/website/components/home/five-minutes.tsx
+++ b/website/components/home/five-minutes.tsx
@@ -1,5 +1,6 @@
 "use client";
 
+import { T, SourceText } from "@/components/locale-provider";
 import { useEffect, useState } from "react";
 
 const steps = [
@@ -66,7 +67,7 @@ export function FiveMinutes() {
             >
               <span className="font-mono text-xs text-tysel-blue">{item.n}</span>
               <span>
-                <span className="block text-sm font-medium">{item.title}</span>
+                <span className="block text-sm font-medium"><SourceText text={item.title} /></span>
                 <span className="mt-1 block font-mono text-xs text-fd-muted-foreground">
                   $ {item.command}
                 </span>
@@ -86,11 +87,10 @@ export function FiveMinutes() {
           key={`${step.n}-copy`}
           className="home-code-fade mt-4 text-sm leading-6 text-white/70"
         >
-          {step.copy}
+          <SourceText text={step.copy} />
         </p>
         <p className="mt-6 text-xs text-white/40">
-          Node.js is optional for editor declarations. The packaged application
-          does not need it. {paused ? "Paused." : "Hover to pause."}
+          <T id="ui.node.js.is.optional.for.editor.declarations.the" /> <SourceText text={paused ? "Paused." : "Hover to pause."} />
         </p>
       </div>
     </div>
diff --git a/website/app/(home)/page.tsx b/website/components/home/home-page.tsx
similarity index 81%
rename from website/app/(home)/page.tsx
rename to website/components/home/home-page.tsx
index 93fc20e..bde8d3c 100644
--- a/website/app/(home)/page.tsx
+++ b/website/components/home/home-page.tsx
@@ -1,4 +1,9 @@
-import Link from "next/link";
+import { getMessages } from "@/lib/i18n/messages";
+import { localePath } from "@/lib/i18n/routing";
+import { sourceLocale, type Locale } from "@/lib/i18n/config";
+import { alternates } from "@/lib/i18n/seo";
+import { T, SourceText } from "@/components/locale-provider";
+import { SiteLink as Link } from "@/components/locale-provider";
 import type { Metadata } from "next";
 import { ArtifactDemo } from "@/components/home/artifact-demo";
 import { FiveMinutes } from "@/components/home/five-minutes";
@@ -12,7 +17,7 @@ const description =
   "A native TypeScript runtime for services and agents. One executable, explicit capabilities, and durable work that survives restarts.";
 
 export const metadata: Metadata = {
-  alternates: { canonical: canonicalUrl() },
+  alternates: alternates(),
   openGraph: {
     url: canonicalUrl(),
     title: "Tysel — Write TypeScript. Ship a binary.",
@@ -100,38 +105,37 @@ const contracts = [
   },
 ];
 
-export default function HomePage() {
-  const featuredPost = getFeaturedBlogPost();
+export default function HomePage({ locale = sourceLocale }: { locale?: Locale } = {}) {
+  const featuredPost = getFeaturedBlogPost(locale);
 
   return (
     <main>
-      <StructuredData data={jsonLd} />
+      <StructuredData data={{ ...jsonLd, "@graph": jsonLd["@graph"].map(item => ({ ...item, url: canonicalUrl(localePath("/", locale)), "@id": `${canonicalUrl(localePath("/", locale))}#${item["@type"] === "WebSite" ? "website" : "software"}`, description: getMessages(locale)["site.description"], inLanguage: locale })) }} />
       <section className="relative overflow-hidden border-b border-fd-border">
         <div className="home-atmosphere pointer-events-none absolute inset-0" />
         <div className="home-grid pointer-events-none absolute inset-0" />
-        <div className="relative mx-auto grid max-w-6xl gap-12 px-6 pt-16 pb-20 lg:grid-cols-[minmax(0,1.05fr)_minmax(0,0.95fr)] lg:pt-20 lg:pb-28">
+        <div className="relative mx-auto grid grid-cols-1 max-w-6xl gap-12 px-6 pt-16 pb-20 lg:grid-cols-[minmax(0,1.05fr)_minmax(0,0.95fr)] lg:pt-20 lg:pb-28">
           <div className="home-fade-up">
             <h1 className="font-heading text-4xl leading-[1.05] font-medium tracking-tighter text-balance sm:text-6xl sm:leading-[1.05]">
-              Write TypeScript.
+              <T id="home.hero.title" />
               <br />
-              Ship a <span className="text-tysel-blue">binary</span>.
+              <T id="home.hero.ship" /> <span className="text-tysel-blue"><T id="home.hero.binary" /></span>.
             </h1>
             <p className="mt-6 max-w-xl text-base leading-7 text-fd-muted-foreground sm:text-lg">
-              A native runtime for services and AI agents — one executable,
-              explicit capabilities, durable work that survives restarts.
+              <T id="ui.a.native.runtime.for.services.and.ai.agents" />
             </p>
             <div className="mt-8 flex flex-wrap gap-3">
               <Link
                 href="/docs/getting-started"
                 className="bg-fd-foreground px-4 py-2 text-sm font-medium text-fd-background transition-opacity hover:opacity-90"
               >
-                Get started
+                <T id="common.getStarted" />
               </Link>
               <Link
                 href="/docs"
                 className="border border-fd-border px-4 py-2 text-sm font-medium transition-colors hover:bg-fd-accent"
               >
-                Read the docs
+                <T id="ui.read.the.docs" />
               </Link>
             </div>
             <div className="mt-8">
@@ -152,9 +156,9 @@ export default function HomePage() {
               href={item.href}
               className="bg-fd-background px-6 py-6 transition-colors hover:bg-fd-accent"
             >
-              <h2 className="text-sm font-medium">{item.title}</h2>
+              <h2 className="text-sm font-medium"><SourceText text={item.title} /></h2>
               <p className="mt-2 text-sm leading-6 text-fd-muted-foreground">
-                {item.body}
+                <SourceText text={item.body} />
               </p>
             </Link>
           ))}
@@ -164,11 +168,10 @@ export default function HomePage() {
       <section className="border-b border-fd-border">
         <div className="mx-auto max-w-6xl px-6 py-20">
           <p className="text-xs font-medium uppercase tracking-[0.18em] text-fd-muted-foreground">
-            Three product contracts
+            <T id="ui.three.product.contracts" />
           </p>
           <h2 className="font-heading mt-3 max-w-3xl text-3xl font-medium tracking-tight text-balance sm:text-4xl">
-            Bun and Deno optimize a general JavaScript toolchain. Tysel ships a
-            narrower production contract.
+            <T id="ui.bun.and.deno.optimize.a.general.javascript.toolchain" />
           </h2>
           <div className="mt-12 grid gap-px bg-fd-border lg:grid-cols-3">
             {contracts.map((item) => (
@@ -178,9 +181,9 @@ export default function HomePage() {
                 className="bg-fd-background p-6 transition-colors hover:bg-fd-accent"
               >
                 <span className="font-mono text-xs text-tysel-blue">{item.n}</span>
-                <h3 className="mt-3 text-xl font-medium">{item.title}</h3>
+                <h3 className="mt-3 text-xl font-medium"><SourceText text={item.title} /></h3>
                 <p className="mt-3 text-sm leading-6 text-fd-muted-foreground">
-                  {item.body}
+                  <SourceText text={item.body} />
                 </p>
               </Link>
             ))}
@@ -196,15 +199,14 @@ export default function HomePage() {
               className="size-2 shrink-0 bg-tysel-blue"
             />
             <p className="text-xs font-medium uppercase tracking-[0.18em] text-fd-muted-foreground">
-              Workloads
+              <T id="ui.workloads" />
             </p>
           </div>
           <h2 className="font-heading mt-4 max-w-3xl text-3xl font-medium tracking-tight text-balance sm:text-4xl">
-            Services, agents, and Wasm — each with a named grant.
+            <T id="ui.services.agents.and.wasm.each.with.a.named" />
           </h2>
           <p className="mt-4 max-w-2xl text-sm leading-6 text-fd-muted-foreground">
-            A narrow host surface, not a kitchen-sink stdlib. Network, secrets,
-            storage, and LLM access stay closed until the manifest opens them.
+            <T id="ui.a.narrow.host.surface.not.a.kitchen.sink" />
           </p>
           <div className="mt-10">
             <RuntimeCapabilities />
@@ -215,10 +217,10 @@ export default function HomePage() {
       <section className="border-b border-fd-border">
         <div className="mx-auto max-w-6xl px-6 py-20">
           <p className="text-xs font-medium uppercase tracking-[0.18em] text-fd-muted-foreground">
-            Five minutes with Tysel
+            <T id="ui.five.minutes.with.tysel" />
           </p>
           <h2 className="font-heading mt-3 text-3xl font-medium tracking-tight text-balance">
-            One loop from source to an executable.
+            <T id="ui.one.loop.from.source.to.an.executable" />
           </h2>
           <div className="mt-10">
             <FiveMinutes />
@@ -229,16 +231,13 @@ export default function HomePage() {
       <section className="border-b border-fd-border">
         <div className="mx-auto max-w-6xl px-6 py-20">
           <p className="text-xs font-medium uppercase tracking-[0.18em] text-fd-muted-foreground">
-            Ship with proof
+            <T id="ui.ship.with.proof" />
           </p>
           <h2 className="font-heading mt-3 max-w-3xl text-3xl font-medium tracking-tight text-balance">
-            Every release carries evidence, not just a binary.
+            <T id="ui.every.release.carries.evidence.not.just.a.binary" />
           </h2>
           <p className="mt-4 max-w-2xl text-sm leading-6 text-fd-muted-foreground">
-            Compatibility reports, SBOMs, checksums, and CI admission gates
-            travel with the artifact. Marketing performance claims stay off the
-            homepage until cross-runtime evidence clears the publication
-            contract.
+            <T id="ui.compatibility.reports.sboms.checksums.and.ci.admission.gates" />
           </p>
           <div className="mt-10 grid gap-px bg-fd-border sm:grid-cols-2 lg:grid-cols-4">
             {[
@@ -252,7 +251,7 @@ export default function HomePage() {
                 href={href}
                 className="bg-fd-background px-4 py-4 text-sm transition-colors hover:bg-fd-accent"
               >
-                {label} →
+                <SourceText text={label} /> →
               </Link>
             ))}
           </div>
@@ -265,17 +264,17 @@ export default function HomePage() {
             <div className="flex items-end justify-between gap-6">
               <div>
                 <p className="text-xs font-medium uppercase tracking-[0.18em] text-fd-muted-foreground">
-                  From the blog
+                  <T id="ui.from.the.blog" />
                 </p>
                 <h2 className="font-heading mt-3 max-w-2xl text-3xl font-medium tracking-tight text-balance">
-                  Why Tysel ships a narrower production contract.
+                  <T id="ui.why.tysel.ships.a.narrower.production.contract" />
                 </h2>
               </div>
               <Link
                 href="/blog"
                 className="hidden shrink-0 text-sm text-fd-muted-foreground transition-colors hover:text-fd-foreground sm:inline"
               >
-                All posts →
+                <T id="ui.all.posts" />
               </Link>
             </div>
             <Link
@@ -298,7 +297,7 @@ export default function HomePage() {
               ) : null}
               <div className="flex flex-col justify-center px-6 py-6 lg:pr-8">
                 <p className="font-mono text-xs text-tysel-blue">
-                  Release · {formatBlogDate(featuredPost)}
+                  <T id="ui.release" /> {formatBlogDate(featuredPost, locale)}
                 </p>
                 <h3 className="font-heading mt-3 text-xl font-medium tracking-tight text-balance sm:text-2xl">
                   {featuredPost.data.title}
@@ -307,7 +306,7 @@ export default function HomePage() {
                   {featuredPost.data.description}
                 </p>
                 <span className="mt-6 text-sm font-medium">
-                  Read the announcement →
+                  <T id="ui.read.the.announcement" />
                 </span>
               </div>
             </Link>
@@ -320,20 +319,20 @@ export default function HomePage() {
           <div className="home-atmosphere pointer-events-none absolute inset-0 opacity-60" />
           <div className="relative mx-auto max-w-6xl px-6 py-24 text-center">
             <h2 className="font-heading text-3xl font-medium tracking-tight text-balance sm:text-5xl">
-              From TypeScript source to one production artifact.
+              <T id="ui.from.typescript.source.to.one.production.artifact" />
             </h2>
             <div className="mt-8 flex justify-center gap-3">
               <Link
                 href="/docs/getting-started"
                 className="bg-fd-foreground px-4 py-2 text-sm font-medium text-fd-background transition-opacity hover:opacity-90"
               >
-                Build your first service
+                <T id="ui.build.your.first.service" />
               </Link>
               <Link
                 href="/docs/guides/examples"
                 className="border border-fd-border px-4 py-2 text-sm font-medium transition-colors hover:bg-fd-accent"
               >
-                Run the durable agent example
+                <T id="ui.run.the.durable.agent.example" />
               </Link>
             </div>
           </div>
diff --git a/website/components/home/install-panel.tsx b/website/components/home/install-panel.tsx
index 46c7a53..1cbc449 100644
--- a/website/components/home/install-panel.tsx
+++ b/website/components/home/install-panel.tsx
@@ -1,5 +1,6 @@
 "use client";
 
+import { T } from "@/components/locale-provider";
 import { CopyButton } from "@/components/copy-button";
 
 const installCommand = "curl -fsSL https://tysel.dev/install.sh | sh";
@@ -20,11 +21,11 @@ export function InstallPanel() {
         />
       </div>
       <p className="mt-2 text-xs leading-5 text-fd-muted-foreground">
-        Then run{" "}
+        <T id="ui.then.run" />{" "}
         <code className="font-mono text-[12px] text-fd-foreground/80">
           tysel doctor --install
         </code>
-        . No Rust, Node.js, or npm on the machine.
+        <T id="ui.no.rust.node.js.or.npm.on.the" />
       </p>
     </div>
   );
diff --git a/website/components/home/runtime-capabilities.tsx b/website/components/home/runtime-capabilities.tsx
index a37aee1..58d8496 100644
--- a/website/components/home/runtime-capabilities.tsx
+++ b/website/components/home/runtime-capabilities.tsx
@@ -1,6 +1,7 @@
 "use client";
 
-import Link from "next/link";
+import { T, SourceText } from "@/components/locale-provider";
+import { SiteLink as Link } from "@/components/locale-provider";
 import type { KeyboardEvent, ReactNode } from "react";
 import { useId, useRef, useState } from "react";
 import { CopyButton } from "@/components/copy-button";
@@ -351,7 +352,7 @@ const apiGroups: ApiGroup[] = [
       {
         name: "tysel inspect",
         description: "Effective authority and limits",
-        href: "/reference/cli/development#tysel-inspect",
+        href: "/reference/cli/development#static-validation",
       },
       {
         name: "@tysel/test",
@@ -402,13 +403,13 @@ function ExamplePanel({ example }: { example: Example }) {
           key={example.id}
           className="home-code-fade max-w-xl text-sm leading-6 text-white/65"
         >
-          {example.blurb}
+          <SourceText text={example.blurb} />
         </p>
         <Link
           href={example.docsHref}
           className="shrink-0 text-sm text-white/70 underline decoration-white/30 underline-offset-4 hover:text-white hover:decoration-white"
         >
-          Docs →
+          <T id="ui.docs" />
         </Link>
       </div>
 
@@ -429,8 +430,8 @@ function ExamplePanel({ example }: { example: Example }) {
 
       <div className="mt-auto flex flex-col justify-between gap-2 border-t border-white/10 px-5 py-3 text-xs text-white/45 sm:flex-row sm:items-center">
         <span>
-          <span className="text-white/30">Grant · </span>
-          {example.grant}
+          <span className="text-white/30"><T id="ui.grant" /> </span>
+          <SourceText text={example.grant} />
         </span>
         {example.exampleHref ? (
           <Link
@@ -442,7 +443,7 @@ function ExamplePanel({ example }: { example: Example }) {
               : "Open example →"}
           </Link>
         ) : (
-          <span className="shrink-0 text-white/35">Reference recipe</span>
+          <span className="shrink-0 text-white/35"><T id="ui.reference.recipe" /></span>
         )}
       </div>
     </div>
@@ -509,7 +510,7 @@ export function RuntimeCapabilities() {
                         selected ? "bg-tysel-blue" : "bg-fd-border"
                       }`}
                     />
-                    {item.label}
+                    <SourceText text={item.label} />
                   </button>
                 </li>
               );
@@ -530,18 +531,17 @@ export function RuntimeCapabilities() {
       <div className="mt-16 flex flex-col justify-between gap-4 sm:flex-row sm:items-end">
         <div>
           <h3 className="font-heading max-w-xl text-xl font-medium tracking-tight text-balance sm:text-2xl">
-            Lookup by contract
+            <T id="ui.lookup.by.contract" />
           </h3>
           <p className="mt-2 max-w-xl text-sm leading-6 text-fd-muted-foreground">
-            Each link is an exact interface page — accepted values, defaults,
-            and what the profile can still deny.
+            <T id="ui.each.link.is.an.exact.interface.page.accepted" />
           </p>
         </div>
         <Link
           href="/reference"
           className="inline-flex shrink-0 items-center border border-fd-border px-4 py-2 text-sm font-medium transition-colors hover:bg-fd-accent"
         >
-          API reference →
+          <T id="ui.api.reference" />
         </Link>
       </div>
 
@@ -549,17 +549,17 @@ export function RuntimeCapabilities() {
         {apiGroups.map((group) => (
           <div key={group.title} className="bg-fd-background p-5">
             <p className="text-[11px] font-medium uppercase tracking-[0.14em] text-fd-muted-foreground">
-              {group.title}
+              <SourceText text={group.title} />
             </p>
             <ul className="mt-4 space-y-4">
               {group.items.map((item) => (
                 <li key={item.name}>
                   <Link href={item.href} className="group block">
                     <p className="font-mono text-sm text-tysel-blue group-hover:underline">
-                      {item.name}
+                      <SourceText text={item.name} />
                     </p>
                     <p className="mt-1 text-sm leading-5 text-fd-muted-foreground">
-                      {item.description}
+                      <SourceText text={item.description} />
                     </p>
                   </Link>
                 </li>
@@ -570,27 +570,26 @@ export function RuntimeCapabilities() {
       </div>
 
       <p className="mt-6 max-w-3xl text-sm leading-6 text-fd-muted-foreground">
-        Shell, child processes, FFI, and dynamic libraries are outside the
-        application contract — not missing features. See the{" "}
+        <T id="ui.shell.child.processes.ffi.and.dynamic.libraries.are" />{" "}
         <Link
           href="/docs/capabilities"
           className="text-fd-foreground underline-offset-4 hover:underline"
         >
-          capability matrix
+          <T id="ui.capability.matrix" />
         </Link>
         ,{" "}
         <Link
           href="/docs/concepts/execution-profiles"
           className="text-fd-foreground underline-offset-4 hover:underline"
         >
-          execution profiles
+          <T id="ui.execution.profiles" />
         </Link>
-        , and{" "}
+        <T id="ui.and" />{" "}
         <Link
           href="/docs/guides/examples"
           className="text-fd-foreground underline-offset-4 hover:underline"
         >
-          example gallery
+          <T id="ui.example.gallery" />
         </Link>
         .
       </p>
diff --git a/website/components/language-switcher.tsx b/website/components/language-switcher.tsx
new file mode 100644
index 0000000..b773d45
--- /dev/null
+++ b/website/components/language-switcher.tsx
@@ -0,0 +1,121 @@
+"use client";
+
+import { useLocale } from "@/components/locale-provider";
+import { headerIconButtonClass, headerIconLabelClass } from "@/components/header-chrome";
+import { localeConfig, type Locale } from "@/lib/i18n/config";
+import { availableLocalePath } from "@/lib/i18n/routing";
+import { cn } from "@/lib/cn";
+import { Check, ChevronDown } from "lucide-react";
+import { usePathname } from "next/navigation";
+import { useEffect, useId, useRef, useState } from "react";
+
+export type LanguageChoice = { locale: Locale; name: string; paths: string[] };
+
+function shortLabel(locale: Locale) {
+  return localeConfig[locale].short ?? localeConfig[locale].name;
+}
+
+/** Two published locales: one-click switch to the other language. */
+function LocaleToggle({ choices }: { choices: [LanguageChoice, LanguageChoice] }) {
+  const { locale, t } = useLocale();
+  const pathname = usePathname();
+  const other = choices.find((choice) => choice.locale !== locale) ?? choices[0];
+
+  return (
+    <a
+      href={availableLocalePath(pathname, other.locale, other.paths)}
+      hrefLang={other.locale}
+      lang={other.locale}
+      aria-label={`${t("locale.label")}: ${other.name}`}
+      title={other.name}
+      className={headerIconButtonClass}
+    >
+      <span className={headerIconLabelClass}>{shortLabel(other.locale)}</span>
+    </a>
+  );
+}
+
+/** Three or more locales: compact menu of native names. */
+function LocaleMenu({ choices }: { choices: LanguageChoice[] }) {
+  const { locale, t } = useLocale();
+  const pathname = usePathname();
+  const [open, setOpen] = useState(false);
+  const rootRef = useRef<HTMLDivElement>(null);
+  const menuId = useId();
+
+  useEffect(() => {
+    if (!open) return;
+    const onPointer = (event: MouseEvent) => {
+      if (!rootRef.current?.contains(event.target as Node)) setOpen(false);
+    };
+    const onKey = (event: KeyboardEvent) => {
+      if (event.key === "Escape") setOpen(false);
+    };
+    document.addEventListener("mousedown", onPointer);
+    document.addEventListener("keydown", onKey);
+    return () => {
+      document.removeEventListener("mousedown", onPointer);
+      document.removeEventListener("keydown", onKey);
+    };
+  }, [open]);
+
+  useEffect(() => {
+    setOpen(false);
+  }, [pathname, locale]);
+
+  return (
+    <div ref={rootRef} className="relative">
+      <button
+        type="button"
+        aria-label={t("locale.label")}
+        aria-haspopup="menu"
+        aria-expanded={open}
+        aria-controls={menuId}
+        className={cn(headerIconButtonClass, "gap-0.5")}
+        onClick={() => setOpen((value) => !value)}
+      >
+        <span className={headerIconLabelClass}>{shortLabel(locale)}</span>
+        <ChevronDown className={cn("size-2.5 opacity-70 transition-transform", open && "rotate-180")} />
+      </button>
+      {open ? (
+        <ul
+          id={menuId}
+          role="menu"
+          aria-label={t("locale.label")}
+          className="absolute end-0 top-full z-50 mt-1 min-w-[10rem] border border-fd-border bg-fd-popover py-1 text-sm shadow-md"
+        >
+          {choices.map((choice) => {
+            const active = choice.locale === locale;
+            return (
+              <li key={choice.locale} role="none">
+                <a
+                  role="menuitem"
+                  href={availableLocalePath(pathname, choice.locale, choice.paths)}
+                  hrefLang={choice.locale}
+                  lang={choice.locale}
+                  aria-current={active ? "true" : undefined}
+                  className={cn(
+                    "flex items-center justify-between gap-3 px-3 py-1.5 text-fd-muted-foreground transition-colors hover:bg-fd-accent hover:text-fd-foreground",
+                    active && "bg-fd-accent/60 text-fd-foreground",
+                  )}
+                  onClick={() => setOpen(false)}
+                >
+                  <span>{choice.name}</span>
+                  {active ? <Check className="size-3.5 shrink-0 opacity-70" aria-hidden /> : <span className="size-3.5" />}
+                </a>
+              </li>
+            );
+          })}
+        </ul>
+      ) : null}
+    </div>
+  );
+}
+
+export function LanguageSwitcher({ choices }: { choices: LanguageChoice[] }) {
+  if (choices.length < 2) return null;
+  if (choices.length === 2) {
+    return <LocaleToggle choices={choices as [LanguageChoice, LanguageChoice]} />;
+  }
+  return <LocaleMenu choices={choices} />;
+}
diff --git a/website/components/locale-original-link.tsx b/website/components/locale-original-link.tsx
new file mode 100644
index 0000000..9433da1
--- /dev/null
+++ b/website/components/locale-original-link.tsx
@@ -0,0 +1,25 @@
+import { sourceLocale } from "@/lib/i18n/config";
+
+/** Quiet meta link back to the English source — sits in page chrome, not in the prose flow. */
+export function LocaleOriginalLink({
+  href,
+  label,
+  className,
+}: {
+  href: string;
+  label: string;
+  className?: string;
+}) {
+  return (
+    <a
+      href={href}
+      hrefLang={sourceLocale}
+      className={
+        className ??
+        "text-sm text-fd-muted-foreground transition-colors hover:text-fd-foreground"
+      }
+    >
+      {label}
+    </a>
+  );
+}
diff --git a/website/components/locale-provider.tsx b/website/components/locale-provider.tsx
new file mode 100644
index 0000000..37ad302
--- /dev/null
+++ b/website/components/locale-provider.tsx
@@ -0,0 +1,42 @@
+"use client";
+
+import { createContext, useContext, type ComponentProps, type ReactNode } from "react";
+import NextLink from "next/link";
+import { RootProvider } from "fumadocs-ui/provider/next";
+import { sourceLocale, type Locale } from "@/lib/i18n/config";
+import { availableLocalePath } from "@/lib/i18n/routing";
+import { translateSource, type MessageKey, type Messages } from "@/lib/i18n/catalog";
+
+type LocaleValue = { locale: Locale; messages: Messages; paths: string[] };
+const Context = createContext<LocaleValue | null>(null);
+export function LocaleProvider({ children, locale, messages, paths, uiTranslations = {} }: LocaleValue & {
+  children: ReactNode;
+  uiTranslations?: Record<string, string>;
+}) {
+  return (
+    <Context value={{ locale, messages, paths }}>
+      <RootProvider
+        i18n={{ locale, translations: uiTranslations }}
+        search={{ options: { type: "static", api: locale === sourceLocale ? "/api/search" : `/${locale}/search.json` } }}
+        theme={{ defaultTheme: "dark", enableSystem: true }}
+      >{children}</RootProvider>
+    </Context>
+  );
+}
+export function useLocale() {
+  const context = useContext(Context);
+  if (!context) throw new Error("useLocale requires LocaleProvider");
+  return { ...context, t: (id: MessageKey) => context.messages[id] };
+}
+export function T({ id }: { id: MessageKey }) {
+  const { t } = useLocale();
+  return <>{t(id)}</>;
+}
+export function SourceText({ text }: { text: string }) {
+  const { messages } = useLocale();
+  return <>{translateSource(text, messages)}</>;
+}
+export function SiteLink({ href, ...props }: ComponentProps<typeof NextLink>) {
+  const { locale, paths } = useLocale();
+  return <NextLink {...props} href={typeof href === "string" ? availableLocalePath(href, locale, paths) : href} />;
+}
diff --git a/website/app/layout.tsx b/website/components/site-document.tsx
similarity index 70%
rename from website/app/layout.tsx
rename to website/components/site-document.tsx
index bb522ec..6a3a5d7 100644
--- a/website/app/layout.tsx
+++ b/website/components/site-document.tsx
@@ -1,10 +1,13 @@
 import type { Metadata } from "next";
 import { Geist_Mono, Inter, Inter_Tight } from "next/font/google";
-import { RootProvider } from "fumadocs-ui/provider/next";
+import { LocaleProvider } from "@/components/locale-provider";
+import { getMessages, getUITranslations } from "@/lib/i18n/messages";
+import { type Locale } from "@/lib/i18n/config";
+import { languageChoices, availablePaths } from "@/lib/i18n/pages";
 import { ScrollToTop } from "@/components/scroll-to-top";
 import { SiteHeader } from "@/components/site-header";
 import { appName, siteUrl } from "@/lib/shared";
-import "./global.css";
+import "@/app/global.css";
 
 /** Body / UI — matches vite.dev (`Inter`). */
 const inter = Inter({
@@ -47,31 +50,31 @@ export const metadata: Metadata = {
     siteName: appName,
     locale: "en_US",
     type: "website",
+    images: [{ url: `${siteUrl}/opengraph-image`, width: 1200, height: 630 }],
   },
   twitter: {
     card: "summary_large_image",
+    images: [`${siteUrl}/twitter-image`],
   },
   icons: {
     icon: "/brand/tysel-mark.svg",
   },
 };
 
-export default function Layout({ children }: LayoutProps<"/">) {
+export function SiteDocument({ children, locale }: { children: React.ReactNode; locale: Locale }) {
+  const messages = getMessages(locale);
   return (
     <html
-      lang="en"
+      lang={locale}
       className={`${inter.variable} ${interTight.variable} ${geistMono.variable} dark`}
       suppressHydrationWarning
     >
       <body className="flex min-h-screen flex-col font-sans">
-        <RootProvider
-          search={{ options: { type: "static", api: "/api/search" } }}
-          theme={{ defaultTheme: "dark", enableSystem: true }}
-        >
+        <LocaleProvider locale={locale} messages={messages} paths={availablePaths(locale)} uiTranslations={getUITranslations(messages)}>
           <ScrollToTop />
-          <SiteHeader />
+          <SiteHeader languages={languageChoices()} />
           {children}
-        </RootProvider>
+        </LocaleProvider>
       </body>
     </html>
   );
diff --git a/website/components/site-footer.tsx b/website/components/site-footer.tsx
index 6c17009..4d27029 100644
--- a/website/components/site-footer.tsx
+++ b/website/components/site-footer.tsx
@@ -1,4 +1,4 @@
-import Link from "next/link";
+import { SiteLink as Link, SourceText } from "@/components/locale-provider";
 import { githubUrl } from "@/lib/shared";
 import { Wordmark } from "@/components/wordmark";
 
@@ -41,7 +41,7 @@ export function SiteFooter() {
             <Wordmark className="h-7" />
           </Link>
           <p className="mt-3 max-w-xs text-sm leading-6 text-fd-muted-foreground">
-            A native TypeScript runtime for services and agents.
+            <SourceText text="A native TypeScript runtime for services and agents." />
           </p>
         </div>
 
@@ -49,7 +49,7 @@ export function SiteFooter() {
           {columns.map((column) => (
             <div key={column.title}>
               <p className="text-xs font-medium uppercase tracking-[0.14em] text-fd-muted-foreground">
-                {column.title}
+                <SourceText text={column.title} />
               </p>
               <ul className="mt-3 space-y-2">
                 {column.links.map((link) => {
@@ -69,11 +69,11 @@ export function SiteFooter() {
                             : {})}
                           className={className}
                         >
-                          {link.label}
+                          <SourceText text={link.label} />
                         </a>
                       ) : (
                         <Link href={link.href} className={className}>
-                          {link.label}
+                          <SourceText text={link.label} />
                         </Link>
                       )}
                     </li>
diff --git a/website/components/site-header.tsx b/website/components/site-header.tsx
index b3d8a5d..dbfcc62 100644
--- a/website/components/site-header.tsx
+++ b/website/components/site-header.tsx
@@ -1,6 +1,8 @@
 "use client";
 
-import Link from "next/link";
+import { SiteLink as Link, T, useLocale } from "@/components/locale-provider";
+import { LanguageSwitcher, type LanguageChoice } from "@/components/language-switcher";
+import { splitLocale } from "@/lib/i18n/routing";
 import { usePathname } from "next/navigation";
 import { useEffect, useId, useState } from "react";
 import {
@@ -12,19 +14,21 @@ import { cn } from "@/lib/cn";
 import { githubUrl } from "@/lib/shared";
 import { Wordmark } from "@/components/wordmark";
 import { ThemeToggle } from "@/components/theme-toggle";
+import { headerIconButtonClass, headerIconClass } from "@/components/header-chrome";
 
 const links = [
-  { href: "/", label: "Home" },
-  { href: "/docs", label: "Docs" },
-  { href: "/blog", label: "Blog" },
-  { href: "/reference", label: "Reference" },
-  { href: "/examples", label: "Examples" },
-  { href: "/benchmarks", label: "Benchmarks" },
-];
+  { href: "/", label: "nav.home" },
+  { href: "/docs", label: "nav.docs" },
+  { href: "/blog", label: "nav.blog" },
+  { href: "/reference", label: "nav.reference" },
+  { href: "/examples", label: "nav.examples" },
+  { href: "/benchmarks", label: "nav.benchmarks" },
+] as const;
 
 function GitHubIcon() {
+  // Filled Simple Icons path reads heavier than Lucide strokes at the same box size.
   return (
-    <svg role="img" viewBox="0 0 24 24" fill="currentColor" className="size-4">
+    <svg role="img" viewBox="0 0 24 24" fill="currentColor" className={cn(headerIconClass, "scale-90")}>
       <path d="M12 .297c-6.63 0-12 5.373-12 12 0 5.303 3.438 9.8 8.205 11.385.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12" />
     </svg>
   );
@@ -35,8 +39,9 @@ function isActive(pathname: string, href: string) {
 }
 
 /** Shared top nav — padding matches fumadocs docs sidebar (`p-4`). */
-export function SiteHeader() {
-  const pathname = usePathname();
+export function SiteHeader({ languages }: { languages: LanguageChoice[] }) {
+  const { t } = useLocale();
+  const pathname = splitLocale(usePathname()).pathname;
   const [open, setOpen] = useState(false);
   const menuId = useId();
 
@@ -76,7 +81,7 @@ export function SiteHeader() {
                   : undefined,
               )}
             >
-              {link.label}
+              <T id={link.label} />
             </Link>
           ))}
         </nav>
@@ -88,13 +93,14 @@ export function SiteHeader() {
           />
           <div className="flex shrink-0 items-center gap-1.5">
             <SearchTrigger hideIfDisabled className="shrink-0 rounded-none p-2 md:hidden" />
+            <LanguageSwitcher choices={languages} />
             <ThemeToggle />
             <Link
               href={githubUrl}
               target="_blank"
               rel="noreferrer"
               aria-label="GitHub"
-              className="inline-flex size-8 shrink-0 items-center justify-center text-fd-muted-foreground transition-colors hover:bg-fd-accent hover:text-fd-foreground"
+              className={headerIconButtonClass}
             >
               <GitHubIcon />
             </Link>
@@ -102,17 +108,17 @@ export function SiteHeader() {
               href="/docs/getting-started"
               className="hidden shrink-0 items-center whitespace-nowrap bg-fd-foreground px-3 py-1.5 text-sm font-medium text-fd-background lg:inline-flex"
             >
-              Get started
+              <T id="common.getStarted" />
             </Link>
             <button
               type="button"
-              className="inline-flex size-8 items-center justify-center text-fd-muted-foreground transition-colors hover:bg-fd-accent hover:text-fd-foreground lg:hidden"
+              className={cn(headerIconButtonClass, "lg:hidden")}
               aria-expanded={open}
               aria-controls={menuId}
-              aria-label={open ? "Close menu" : "Open menu"}
+              aria-label={t(open ? "nav.closeMenu" : "nav.openMenu")}
               onClick={() => setOpen((value) => !value)}
             >
-              {open ? <X className="size-4" /> : <Menu className="size-4" />}
+              {open ? <X className={headerIconClass} /> : <Menu className={headerIconClass} />}
             </button>
           </div>
         </div>
@@ -138,7 +144,7 @@ export function SiteHeader() {
                       : undefined,
                   )}
                 >
-                  {link.label}
+                  <T id={link.label} />
                 </Link>
               </li>
             ))}
@@ -147,7 +153,7 @@ export function SiteHeader() {
                 href="/docs/getting-started"
                 className="mt-2 block bg-fd-foreground px-3 py-2 text-center text-sm font-medium text-fd-background"
               >
-                Get started
+                <T id="common.getStarted" />
               </Link>
             </li>
           </ul>
diff --git a/website/components/theme-toggle.tsx b/website/components/theme-toggle.tsx
index 4078e2c..087937b 100644
--- a/website/components/theme-toggle.tsx
+++ b/website/components/theme-toggle.tsx
@@ -1,5 +1,8 @@
 "use client";
 
+import { useLocale } from "@/components/locale-provider";
+import { headerIconButtonClass, headerIconClass } from "@/components/header-chrome";
+
 import { Moon, Sun } from "lucide-react";
 import { useEffect, useState } from "react";
 
@@ -14,6 +17,7 @@ function applyTheme(dark: boolean) {
 }
 
 export function ThemeToggle() {
+  const { t } = useLocale();
   const [dark, setDark] = useState(true);
 
   useEffect(() => {
@@ -23,15 +27,15 @@ export function ThemeToggle() {
   return (
     <button
       type="button"
-      aria-label={dark ? "Switch to light theme" : "Switch to dark theme"}
-      className="inline-flex size-8 shrink-0 items-center justify-center text-fd-muted-foreground transition-colors hover:bg-fd-accent hover:text-fd-foreground"
+      aria-label={t(dark ? "theme.light" : "theme.dark")}
+      className={headerIconButtonClass}
       onClick={() => {
         const next = !isDarkMode();
         applyTheme(next);
         setDark(next);
       }}
     >
-      {dark ? <Sun className="size-4" /> : <Moon className="size-4" />}
+      {dark ? <Sun className={headerIconClass} /> : <Moon className={headerIconClass} />}
     </button>
   );
 }
diff --git a/website/content/docs/concepts/projects-and-configuration.mdx b/website/content/docs/concepts/projects-and-configuration.mdx
index 3475c07..59d6a2c 100644
--- a/website/content/docs/concepts/projects-and-configuration.mdx
+++ b/website/content/docs/concepts/projects-and-configuration.mdx
@@ -239,6 +239,39 @@ root manifest that would make discovery ambiguous.
 `tysel config schema` prints the bundled Draft 2020-12 JSON Schema for editor,
 CI, and tooling integration. The runtime validator remains authoritative.
 
+New TOML projects include `.tysel/manifest.schema.json` and this header in
+`tysel.toml`:
+
+```toml
+#:schema .tysel/manifest.schema.json
+```
+
+A Taplo-enabled editor uses the local schema for field completion and schema
+validation without downloading it. Keep the schema in version control. For an
+existing project, export the installed toolchain's schema and add the header:
+
+```sh
+mkdir -p .tysel
+tysel config schema > .tysel/manifest.schema.json
+```
+
+New projects keep this schema visible to Git while ignoring other `.tysel`
+contents. If an existing project ignores `.tysel/`, append these ordered rules
+to `.gitignore` so the schema is available to other developers after checkout:
+
+```text
+!.tysel/
+.tysel/*
+!.tysel/manifest.schema.json
+```
+
+Re-export after upgrading the toolchain. JSON projects can associate this schema
+through their editor's JSON schema settings; do not add a `$schema` property to
+`tysel.json`, because the manifest rejects unknown fields. Schema feedback does
+not replace `tysel check`: grant syntax and task dependency checks also use
+runtime validation rules.
+
+
 ## Reproducible project tasks
 
 The manifest can compose Tysel commands without shell-specific quoting or a
diff --git a/website/content/docs/operations/deployment.mdx b/website/content/docs/operations/deployment.mdx
index d51da26..5ea0716 100644
--- a/website/content/docs/operations/deployment.mdx
+++ b/website/content/docs/operations/deployment.mdx
@@ -56,7 +56,13 @@ APP.licenses.json
 APP.evidence.json
 ```
 
-The runtime host needs only `APP`. Admission and rollback still depend on the
+For the `service` profile, the runtime host needs only `APP`. An `isolated`
+application also requires a matching-version, matching-platform `tysel-worker`
+beside the executable, or its path set through `TYSEL_WORKER`. The build command
+reports this requirement but does not copy the worker into the output directory.
+Keep the worker alongside the application in the deployment artifact set;
+copying only the isolated application will fail at startup with
+`worker binary not found`. Admission and rollback still depend on the
 complete immutable set. When using a container, record the mapping from the
 image digest to the admitted executable digest.
 
diff --git a/website/content/docs/operations/production.mdx b/website/content/docs/operations/production.mdx
index fc045ee..0d4ed95 100644
--- a/website/content/docs/operations/production.mdx
+++ b/website/content/docs/operations/production.mdx
@@ -179,7 +179,7 @@ These manifest defaults are limits, not capacity promises:
 | In-flight requests | 1,000 |
 | Request body | 16 MiB |
 | Response body | 16 MiB |
-| PostgreSQL pool | 16 connections per process |
+| Application PostgreSQL pool | Up to 4 connections per process; separate from durable PostgreSQL storage |
 
 Load-test the exact release with production request bodies, task mix,
 capabilities, dependencies, and telemetry. Budget total database connections
diff --git a/website/content/reference/cli/development.mdx b/website/content/reference/cli/development.mdx
index 758bc0e..0becd26 100644
--- a/website/content/reference/cli/development.mdx
+++ b/website/content/reference/cli/development.mdx
@@ -91,6 +91,18 @@ successful rebuild. An explicit `ENTRY` overrides `app.entry` for this run.
 Development mode can read `.env`, but only declared secrets and named Postgres
 and Redis connections become visible through their host capabilities.
 
+At startup and on reload, dev validates the manifest and synchronizes the default
+`tysel-env.d.ts` before building the application. Identical output is not written,
+and generated declaration changes do not trigger another reload. A rejected
+manifest preserves the previous declaration and running application. A valid
+manifest can update types even if the subsequent source build fails.
+
+Dev refuses to overwrite a user-owned declaration or follow an output symlink.
+Custom `tysel types --output` destinations remain manually managed. Use
+`tysel types --check` in CI; it never updates files. `tysel run` and `tysel check`
+also leave generated types unchanged.
+
+
 `tysel dev` rejects a `.wasm` Component entry. Components are one-shot tasks;
 use `tysel run` and provide one JSON value on stdin.
 
diff --git a/website/content/reference/errors-and-output.mdx b/website/content/reference/errors-and-output.mdx
index d568258..347e327 100644
--- a/website/content/reference/errors-and-output.mdx
+++ b/website/content/reference/errors-and-output.mdx
@@ -50,6 +50,25 @@ Fatal errors are one JSON object on stderr. Build failures also include a
 diagnostic, not as a stable programmatic discriminator. The process exits with
 status `1` for this fatal path.
 
+Individual static diagnostics use these stable codes:
+
+| Code | Meaning |
+| --- | --- |
+| `TYSEL_MANIFEST_PARSE_ERROR` | TOML/JSON syntax or deserialization failed. |
+| `TYSEL_MANIFEST_INVALID` | A manifest semantic rule failed. |
+| `TYSEL_NODE_BUILTIN_UNSUPPORTED` | A runtime import requests a Node builtin. |
+| `TYSEL_IMPORT_UNRESOLVED` | A runtime import cannot be resolved. |
+
+Manifest diagnostics use phase `manifest`; import diagnostics use `resolve`.
+Manifest validation reports the first failure, with its field range when
+available. Missing fields may have no range, and parser errors may point to an
+insertion point or enclosing table. Import diagnostics cover modules reached by
+the build resolver, including dependencies, and refer to original TypeScript
+source rather than emitted JavaScript. Erased type-only imports are excluded.
+TypeScript typecheck output itself remains compiler text, not this structured
+protocol.
+
+
 ## Development diagnostic stream
 
 `tysel --error-format json dev` writes one JSON object per diagnostic update to
diff --git a/website/lib/blog.ts b/website/lib/blog.ts
index 1526cb8..3bbe5e1 100644
--- a/website/lib/blog.ts
+++ b/website/lib/blog.ts
@@ -1,3 +1,6 @@
+import { estimateReadingMinutes } from "./reading-time.mjs";
+import { translatedBlog } from "@/lib/i18n/content";
+import { sourceLocale, type Locale } from "@/lib/i18n/config";
 import type { BlogPage } from "@/lib/source";
 import { blog } from "@/lib/source";
 
@@ -12,8 +15,8 @@ export function getBlogUpdatedAt(page: BlogPage): Date {
   return value instanceof Date ? value : new Date(value);
 }
 
-export function formatBlogDate(page: BlogPage): string {
-  return new Intl.DateTimeFormat("en", {
+export function formatBlogDate(page: BlogPage, locale: Locale = sourceLocale): string {
+  return new Intl.DateTimeFormat(locale, {
     year: "numeric",
     month: "long",
     day: "numeric",
@@ -21,33 +24,21 @@ export function formatBlogDate(page: BlogPage): string {
   }).format(getBlogDate(page));
 }
 
-export function getBlogPosts(): BlogPage[] {
-  return [...blog.getPages()].sort(
+export function getBlogPosts(locale: Locale = sourceLocale): BlogPage[] {
+  const pages = locale === sourceLocale ? blog.getPages() : blog.getPages().flatMap((original) => {
+    const translated = translatedBlog.getPage(original.slugs, locale);
+    return translated ? [{ ...original, ...translated, data: { ...original.data, ...translated.data } }] : [];
+  });
+  return pages.sort(
     (a, b) => getBlogDate(b).getTime() - getBlogDate(a).getTime(),
   );
 }
 
-export function getFeaturedBlogPost(): BlogPage | undefined {
-  return getBlogPosts()[0];
+export function getFeaturedBlogPost(locale: Locale = sourceLocale): BlogPage | undefined {
+  return getBlogPosts(locale)[0];
 }
 
-/** Words per minute for reading-time estimates. */
-const WORDS_PER_MINUTE = 220;
-
 export async function getReadingMinutes(page: BlogPage): Promise<number> {
   if (page.data.readingMinutes) return page.data.readingMinutes;
-
-  const raw = await page.data.getText("raw");
-  const body = raw.startsWith("---")
-    ? raw.slice(raw.indexOf("\n---", 3) + 4)
-    : raw;
-  const words = body
-    .replace(/```[\s\S]*?```/g, " ")
-    .replace(/!\[[^\]]*]\([^)]+\)/g, " ")
-    .replace(/\[[^\]]*]\([^)]+\)/g, " ")
-    .replace(/[#>*`|_~\-={}]/g, " ")
-    .split(/\s+/)
-    .filter(Boolean).length;
-
-  return Math.max(1, Math.round(words / WORDS_PER_MINUTE));
+  return estimateReadingMinutes(await page.data.getText("raw"));
 }
diff --git a/website/lib/i18n/catalog.ts b/website/lib/i18n/catalog.ts
new file mode 100644
index 0000000..dc311ae
--- /dev/null
+++ b/website/lib/i18n/catalog.ts
@@ -0,0 +1,8 @@
+import en from "../../locales/en/messages.json";
+export type MessageKey = keyof typeof en;
+export type Messages = Record<MessageKey, string>;
+const sourceKeys = new Map(Object.entries(en).map(([key, text]) => [text, key as MessageKey]));
+export function translateSource(text: string, messages: Messages): string {
+  const key = sourceKeys.get(text);
+  return key ? messages[key] : text;
+}
diff --git a/website/lib/i18n/config.ts b/website/lib/i18n/config.ts
new file mode 100644
index 0000000..b2c5349
--- /dev/null
+++ b/website/lib/i18n/config.ts
@@ -0,0 +1,12 @@
+import config from "../../locales/config.json";
+
+export type Locale = keyof typeof config.locales;
+export const sourceLocale = config.sourceLocale as Locale;
+export const localeConfig = config.locales;
+export const configuredLocales = Object.keys(localeConfig) as Locale[];
+export function isLocale(value: string): value is Locale {
+  return Object.hasOwn(localeConfig, value);
+}
+export function publishedLocales(): Locale[] {
+  return configuredLocales.filter((locale) => localeConfig[locale].published);
+}
diff --git a/website/lib/i18n/content.ts b/website/lib/i18n/content.ts
new file mode 100644
index 0000000..3474316
--- /dev/null
+++ b/website/lib/i18n/content.ts
@@ -0,0 +1,25 @@
+import { pageSchema } from "fumadocs-core/source/schema";
+import { z } from "zod";
+import { defineDocs } from "fumadocs-mdx/macro";
+import { loader } from "fumadocs-core/source";
+import { configuredLocales, sourceLocale } from "./config";
+
+// Build outputs only. The durable translation source lives under locales/<locale>/content.
+const docs = defineDocs({ dir: "content/translations/docs", docs: { postprocess: { includeProcessedMarkdown: true } } });
+const reference = defineDocs({ dir: "content/translations/reference", docs: { postprocess: { includeProcessedMarkdown: true } } });
+const blog = defineDocs({ dir: "content/translations/blog", docs: {
+  schema: pageSchema.extend({
+    author: z.string(),
+    date: z.union([z.string(), z.date()]),
+    cover: z.string().optional(),
+    coverAlt: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    readingMinutes: z.number().int().positive().optional(),
+    updatedAt: z.union([z.string(), z.date()]).optional(),
+  }),
+  postprocess: { includeProcessedMarkdown: true },
+} });
+const i18n = { languages: configuredLocales, defaultLanguage: sourceLocale, parser: "dir" as const, fallbackLanguage: null };
+export const translatedDocs = loader({ baseUrl: "/docs", source: docs.toFumadocsSource(), i18n });
+export const translatedReference = loader({ baseUrl: "/reference", source: reference.toFumadocsSource(), i18n });
+export const translatedBlog = loader({ baseUrl: "/blog", source: blog.toFumadocsSource(), i18n });
diff --git a/website/lib/i18n/messages.ts b/website/lib/i18n/messages.ts
new file mode 100644
index 0000000..446f67b
--- /dev/null
+++ b/website/lib/i18n/messages.ts
@@ -0,0 +1,16 @@
+import fs from "node:fs";
+import path from "node:path";
+import en from "../../locales/en/messages.json";
+import { sourceLocale, isLocale, type Locale } from "./config";
+import type { Messages } from "./catalog";
+
+/** Build/server only: target dictionaries never enter every locale's client bundle. */
+export function getMessages(locale: Locale): Messages {
+  if (!isLocale(locale)) throw new Error(`Unknown locale: ${locale}`);
+  if (locale === sourceLocale) return en;
+  const translated = JSON.parse(fs.readFileSync(path.join(process.cwd(), "locales", locale, "messages.json"), "utf8"));
+  return { ...en, ...translated };
+}
+export function getUITranslations(messages: Messages): Record<string, string> {
+  return Object.fromEntries(Object.entries(messages).filter(([key]) => key.startsWith("fumadocs.")).map(([key, value]) => [key.slice(9), value]));
+}
diff --git a/website/lib/i18n/pages.ts b/website/lib/i18n/pages.ts
new file mode 100644
index 0000000..8231230
--- /dev/null
+++ b/website/lib/i18n/pages.ts
@@ -0,0 +1,23 @@
+import { source, referenceSource, blog } from "@/lib/source";
+import { localeConfig, publishedLocales, sourceLocale, type Locale } from "./config";
+import { translatedDocs, translatedReference, translatedBlog } from "./content";
+import { localePath, splitLocale } from "./routing";
+
+export const marketingPaths = ["/", "/examples", "/benchmarks", "/blog"];
+export function contentPages(locale: Locale) {
+  return locale === sourceLocale
+    ? [...source.getPages(), ...referenceSource.getPages(), ...blog.getPages()]
+    : [...translatedDocs.getPages(locale), ...translatedReference.getPages(locale), ...translatedBlog.getPages(locale)];
+}
+export function availablePaths(locale: Locale): string[] {
+  if (!localeConfig[locale].published) return [];
+  return [...marketingPaths, ...contentPages(locale).map((page) => splitLocale(page.url).pathname)];
+}
+export function languageChoices() {
+  return publishedLocales().map((locale) => ({ locale, name: localeConfig[locale].name, paths: availablePaths(locale) }));
+}
+export function pageAlternates(pathname: string) {
+  const sourcePath = splitLocale(pathname).pathname;
+  return Object.fromEntries(publishedLocales().filter((locale) => availablePaths(locale).includes(sourcePath))
+    .map((locale) => [locale, localePath(sourcePath, locale)]));
+}
diff --git a/website/lib/i18n/routes/layout.tsx b/website/lib/i18n/routes/layout.tsx
new file mode 100644
index 0000000..de182ad
--- /dev/null
+++ b/website/lib/i18n/routes/layout.tsx
@@ -0,0 +1,11 @@
+import { notFound } from "next/navigation";
+import { SiteDocument, metadata } from "@/components/site-document";
+import { isLocale, localeConfig, sourceLocale } from "@/lib/i18n/config";
+export { metadata };
+export default async function Layout({ children, params }: {
+  children: React.ReactNode; params: Promise<{ lang: string }>;
+}) {
+  const { lang } = await params;
+  if (!isLocale(lang) || lang === sourceLocale || !localeConfig[lang].published) notFound();
+  return <SiteDocument locale={lang}>{children}</SiteDocument>;
+}
diff --git a/website/lib/i18n/routes/page.tsx b/website/lib/i18n/routes/page.tsx
new file mode 100644
index 0000000..32b4728
--- /dev/null
+++ b/website/lib/i18n/routes/page.tsx
@@ -0,0 +1,99 @@
+import { LocaleOriginalLink } from "@/components/locale-original-link";
+import { StructuredData } from "@/components/seo/structured-data";
+import { createArticleJsonLd } from "@/lib/seo";
+import BlogArticle, { blogMetadata } from "@/components/blog/article";
+import { getBlogPosts } from "@/lib/blog";
+import { source, referenceSource, blog } from "@/lib/source";
+import type { Metadata } from "next";
+import { notFound } from "next/navigation";
+import { DocsLayout } from "fumadocs-ui/layouts/docs";
+import { DocsPage, DocsTitle, DocsDescription, DocsBody } from "fumadocs-ui/layouts/docs/page";
+import HomePage from "@/components/home/home-page";
+import ExamplesPage from "@/app/(site)/(home)/examples/page";
+import BenchmarksPage from "@/app/(site)/(home)/benchmarks/page";
+import BlogIndexPage from "@/components/home/blog-index-page";
+import HomeLayout from "@/app/(site)/(home)/layout";
+import { getMDXComponents } from "@/components/mdx";
+import { SiteLink } from "@/components/locale-provider";
+import { baseOptions } from "@/lib/layout.shared";
+import { isLocale, localeConfig, publishedLocales, sourceLocale } from "@/lib/i18n/config";
+import { availablePaths, pageAlternates } from "@/lib/i18n/pages";
+import { localePath } from "@/lib/i18n/routing";
+import { getMessages } from "@/lib/i18n/messages";
+import { translatedDocs, translatedReference, translatedBlog } from "@/lib/i18n/content";
+import { absoluteUrl, canonicalUrl } from "@/lib/shared";
+
+export const dynamic = "force-static";
+export const dynamicParams = false;
+type Props = { params: Promise<{ lang: string; path?: string[] }> };
+export function generateStaticParams() {
+  return publishedLocales().filter((locale) => locale !== sourceLocale).flatMap((lang) =>
+    availablePaths(lang).map((pathname) => ({ lang, path: pathname.split("/").filter(Boolean) })));
+}
+async function resolve(props: Props) {
+  const { lang, path = [] } = await props.params;
+  if (!isLocale(lang) || lang === sourceLocale || !localeConfig[lang].published) notFound();
+  const pathname = `/${path.join("/")}`;
+  if (!availablePaths(lang).includes(pathname)) notFound();
+  const collection = path[0] === "docs" ? translatedDocs : path[0] === "reference" ? translatedReference : translatedBlog;
+  const page = path.length > 1 || path[0] === "docs" || path[0] === "reference" ? collection.getPage(path.slice(1), lang) : undefined;
+  return { lang, path, pathname, collection, page };
+}
+export default async function Page(props: Props) {
+  const { lang, pathname, collection, page } = await resolve(props);
+  if (page) {
+    const MDX = page.data.body;
+    const originalCollection = pathname.startsWith("/docs") ? source : pathname.startsWith("/reference") ? referenceSource : blog;
+    const original = originalCollection.getPage(page.slugs);
+    const aliases = new Map<string, string>();
+    if (!original || original.data.toc.length !== page.data.toc.length) throw new Error(`Translated heading structure differs: ${pathname}`);
+    page.data.toc.forEach((item, index) => {
+      const sourceItem = original.data.toc[index];
+      if (item.depth !== sourceItem.depth) throw new Error(`Translated heading depth differs: ${pathname}`);
+      if (item.url !== sourceItem.url) aliases.set(item.url.slice(1), sourceItem.url.slice(1));
+    });
+    const components = getMDXComponents();
+    const headings = Object.fromEntries((["h1", "h2", "h3", "h4", "h5", "h6"] as const).map((tag) => {
+      const Heading = (components[tag] ?? tag) as React.ElementType<React.ComponentProps<"h2">>;
+      return [tag, ({ id, children, ...props }: React.ComponentProps<"h2">) => <Heading {...props} id={id}>
+        {id && aliases.has(id) && <span id={aliases.get(id)} className="scroll-mt-28" aria-hidden="true" />}
+        {children}
+      </Heading>];
+    }));
+    if (pathname.startsWith("/blog/")) {
+      const post = getBlogPosts(lang).find(item => item.url === page.url);
+      if (!post) notFound();
+      return <HomeLayout params={Promise.resolve({})}><BlogArticle page={post} locale={lang} originalUrl={localePath(pathname, sourceLocale)} components={getMDXComponents({ ...headings, a: ({ href = "", ...props }) => <SiteLink {...props} href={href} /> })} /></HomeLayout>;
+    }
+    return <DocsLayout tree={collection.getPageTree(lang)} {...baseOptions()} nav={{ enabled: false }}>
+      <StructuredData data={createArticleJsonLd(page, { name: getMessages(lang)[pathname.startsWith("/docs") ? "nav.docs" : "nav.reference"], url: localePath(pathname.startsWith("/docs") ? "/docs" : "/reference", lang) }, { locale: lang })} />
+      <DocsPage toc={page.data.toc}>
+        <DocsTitle>{page.data.title}</DocsTitle>
+        <DocsDescription className="mb-0">{page.data.description}</DocsDescription>
+        <div className="flex flex-row items-center gap-2 border-b pb-6">
+          <LocaleOriginalLink href={localePath(pathname, sourceLocale)} label={getMessages(lang)["locale.original"]} />
+        </div>
+        <DocsBody><MDX components={getMDXComponents({ ...headings, a: ({ href = "", ...props }) => <SiteLink {...props} href={(collection as typeof translatedDocs).resolveHref(href, page)} /> })} /></DocsBody>
+      </DocsPage>
+    </DocsLayout>;
+  }
+  const content = pathname === "/" ? <HomePage locale={lang} /> : pathname === "/examples" ? <ExamplesPage />
+    : pathname === "/benchmarks" ? <BenchmarksPage /> : <BlogIndexPage locale={lang} />;
+  return <HomeLayout params={Promise.resolve({})}>{content}</HomeLayout>;
+}
+export async function generateMetadata(props: Props): Promise<Metadata> {
+  const { lang, pathname, page } = await resolve(props);
+  const messages = getMessages(lang);
+  const title = page?.data.title ?? (pathname === "/" ? messages["site.title"] : messages[`nav.${pathname.slice(1)}` as "nav.examples" | "nav.benchmarks" | "nav.blog"]);
+  const url = canonicalUrl(localePath(pathname, lang));
+  if (pathname.startsWith("/blog/")) {
+    const post = getBlogPosts(lang).find(item => item.url === page?.url);
+    if (!post) notFound();
+    const metadata = blogMetadata(post);
+    return { ...metadata, alternates: { ...metadata.alternates, canonical: url, languages: Object.fromEntries(Object.entries(pageAlternates(pathname)).map(([locale, path]) => [locale, canonicalUrl(path)])) }, openGraph: { ...metadata.openGraph, locale: localeConfig[lang].ogLocale } };
+  }
+  return { title, description: page?.data.description ?? messages["site.description"],
+    alternates: { canonical: url, languages: Object.fromEntries(Object.entries(pageAlternates(pathname)).map(([locale, path]) => [locale, canonicalUrl(path)])) },
+    openGraph: { url, title, description: page?.data.description ?? messages["site.description"], locale: localeConfig[lang].ogLocale, images: [absoluteUrl("/opengraph-image")] },
+  };
+}
diff --git a/website/lib/i18n/routes/search.ts b/website/lib/i18n/routes/search.ts
new file mode 100644
index 0000000..2db04ad
--- /dev/null
+++ b/website/lib/i18n/routes/search.ts
@@ -0,0 +1,20 @@
+import { notFound } from "next/navigation";
+import { createFromSource } from "fumadocs-core/search/server";
+import { isLocale, localeConfig, publishedLocales, sourceLocale } from "@/lib/i18n/config";
+import { translatedDocs, translatedReference, translatedBlog } from "@/lib/i18n/content";
+
+export const dynamic = "force-static";
+export const dynamicParams = false;
+export function generateStaticParams() {
+  return publishedLocales().filter((lang) => lang !== sourceLocale).map((lang) => ({ lang }));
+}
+export async function GET(_request: Request, { params }: { params: Promise<{ lang: string }> }) {
+  const { lang } = await params;
+  if (!isLocale(lang) || !localeConfig[lang].published || lang === sourceLocale) notFound();
+  const sources = [translatedDocs, translatedReference, translatedBlog];
+  const combined = {
+    getPages: () => sources.flatMap((source) => source.getPages(lang)),
+    getPageTree: () => ({ name: "Tysel", children: sources.flatMap((source) => source.getPageTree(lang).children) }),
+  };
+  return createFromSource(combined as unknown as typeof translatedDocs).staticGET();
+}
diff --git a/website/lib/i18n/routing.ts b/website/lib/i18n/routing.ts
new file mode 100644
index 0000000..63bca22
--- /dev/null
+++ b/website/lib/i18n/routing.ts
@@ -0,0 +1,27 @@
+import { configuredLocales, sourceLocale, type Locale } from "./config";
+
+/** Asset, feed, search, install, and external URLs are language-neutral. */
+export function splitLocale(path: string): { locale: Locale; pathname: string } {
+  for (const locale of configuredLocales) {
+    if (path === `/${locale}` || path.startsWith(`/${locale}/`)) {
+      return { locale, pathname: path.slice(locale.length + 1) || "/" };
+    }
+  }
+  return { locale: sourceLocale, pathname: path };
+}
+
+export function localePath(path: string, locale: Locale): string {
+  if (!path.startsWith("/") || path.startsWith("//")) return path;
+  const match = path.match(/^([^?#]*)(.*)$/)!;
+  const pathname = splitLocale(match[1]).pathname.replace(/\/$/, "") || "/";
+  const suffix = match[2];
+  return (locale === sourceLocale ? pathname : `/${locale}${pathname === "/" ? "" : pathname}`) + suffix;
+}
+
+/** Only link to pages that actually exist. Missing translations link to English. */
+export function availableLocalePath(path: string, locale: Locale, available: readonly string[]): string {
+  if (!path.startsWith("/") || path.startsWith("//")) return path;
+  const sourcePath = localePath(path, sourceLocale);
+  const pathname = sourcePath.split(/[?#]/, 1)[0];
+  return available.includes(pathname) ? localePath(sourcePath, locale) : sourcePath;
+}
diff --git a/website/lib/i18n/seo.ts b/website/lib/i18n/seo.ts
new file mode 100644
index 0000000..a2274e9
--- /dev/null
+++ b/website/lib/i18n/seo.ts
@@ -0,0 +1,8 @@
+import { canonicalUrl } from "@/lib/shared";
+import { pageAlternates } from "./pages";
+export function alternates(pathname = "/") {
+  return {
+    canonical: canonicalUrl(pathname),
+    languages: Object.fromEntries(Object.entries(pageAlternates(pathname)).map(([locale, path]) => [locale, canonicalUrl(path)])),
+  };
+}
diff --git a/website/lib/reading-time.d.mts b/website/lib/reading-time.d.mts
new file mode 100644
index 0000000..efcc99c
--- /dev/null
+++ b/website/lib/reading-time.d.mts
@@ -0,0 +1 @@
+export function estimateReadingMinutes(raw: string): number;
diff --git a/website/lib/reading-time.mjs b/website/lib/reading-time.mjs
new file mode 100644
index 0000000..2305cf3
--- /dev/null
+++ b/website/lib/reading-time.mjs
@@ -0,0 +1,10 @@
+// Approximate prose reading time: 400 Han characters/minute, 220 other words/minute.
+export function estimateReadingMinutes(raw) {
+  const body = raw.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, '')
+    .replace(/```[\s\S]*?```/g, ' ')
+    .replace(/!\[[^\]]*\]\([^)]+\)/g, ' ')
+    .replace(/\[([^\]]*)\]\([^)]+\)/g, '$1');
+  const han = (body.match(/\p{Script=Han}/gu) ?? []).length;
+  const words = (body.replace(/\p{Script=Han}/gu, ' ').match(/[\p{L}\p{N}]+(?:['’-][\p{L}\p{N}]+)*/gu) ?? []).length;
+  return Math.max(1, Math.round(han / 400 + words / 220));
+}
diff --git a/website/lib/seo.ts b/website/lib/seo.ts
index 6939d6b..f2eb35a 100644
--- a/website/lib/seo.ts
+++ b/website/lib/seo.ts
@@ -1,3 +1,6 @@
+import { sourceLocale, type Locale } from "@/lib/i18n/config";
+import { localePath } from "@/lib/i18n/routing";
+import { getMessages } from "@/lib/i18n/messages";
 import type { AnySourcePage, BlogPage } from "@/lib/source";
 import { getPageImageUrl } from "@/lib/source";
 import { getBlogDate, getBlogUpdatedAt } from "@/lib/blog";
@@ -6,13 +9,14 @@ import { appName, canonicalUrl, githubUrl, siteUrl } from "@/lib/shared";
 export function createArticleJsonLd(
   page: AnySourcePage,
   section: { name: string; url: string },
-  presentation: { title?: string; description?: string } = {},
+  presentation: { title?: string; description?: string; locale?: Locale } = {},
 ) {
   const url = canonicalUrl(page.url);
+  const locale = presentation.locale ?? sourceLocale;
   const title = presentation.title ?? page.data.title;
   const description = presentation.description ?? page.data.description;
   const breadcrumbs = [
-    { name: "Home", url: canonicalUrl() },
+    { name: locale === sourceLocale ? "Home" : getMessages(locale)["nav.home"], url: canonicalUrl(localePath("/", locale)) },
     { name: section.name, url: canonicalUrl(section.url) },
   ];
 
@@ -29,8 +33,8 @@ export function createArticleJsonLd(
         description,
         url,
         mainEntityOfPage: url,
-        image: `${siteUrl}${getPageImageUrl(page).url}`,
-        inLanguage: "en",
+        image: locale === sourceLocale ? `${siteUrl}${getPageImageUrl(page).url}` : `${siteUrl}/opengraph-image`,
+        inLanguage: locale,
         author: {
           "@type": "Organization",
           name: `${appName} contributors`,
@@ -50,7 +54,7 @@ export function createArticleJsonLd(
   };
 }
 
-export function createBlogPostingJsonLd(page: BlogPage) {
+export function createBlogPostingJsonLd(page: BlogPage, locale: Locale = sourceLocale) {
   const url = canonicalUrl(page.url);
   const image = page.data.cover
     ? page.data.cover.startsWith("http")
@@ -75,12 +79,12 @@ export function createBlogPostingJsonLd(page: BlogPage) {
         image,
         datePublished,
         dateModified,
-        inLanguage: "en",
+        inLanguage: locale,
         isPartOf: {
           "@type": "Blog",
-          "@id": `${canonicalUrl("/blog")}#blog`,
+          "@id": `${canonicalUrl(localePath("/blog", locale))}#blog`,
           name: `${appName} Blog`,
-          url: canonicalUrl("/blog"),
+          url: canonicalUrl(localePath("/blog", locale)),
         },
         author: {
           "@type": "Organization",
@@ -104,14 +108,14 @@ export function createBlogPostingJsonLd(page: BlogPage) {
           {
             "@type": "ListItem",
             position: 1,
-            name: "Home",
-            item: canonicalUrl(),
+            name: locale === sourceLocale ? "Home" : getMessages(locale)["nav.home"],
+            item: canonicalUrl(localePath("/", locale)),
           },
           {
             "@type": "ListItem",
             position: 2,
-            name: "Blog",
-            item: canonicalUrl("/blog"),
+            name: getMessages(locale)["nav.blog"],
+            item: canonicalUrl(localePath("/blog", locale)),
           },
           {
             "@type": "ListItem",
@@ -125,18 +129,18 @@ export function createBlogPostingJsonLd(page: BlogPage) {
   };
 }
 
-export function createBlogIndexJsonLd(posts: BlogPage[]) {
+export function createBlogIndexJsonLd(posts: BlogPage[], locale: Locale = sourceLocale) {
   return {
     "@context": "https://schema.org",
     "@graph": [
       {
         "@type": "Blog",
-        "@id": `${canonicalUrl("/blog")}#blog`,
+        "@id": `${canonicalUrl(localePath("/blog", locale))}#blog`,
         name: `${appName} Blog`,
         description:
-          "Release notes, runtime design notes, and production guidance from the Tysel team.",
-        url: canonicalUrl("/blog"),
-        inLanguage: "en",
+          getMessages(locale)["blog.description"],
+        url: canonicalUrl(localePath("/blog", locale)),
+        inLanguage: locale,
         publisher: {
           "@type": "Organization",
           name: appName,
@@ -157,14 +161,14 @@ export function createBlogIndexJsonLd(posts: BlogPage[]) {
           {
             "@type": "ListItem",
             position: 1,
-            name: "Home",
-            item: canonicalUrl(),
+            name: locale === sourceLocale ? "Home" : getMessages(locale)["nav.home"],
+            item: canonicalUrl(localePath("/", locale)),
           },
           {
             "@type": "ListItem",
             position: 2,
-            name: "Blog",
-            item: canonicalUrl("/blog"),
+            name: getMessages(locale)["nav.blog"],
+            item: canonicalUrl(localePath("/blog", locale)),
           },
         ],
       },
diff --git a/website/locales/config.json b/website/locales/config.json
new file mode 100644
index 0000000..8b447ed
--- /dev/null
+++ b/website/locales/config.json
@@ -0,0 +1,7 @@
+{
+  "sourceLocale": "en",
+  "locales": {
+    "en": { "name": "English", "short": "EN", "ogLocale": "en_US", "published": true },
+    "zh-CN": { "name": "简体中文", "short": "中", "ogLocale": "zh_CN", "published": true }
+  }
+}
diff --git a/website/locales/en/messages.json b/website/locales/en/messages.json
new file mode 100644
index 0000000..4d76c40
--- /dev/null
+++ b/website/locales/en/messages.json
@@ -0,0 +1,390 @@
+{
+  "nav.home": "Home",
+  "nav.docs": "Docs",
+  "nav.blog": "Blog",
+  "nav.reference": "Reference",
+  "nav.examples": "Examples",
+  "nav.benchmarks": "Benchmarks",
+  "ui.product": "Product",
+  "ui.source": "Source",
+  "common.getStarted": "Get started",
+  "ui.a.native.typescript.runtime.for.services.and.agents": "A native TypeScript runtime for services and agents.",
+  "home.hero.title": "Write TypeScript.",
+  "home.hero.ship": "Ship a",
+  "home.hero.binary": "binary",
+  "ui.a.native.runtime.for.services.and.ai.agents": "A native runtime for services and AI agents — one executable, explicit capabilities, durable work that survives restarts.",
+  "ui.read.the.docs": "Read the docs",
+  "ui.web.api.first": "Web API first",
+  "ui.request.response.fetch.streams.and.web.crypto.not": "Request, Response, fetch, streams, and Web Crypto. Not a Node.js compatibility layer.",
+  "ui.no.node.in.production": "No Node in production",
+  "ui.the.packaged.executable.embeds.the.runtime.targets.do": "The packaged executable embeds the runtime. Targets do not need V8 or node_modules.",
+  "ui.deny.by.default": "Deny by default",
+  "ui.network.secrets.files.and.databases.stay.closed.until": "Network, secrets, files, and databases stay closed until the manifest grants them.",
+  "ui.durable.resume": "Durable resume",
+  "ui.steps.effects.sleep.and.signals.persist.restarts.replay": "Steps, effects, sleep, and signals persist. Restarts replay completed work instead of repeating it.",
+  "ui.ship.one.executable": "Ship one executable",
+  "ui.typescript.becomes.an.application.package.then.a.native": "TypeScript becomes an application package, then a native file. Checksums, SBOM, compatibility, and evidence travel with the release.",
+  "ui.bound.every.capability": "Bound every capability",
+  "ui.the.manifest.requests.authority.the.execution.profile.and": "The manifest requests authority. The execution profile and deployment policy can only reduce it. Linux isolated workers add Landlock, seccomp, and cgroup limits.",
+  "ui.resume.durable.work": "Resume durable work",
+  "ui.llm.call.persisted.effect.approval.restart.resume.save": "LLM call → persisted effect → approval → restart → resume → save once. Durability is a runtime primitive, not an exactly-once claim.",
+  "ui.three.product.contracts": "Three product contracts",
+  "ui.bun.and.deno.optimize.a.general.javascript.toolchain": "Bun and Deno optimize a general JavaScript toolchain. Tysel ships a narrower production contract.",
+  "ui.workloads": "Workloads",
+  "ui.services.agents.and.wasm.each.with.a.named": "Services, agents, and Wasm — each with a named grant.",
+  "ui.a.narrow.host.surface.not.a.kitchen.sink": "A narrow host surface, not a kitchen-sink stdlib. Network, secrets, storage, and LLM access stay closed until the manifest opens them.",
+  "ui.five.minutes.with.tysel": "Five minutes with Tysel",
+  "ui.one.loop.from.source.to.an.executable": "One loop from source to an executable.",
+  "ui.ship.with.proof": "Ship with proof",
+  "ui.every.release.carries.evidence.not.just.a.binary": "Every release carries evidence, not just a binary.",
+  "ui.compatibility.reports.sboms.checksums.and.ci.admission.gates": "Compatibility reports, SBOMs, checksums, and CI admission gates travel with the artifact. Marketing performance claims stay off the homepage until cross-runtime evidence clears the publication contract.",
+  "ui.from.the.blog": "From the blog",
+  "ui.why.tysel.ships.a.narrower.production.contract": "Why Tysel ships a narrower production contract.",
+  "ui.all.posts": "All posts →",
+  "ui.release": "Release ·",
+  "ui.read.the.announcement": "Read the announcement →",
+  "ui.from.typescript.source.to.one.production.artifact": "From TypeScript source to one production artifact.",
+  "ui.build.your.first.service": "Build your first service",
+  "ui.run.the.durable.agent.example": "Run the durable agent example",
+  "ui.compatibility.evidence": "Compatibility & evidence",
+  "ui.security.model": "Security model",
+  "ui.production.operations": "Production operations",
+  "ui.ci.admission": "CI admission",
+  "ui.a.fetch.handler.is.the.whole.application": "A Fetch handler is the whole application.",
+  "ui.package.the.app.and.native.runtime.together": "Package the app and native runtime together.",
+  "ui.no.node.js.v8.or.node.modules.on": "No Node.js, V8, or node_modules on the target.",
+  "ui.paused": "paused",
+  "ui.replay": "replay",
+  "ui.verify.the.toolchain": "Verify the toolchain",
+  "ui.confirm.tysel.tysel.service.and.tysel.worker.are": "Confirm tysel, tysel-service, and tysel-worker are on PATH together.",
+  "ui.create.a.project": "Create a project",
+  "ui.writes.src.index.ts.tests.and.tysel.toml": "Writes src/index.ts, tests, and tysel.toml without overwriting existing files.",
+  "ui.validate.configuration": "Validate configuration",
+  "ui.the.manifest.is.the.contract.entry.profile.permissions": "The manifest is the contract: entry, profile, permissions, and limits.",
+  "ui.check.and.test": "Check and test",
+  "ui.type.capability.import.and.isolate.tests.before.you": "Type, capability, import, and isolate tests before you package.",
+  "ui.run.then.ship.one.file": "Run, then ship one file",
+  "ui.reload.in.development.then.emit.one.executable.plus": "Reload in development, then emit one executable plus release evidence.",
+  "ui.node.js.is.optional.for.editor.declarations.the": "Node.js is optional for editor declarations. The packaged application does not need it.",
+  "ui.paused.67": "Paused.",
+  "ui.hover.to.pause": "Hover to pause.",
+  "ui.then.run": "Then run",
+  "ui.no.rust.node.js.or.npm.on.the": ". No Rust, Node.js, or npm on the machine.",
+  "ui.http.service": "HTTP service",
+  "ui.a.fetch.handler.is.enough.for.a.first": "A Fetch handler is enough for a first-party service. No host grant until you call one.",
+  "ui.service.no.host.capability.required": "service · no host capability required",
+  "ui.durable.agent": "Durable agent",
+  "ui.llm.call.human.approval.then.resume.after.restart": "LLM call, human approval, then resume after restart — completed effects replay instead of re-running.",
+  "ui.service.durable.store.llm.declared.secret": "service · durable store + LLM + declared secret",
+  "ui.llm.call": "LLM call",
+  "ui.generation.goes.through.the.host.model.aliases.and": "Generation goes through the host. Model aliases and credentials stay outside application source.",
+  "ui.service.provider.config.declared.secret": "service · provider config + declared secret",
+  "ui.mcp.tool": "MCP tool",
+  "ui.validated.json.tools.over.bounded.stdio.isolated.workers": "Validated JSON tools over bounded stdio. Isolated workers only see brokered secret handles.",
+  "ui.isolated.brokered.secret.handle.only": "isolated · brokered secret handle only",
+  "ui.sqlite.worker": "SQLite worker",
+  "ui.local.state.through.a.runtime.owned.client.the": "Local state through a runtime-owned client. The path is grant-bound, not ambient cwd access.",
+  "ui.service.runtime.relative.sqlite.grant": "service · runtime-relative SQLite grant",
+  "ui.postgres.service": "Postgres service",
+  "ui.query.a.named.database.the.connection.url.stays": "Query a named database. The connection URL stays in the host; the app only sees the grant name.",
+  "ui.service.named.postgres.grant.e.g.main.read": "service · named Postgres grant (e.g. main:read-write)",
+  "ui.inbound.upgrades.need.an.explicit.server.flag.outbound": "Inbound upgrades need an explicit server flag. Outbound sockets follow the same fetch allowlist.",
+  "ui.filesystem": "Filesystem",
+  "ui.utf.8.read.and.write.only.beneath.manifest": "UTF-8 read and write only beneath manifest-pinned roots. There is no open-ended FS.",
+  "ui.service.matching.fs.read.fs.write.roots": "service · matching fs_read / fs_write roots",
+  "ui.wasm.component": "Wasm Component",
+  "ui.a.language.neutral.one.shot.json.task.through": "A language-neutral, one-shot JSON task through the Component Model. Deny by default; experimental.",
+  "ui.component.experimental.isolated.task.trust": "component · experimental · isolated-task trust",
+  "ui.services": "Services",
+  "ui.web.request.response.entrypoint": "Web Request / Response entrypoint",
+  "ui.inbound.upgrade.or.allowlisted.client": "Inbound upgrade or allowlisted client",
+  "ui.scheduled.and.queued.task.handlers": "Scheduled and queued task handlers",
+  "ui.agents": "Agents",
+  "ui.effects.sleep.signals.resume": "Effects, sleep, signals, resume",
+  "ui.host.brokered.model.generation": "Host-brokered model generation",
+  "ui.mcp.tasks": "MCP tasks",
+  "ui.bounded.stdio.tools.with.validation": "Bounded stdio tools with validation",
+  "ui.host.grants": "Host grants",
+  "ui.opaque.handles.never.plaintext.env": "Opaque handles, never plaintext env",
+  "ui.named.grant.bound.sql.clients": "Named, grant-bound SQL clients",
+  "ui.read.write.under.pinned.roots": "Read / write under pinned roots",
+  "ui.web.api.first.application.surface": "Web-API-first application surface",
+  "ui.outbound.http.on.an.allowlist": "Outbound HTTP on an allowlist",
+  "ui.web.crypto.subset.no.node.crypto": "Web Crypto subset, no Node crypto",
+  "ui.wasm.components": "Wasm Components",
+  "ui.one.shot.json.task.world": "One-shot JSON task world",
+  "ui.guest.types.and.dispatcher": "Guest types and dispatcher",
+  "ui.generated.bindings": "Generated bindings",
+  "ui.contracts": "Contracts",
+  "ui.manifest.grants.and.reductions": "Manifest grants and reductions",
+  "ui.effective.authority.and.limits": "Effective authority and limits",
+  "ui.handlers.in.a.fresh.isolate": "Handlers in a fresh isolate",
+  "ui.docs": "Docs →",
+  "ui.grant": "Grant ·",
+  "ui.reference.recipe": "Reference recipe",
+  "ui.lookup.by.contract": "Lookup by contract",
+  "ui.each.link.is.an.exact.interface.page.accepted": "Each link is an exact interface page — accepted values, defaults, and what the profile can still deny.",
+  "ui.api.reference": "API reference →",
+  "ui.shell.child.processes.ffi.and.dynamic.libraries.are": "Shell, child processes, FFI, and dynamic libraries are outside the application contract — not missing features. See the",
+  "ui.capability.matrix": "capability matrix",
+  "ui.execution.profiles": "execution profiles",
+  "ui.and": ", and",
+  "ui.example.gallery": "example gallery",
+  "ui.open.example": "Open example →",
+  "ui.ci.admission.linux.x64": "CI admission · Linux x64",
+  "ui.clear": "clear",
+  "ui.sample.layout": "Sample layout",
+  "ui.waiting.on.ci": "Waiting on CI",
+  "ui.not.a.ci.claim": "Not a CI claim",
+  "ui.illustrative.snapshot": "illustrative snapshot",
+  "ui.ci.run": "CI run",
+  "ui.fetched": "fetched",
+  "ui.gates.stay.public.measured.cells.fill.from": "Gates stay public. Measured cells fill from",
+  "ui.admit.on.p50.linux.pss.regression.budget.not": "Admit on p50 · Linux PSS · regression budget, not capacity",
+  "ui.runtime.microbenchmarks": "Runtime microbenchmarks",
+  "ui.same.run.not.release.gates": "Same run · not release gates",
+  "ui.observational.only.they.never.fail.a.release.and": "Observational only — they never fail a release and are not production throughput claims. Values in ms.",
+  "ui.metric": "Metric",
+  "ui.on.this.page": "On this page",
+  "ui.lock.the.environment": "Lock the environment",
+  "ui.pin.runtime.versions.and.hashes.reject.dirty.trees": "Pin runtime versions and hashes; reject dirty trees, loaded hosts, and unexpected CPU settings.",
+  "ui.rotate.every.runtime": "Rotate every runtime",
+  "ui.run.node.js.bun.deno.and.tysel.in": "Run Node.js, Bun, Deno, and Tysel in four orders so one runtime does not always benefit from the same position.",
+  "ui.prove.both.architectures": "Prove both architectures",
+  "ui.complete.three.record.cycles.on.dedicated.linux.x86": "Complete three record cycles on dedicated Linux x86_64 and arm64 runners. Architectures are never merged into one ranking.",
+  "ui.replicate.externally": "Replicate externally",
+  "ui.repeat.the.workload.from.a.separate.load.host": "Repeat the workload from a separate load host with the exact recorded server binary before a comparison reaches this page.",
+  "ui.release.guards": "Release guards",
+  "ui.shown": "Shown",
+  "ui.runtime.suites": "Runtime suites",
+  "ui.observe": "Observe",
+  "ui.cross.runtime": "Cross-runtime",
+  "ui.withheld": "Withheld",
+  "ui.seven.gates.ci.measured": "Seven gates. CI measured.",
+  "ui.seven.gates.sample.layout": "Seven gates. Sample layout.",
+  "ui.seven.gates.waiting.on.data": "Seven gates. Waiting on data.",
+  "ui.illustrative.layout.only.not.a.published.ci.claim": "Illustrative layout only — not a published CI claim.",
+  "ui.fixed.runner.regression.gates.not.a.production.performance": "Fixed-runner regression gates. Not a production performance SLA.",
+  "ui.ladder": "Ladder",
+  "ui.reproduce.locally": "Reproduce locally",
+  "ui.release.mode.clean.tree.time.gates.admit.on": "Release mode, clean tree. Time gates admit on p50; suites may still report p95/p99. Startup uses 2 warm-ups + 11 samples on a warm page cache. Linux PSS is the memory result of record.",
+  "ui.release.evidence": "release evidence",
+  "ui.performance.documentation": "Performance documentation",
+  "ui.benchmark.source": "Benchmark source ↗",
+  "ui.raw.evidence.json": "Raw evidence JSON",
+  "ui.evidence.reference": "Evidence reference",
+  "ui.cross.runtime.publication.contract": "Cross-runtime publication contract",
+  "ui.separate.bar.for.public.comparisons.not.these.ci": "Separate bar for public comparisons — not these CI gates.",
+  "ui.expand": "Expand →",
+  "ui.collapse": "Collapse",
+  "ui.no.cross.runtime.winner.is.published.yet.the": "No cross-runtime winner is published yet. The matched Node.js, Bun, Deno, and Tysel harness is public; results stay internal until these steps complete on both architectures.",
+  "ui.comparison.protocol": "Comparison protocol ↗",
+  "ui.looking.for.the.product.story.start.on": "Looking for the product story? Start on",
+  "ui.post": "Post",
+  "ui.min.read": "min read ·",
+  "ui.next": "Next",
+  "ui.get.started": "Get started →",
+  "ui.install.the.toolchain.and.ship.a.hello.service": "Install the toolchain and ship a hello-service binary.",
+  "ui.read.the.docs.186": "Read the docs →",
+  "ui.concepts.capabilities.durable.work.and.operations": "Concepts, capabilities, durable work, and operations.",
+  "ui.browse.the.runtime.examples.and.release.evidence": "Browse the runtime, examples, and release evidence.",
+  "ui.all.posts.189": "← All posts",
+  "ui.tysel.blog": "Tysel Blog",
+  "ui.notes.on.shipping.typescript.as.a.binary": "Notes on shipping TypeScript as a binary.",
+  "ui.rss.feed": "RSS feed →",
+  "ui.featured": "Featured ·",
+  "ui.min.read.194": "min read",
+  "ui.read.the.post": "Read the post →",
+  "ui.earlier": "Earlier",
+  "ui.fetch.style.service.on.the.web.api.runtime": "Fetch-style service on the Web API runtime.",
+  "ui.queue.worker": "Queue worker",
+  "ui.service.with.one.named.queue.handler": "Service with one named Queue handler.",
+  "ui.isolated.mcp.stdio.tool.with.validated.input": "Isolated MCP stdio tool with validated input.",
+  "ui.minimal.service": "Minimal service",
+  "ui.smallest.fetch.handler.for.custom.application.structure": "Smallest Fetch handler for custom application structure.",
+  "ui.guide": "Guide",
+  "ui.contract": "Contract",
+  "ui.create.a.starter.or.open.an.exact.example": "Create a starter or open an exact example.",
+  "ui.use.a.built.in.template.when.starting.a": "Use a built-in template when starting a new project. Use the version-matched repository examples when you need a complete capability walkthrough such as WebSocket, Postgres, Durable execution, or Wasm.",
+  "ui.start.from.a.built.in.template": "Start from a built-in template",
+  "ui.these.commands.create.the.project.before.validating.and": "These commands create the project before validating and running it. Choose the closest application shape, then add explicit capabilities.",
+  "ui.init.reference": "Init reference",
+  "ui.download.version.matched.examples": "download version-matched examples",
+  "ui.replace": "Replace",
+  "ui.with.another.directory.listed.below.this.downloads.application": "with another directory listed below. This downloads application source without a fork, repository clone, or local Tysel build.",
+  "ui.start.with.the.durable.path": "Start with the durable path",
+  "ui.requires.a.real.openai.compatible.endpoint.see.the": "Requires a real OpenAI-compatible endpoint; see the README for",
+  "ui.development.source": "Development source",
+  "ui.durable.execution": "Durable execution",
+  "ui.durable.api": "Durable API",
+  "ui.one.installed.toolchain": "One installed toolchain",
+  "ui.install.tysel.once.then.use.the.same": "Install Tysel once, then use the same",
+  "ui.command.in.every.example.project.the.managed.installation": "command in every example project. The managed installation already includes the matching service runtime and isolated worker; no repository build or worker-path override is required.",
+  "ui.installation.guide": "Installation guide",
+  "ui.effective.profile.default": "Effective profile default.",
+  "ui.supported.no.dedicated.tree.yet": "Supported, no dedicated tree yet",
+  "ui.these.apis.ship.today.they.are.reference.recipes": "These APIs ship today. They are reference recipes — not missing Node-style stdlib examples, and not end-to-end acceptance paths.",
+  "ui.recipe.contract.only": "Recipe · contract only",
+  "ui.shell.child.processes.ffi.and.dynamic.libraries.stay": "Shell, child processes, FFI, and dynamic libraries stay outside the application contract. See the",
+  "ui.and.227": "and",
+  "ui.docs.gallery": "docs gallery",
+  "ui.runnable": "Runnable",
+  "ui.experimental": "Experimental",
+  "ui.recipe": "Recipe",
+  "ui.after.opening.the.example.directory": "after opening the example directory",
+  "common.copy": "Copy",
+  "common.copied": "Copied",
+  "nav.openMenu": "Open menu",
+  "nav.closeMenu": "Close menu",
+  "theme.light": "Switch to light theme",
+  "theme.dark": "Switch to dark theme",
+  "ui.tysel.workload.examples": "Tysel workload examples",
+  "ui.start.an.llm.draft.suspend.for.human.approval": "Start an LLM draft, suspend for human approval, restart the process, resume, and save the result once.",
+  "ui.llm.secret.sqlite.durable.execution": "LLM · secret · SQLite · durable execution",
+  "ui.trusted.first.party.http.apps.labels.name.the": "Trusted first-party HTTP apps. Labels name the behavior each example exercises.",
+  "ui.the.service.profile.currently.defaults.to.durable.store": "The service profile currently defaults to durable.store = \"sqlite\" and ./data/tysel.db, even when an example does not call SQLite. Run tysel inspect to review the complete effective configuration.",
+  "ui.hello.service": "Hello service",
+  "ui.minimal.fetch.handler.and.one.executable.build": "Minimal Fetch handler and one-executable build.",
+  "ui.web.api.first.npm.router.compatibility.is.scanned": "Web-API-first npm router. Compatibility is scanned, not assumed.",
+  "ui.websocket.service": "WebSocket service",
+  "ui.http.1.1.upgrade.and.bounded.text.echo": "HTTP/1.1 upgrade and bounded text echo.",
+  "ui.http.inbound.websocket": "HTTP · inbound WebSocket",
+  "ui.persistent.counter.through.a.runtime.owned.grant.bound": "Persistent counter through a runtime-owned, grant-bound client.",
+  "ui.named.database.grant.the.url.stays.in.the": "Named database grant. The URL stays in the host environment.",
+  "ui.redis.service": "Redis service",
+  "ui.bounded.cache.operations.through.a.named.host.injected": "Bounded cache operations through a named, host-injected Redis grant.",
+  "ui.filesystem.transform": "Filesystem transform",
+  "ui.read.and.write.utf.8.files.beneath.separate": "Read and write UTF-8 files beneath separate pinned roots.",
+  "ui.filesystem.read.filesystem.write": "filesystem read · filesystem write",
+  "ui.cron.and.queue": "Cron and Queue",
+  "ui.scheduled.and.produced.json.work.on.the.bounded": "Scheduled and produced JSON work on the bounded task path.",
+  "ui.task.worker": "Task worker",
+  "ui.utc.cron.registration.and.one.named.queue.consumer": "UTC Cron registration and one named Queue consumer.",
+  "ui.agents.and.tools": "Agents and tools",
+  "ui.work.that.must.survive.restarts.or.run.as": "Work that must survive restarts, or run as an isolated MCP tool.",
+  "ui.llm.service": "LLM service",
+  "ui.host.configured.provider.alias.with.credential.isolation.and": "Host-configured provider alias with credential isolation and usage metadata.",
+  "ui.llm.provider.secret": "LLM · provider secret",
+  "ui.validated.json.tool.over.bounded.stdio.returns.an": "Validated JSON tool over bounded stdio. Returns an opaque secret handle only.",
+  "ui.mcp.brokered.secret": "MCP · brokered secret",
+  "ui.isolation.and.wasm": "Isolation and Wasm",
+  "ui.separate.worker.process.or.a.language.neutral.one": "Separate worker process, or a language-neutral one-shot Component task.",
+  "ui.isolated.plugin": "Isolated plugin",
+  "ui.fetch.handler.under.the.isolated.profile.manifest.grants": "Fetch handler under the isolated profile. Manifest grants are still denied.",
+  "ui.host.capabilities.denied": "host capabilities denied",
+  "ui.rust.component": "Rust Component",
+  "ui.one.shot.json.task.via.tysel.component.task": "One-shot JSON task via tysel:component/task@0.4.0.",
+  "ui.json.task.no.ambient.wasi": "JSON task · no ambient WASI",
+  "ui.after.building.the.rust.starter": "after building the Rust starter",
+  "ui.starter.guide": "Starter guide",
+  "ui.go.component": "Go Component",
+  "ui.same.component.world.with.committed.go.bindings": "Same Component world with committed Go bindings.",
+  "ui.after.building.the.go.starter": "after building the Go starter",
+  "ui.handler.tests": "Handler tests",
+  "ui.invoke.fetch.handlers.in.a.fresh.isolate": "Invoke Fetch handlers in a fresh isolate.",
+  "ui.fresh.startup": "Fresh startup",
+  "ui.p50.spawn.listen.2.warm.ups.11.samples": "p50 spawn→listen · 2 warm-ups + 11 samples · warm page cache",
+  "ui.idle.pss": "Idle PSS",
+  "ui.single.pss.sample.400ms.after.listen": "Single PSS sample ~400ms after listen",
+  "ui.executable.size": "Executable size",
+  "ui.uncompressed.on.disk.hello.service.binary": "Uncompressed on-disk hello-service binary",
+  "ui.isolate.create": "Isolate create",
+  "ui.p50.in.process.create.not.pool.reuse": "p50 in-process create · not pool reuse",
+  "ui.reuse.growth": "Reuse growth",
+  "ui.single.before.after.pss.delta.1.000.reuses": "Single before/after PSS delta · 1,000 reuses",
+  "ui.queue.delta": "Queue delta",
+  "ui.in.memory.scheduler.pss.delta.10k.tasks": "In-memory scheduler PSS delta · 10k tasks",
+  "ui.p50.on.in.memory.sqlite.not.disk.or": "p50 on in-memory SQLite · not disk or Postgres",
+  "ui.isolates": "Isolates",
+  "ui.single.host.lifecycle.microbenchmarks.process.spawn.request.dispatch": "Single-host lifecycle microbenchmarks — process spawn, request dispatch, and crash replacement.",
+  "ui.worker.process.spawn": "Worker process spawn",
+  "ui.p50.supervisor.spawn.worker.ready": "p50 supervisor spawn → worker ready",
+  "ui.warm.pool.request": "Warm pool request",
+  "ui.p50.full.request.through.a.pre.warmed.isolated": "p50 full request through a pre-warmed isolated pool",
+  "ui.crash.replace": "Crash replace",
+  "ui.p50.replacement.after.isolate.crash": "p50 replacement after isolate crash",
+  "ui.tasks": "Tasks",
+  "ui.in.memory.scheduler.microbenchmarks.not.database.or.distributed": "In-memory scheduler microbenchmarks — not database or distributed throughput.",
+  "ui.enqueue.10k": "Enqueue 10k",
+  "ui.p50.time.to.enqueue.10.000.in.memory": "p50 time to enqueue 10,000 in-memory tasks",
+  "ui.claim.commit": "Claim + commit",
+  "ui.p50.claim.commit.for.1.000.in.memory": "p50 claim/commit for 1,000 in-memory tasks",
+  "ui.crash.requeue": "Crash requeue",
+  "ui.p50.requeue.after.worker.crash": "p50 requeue after worker crash",
+  "ui.durable": "Durable",
+  "ui.in.memory.sqlite.except.the.explicitly.file.backed": "In-memory SQLite except the explicitly file-backed restart recovery case.",
+  "ui.sqlite.append.32.events": "SQLite append · 32 events",
+  "ui.p50.append.on.in.memory.sqlite": "p50 append on in-memory SQLite",
+  "ui.replay.1.000.effects": "Replay · 1,000 effects",
+  "ui.p50.replay.on.in.memory.sqlite": "p50 replay on in-memory SQLite",
+  "ui.file.backed.restart": "File-backed restart",
+  "ui.p50.reopen.replay.of.16.events.on.temporary": "p50 reopen + replay of 16 events on temporary SQLite",
+  "ui.loopback.microbenchmarks.with.explicit.connection.and.batch.boundaries": "Loopback microbenchmarks with explicit connection and batch boundaries — not external throughput.",
+  "ui.json.1.kib.new.h1": "JSON 1 KiB · new H1",
+  "ui.p50.tcp.connect.request.full.response": "p50 TCP connect + request + full response",
+  "ui.websocket.connect.echo": "WebSocket connect + echo",
+  "ui.p50.handshake.one.echo.close": "p50 handshake + one echo + close",
+  "ui.h1.100.request.batch": "H1 · 100-request batch",
+  "ui.p50.wall.time.until.all.100.concurrent.new": "p50 wall time until all 100 concurrent new-connection requests finish",
+  "ui.pass": "PASS",
+  "ui.fail": "FAIL",
+  "ui.skip": "SKIP",
+  "ui.open": "OPEN",
+  "ui.demo": "DEMO",
+  "locale.label": "Language",
+  "locale.original": "Read the English original",
+  "locale.untranslated": "This page is not available in the selected language yet.",
+  "site.description": "A native TypeScript runtime for services and agents. One executable, explicit capabilities, and durable work that survives restarts.",
+  "fumadocs.Ask AI(AI chat button)": "Ask AI",
+  "fumadocs.Back to Home(404 page)": "Back to Home",
+  "fumadocs.Choose a language(language switcher)": "Choose a language",
+  "fumadocs.Choose a language(language switcher)(aria-label)": "Choose a language",
+  "fumadocs.Close Banner(banner)(aria-label)": "Close Banner",
+  "fumadocs.Close Search(search dialog)(aria-label)": "Close Search",
+  "fumadocs.Close Sidebar(aria-label)": "Close Sidebar",
+  "fumadocs.Close Sidebar(sidebar)(aria-label)": "Close Sidebar",
+  "fumadocs.Collapse Sidebar(sidebar)(aria-label)": "Collapse Sidebar",
+  "fumadocs.Copied Text(code block)(aria-label)": "Copied Text",
+  "fumadocs.Copy Anchor Link(heading anchor)(aria-label)": "Copy Anchor Link",
+  "fumadocs.Copy Link(accordion)(aria-label)": "Copy Link",
+  "fumadocs.Copy Markdown(page actions)": "Copy Markdown",
+  "fumadocs.Copy Text(code block)(aria-label)": "Copy Text",
+  "fumadocs.Dark(theme switcher)(aria-label)": "Dark",
+  "fumadocs.Default(type table)": "Default",
+  "fumadocs.Edit on GitHub(edit page)": "Edit on GitHub",
+  "fumadocs.Hide Sidebar(sidebar)": "Hide Sidebar",
+  "fumadocs.Last updated on(page footer)": "Last updated on",
+  "fumadocs.Layout Tab(layout tab trigger)": "Layout Tab",
+  "fumadocs.Light(theme switcher)(aria-label)": "Light",
+  "fumadocs.Next Page(pagination)": "Next Page",
+  "fumadocs.No Headings(table of contents)": "No Headings",
+  "fumadocs.No results found(search dialog)": "No results found",
+  "fumadocs.On this page(table of contents)": "On this page",
+  "fumadocs.Open Search(search trigger)(aria-label)": "Open Search",
+  "fumadocs.Open Sidebar(sidebar)(aria-label)": "Open Sidebar",
+  "fumadocs.Open in ChatGPT(page actions)": "Open in ChatGPT",
+  "fumadocs.Open in Claude(page actions)": "Open in Claude",
+  "fumadocs.Open in Cursor(page actions)": "Open in Cursor",
+  "fumadocs.Open in GitHub(page actions)": "Open in GitHub",
+  "fumadocs.Open in Scira AI(page actions)": "Open in Scira AI",
+  "fumadocs.Open(page actions)": "Open",
+  "fumadocs.Page Not Found(404 page)": "Page Not Found",
+  "fumadocs.Parameters(type table)": "Parameters",
+  "fumadocs.Previous Page(pagination)": "Previous Page",
+  "fumadocs.Prop(type table)": "Prop",
+  "fumadocs.Read {url}, I want to ask questions about it.(page actions)": "Read {url}, I want to ask questions about it.",
+  "fumadocs.Returns(type table)": "Returns",
+  "fumadocs.Search(search dialog)": "Search",
+  "fumadocs.Search(search trigger)": "Search",
+  "fumadocs.Show Sidebar(sidebar)": "Show Sidebar",
+  "fumadocs.System(theme switcher)(aria-label)": "System",
+  "fumadocs.Table of Contents(inline table of contents)": "Table of Contents",
+  "fumadocs.The page you are looking for might have been removed, had its name changed, or is temporarily unavailable.(404 page)": "The page you are looking for might have been removed, had its name changed, or is temporarily unavailable.",
+  "fumadocs.Toggle Menu(mobile menu)(aria-label)": "Toggle Menu",
+  "fumadocs.Toggle Theme(theme switcher)(aria-label)": "Toggle Theme",
+  "fumadocs.Type(type table)": "Type",
+  "fumadocs.View as Markdown(page actions)": "View as Markdown",
+  "fumadocs.displayName": "English",
+  "site.title": "Tysel — Write TypeScript. Ship a binary.",
+  "blog.description": "Release notes, runtime design notes, and production guidance from the Tysel team."
+}
diff --git a/website/locales/zh-CN/content/blog/capability-by-default.mdx b/website/locales/zh-CN/content/blog/capability-by-default.mdx
new file mode 100644
index 0000000..a5625bc
--- /dev/null
+++ b/website/locales/zh-CN/content/blog/capability-by-default.mdx
@@ -0,0 +1,184 @@
+---
+title: "默认拒绝：为什么智能体需要显式能力"
+description: "智能体软件可以在运行时选择操作。Tysel 要求事先声明操作所需的资源，并限制访问范围，让权限可以在执行前接受审查。"
+author: "Tysel"
+date: "2026-09-03T11:00:00Z"
+cover: "/blog/capability-by-default/hero.jpg"
+coverAlt: "一条青柠色路径穿过大型白色能力边界中唯一开放的入口"
+tags:
+  - security
+  - agents
+  - capabilities
+---
+
+> 智能体应获得完成任务所需的权限，而不是其进程能够访问的所有资源。
+
+传统应用安全通常从身份开始：验证调用方、授权请求，并保护服务的外部访问边界。智能体软件在这道边界内部增加了一个问题：程序开始自行决定下一步操作后，究竟允许它做什么？
+
+智能体可以连续执行一系列操作，因此一次错误的影响也可能随之扩大。它可能读取不受信任的指令、动态选择工具、调用模型、失败后重试、等待人工处理，并在数小时后继续。如果进程可以使用部署环境中的所有凭据、访问所有主机、数据库和文件，提示词注入或普通编程错误都会造成更严重的后果。
+
+在 Tysel 中，应用需要明确声明所需的宿主权限。对于由清单控制的资源，应用必须先声明访问需求，再接受部署策略和执行配置等限制。声明本身并不等于获得授权。
+
+本文所说的“能力”是 Tysel 公开的宿主操作，并不声称所有 Tysel 代码都在沙箱中运行。`service` 执行配置适用于受信任的第一方代码，并与原生宿主共享进程。Linux `isolated` 执行配置为信任度较低的 JavaScript 增加工作进程边界，但会有意拒绝下文讨论的宿主能力。能力限制和进程隔离是两个独立层次。
+
+## 未声明的权限，默认不授予
+
+新的 Tysel 项目可以包含空权限表：
+
+```toml
+[permissions]
+```
+
+此时，应用没有访问出站主机、机密信息、Postgres、Redis 或文件系统根目录的清单授权。即使环境变量已经存在，或依赖库试图调用相关功能，也不会自动获得这些权限。
+
+不过，并不是所有宿主功能都通过 `[permissions]` 中的具名条目授权。嵌入式 SQLite 由受信任执行配置控制；持久存储和入站监听器属于宿主管理的基础设施。关键是每项功能的权限来源都必须明确：清单授权、执行配置或宿主部署配置。
+
+只需要少量资源的服务可以请求：
+
+```toml
+[permissions]
+fetch = ["api.example.com"]
+secrets = ["API_TOKEN"]
+postgres = ["main:read-only"]
+fs_read = ["./prompts"]
+fs_write = ["./data/output"]
+```
+
+每个字段都要指定具体的资源范围，不能只笼统声明资源类别：
+
+- `fetch` 包含主机名，而非任意 URL 前缀；
+- 重定向会再次根据白名单检查；
+- `secrets` 包含名称，而非机密信息的值；
+- 数据库授权具名且可以只读；
+- 文件系统访问限制在固定根目录下；
+- 读权限不隐含写权限。
+
+加载清单时会拒绝未知字段、空条目和重复条目。配置带有版本，可以和应用代码一起审查。
+
+## 请求不等于权限
+
+清单只是决策的一层：
+
+```text
+manifest request
+  ∩ deployment policy
+  ∩ execution profile
+  ∩ runtime support
+  = effective capability
+```
+
+这可以防止代码变更授予自身超出环境允许范围的权限。在清单中添加文件系统根目录，无法覆盖禁止文件系统访问的执行配置。导入 Wasm Component 接口，无法绕过拒绝该能力的部署策略。同样，清单无法启用运行时尚未实现的能力。
+
+`service` 执行配置为受信任的第一方代码提供完整宿主能力接口，同时仍要求清单授权。`isolated` 执行配置在单独工作进程中运行 JavaScript，即使清单列出相应能力，也会拒绝面向宿主的网络、数据库、文件系统、LLM 和 WebSocket 能力。在 Linux 上，该工作进程还会应用 Landlock、seccomp、资源限额和尽力而为的 cgroup 强制限制。
+
+实验性的 `component` 执行配置也有相应限制：组件导入的接口、清单声明的根目录和部署策略必须相互匹配。它目前向应用开放的能力范围更小，这是有意作出的限制。
+
+选择执行配置，就是进一步限定应用的权限范围。
+
+## 用引用传递机密信息
+
+清单只声明机密信息的名称，不会把实际值写入构建产物。连接 URL 和机密信息的值仍由部署方管理。
+
+对于 `API_TOKEN` 这类已声明的机密信息，JavaScript 会向宿主请求不透明引用。应用可以将该句柄传给宿主能力，而不会获得明文环境变量值。声明本身不会创建机密信息或为其赋值，也不会授权任何未声明名称。
+
+这可以减少日志、异常信息、序列化或模型上下文造成的意外泄露，但不能免除运维责任：环境变量和提供商凭据仍需得到保护、轮换和基础设施策略约束。
+
+## 让类型提示反映实际权限
+
+修改清单权限后，可以用 `tysel types` 生成与该清单对应的 TypeScript 类型声明：
+
+```sh
+tysel types
+tysel types --check
+```
+
+生成的 `TyselEnv` 只包含项目已声明的能力。调用未获授权的能力时，开发者可以在编辑器或 CI 类型检查中提前发现问题。
+
+类型提示能帮助开发者发现问题，但安全限制仍须在运行时执行。生成的声明不会授予权限，类型中出现的主机名仍需运行时白名单强制检查。最终是否允许操作，仍由原生宿主决定。
+
+这样，类型检查负责提前反馈，宿主负责实际执行权限限制，两者各有职责。
+
+## 检查结果，而不只检查源码
+
+仓库中的 `durable-agent` 示例声明了一项机密信息访问权限，并使用默认 SQLite 持久存储。针对该清单运行仓库工具会得到：
+
+```text
+$ tysel inspect --manifest examples/durable-agent/tysel.toml
+Application: durable-agent
+Profile: service
+Entry: src/index.ts
+Listen: 127.0.0.1:3000
+Logs: json
+
+Capabilities
+  Secrets
+    OPENAI_API_KEY
+  SQLite
+    ./data/tysel.db
+
+Denied
+  Raw TCP
+  Child Process
+  FFI
+  Dynamic Library
+  Environment
+```
+
+该输出比“沙箱化智能体”更有审查价值。它展示所选执行配置、清单授权访问的机密信息等资源、由执行配置控制的嵌入式 SQLite 等设施，以及仍不属于应用约定的操作。它没有声称进程本身能够安全运行恶意代码。
+
+## 能力设计会改变审查方式
+
+设想一个读取支持工单、调用 LLM、查询订单并编写建议回复的智能体。传统审查可能关注提示词构造和业务逻辑。能力审查则可以提出具体运维问题：
+
+- 它可以访问哪个模型端点？
+- 调用该服务时，使用的是哪一项已声明的机密信息？
+- 订单数据库授权是否只读？
+- 哪个目录可以保存生成的草稿？
+- 工作负载是否需要与宿主共享进程？
+- 适用哪些请求、响应、内存、截止时间和并发限额？
+
+这些问题无需追踪智能体的每个可能分支即可回答。清单列出应用请求执行的外部操作及其资源范围；执行配置和部署策略会进一步缩小这一范围。
+
+`tysel inspect` 使实际结果可见：
+
+```sh
+tysel check
+tysel inspect
+```
+
+权限变更后，应在 CI 中运行两条命令。拒绝访问的情况也应与成功调用一样纳入测试：未声明的重定向目标、文件系统穿越、通过只读授权执行修改，以及缺失机密信息，都必须被拒绝，而不能在出错时放行。
+
+## 能力不能替代隔离
+
+能力模型和进程沙箱回答不同的问题。
+
+能力模型规定运行时可以代表应用执行哪些宿主操作。进程隔离限制代码在这些运行时 API 之外能够访问什么。Tysel 的 `service` 执行配置限制能力，但以进程内代码可信为前提，面向第一方代码。Linux `isolated` 执行配置为插件和生成代码增加工作进程边界，同时有意收回面向宿主的能力。
+
+两者都不能替代基础设施控制。生产运维仍需要非 root 身份、出站网络策略、TLS 终止、宿主补丁、机密信息管理，以及数据库和持久存储保护。
+
+要做好纵深防御，首先需要明确每一层负责什么、能防住什么。
+
+## 有权执行，不代表符合用户意图
+
+显式权限可以限制错误的影响范围，但无法证明操作符合用户意图。
+
+如果智能体被允许发送邮件，提示词注入仍可能诱导它发错邮件。能力边界可以限制服务提供商、所用机密信息及相关资源，但产品逻辑仍必须处理确认、策略检查、收件人验证、审计和人工批准。
+
+持久工作流可以记录等待批准的状态和最终决策，避免流程只停留在内存中。但能否在重启后恢复流程，与谁有权批准，仍需分别处理。
+
+## 为长时间运行的智能体设定权限边界
+
+实际目标是明确智能体最多拥有哪些权限，让开发和运维人员能够检查授权、缩小范围，并验证限制是否生效。
+
+对于每项新能力：
+
+1. 从空权限集开始；
+2. 添加范围最窄的资源选择器；
+3. 选择能够运行工作负载、权限最小的执行配置；
+4. 将凭据保留在清单和产物之外；
+5. 运行 `tysel check`、`tysel types --check` 和 `tysel inspect`；
+6. 在部署环境中测试拒绝路径。
+
+智能体可以决定下一步做什么，但运行时仍应决定它被允许接触什么。
+
+接下来请阅读[安全模型](/docs/security)、[能力矩阵](/docs/capabilities)和[清单权限参考](/reference/manifest/permissions)。
diff --git a/website/locales/zh-CN/content/blog/durable-execution-recovery-semantics.mdx b/website/locales/zh-CN/content/blog/durable-execution-recovery-semantics.mdx
new file mode 100644
index 0000000..92a7b93
--- /dev/null
+++ b/website/locales/zh-CN/content/blog/durable-execution-recovery-semantics.mdx
@@ -0,0 +1,197 @@
+---
+title: "持久执行：恢复究竟意味着什么"
+description: "Tysel 如何通过历史记录恢复工作流？本文解释回放、持久边界与幂等性，以及运行时为何无法单独保证外部操作恰好执行一次。"
+author: "Tysel"
+date: "2026-09-03T09:00:00Z"
+cover: "/blog/durable-execution-recovery-semantics/hero.jpg"
+coverAlt: "一条白色执行路径跨过断点回放三个已记录的青柠色检查点，并延伸至一个紫色待处理检查点"
+tags:
+  - durable-execution
+  - recovery
+  - agents
+---
+
+> 恢复是依据已记录历史进行回放，并非延续一个被冻结的 JavaScript 堆。
+
+长时间运行的任务面临的故障场景，与短时请求处理不同。智能体等待批准时，进程可能重启；等待退避重试时，机器可能下线；队列任务处理器可能已完成外部调用，却在记录本地成功状态前崩溃；一次重新部署就可能清除内存中的所有计时器。
+
+让一个 Promise 始终存活在同一 JavaScript 进程中，并不等于持久执行。Tysel 将选定的边界持久化，使处理程序能够重新开始、读取自身历史记录，并从最后一个已完成边界之后继续执行。
+
+要正确使用这一机制，需要先弄清楚它保存了什么，以及恢复时会重新执行什么。
+
+## 带显式边界的普通异步函数
+
+持久处理程序以异步函数编写：
+
+```ts
+import type { DurableContext, TyselApp } from "@tysel/types";
+
+const approvalFlow = async (
+  ctx: DurableContext,
+  input: { orderId: string },
+) => {
+  const order = await ctx.effect("load-order", () => loadOrder(input.orderId));
+  const draft = await ctx.effect("create-draft", () => createDraft(order));
+
+  await ctx.sleep("10m");
+  const decision = await ctx.waitForSignal<{ approved: boolean }>("approval");
+
+  return { draft, approved: decision.approved };
+};
+
+export default {
+  durable: { approvalFlow },
+} satisfies TyselApp;
+```
+
+语法看起来很熟悉，但 `ctx` 上的调用不是普通辅助函数。这些调用会记录恢复执行所需的历史信息。
+
+| 边界 | 持久化含义 |
+| --- | --- |
+| `step` | 记录计算结果 |
+| `effect` | 记录外部副作用的结果 |
+| `sleep` | 持久化唤醒时间并挂起 |
+| `waitForSignal` | 挂起，直到指定名称的 JSON 信号被持久化 |
+| `retry` | 记录次数受限的重试及其等待时间 |
+| `now` | 返回可安全回放的时间 |
+| `random` | 返回可安全回放的随机值 |
+
+输入、边界结果、信号和处理程序结果必须可序列化为 JSON。对持久边界的调用必须按顺序 `await`，传入和返回的数据也有大小限制。
+
+## 挂起时会发生什么
+
+当处理程序到达 `sleep` 或 `waitForSignal` 时，Tysel 会持久化挂起状态。计时器运行或等待人工决策期间，无需持续占用 JavaScript 隔离实例。
+
+控制 API 会返回任务 ID，以及已完成或已挂起状态：
+
+```ts
+const status = tysel.durable.start("approvalFlow", { orderId: "ord_123" });
+
+tysel.durable.sendSignal(status.taskId, "approval", {
+  approved: true,
+});
+```
+
+信号会追加到持久历史记录中。重启后，运行时可以据此确定：哪个处理程序在等待、哪些边界已经完成，以及所需信号是否已到达。
+
+与进程本地 Promise 或计时器相比，这更适合批准流程、延迟重试、编排和智能体计划。
+
+## 回放从头开始
+
+重启后，Tysel 会依据持久历史记录从第一行开始调用处理程序。它不会反序列化已挂起的 JavaScript 调用栈。
+
+对于每个已完成且有名称的边界，运行时会返回已记录结果，而不会再次执行该操作。已有历史回放完毕后，处理程序才继续执行尚未完成的部分。
+
+以前面的工作流为例：`create-draft` 已完成，任务随后因等待批准而挂起。批准信号持久化后，恢复执行时会依次回放已有记录，再继续处理结果：
+
+```text
+start handler
+  → load-order: return recorded result
+  → create-draft: return recorded result
+  → sleep: return recorded completion
+  → approval: consume persisted signal
+  → execute new code
+```
+
+因此，边界名称和顺序是已部署工作流约定的一部分，而不是仅供展示的日志标签。
+
+## 边界之间的代码必须保持确定性
+
+回放会重新运行持久操作之间的普通 JavaScript。对于相同的输入和历史记录，这段代码必须到达相同的持久边界序列。
+
+直接读取的系统时间、未记录的随机值、可变全局状态和无序并发都可能使回放路径发生偏离。因此，持久代码应当：
+
+- 使用 `ctx.now()`，而不是直接读取系统当前时间；
+- 使用 `ctx.random()`，而不是未记录的随机值；
+- 将外部读取和写入放入已记录边界；
+- 按顺序等待持久边界；
+- 保持已有边界名称稳定；
+- 不要改变进行中任务所用边界的顺序。
+
+边界之间可以进行纯数据转换，只要相同输入始终得到相同结果，就不会破坏回放。影响分支选择的数据库读取即便使用 `SELECT`，也不是纯操作；它应位于已记录的 `effect` 边界内。需要保存确定性计算的结果时，使用 `step`；与外部系统交互时使用 `effect`，包括返回值会影响后续执行的读取操作。
+
+## 副作用提供什么保证
+
+`ctx.effect` 会记录外部副作用的结果。该结果提交到持久历史记录后，回放会直接返回结果，而不会再次发起该外部调用。
+
+这能防止正常恢复期间重复执行已经完成并记录的副作用，却不会凭空创建与任意 API 之间的分布式事务。
+
+以下故障窗口无法避免：
+
+```text
+external service commits action
+          ↓
+process fails before local history commits outcome
+```
+
+恢复后，除非外部系统提供识别或查询该操作的方法，否则 Tysel 无法知道外部系统是否已经提交。盲目重试可能会重复产生副作用。
+
+向外部服务发起请求时，应根据持久任务和边界生成稳定的幂等键，并将其传给服务方。如果条件允许，在创建新操作前先用该键查询外部结果。两个独立系统之间的恰好一次行为需要双方配合；运行时无法单方面制造这种保证。
+
+这一区别对于支付、消息、资源创建和模型驱动的工具调用尤其重要。
+
+## 信号是历史记录，而非回调
+
+信号可以在处理程序到达 `waitForSignal` 之前或之后到达。由于信号会被持久化，接收信号时不必恰好有一个监听器在内存中等待。
+
+信号名称和载荷结构是工作流约定的一部分。追加信号前必须验证授权：持有任务 ID 不应自动获得批准、取消或修改工作流的权限。
+
+因此，人工批准至少包含三个层次：
+
+1. 产品逻辑确定需要批准；
+2. 接收决策的控制接口先验证调用方身份，再检查其是否有权发送该决策；
+3. 持久历史记录保存最终信号，以供回放。
+
+持久存储负责保存决策，应用负责检查发送者的权限。
+
+## 将持久存储作为生产数据管理
+
+SQLite 是默认持久存储：
+
+```toml
+[durable]
+store = "sqlite"
+path = "./data/tysel.db"
+```
+
+宿主环境完成相应配置后，运行时也可以使用基于 Postgres 的持久存储。目前，版本 1 清单中的存储配置使用 `sqlite`；要使用 Postgres，需由运维人员在部署配置中指定。
+
+无论选择哪种存储，都应将其视为敏感的运维状态：
+
+- 进行备份并测试恢复；
+- 为相对路径设置明确的工作目录；
+- 像保护应用数据一样保护它；
+- 监控恢复失败、信号处理和调度器健康状态；
+- 不要让多个独立调度器操作同一个 SQLite 文件。
+
+历史记录能否可靠保存、部署方式是否正确，直接决定了重启后能否恢复任务。
+
+## 修改已部署工作流
+
+修改工作流代码时，必须考虑正在运行的任务能否用新代码回放已有历史。重命名 `create-draft`、在它之前插入新边界或修改分支条件，可能导致新代码预期的历史记录结构与现有任务不符。
+
+修改之前，先确认现有任务的状态：
+
+- 哪些处理程序版本仍有进行中的实例？
+- 它们已经记录了哪些边界名称和序列？
+- 新代码能否以确定性方式读取旧历史记录？
+- 是否应引入新的工作流名称，而不是修改旧工作流？
+- 如何等待旧实例执行完毕，或将它们迁移到新版本？
+
+Tysel 提供回放机制；应用所有者仍需制定工作流版本策略。
+
+## 恢复机制提供的保证
+
+Tysel 持久执行承诺一种明确的模型：
+
+- 已完成的持久边界会被持久化；
+- 休眠和等待信号的工作可以释放隔离实例；
+- 处理程序中断后会从头开始；
+- 回放时复用已记录的边界结果，不再执行对应操作；
+- 已有历史回放完毕后，继续执行尚未完成的部分。
+
+它不会保存并还原整个 JavaScript 堆，也无法保证任意非确定性代码都能正确回放。它不会自动与外部服务建立原子事务，传入信号的授权检查也仍由应用负责。
+
+明确这些限制后，才能判断任务在不同故障下会如何恢复。准确的边界标识、信号顺序、重试限制和存储协调都是不断演进的 Durable API 约定的一部分，应在部署前对照当前参考资料进行验证。
+
+请在[持久执行](/docs/concepts/durable-execution)中构建完整示例，然后在设计稳定边界时查阅 [Durable API 参考](/reference/runtime/durable)。
diff --git a/website/locales/zh-CN/content/blog/from-typescript-to-one-executable.mdx b/website/locales/zh-CN/content/blog/from-typescript-to-one-executable.mdx
new file mode 100644
index 0000000..21f1371
--- /dev/null
+++ b/website/locales/zh-CN/content/blog/from-typescript-to-one-executable.mdx
@@ -0,0 +1,231 @@
+---
+title: "从 TypeScript 到单一可执行文件"
+description: "从项目检查到生成发布验证材料，逐步了解 Tysel 如何将 TypeScript 应用打包为一个可执行文件。"
+author: "Tysel"
+date: "2026-09-03T10:00:00Z"
+cover: "/blog/from-typescript-to-one-executable/hero.jpg"
+coverAlt: "五个宽阔的源码平面经过一道青柠色构建接缝汇聚成一个完整的可执行文件块"
+tags:
+  - build
+  - typescript
+  - delivery
+---
+
+> 要理解“交付一个可执行文件”，需要先看清它是怎样构建出来的。
+
+Tysel 最简短的承诺很容易记住：编写 TypeScript，交付二进制文件。从工程角度看，更值得了解的是从编写到交付经历了哪些步骤，以及最终产物包含和不包含什么。
+
+Tysel 不会把 TypeScript 直接转换为原生机器指令。构建时，它先检查应用并生成 JavaScript 代码包，再将代码和相关配置封装后嵌入原生运行时。启动后，其中的 JavaScript 由 QuickJS 隔离实例执行。Rust 宿主管理套接字、存储、机密信息、限制、执行配置和持久调度。
+
+这里的“原生”指最终交付的产物：一个操作系统可执行文件，其中包含应用及运行它所需的运行时。
+
+## 输入
+
+Tysel 项目从三类输入开始：
+
+```text
+TypeScript source
+project dependencies
+tysel.toml or tysel.json
+```
+
+清单是唯一的 Tysel 项目配置文件。`package.json` 和 `tsconfig.json` 可以辅助开发，但不能替代或覆盖清单。应用入口、执行配置、监听地址、权限请求、资源限制、持久存储、可观测性需求和项目任务，都由清单声明。
+
+一个最小 HTTP 服务可以完全不请求宿主能力：
+
+```toml
+schema_version = 1
+
+[app]
+name = "hello-service"
+entry = "src/index.ts"
+profile = "service"
+
+[server]
+listen = "127.0.0.1:3000"
+
+[permissions]
+
+[limits]
+memory_mb = 64
+cpu_ms_per_turn = 50
+request_timeout_ms = 30000
+max_in_flight = 256
+```
+
+清单中的未知字段会被视为错误。相对路径以发现的项目根目录为基准解析，任何试图逃逸该根目录的操作都会被拒绝。
+
+## 第 1 步：检查项目配置与兼容性
+
+打包前，Tysel 会验证清单，并检查项目是否符合所选运行时约定：
+
+```sh
+tysel check
+tysel compat --strict --deny-unknown
+tysel inspect
+```
+
+这些命令回答彼此相关但不同的问题：
+
+- 清单结构是否有效？
+- TypeScript 项目能否成功通过检查？
+- 依赖图能否纳入受支持的兼容性范围？
+- 哪些能力和限制会实际生效？
+- 应用使用的能力是否与清单一致？
+
+Node.js 内置模块、原生扩展、子进程和动态库不在应用约定范围内。应在生产构建前找出对这些功能的依赖，避免部署到目标机器后才暴露问题。
+
+`tysel types --check` 还可以验证清单限定的 TypeScript 环境是否为最新状态。类型为开发者提供反馈；权限最终仍由运行时检查并执行。
+
+## 第 2 步：报告类型检查状态并打包 TypeScript
+
+项目包含 `tsconfig.tysel.json` 或 `tsconfig.json` 且本地存在 TypeScript 编译器时，构建会使用 `--noEmit` 运行该编译器，并在出现类型错误时停止。如果任一条件不满足，构建会报告跳过类型检查，然后继续。要求类型检查成功的发布流水线应将报告的状态作为准入判定，而不能假定打包成功就证明类型正确。
+
+随后，构建会根据 TypeScript 入口点生成 JavaScript 代码包和源映射。开发期间仍可以使用 npm 包、编辑器工具和 TypeScript 声明。生产层面的承诺范围更窄：运行打包应用的机器不需要安装这些工具。
+
+打包也建立了清晰的兼容性边界。能够解析为受支持 JavaScript 的依赖可以纳入代码包。依赖 Node 专用全局变量或原生行为的包必须明确分类，而不能默认它能够运行。
+
+代码包是应用代码，并非整个运行时。QuickJS 和宿主能力位于原生可执行文件存根中。
+
+## 第 3 步：创建应用程序包
+
+应用程序包包含以下内容：
+
+```text
+JavaScript bundle
+source map
+validated manifest
+compatibility metadata
+```
+
+程序包把代码与构建时验证过的配置绑定在一起，记录该应用的入口、执行配置、监听地址、能力请求和资源限制。
+
+源映射仍有助于诊断，但目标环境启动服务时不需要原始 TypeScript 源码树。当前源映射包含 `sourcesContent`，因此打包产物内部存在源码文本。将应用源码视为敏感信息的团队在检查和分发可执行文件时应考虑这一点。
+
+## 第 4 步：选择并验证运行时
+
+为本机平台构建时，Tysel 使用匹配的本地运行时存根。也可以为以下受支持的目标平台打包：
+
+- `linux-x64`；
+- `linux-arm64`；
+- `darwin-x64`；
+- `darwin-arm64`。
+
+```sh
+tysel build --release \
+  --target linux-arm64 \
+  --output dist/orders-linux-arm64
+```
+
+这是经过验证的跨目标打包，而不是原生运行时交叉编译。当目标平台与宿主不同时，Tysel 会验证同版本的官方运行时、目标平台、发布清单、归档签名和文件哈希，然后将该运行时放入受管理缓存。
+
+`--offline` 会拒绝网络访问，并要求缓存中已经存在经过验证的目标运行时。跨目标构建显式指定的 `--stub` 必须与经过验证的官方运行时逐字节一致。
+
+这些校验确保跨目标打包使用的是经过验证的运行时，避免借此替换成来源不明的文件。
+
+## 第 5 步：嵌入程序包
+
+原生运行时与应用程序包会合并到 `--output` 选择的可执行文件中：
+
+```text
+native Tysel runtime
+        +
+embedded application package
+        =
+one executable
+```
+
+启动时，宿主读取嵌入的程序包，强制执行其执行配置和限制，创建所需的 QuickJS 隔离实例或工作进程边界，并且只公开已准入的运行时能力。
+
+目标机器不需要 Node.js、V8、npm 或 `node_modules`。它仍需要与所选产物兼容的操作系统和架构，以及该可执行文件需要的系统库。“单一可执行文件”并不意味着“能在所有内核和架构上运行”。
+
+## 第 6 步：生成发布记录
+
+使用 `--release` 时，可执行文件只是产物集的一员：
+
+| 文件 | 用途 |
+| --- | --- |
+| 可执行文件 | 嵌入应用的原生运行时 |
+| `.sha256` | 可执行文件摘要 |
+| `.compat.json` | 运行时和程序包的兼容性判定 |
+| `.sbom.cdx.json` | 应用产物和嵌入式运行时清单的 CycloneDX 1.5 文档 |
+| `.licenses.json` | 运行时组件许可证清单 |
+| `.evidence.json` | 将产物与伴随文件关联起来的索引 |
+
+这些伴随文件有意保持独立。运行服务只需要可执行文件；审计并判断该版本是否允许发布，则需要完整文件集。请按可执行文件摘要将它们存放在一起，不要独立重新生成或编辑其中一个文件。
+
+运行时清单会列举 Tysel 嵌入的原生组件。目前，打包的 npm 依赖不会作为独立 SBOM 组件列出，因此应用依赖锁定、审查和许可证策略仍由项目负责。
+
+所以，不应将“单一二进制文件”理解为“把所有发布信息隐藏在一个不透明文件中”。可执行文件用于启动服务，发布验证材料用于审查和核验，两者可以分别交付和使用。
+
+## 一次实际构建会输出什么
+
+撰写本文时，我们在 `darwin-arm64` 上使用仓库中的发布构建工具，构建了随仓库提供的 `hello-service` 示例，输出摘要如下：
+
+```text
+Type check       passed
+Bundle           143 B
+Capabilities     sqlite
+Runtime          service
+Executable       12.6 MB
+Target           darwin-arm64
+```
+
+输出目录包含：
+
+```text
+hello-service
+hello-service.sha256
+hello-service.compat.json
+hello-service.sbom.cdx.json
+hello-service.licenses.json
+hello-service.evidence.json
+```
+
+这只是一次实际构建的结果，不代表所有应用都能达到相同体积。它使用已经构建好的本地 Tysel 工具链和极小的参考应用。不同的应用、目标平台、依赖图或运行时版本可能产生不同大小的可执行文件。
+
+校验和文件包含可执行文件的 SHA-256，独立计算的 SHA-256 与之一致。验证材料 JSON 另行记录了规范目标平台、产物大小和产物摘要。这些检查能够确定伴随文件描述的是所生成的文件，但不能证明不同且未统一配置的构建机器能够生成逐字节相同的产物。
+
+## 哪些内容可以复现
+
+Tysel 会记录源码提交、目标平台、应用标识、兼容性判定、运行时清单、产物哈希、SBOM、许可证和构建关系。运维人员可以依据部署方管理的信任策略对该集合签名和验证。
+
+这些验证材料证明某一产物及其伴随文件属于同一集合，却不承诺任意构建宿主都能生成逐字节相同的可执行文件。发布流水线仍需控制工具链版本、操作系统、依赖状态、源码修订版本和目标平台。
+
+一个实用的发布流程如下：
+
+```sh
+tysel doctor --install
+tysel task verify
+tysel inspect
+tysel build --release --target linux-arm64 --output dist/orders
+tysel release sign dist/orders --key /secure/offline-release.key
+tysel release verify dist/orders --trust deploy/trust.json
+```
+
+签名密钥和信任策略由部署方管理。机密信息的值、数据库 URL 和凭据不应进入产物验证材料。
+
+## 容器仍是可选项
+
+单一可执行文件可以直接由服务管理器运行，也可以放入精简的容器镜像。`tysel image` 会创建以非 root 身份运行的 Linux 容器上下文，并能复制已验证的发布伴随文件以供准入，而无需将它们放入运行时镜像。
+
+容器仍能提供有价值的分发、文件系统、身份和编排边界。Tysel 产物减少了容器需要组装的内容，但容器或宿主策略仍然不可或缺。
+
+## 将各项检查串成完整的构建流程
+
+因此，完整路径如下：
+
+```text
+source and manifest
+  → validation
+  → reported TypeScript-check state and bundle
+  → compatibility decision
+  → application package
+  → authenticated runtime selection
+  → one native executable
+  → release evidence and optional signature
+```
+
+这一流程的价值不仅是得到一个便于分发的文件，还在于应用代码、权限请求、运行时、目标平台和发布验证材料都经过了同一套构建检查。
+
+请按照[可复现发布指南](/docs/guides/reproducible-release)操作，或查阅完整的 [`tysel build` 参考](/reference/cli/delivery#tysel-build)。
diff --git a/website/locales/zh-CN/content/blog/tysel-v0-1-1.mdx b/website/locales/zh-CN/content/blog/tysel-v0-1-1.mdx
new file mode 100644
index 0000000..b6351c5
--- /dev/null
+++ b/website/locales/zh-CN/content/blog/tysel-v0-1-1.mdx
@@ -0,0 +1,147 @@
+---
+title: "Tysel v0.1.1 现已发布：编写 TypeScript，交付一个二进制文件"
+description: "面向服务和 AI 智能体的 TypeScript 运行时：以单个可执行文件交付，显式声明权限，并支持任务在重启后恢复。"
+author: "Tysel"
+date: 2026-09-02
+cover: "/blog/tysel-v0-1-1/hero.jpg"
+coverAlt: "Tysel v0.1 发布线以刻意裁切的编辑海报形式呈现"
+readingMinutes: 8
+tags:
+  - release
+  - typescript
+  - runtime
+---
+
+> 专注于 TypeScript 服务和智能体，明确限定运行能力与权限范围。
+
+我喜欢清楚了解自身定位，也同样清楚自身边界的开发者工具。
+
+Tysel v0.1.1 现已公开发布。它仍处于 1.0 之前：可以安装试用、评估，并参与后续设计，但尚不承诺次版本之间的 API 稳定性。
+
+Tysel 是面向服务和 AI 智能体的 TypeScript 运行时。“原生”描述宿主和交付物：TypeScript 在构建时完成检查和打包，应用 JavaScript 在嵌入式 QuickJS 隔离实例中运行，Rust 宿主管理网络、存储、机密信息、限额和调度。Tysel 不会将 TypeScript AOT 编译为机器码。
+
+它的主张很直接：**编写 TypeScript，交付一个二进制文件。** 单个二进制文件并非 Tysel 独有的能力。Tysel 将三项内容组合成一套生产模型：自包含可执行文件、默认拒绝访问的权限模型，以及能在重启后恢复的持久工作。
+
+## 一个运行时文件，一次可验证发布
+
+部署 JavaScript 应用，通常需要组装多项内容。源码或许简单，但实际部署的系统还包括运行时版本、依赖、脚本、镜像层、权限，以及应用外部的各种约定。
+
+Tysel 将这些内容收敛为一个原生产物：
+
+![Tysel 将 TypeScript 源码和清单构建为一个原生可执行文件](/blog/tysel-v0-1-1/pipeline.svg)
+
+目标机器无需单独安装 Node.js、V8、npm 或 `node_modules`。开发阶段仍可使用 TypeScript、npm 包和编辑器类型提示；变化在于，部署时不再需要另行准备这套 JavaScript 运行环境。
+
+运行应用只需要一个可执行文件。构建还会生成校验和、兼容性报告、SBOM、许可证清单和验证材料，作为用于审计和复现的独立伴随文件。这些材料随版本一同交付，但与可执行文件分开保存，便于独立查阅和审计。
+
+这一模型适合小型 HTTP 服务、队列任务处理器和定时任务、MCP 工具、隔离插件和智能体。对这些工作负载而言，通用 JavaScript 环境默认提供的许多系统访问能力往往用不上。
+
+## 参考体积与冷启动
+
+单个文件不一定很小，因此 Tysel 使用参考应用验证产物体积和启动时间。发布验证要求参考 `hello-service` 生成的**包不大于 20 MiB**，且**冷启动 p50 不慢于 15 ms**。这不是任意用户应用的体积保证；打包内容、依赖和启用的能力仍会影响结果。
+
+Tysel 0.1.1 随版本发布了 Ubuntu 24.04.4 上的原始 `hello-service` 验证材料：
+
+| 发布验证材料 | Linux arm64 | Linux x64 |
+| --- | ---: | ---: |
+| 单个可执行文件 | 15.98 MiB | 19.77 MiB |
+| 冷启动 p50 | 4.85 ms | 6.60 ms |
+| 空闲内存，PSS | 6.81 MiB | 7.36 MiB |
+
+冷启动在两次预热后测量 11 次进程启动，并在服务报告就绪时停止计时。这是启动测量，不是 HTTP 请求延迟或吞吐量。每份材料都记录产物 SHA-256、源码提交、系统和命令；可直接从发布页获取原始 [arm64 材料](https://github.com/wangcch/tysel/releases/download/v0.1.1/benchmark-evidence-linux-arm64.json)和 [x64 材料](https://github.com/wangcch/tysel/releases/download/v0.1.1/benchmark-evidence-linux-x64.json)。
+
+构建时间随应用大小和 TypeScript 检查变化。作为开发机器参考，在 Apple M5 Pro 上使用官方 Tysel 0.1.1 macOS arm64 工具链，对默认 `hello-service` 执行三次 `tysel build --release`，分别耗时 **0.24、0.33 和 0.16 秒**。测量涵盖 TypeScript 检查、打包、能力分析、可执行文件封装和发布验证材料生成，最终可执行文件约为 12.6 MiB。
+
+需要注意，示例代码包只有 143 字节，三次测量不足以代表大型项目的构建性能。这些结果只说明：使用已安装的工具链，打包这个小型应用可以在半秒内完成。测量不包含从 Rust 源码编译 Tysel 本身的时间。
+
+这些数字属于指定系统、指定版本和小型示例应用，并不代表所有配置或工作负载。因此，这些数据只能支持一个有限的结论：v0.1.1 参考服务在记录的 Linux 环境中体积为数十 MiB，并在数毫秒内达到就绪状态。
+
+## 所需能力要显式声明
+
+Tysel 默认拒绝访问。网络目标、机密信息名称、数据库、文件系统根目录和资源限额必须在带版本的 TOML 或 JSON 清单中请求。
+
+```toml
+[permissions]
+fetch = ["api.example.com"]
+secrets = ["API_TOKEN"]
+```
+
+清单并不拥有最终决定权。实际权限是应用授权、部署策略、执行配置和运行时支持的交集。添加权限无法突破更严格的部署或执行配置。
+
+这一模型对普通服务有用，对智能体软件更有价值。智能体可能需要调用模型、获取机密信息引用、访问一个 API 或写入特定存储。这些需求应成为可审查的约定，不能依赖进程环境中碰巧存在的资源。
+
+Tysel 的原生宿主管理套接字、存储连接、机密信息解析、文件系统句柄、限额和持久调度。应用 JavaScript 通过有明确访问限制的运行时 API 访问它们。换言之，权限仍由宿主管理。
+
+能力限制不等于所有执行配置都拥有同等强度的沙箱。`service` 执行配置适用于受信任的第一方代码，并与原生宿主共享进程。`isolated` 将执行移至单独工作进程，在 Linux 上增加 Landlock、seccomp 和资源限额。macOS 隔离是开发检查，而非生产安全检查；运维人员仍需负责操作系统加固和基础设施出站策略。
+
+## 运行时内置持久执行支持
+
+设想一个订单审批智能体：加载订单，调用模型创建草稿，休眠十分钟，再等待人工批准信号。AI 智能体和长时工作流有相当多的时间并未实际运行，而且进程可能在模型调用后、批准到达前重启。
+
+Tysel 为步骤、副作用、休眠、重试、回放安全的时间与随机数，以及外部信号提供明确的持久边界：
+
+```ts
+const draft = await ctx.effect("create-draft", () => createDraft(order));
+await ctx.sleep("10m");
+const decision = await ctx.waitForSignal("approval");
+```
+
+任务恢复时，已完成且已记录的边界会返回持久化结果，处理程序据此继续执行。只要结果已经保存，模型调用或外部写入就不必因为服务重启而再次执行。
+
+这项保证并不等于外部操作“恰好执行一次”。调用外部服务时仍应传入幂等键；持久存储仍是必须保护的运维状态；已部署代码必须为运行中任务保持现有持久边界的名称和顺序。默认 SQLite 存储不应由多个独立调度器同时驱动。Tysel 提供明确的恢复模型，但不声称取代分布式工作流平台。
+
+## 定位并非精简版 Node.js
+
+Tysel 以 Web API 为先：Fetch 风格 HTTP 处理程序、`Request`、`Response`、流（Streams）、Web Crypto，以及访问范围受限的 `globalThis.tysel` 宿主 API。它并非通用 Node.js 兼容层。
+
+原生插件、子进程、动态库、Node 内置模块和隐式操作系统访问都不属于应用约定。`tysel compat` 帮助团队在接入前发现依赖风险，但它只是早期报告，不能替代测试。
+
+如果唯一要求是把 JavaScript 或 TypeScript 编译为一个文件，Bun 和 Deno 也提供对应路径。如果首要要求是广泛兼容 Node.js，Node.js、Bun 或 Deno 通常更合适。Tysel 的区别是将二进制交付、显式宿主授权和持久工作流支持整合进同一套范围明确的应用模型。
+
+共有三种执行配置：
+
+- `service`：受信任的第一方代码，在进程内 QuickJS 隔离实例中运行；
+- `isolated`：单独工作进程，生产环境的沙箱检查仅在 Linux 上进行；
+- 实验性的 `component`：有边界的 Rust 或 Go Wasm Component 任务。
+
+## 从零到可执行文件
+
+已发布工具链目前支持 Linux 和 macOS 的 x64 与 arm64。Windows 用户可通过 WSL 运行。
+
+```sh
+curl -fsSL https://tysel.dev/install.sh | sh
+tysel doctor --install
+
+tysel init hello-tysel --yes
+cd hello-tysel
+tysel task verify
+tysel dev
+```
+
+服务准备交付时：
+
+```sh
+tysel task release
+./dist/hello-tysel
+```
+
+`dist/` 中的文件就是应用及其运行时。在 v0.1.1 中，构建以宿主平台为目标，因此 Linux 产物应在 Linux 构建，macOS 产物应在 macOS 构建；尚未实现交叉编译。
+
+## 现在谁应该尝试 Tysel？
+
+Tysel 尚未达到 1.0，因此 API 可能在次版本之间变化。现在可以试用、评估并参与后续设计；正式采用前，仍应验证应用兼容性，以及部署和运维要求。
+
+以下场景值得认真评估 Tysel：
+
+- 应以单个可执行文件部署的 TypeScript API 或任务处理器；
+- 必须限制网络、机密信息、文件和数据库访问的 MCP 工具或插件；
+- 能调用模型、暂停等待批准、休眠、重试，并在重启后恢复的智能体；
+- 重视校验和、SBOM、兼容性报告和可复现基准验证材料的发布流水线。
+
+Tysel 希望为这类工作负载提供一条更精简、更清晰、也更容易验证的生产交付路径。
+
+是否值得采用，取决于这些取舍是否符合你的应用需求。
+
+从 [tysel.dev](https://tysel.dev) 开始。<br />
+在 [GitHub](https://github.com/wangcch/tysel) 阅读源码。<br />
+通过[快速开始指南](https://tysel.dev/docs/getting-started/)构建第一个服务。
diff --git a/website/locales/zh-CN/content/blog/why-tysel-is-not-another-nodejs-runtime.mdx b/website/locales/zh-CN/content/blog/why-tysel-is-not-another-nodejs-runtime.mdx
new file mode 100644
index 0000000..05011a4
--- /dev/null
+++ b/website/locales/zh-CN/content/blog/why-tysel-is-not-another-nodejs-runtime.mdx
@@ -0,0 +1,142 @@
+---
+title: "为什么 Tysel 不是另一个 Node.js 运行时"
+description: "Tysel 同样运行 TypeScript，但更关注交付、权限与恢复的明确边界。这种定位与通用 JavaScript 环境有何不同？"
+author: "Tysel"
+date: "2026-09-03T12:00:00Z"
+cover: "/blog/why-tysel-is-not-another-nodejs-runtime/hero.jpg"
+coverAlt: "一条青柠色执行线上，巨大的开放圆环与紧凑的有界单元形成对比"
+tags:
+  - architecture
+  - typescript
+  - runtime
+---
+
+> 关键问题不是 Tysel 能否取代 Node.js，而是你的工作负载在生产环境中需要哪些能力和保证。
+
+把 Tysel 称为“Node.js 替代品”可以理解。两者在表面上确有重合：都能运行 JavaScript 应用、提供 HTTP 服务、调用远程系统，也都可以在目标机器无需单独安装运行时的情况下交付。
+
+最后一点很重要。现代 Node.js 拥有稳定的[权限模型](https://nodejs.org/api/permissions.html)，可限制文件系统、网络、子进程、工作线程、原生插件、WASI、FFI 和调试器访问。它也拥有[单可执行应用](https://nodejs.org/api/single-executable-applications.html)，可以将脚本嵌入 Node.js 二进制文件。[Bun 可以编译](https://bun.sh/docs/bundler/executables) TypeScript 或 JavaScript 入口、依赖和 Bun 运行时，生成独立可执行文件。Deno 也长期通过其[运行时安全模型](https://docs.deno.com/runtime/fundamentals/security/)明确声明 I/O 权限。
+
+因此，要理解 Tysel 的定位，需要看这些能力如何协同工作。Tysel 用同一套应用模型组织代码、权限、执行配置、恢复机制和发布验证材料。
+
+Tysel 是一个有意收窄范围的运行时，面向服务、任务处理器、MCP 工具、插件和持久智能体。开发者编写 TypeScript，构建工具检查项目配置和兼容性，再将应用与原生 Rust 宿主封装为一个可执行文件。
+
+应用 JavaScript 仍在嵌入式 QuickJS 隔离实例中运行。Tysel **不会**把 TypeScript 编译为原生机器码。“原生”描述的是宿主和交付产物，而不是新的 JavaScript 执行模型。
+
+## 换一种方式组织部署产物
+
+传统 Node.js 部署通常由多项内容组成：
+
+- 一个 Node.js 版本；
+- 应用源码或打包结果；
+- 生产依赖；
+- 包管理器和启动约定；
+- 文件系统和环境假设；
+- 用于承载这些内容的容器镜像或宿主。
+
+该模型灵活、成熟，适用于非常广泛的应用。它的优势在于环境几乎可以完成服务器进程需要的任何操作。
+
+Tysel 从相反的问题出发：一次部署能否只交付应用、经过验证的配置，以及按这些配置运行应用所需的运行时？
+
+`tysel build` 输出一个包含应用包、清单、源码映射、兼容性元数据和原生运行时的可执行文件。目标机器不需要 Node.js、npm、V8 或 `node_modules`。发布构建还会生成校验和、兼容性结果、聚焦运行时的 SBOM、运行时许可证清单和验证材料索引，作为独立审计伴随文件。
+
+即使可执行文件本身不算小，这种交付方式也能减少运维需要管理的内容：一个可以直接启动的产物、一套可检查的权限模型，以及一个与应用绑定的运行时版本。Node.js SEA、Bun 编译的可执行文件和 `deno compile` 已经解决了运行时安装的大部分问题。Tysel 关注的不只是文件格式：验证、兼容性、打包、权限和发布验证材料都纳入同一套构建检查。
+
+## 权限由宿主管理
+
+在通用服务器运行时中，代码通常通过隐式 API 访问文件系统、进程环境、网络、子进程和原生扩展。容器和操作系统策略可以收紧权限，但应用约定本身不一定逐项列出这些权限。
+
+Tysel 通过原生宿主管理网络、机密信息、数据库、文件系统句柄、限额和持久调度。权限可以来自具名清单授权、所选执行配置或部署方管理的配置。即使某个依赖包默认可以调用 Node.js API，应用也不会因此获得相应的宿主操作权限。
+
+对于清单控制的资源，实际权限不会超出请求范围，还可能进一步缩小：
+
+```text
+manifest request
+  ∩ deployment policy
+  ∩ execution profile
+  ∩ runtime support
+  = effective capability
+```
+
+这种区别对智能体软件尤其重要。智能体可能动态选择操作、处理不受信任的内容、调用模型，并且存活时间远长于一个 HTTP 请求。应用代码不应继承进程环境中恰好存在的所有凭据和文件系统路径。
+
+在 Tysel 中，这些资源需求可以在程序启动前接受审查：`fetch` 可访问的主机名、机密信息名称、数据库授权和文件系统根目录，都需要写入带版本的清单。
+
+完整模型请阅读[默认拒绝：为什么智能体需要显式能力](/blog/capability-by-default)。
+
+## 明确限定兼容范围
+
+Tysel 支持 TypeScript、符合其兼容性约定的 npm 包、Fetch 风格 HTTP，以及一组满足这些场景需求的 Web 标准全局对象。它不承诺支持完整的 Node.js API。
+
+Node.js 内置模块、原生插件、子进程、动态库和任意隐式操作系统访问都不属于 Tysel 应用模型。有些 npm 包打包后可以工作；另一些依赖 Node 特有行为，会被分类为不兼容或未知。兼容性分析为发布准入提供判断依据，不能替代应用测试。
+
+这是一项有意作出的设计取舍：限制兼容范围，才能明确应用可以调用哪些接口、访问哪些资源。
+
+实际工作流因此非常明确：
+
+```sh
+tysel check
+tysel compat --strict --deny-unknown
+tysel inspect
+```
+
+`check` 验证项目和能力使用，`compat` 对导入和依赖分类，`inspect` 打印实际权限和限额。兼容性成为发布流程可以检查的内容，而不是只能在部署后发现的问题。
+
+## QuickJS 是实现选择，不是产品本身
+
+QuickJS-ng 为 Tysel 提供适合嵌入、所需集成接口较少的 JavaScript 引擎。这有助于运行时将隔离实例封装进原生宿主，而无需引入通用 Node.js 环境。
+
+但仅将 V8 替换为 QuickJS 并不构成价值主张。单独嵌入一个引擎不会提供能力清单、发布验证材料、执行配置、持久历史、宿主管理的机密信息或构建准入。
+
+Tysel 在引擎之外还提供：
+
+- TypeScript 检查状态报告与应用打包；
+- 兼容性分析；
+- 受能力控制的宿主；
+- 有边界的执行配置；
+- 持久操作与恢复；
+- 可验证的发布产物集。
+
+QuickJS 支撑这些能力的实现，但引擎本身并不能替代整套应用模型。
+
+## Tysel 的适用场景
+
+如果希望简化部署，并明确限制应用可用的能力，可以在以下场景中评估 Tysel：
+
+- 以单个可执行文件交付的 TypeScript API 或任务处理器；
+- 需要审查出站主机和机密信息名称的 MCP 服务器；
+- 需要限制并发量和资源用量的定时服务或队列消费服务；
+- 能够休眠、等待批准、重试和恢复的持久智能体；
+- 应在权限收紧的执行配置下运行的插件或生成函数。
+
+如果应用依赖广泛的 Node.js 兼容性、原生插件、子进程、运行时代码生成，或假设可无限制访问 Node 内部机制的生态框架，那么 Tysel 并不适合。它也不是浏览器运行时、桌面应用框架，不能替代操作系统和网络加固。
+
+## 相似功能，不同约定
+
+比较这些运行时时，需要同时看功能及其使用条件。Node.js、Bun 和 Deno 已具备许多相似能力，Tysel 的区别主要在于如何将它们组合起来：
+
+- **受限 I/O。** Node.js 有稳定的可选权限模型；Deno 在通过命令行参数或交互提示获得授权前拒绝大多数 I/O。Tysel 将能力请求写入带版本清单，再通过部署策略、执行配置和运行时支持收紧。
+- **单个可执行文件。** Node.js SEA 嵌入脚本和资源；Bun 将应用包和运行时编译到一起；[`deno compile`](https://docs.deno.com/runtime/reference/cli/compile/) 嵌入程序与运行时。Tysel 将经过验证的应用包嵌入原生宿主，并在发布构建时输出审计伴随文件。
+- **威胁模型。** Node 的权限模型保护受信任代码；Deno 的原生库需要单独谨慎处理。Tysel 的 `service` 执行配置同样以进程内代码可信为前提；Linux `isolated` 增加工作进程边界，同时收回宿主能力。
+- **高层资源。** 通用运行时提供广泛 API。Tysel 通过清单授权、执行配置和部署配置，为宿主资源提供明确的权限来源。
+- **发布记录。** 通用运行时将验证材料和准入策略交给各项目。Tysel 发布构建会输出兼容性、运行时供应链、校验和及验证材料伴随文件。
+
+这种比较不是安全排名。Node.js 明确说明其权限模型是面向受信任代码的“安全带”，而非恶意代码沙箱。Deno 说明原生库会作为机器码在进程内运行。Tysel 自身的 `service` 执行配置也与宿主共享进程，适用于受信任的第一方代码。
+
+Tysel 更具体的区别在于组合：打包、能力请求、执行配置、持久恢复和发布验证材料都属于同一应用模型。该组合是否有价值，取决于工作负载。
+
+## 明确取舍，再选择运行时
+
+Tysel 不试图提供最多的 JavaScript API，而是希望让 TypeScript 应用从开发到上线的各个环节都更容易检查：
+
+```text
+write TypeScript
+declare authority
+verify compatibility
+ship one executable
+recover durable work
+```
+
+如果应用需要 Node.js 的灵活性，就应使用 Node.js。如果你的服务或智能体只需要有限的一组接口，希望显式管理权限，并将应用与运行时一起交付，就可以考虑 Tysel。
+
+先阅读 [Tysel 的工作原理](/docs/concepts/how-tysel-works)，再构建 [hello 服务](/docs/getting-started)。
diff --git a/website/locales/zh-CN/content/docs/capabilities/index.mdx b/website/locales/zh-CN/content/docs/capabilities/index.mdx
new file mode 100644
index 0000000..4db1f22
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/capabilities/index.mdx
@@ -0,0 +1,25 @@
+---
+title: "能力矩阵"
+description: "Tysel 拒绝访问未声明的资源。声明只代表请求，并非保证：执行配置和部署策略还可以进一步收紧权限。"
+---
+
+Tysel 拒绝访问未声明的资源。声明只代表请求，并非保证：执行配置和部署策略还可以进一步收紧权限。即使清单列出了面向宿主的能力，`isolated` 执行配置仍会拒绝这些能力。
+
+| 能力 | Service | Isolated | Component | 配置 |
+| --- | --- | --- | --- | --- |
+| HTTP 处理程序 | 支持 | 工作进程 IPC | 不支持；一次性任务 | `[server]` |
+| 出站 `fetch` | 白名单控制 | 不支持 | 不支持 | `permissions.fetch` |
+| 不透明机密信息句柄 | 支持 | 仅限代理句柄 | 不支持 | `permissions.secrets` |
+| SQLite / Postgres / Redis | 受授权约束 | 不支持 | 不支持 | 对应的权限/存储配置 |
+| 文件系统 | 受授权约束 | 不支持 | 读/写 WIT 导入 | 清单根目录 + Component 部署策略 |
+| 入站 WebSocket | 支持 | 不支持 | 不支持 | `server.websocket = true` |
+| 出站 WebSocket | 白名单控制 | 不支持 | 不支持 | `permissions.fetch` |
+| LLM 生成 | 支持 | 不支持 | 不支持 | 提供商环境变量 + 密钥 |
+| 持久处理程序 | 支持 | 由监督器执行 | 不支持 | `[durable]` |
+| 定时器、编码、随机数 | 支持 | 支持 | 受限的 WASI 时钟/随机数 | 仅受限额约束 |
+
+`service` 执行配置在进程层面受信任，但能力受到限制。Linux 隔离工作进程还会应用 Landlock、seccomp、资源限额和尽力而为的 cgroup 内存限制；macOS 隔离不是生产环境的安全边界。
+
+实验性的 Component 执行配置使用 `isolated-task` 信任模式。目前实现的应用能力只有 [`tysel:fs/read@0.4.0` 和 `tysel:fs/write@0.4.0`](/reference/component/capabilities)。实际导入、清单根目录和部署策略必须全部一致。
+
+使用 `tysel inspect` 查看生效的权限和限额。另请参阅[执行配置](/docs/concepts/execution-profiles)、[清单参考](/reference/manifest)和[生产运维](/docs/operations/production)。
diff --git a/website/locales/zh-CN/content/docs/compatibility/index.mdx b/website/locales/zh-CN/content/docs/compatibility/index.mdx
new file mode 100644
index 0000000..e8554c8
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/compatibility/index.mdx
@@ -0,0 +1,51 @@
+---
+title: "npm 兼容性"
+description: "Tysel 以 Web API 为先。它不追求普遍的 Node.js 兼容性；只有当 npm 包的运行时假设符合 Tysel 支持的 Web 与 ECMAScript 界面时，该包才能使用。"
+---
+
+Tysel 以 Web API 为先。它不追求普遍的 Node.js 兼容性；只有当 npm 包的运行时假设符合 Tysel 支持的 Web 与 ECMAScript 界面时，该包才能使用。
+
+## 检查项目
+
+```sh
+tysel compat
+tysel compat --json
+tysel compat --strict
+tysel compat --strict --deny-unknown
+```
+
+报告会扫描应用入口可见的直接包依赖和 Node 内置模块导入。
+
+| 状态 | 含义 |
+| --- | --- |
+| `compatible` | 已根据当前 Tysel 约定审查。 |
+| `shim` | 需要显式的 Web/Tysel 适配器。 |
+| `unsupported` | 依赖不可用的内置模块、原生插件或运行时模型。 |
+| `unknown` | 尚未审查，绝不会自动视为兼容。 |
+
+`--strict` 会拒绝不支持的依赖。`--deny-unknown` 还会拒绝未经审查的包。`--json` 输出 schema 版本 1，其中包含数量和原因。
+
+## 通常可以工作的包
+
+使用 ESM、标准 JavaScript 和 Web API，且不会检查或修改宿主环境的包，通常是合适的候选。路由器、schema 验证器、纯数据转换和协议库往往符合这一模型。
+
+## 无法工作的包
+
+- `fs`、`net`、`child_process` 和 `worker_threads` 等 `node:*` 内置模块；
+- Node 原生插件；
+- 子进程和 shell 执行；
+- 动态库加载；
+- CommonJS 加载器钩子和 Node 特有的模块解析行为；
+- 需要隐式访问文件系统、网络、进程或环境的依赖。
+
+Tysel 通过显式宿主能力提供存储、网络、密钥和文件系统操作，而不是使用 Node API。
+
+分类是一种早期预警，并非证明。接入门槛是：
+
+```sh
+tysel compat --strict
+tysel check
+tysel test
+```
+
+另请查看 [JavaScript API 参考](https://tysel.dev/reference/javascript/)，了解确切支持的 Web API 子集。
diff --git a/website/locales/zh-CN/content/docs/concepts/durable-execution.mdx b/website/locales/zh-CN/content/docs/concepts/durable-execution.mdx
new file mode 100644
index 0000000..0342844
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/concepts/durable-execution.mdx
@@ -0,0 +1,80 @@
+---
+title: "持久执行"
+description: "持久处理程序可以暂停执行、经受进程重启，并在恢复时避免重复已完成的工作。你仍然编写普通的 async 函数；Tysel 会保存从显式持久边界继续执行所需的状态。"
+---
+
+持久处理程序可以暂停执行、经受进程重启，并在恢复时避免重复已完成的工作。你仍然编写普通的 `async` 函数；Tysel 会保存从显式持久边界继续执行所需的状态。
+
+## 定义并启动处理程序
+
+```ts
+import type { DurableContext, TyselApp } from "@tysel/types";
+import type { TyselEnv } from "../tysel-env.js";
+
+const approvalFlow = async (
+  ctx: DurableContext,
+  input: { orderId: string },
+) => {
+  const order = await ctx.step("load-order", () => loadOrder(input.orderId));
+  const draft = await ctx.effect("create-draft", () => createDraft(order));
+
+  await ctx.sleep("10m");
+  const decision = await ctx.waitForSignal<{ approved: boolean }>("approval");
+
+  return { draft, approved: decision.approved };
+};
+
+export default {
+  durable: { approvalFlow },
+  async fetch(request, runtime) {
+    const started = runtime.durable.start("approvalFlow", {
+      orderId: new URL(request.url).searchParams.get("orderId")!,
+    });
+    return Response.json(started, { status: 202 });
+  },
+} satisfies TyselApp<TyselEnv>;
+```
+
+由 `tysel init` 创建的类型化项目已经包含 `tysel-env.d.ts`。修改持久存储或其他清单能力后，请运行 `tysel types`。
+
+`tysel.durable.start` 返回任务 ID，以及已完成或已暂停的状态。可通过 `tysel.durable.sendSignal(taskId, "approval", payload)` 发送外部事件。
+
+## 持久边界
+
+| API | 用途 |
+| --- | --- |
+| `ctx.step(name, operation)` | 记录确定性计算的结果。 |
+| `ctx.effect(name, operation)` | 记录外部副作用的结果。 |
+| `ctx.sleep(duration)` | 保存唤醒时间并释放执行资源。 |
+| `ctx.waitForSignal(name)` | 暂停，直至指定名称的信号被保存。 |
+| `ctx.retry(policy, operation)` | 记录有次数上限的尝试和延迟。 |
+| `ctx.now()` | 返回回放安全的时间值。 |
+| `ctx.random()` | 返回回放安全的随机值。 |
+
+持久边界必须按顺序 `await`。输入、信号载荷和结果必须可序列化为 JSON，且大小不得超过 1 MiB。
+
+## 回放模型
+
+任务恢复时，Tysel 会从头运行处理程序，并使用已保存的历史。已完成的具名边界直接返回其记录结果。只有当已记录的历史全部消费完毕后，新代码才会运行。
+
+因此：
+
+- 将外部调用和写操作放入 `effect`；
+- 为边界使用稳定且含义明确的名称；
+- 不要依据环境时间或随机数进行分支，请使用 `ctx.now()` 和 `ctx.random()`；
+- 保持现有边界顺序与正在执行的任务兼容；
+- 如果外部系统支持，应让下游副作用具有幂等性。
+
+持久执行可以防止 Tysel 有意重复一个已经完成并记录的副作用，但无法与任意外部服务建立原子事务。如果网络故障可能发生在外部提交与本地历史持久化之间，请使用提供商的幂等键。
+
+## 存储
+
+SQLite 是默认的持久存储：
+
+```toml
+[durable]
+store = "sqlite"
+path = "./data/tysel.db"
+```
+
+该存储属于运行状态。请进行备份、按敏感数据加以保护，并为相对路径设置明确的工作目录。不要让两个独立调度器同时使用同一个 SQLite 文件。恢复指南请参阅[生产运维](/docs/operations/production)，完整的重启与信号流程请参阅[持久智能体示例](https://github.com/wangcch/tysel/tree/main/examples/durable-agent)。
diff --git a/website/locales/zh-CN/content/docs/concepts/execution-profiles.mdx b/website/locales/zh-CN/content/docs/concepts/execution-profiles.mdx
new file mode 100644
index 0000000..7890e6b
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/concepts/execution-profiles.mdx
@@ -0,0 +1,59 @@
+---
+title: "执行配置"
+description: "执行配置决定应用代码在哪里运行，以及 Tysel 强制实施哪种信任边界。可通过 tysel.toml 或 tysel.json 中的 [app].profile 选择。"
+---
+
+执行配置决定应用代码在哪里运行，以及 Tysel 强制实施哪种信任边界。可通过 `tysel.toml` 或 `tysel.json` 中的 `[app].profile` 选择。
+
+## `service`
+
+第一方应用代码应使用 `service`。JavaScript 在服务进程内的隔离实例中运行。宿主资源仍然默认拒绝访问，必须在清单中获得授权，但应用代码与原生宿主共享进程。
+
+该配置支持完整的宿主能力，包括白名单控制的网络访问、SQLite、Postgres、Redis、文件系统根目录、LLM 提供商、入站和出站 WebSocket，以及持久处理程序。
+
+```toml
+[app]
+name = "orders"
+entry = "src/index.ts"
+profile = "service"
+```
+
+## `isolated`
+
+插件、生成的代码，以及其他不应与宿主共享进程的代码，应使用 `isolated`。应用 JavaScript 在单独的 `tysel-worker` 进程中运行。即使清单列出了面向宿主的网络、数据库、文件系统、LLM 和 WebSocket 能力，这些能力仍会被拒绝。
+
+```toml
+[app]
+name = "plugin"
+entry = "src/index.ts"
+profile = "isolated"
+```
+
+在 Linux 上，工作进程还会应用 Landlock 文件系统规则、seccomp 系统调用过滤、资源限额，以及尽力而为的 cgroup 内存限制。工作进程崩溃后，监督器会将其替换。macOS 支持开发阶段检查，但不作为生产隔离的安全边界。
+
+`isolated` 配置会收紧权限，但无法保证任意恶意原生代码的安全。Tysel 应用代码是由托管引擎执行的 JavaScript。原生插件、子进程、动态库和隐式操作系统访问不属于应用模型。
+
+## `component`
+
+实现 `tysel:component/task@0.4.0` 的 Wasm 组件应使用 `component`。清单入口指向一个 `.wasm` 组件，运行时通过有边界的 JSON 任务接口调用它。
+
+```toml
+[app]
+name = "echo-component"
+entry = "echo.component.wasm"
+profile = "component"
+```
+
+Component ABI 仍处于实验阶段，其范围有意小于 TypeScript 服务 API。组件是一次性 JSON 任务：`tysel run` 从 stdin 读取一次并向 stdout 写入一次；不支持 `tysel dev`。核心 Wasm 模块和通用 WASI 应用不属于该配置的支持范围。
+
+请从 [Wasm Component 参考](/reference/component)开始，再阅读 [Rust](/docs/guides/wasm-component-rust) 或 [Go](/docs/guides/wasm-component-go) 指南。
+
+## 选择执行配置
+
+| 需求 | 执行配置 |
+| --- | --- |
+| 第一方 HTTP 服务或持久智能体 | `service` |
+| AI 生成的函数或第三方 JavaScript 插件 | `isolated` |
+| 编译为 Wasm 组件、与语言无关的任务 | `component` |
+
+有关生产隔离要求，请阅读[安全模型](/docs/security)和[运维手册](/docs/operations/production)。
diff --git a/website/locales/zh-CN/content/docs/concepts/how-tysel-works.mdx b/website/locales/zh-CN/content/docs/concepts/how-tysel-works.mdx
new file mode 100644
index 0000000..83829f9
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/concepts/how-tysel-works.mdx
@@ -0,0 +1,60 @@
+---
+title: "Tysel 的工作原理"
+description: "Tysel 将 TypeScript 应用转换为自包含的原生可执行文件。"
+---
+
+Tysel 将 TypeScript 应用转换为自包含的原生可执行文件。该可执行文件包含应用程序包、经过验证的清单、源码映射、兼容性元数据，以及执行应用所需的原生运行时。
+
+## 从源码到可执行文件
+
+```text
+TypeScript source
+      │
+      ├─ type and compatibility checks
+      ├─ JavaScript bundle + source map
+      └─ validated tysel.toml or tysel.json
+                    │
+                    ▼
+          Tysel application package
+                    │
+                    ▼
+        native runtime + embedded package
+                    │
+                    ▼
+             one executable
+```
+
+`tysel build` 在当前宿主上完成打包。生成的文件在运行时不需要 Node.js、V8、npm 或 `node_modules`。这是经过验证的跨目标打包，并非原生运行时的交叉编译：当 `--target` 与宿主不同时，Tysel 会验证同版本的官方目标运行时，并将应用程序包嵌入该运行时存根。
+
+## 运行时的职责
+
+应用 JavaScript 在 QuickJS 隔离实例中执行。原生宿主管理网络套接字、存储连接、密钥、文件系统句柄、限额和持久调度。JavaScript 只能通过运行时 API 和应用清单中的授权访问这些资源。
+
+这种分工为 Tysel 建立了范围明确的应用约定：
+
+- 应用代码使用 Web 标准 API 和 `globalThis.tysel`；
+- 清单声明所需权限和资源限额；
+- 宿主验证并强制实施该约定；
+- 执行配置决定最终的信任边界。
+
+最终生效的权限是应用清单、部署策略、执行配置和运行时支持范围的交集。声明权限不会突破所选执行配置允许的范围。
+
+CLI 命令会从当前目录开始向上查找最近的清单，并以该项目根目录执行。TOML 和 JSON 共用一套带版本的 schema；`package.json` 是可选的。请参阅[项目与配置](/docs/concepts/projects-and-configuration)。
+
+## 请求与任务生命周期
+
+HTTP 应用导出 Fetch 风格的处理程序。Cron、Queue 和 MCP 处理程序使用相同的有边界执行环境。每次调用都有截止时间，并受已配置的内存、CPU 轮次、并发数、请求和响应限额约束。
+
+持久处理程序还会保存事件历史。持久边界会先记录结果，再继续执行，使运行时能够在任务休眠或等待信号时释放 JavaScript 隔离实例。进程重启后，已完成的边界从历史中回放，不会再次执行。
+
+## 开发与交付
+
+开发工具链包含三个协作工具：
+
+- `tysel`：提供项目、测试、构建、诊断和发布命令；
+- `tysel-service`：服务运行时和应用构建存根；
+- `tysel-worker`：隔离应用使用的受限工作进程。
+
+这些属于工具链实现细节。`tysel build` 会把选定的应用和运行时嵌入一个可交付的可执行文件中。
+
+接下来可以选择[执行配置](/docs/concepts/execution-profiles)、查看[清单](/reference/manifest)，或构建[第一个服务](/docs/getting-started)。
diff --git a/website/locales/zh-CN/content/docs/concepts/meta.json b/website/locales/zh-CN/content/docs/concepts/meta.json
new file mode 100644
index 0000000..66f8be6
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/concepts/meta.json
@@ -0,0 +1,9 @@
+{
+  "title": "了解 Tysel",
+  "pages": [
+    "how-tysel-works",
+    "projects-and-configuration",
+    "execution-profiles",
+    "durable-execution"
+  ]
+}
diff --git a/website/locales/zh-CN/content/docs/concepts/projects-and-configuration.mdx b/website/locales/zh-CN/content/docs/concepts/projects-and-configuration.mdx
new file mode 100644
index 0000000..a58adce
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/concepts/projects-and-configuration.mdx
@@ -0,0 +1,234 @@
+---
+title: "项目与配置"
+description: "Tysel 项目是恰好包含一个应用清单的目录：tysel.toml 或 tysel.json。两种格式使用相同的版本化模式。"
+---
+
+Tysel 项目是恰好包含一个应用清单的目录：`tysel.toml` 或 `tysel.json`。两种格式使用相同的版本化模式。相邻的 `package.json` 可有可无，并且绝不会覆盖 Tysel 配置。
+
+## 选择所需文件
+
+Tysel 不要求固定的项目布局。清单和应用入口组成运行时项目；包管理器、编译器和测试文件都是相互独立的附加项。
+
+| 文件 | 是否必需 | 用途 |
+| --- | --- | --- |
+| `tysel.toml` **或** `tysel.json` | 必须有一个 | 定义 Tysel 应用标识、入口、执行配置、权限、限制、服务器设置和项目任务。TOML 适合简洁的手工编辑，JSON 适合原生使用 JSON 的工具；两者行为相同。 |
+| 应用入口，例如 `src/index.ts` | 必需 | 由 `app.entry` 选择的 TypeScript、JavaScript 或 Wasm Component 代码。路径和文件名均可配置。 |
+| `package.json` | 可选 | npm 依赖、编辑器包和便捷脚本。Tysel 不会将其读取为运行时配置。 |
+| `tsconfig.json` 或 `tsconfig.tysel.json` | 执行时可选 | 控制 `tysel check` 使用的附加 TypeScript 编译器检查。`tsconfig.tysel.json` 优先，可将 Tysel 检查与现有项目配置分开。 |
+| `tests/*.test.ts` | 可选 | 由原生 `tysel test` 运行器执行的测试，不需要包脚本。 |
+
+常见组合如下：
+
+| 目标 | 命令 | 结果 |
+| --- | --- | --- |
+| 原生优先、不使用 npm 的项目 | `tysel init api --package-json none --yes` | 生成清单、源码、编译器配置和测试，不生成 `package.json`。 |
+| 最精简的生成项目 | `tysel init job --template minimal --package-json none --no-tests --yes` | 只生成清单、源码和编译器配置。 |
+| 带编辑器包的 TypeScript 项目 | `tysel init api --yes` | 创建 `package.json`，其中包含版本匹配的可选开发依赖。需要时使用偏好的包管理器安装。 |
+| 在现有项目旁添加 Tysel | `tysel init . --package-json reuse` | 保留现有包文件和源文件，并使用独立的 Tysel 入口与编译器配置。 |
+| 同时添加包脚本 | `tysel init . --package-json reuse --add-scripts` | 向现有包添加不冲突的 `tysel:*` 脚本。 |
+| 由 JSON 管理配置 | 向任意命令添加 `--manifest-format json` | 生成 `tysel.json`，而不是 `tysel.toml`；其他选择仍相互独立。 |
+
+这些选项可以按需组合。例如，一条命令即可让 MCP 工具使用 JSON，同时省略 `package.json` 和测试：
+
+```sh
+tysel init tool \
+  --template mcp \
+  --manifest-format json \
+  --package-json none \
+  --no-tests \
+  --yes
+```
+
+## 清单配置什么
+
+清单按职责组织，而不是按命令组织。只有包含 `name` 和 `entry` 的 `[app]` 是必需的；其他表均可省略，并会采用文档所述的默认值。
+
+| 表 | 常用字段 | 使用场景 |
+| --- | --- | --- |
+| 根级 | `schema_version` | 固定清单约定版本。版本 1 是当前唯一接受的值。 |
+| `[app]` | `name`、`entry`、`profile` | 选择产物、源码入口，以及 `service`、`isolated` 或 `component` 执行边界。 |
+| `[server]` | `listen`、`workers`、`http1`、`http2`、`websocket` | 修改入站监听地址、并发或协议集。它不会授予出站访问权限。 |
+| `[permissions]` | `fetch`、`secrets`、`postgres`、`redis`、`fs_read`、`fs_write` | 请求宿主能力。省略即表示拒绝，部署策略还可进一步拒绝。 |
+| `[limits]` | 内存、CPU、超时、并发、请求和响应大小 | 使用显式预算替换应用资源默认值。 |
+| `[durable]` | `store`、`path` | 选择由清单配置的持久存储及其相对于运行时的 SQLite 路径。 |
+| `[observability]` | `logs`、`traces`、`metrics` | 声明日志格式和遥测端点意图。部分导出控制仍通过环境配置。 |
+| <code>{"[tasks.<name>]"}</code> | `description`、`depends`、`steps` | 无需 shell 或 `package.json` 脚本即可组合可复现的 Tysel 命令。 |
+
+[完整清单字段索引](/reference/manifest#complete-field-index)列出了每个字段的类型、默认值、含义、运行时状态和详细参考页面。它还包括[跨字段规则](/reference/manifest#cross-field-rules)，以及 HTTP 服务、隔离工具和 Wasm Component 的起始配置。
+
+不要因为所有字段都存在就复制完整清单。请从 `[app]` 开始，仅在工作负载需要偏离默认值或请求权限时添加相应表。这样，审查者可以直接从差异中看出安全和资源边界，无需在样板配置中查找。
+
+## 项目发现
+
+感知项目的命令会从当前目录逐级向上查找最近的清单，因此可以从嵌套的源码目录中运行命令：
+
+```sh
+cd my-service/src/routes
+tysel check
+```
+
+使用全局 `-C/--project` 选项，可以在不更改 shell 目录的情况下选择其他项目：
+
+```sh
+tysel -C services/api check
+tysel -C services/api build --release
+```
+
+需要指定确切文件的自动化可以使用 `--manifest`：
+
+```sh
+tysel check --manifest services/api/tysel.json
+```
+
+`-C` 与 `--manifest` 互斥。同一目录中同时存在 `tysel.toml` 和 `tysel.json` 时，发现流程会失败；Tysel 绝不会隐式选择其中一个。
+
+发现的清单所在目录会成为项目根目录。CLI 项目命令以它为基准解析应用入口、SQLite 存储和文件系统根目录。打包后的可执行文件没有外部项目清单，因此其相对运行时路径以进程工作目录为基准解析。
+
+## 创建或采用项目
+
+在终端中，`tysel init` 会提供推荐的快速开始流程和可选的自定义流程：
+
+```sh
+tysel init
+```
+
+未提供路径时，交互流程会先询问是创建新项目，还是将 Tysel 添加到当前目录。创建新项目时还会询问目标目录。提供路径即可跳过这些问题：
+
+```sh
+tysel init my-service
+```
+
+使用方向键和 Enter 选择选项。不支持光标控制的基础终端会改用编号选项。
+
+对于生成的包，`init` 会检测最近的 npm、pnpm、Yarn 或 Bun 锁文件，并询问是否安装依赖。自动化可以明确选择：
+
+```sh
+tysel init my-service --package-manager pnpm --install --yes
+```
+
+添加 `--verify` 可在安装后运行 `tysel check`。交互流程选择安装时会询问是否验证，默认为是，并且只在安装成功后运行。生成的包要求检查中的 TypeScript 部分实际运行，而不能报告 `skipped`。无包项目可以立即验证：
+
+```sh
+tysel init job --package-json none --verify --yes
+```
+
+自定义流程会选择相互独立的维度：
+
+- HTTP 服务、队列工作进程、MCP 工具或最小模板；
+- TOML 或 JSON 清单；
+- 生成的或已有的应用入口；
+- 创建包、复用包或不使用 `package.json`；
+- 是否生成测试。
+
+选择 JSON 并不意味着使用 npm；不使用 `package.json` 也不会禁用 TypeScript 应用或原生测试运行器。
+
+自动化也可通过选项指定每项选择：
+
+```sh
+tysel init worker \
+  --template worker \
+  --manifest-format json \
+  --package-json none \
+  --no-tests \
+  --yes
+```
+
+使用 `--dry-run` 可在不写入文件的情况下打印完整变更计划。添加 `--diff` 可查看完整的统一差异文件内容，添加 `--json` 可获得机器可读计划，其中的变更包含 `before` 和 `after` 值。试运行不要求安装所选包管理器。
+
+`init` 会先检查每个目标，保留现有源码和配置，将缺失的 Tysel 条目合并到现有 `.gitignore`，并拒绝符号链接指向的修改目标。如果项目创建尚未完成就失败，已写入文件会回滚。后续包安装或验证失败时，已创建项目会保留，以供检查和重试。
+
+采用现有 JavaScript 或 TypeScript 项目时，Tysel 默认使用 `src/tysel.ts` 和 `tsconfig.tysel.json`。除非通过 `--add-scripts` 明确请求带命名空间的 `tysel:*` 脚本，否则它会保留 `package.json`：
+
+```sh
+tysel init . --dry-run
+tysel init . --dry-run --diff
+tysel init . --dry-run --json
+tysel init . --add-scripts
+```
+
+在 CI 中使用 `--no-interactive` 可禁用提示，同时保留文档规定的默认值。当所有已提供的选择都应直接接受而无需确认时，使用 `--yes`。
+
+### 包集成模式
+
+`--package-json` 只控制包伴随文件：
+
+| 模式 | 行为 |
+| --- | --- |
+| `auto` | 复用现有 `package.json`；不存在时创建。这是默认值。 |
+| `create` | 创建新包文件；如果已存在则失败。 |
+| `reuse` | 保留现有包文件；如果不存在则失败。 |
+| `none` | 即使 `package.json` 已存在，也不创建或修改它。 |
+
+`--add-scripts` 要求 `auto` 或 `reuse` 模式下存在包文件。它只添加缺失的 `tysel:*` 脚本，并拒绝替换冲突脚本。对于任意组合，都可使用 `--dry-run` 查看将要创建、保留、复用或更新的确切文件。
+
+## 检查和转换配置
+
+`config` 命令使用与执行相同的发现和验证路径：
+
+```sh
+tysel config path
+tysel config validate
+tysel config show
+tysel config show --format json
+tysel config schema
+```
+
+`config path` 会报告发现的文件但不解析它，这在修复无效清单时很有用。`config validate` 会报告格式、项目根目录、可选的包伴随文件和验证状态。`config show` 会打印展开默认值后的有效清单。
+
+在 TOML 与 JSON 之间转换有效配置：
+
+```sh
+tysel config convert --to json
+mkdir -p generated
+tysel config convert --to json --output generated/tysel.json
+```
+
+未提供 `--output` 时，转换结果写入标准输出。它绝不会覆盖文件，不会隐式创建父目录，并要求文件扩展名与请求的格式匹配。Tysel 还会拒绝创建第二个根清单，以免项目发现产生歧义。
+
+`tysel config schema` 会打印内置的 Draft 2020-12 JSON Schema，供编辑器、CI 和工具集成使用。运行时验证器仍是权威依据。
+
+新建 TOML 项目会包含 `.tysel/manifest.schema.json`，并在 `tysel.toml` 中包含以下标头：
+
+```toml
+#:schema .tysel/manifest.schema.json
+```
+
+启用 Taplo 的编辑器会使用本地模式完成字段补全和模式验证，无需下载。请将该模式纳入版本控制。对于现有项目，请导出已安装工具链的模式并添加标头：
+
+```sh
+mkdir -p .tysel
+tysel config schema > .tysel/manifest.schema.json
+```
+
+新项目会让 Git 看见此模式，同时忽略 `.tysel` 中的其他内容。如果现有项目忽略 `.tysel/`，请按顺序将以下规则追加到 `.gitignore`，使其他开发者检出代码后也能使用该模式：
+
+```text
+!.tysel/
+.tysel/*
+!.tysel/manifest.schema.json
+```
+
+升级工具链后请重新导出。JSON 项目可以通过编辑器的 JSON Schema 设置关联该模式；不要向 `tysel.json` 添加 `$schema` 属性，因为清单会拒绝未知字段。模式反馈不能取代 `tysel check`：授权语法和任务依赖检查也会使用运行时验证规则。
+
+## 可复现项目任务
+
+清单可以组合 Tysel 命令，无需依赖 shell 特有的引号规则或必需的 `package.json`：
+
+```toml
+[tasks.verify]
+description = "Check and test"
+steps = [["check"], ["test"]]
+
+[tasks.release]
+depends = ["verify"]
+steps = [["build", "--release"]]
+```
+
+```sh
+tysel task --list
+tysel task verify
+```
+
+依赖会按照依赖顺序执行一次。步骤从项目根目录使用同一清单运行。某个步骤失败会停止任务。为保持执行有界且可复现，步骤不能调用其他任务或覆盖项目选择，并且只接受[清单任务参考](/reference/manifest/tasks#step-commands)中列出的命令。
+
+接下来请阅读[入门指南](/docs/getting-started)、[CLI 参考](/reference/cli)或[清单参考](/reference/manifest)。
diff --git a/website/locales/zh-CN/content/docs/getting-started.mdx b/website/locales/zh-CN/content/docs/getting-started.mdx
new file mode 100644
index 0000000..0d58c18
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/getting-started.mdx
@@ -0,0 +1,125 @@
+---
+title: "快速开始"
+description: "创建、验证、运行并打包一个 HTTP 服务。"
+---
+
+创建、验证、运行并打包一个 HTTP 服务。
+
+## 安装
+
+```sh
+curl -fsSL https://tysel.dev/install.sh | sh
+tysel doctor --install
+```
+
+托管安装包含 Tysel CLI 和原生运行时。完成这条上手路径不需要 Rust、
+Node.js、npm，也不需要检出 Tysel 源码。
+
+## 创建并运行
+
+```sh
+tysel init hello-tysel --yes
+cd hello-tysel
+tysel task verify
+tysel dev
+```
+
+`--yes` 会采用生成的 HTTP 服务默认配置。在另一个终端中运行：
+
+```sh
+curl http://127.0.0.1:3000/hello
+```
+
+预期响应：
+
+```json
+{
+  "message": "Hello from Tysel",
+  "path": "/hello"
+}
+```
+
+按 `Ctrl-C` 停止开发服务器。
+
+如果要接入现有项目、使用其他模板或 JSON 清单，或者采用不同的包集成方式，
+请参阅[项目与配置](/docs/concepts/projects-and-configuration#choose-the-files-you-need)
+中的命令矩阵。
+
+## 编写 Fetch 处理函数
+
+生成的 `src/index.ts` 会导出一个 Fetch 风格的应用：
+
+```ts
+import type { TyselApp } from "@tysel/types";
+import type { TyselEnv } from "../tysel-env.js";
+
+export default {
+  async fetch(request) {
+    return Response.json({
+      message: "Hello from Tysel",
+      path: new URL(request.url).pathname,
+    });
+  },
+} satisfies TyselApp<TyselEnv>;
+```
+
+`tysel-env.d.ts` 根据清单生成。修改权限后，请刷新并验证它：
+
+```sh
+tysel types
+tysel types --check
+tysel check
+tysel compat
+```
+
+`compat` 报告依赖所作的环境假设，不能替代应用测试。
+
+## 授予能力
+
+出站资源在声明前默认不可访问。例如：
+
+```toml
+[permissions]
+fetch = ["api.example.com"]
+secrets = ["API_TOKEN"]
+```
+
+清单请求所需权限，执行配置和部署策略还可以进一步收紧权限。请参阅
+[清单字段索引](/reference/manifest#complete-field-index)和
+[能力矩阵](/docs/capabilities)。
+
+## 构建单个可执行文件
+
+```sh
+tysel task release
+./dist/hello-tysel
+```
+
+发布任务会先运行生成的验证流程，然后执行 `tysel build --release`。
+目标机器只需要这个可执行文件，无需 Node.js 或 `node_modules`。
+
+默认情况下，可执行文件面向当前宿主平台。托管安装也可以在验证并缓存版本相同的
+官方运行时后，为其他受支持的 Linux 或 macOS x64/arm64 目标打包：
+
+```sh
+tysel build --release --target linux-arm64 \
+  --output dist/hello-tysel-linux-arm64
+```
+
+验证并缓存该目标运行时后，可以使用 `--offline`。
+
+构建容器时，请使用监听地址为 `0.0.0.0:3000` 的完整清单。macOS 宿主可以先用
+`--target` 构建 Linux 可执行文件，再通过 `tysel image --binary` 传入该文件。
+请参阅[容器镜像](/docs/guides/container-image)。
+
+## 在 CI 中使用
+
+```sh
+tysel --error-format json check
+tysel compat --json --strict
+tysel test --json
+tysel build --release
+```
+
+致命 JSON 错误写入 stderr，测试和兼容性报告写入 stdout。部署前请阅读
+[生产运维](/docs/operations/production)。
diff --git a/website/locales/zh-CN/content/docs/guides/concurrency-backpressure.mdx b/website/locales/zh-CN/content/docs/guides/concurrency-backpressure.mdx
new file mode 100644
index 0000000..22da863
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/concurrency-backpressure.mdx
@@ -0,0 +1,92 @@
+---
+title: "并发与背压"
+description: "本指南配置服务工作线程和 HTTP 准入，使过载受到限制且清晰可见，而不会形成无界队列。"
+---
+
+本指南配置服务工作线程和 HTTP 准入，使过载受到限制且清晰可见，而不会形成无界队列。
+
+## 从一个工作线程开始
+
+每个 `service` 工作线程都有独立的 QuickJS 隔离实例、全局作用域和内存预算。应从一个工作线程开始，先将共享状态外置，再增加数量：
+
+```toml
+[server]
+workers = 1
+
+[limits]
+memory_mb = 128
+request_timeout_ms = 15000
+max_in_flight = 100
+max_request_mb = 4
+max_response_mb = 8
+```
+
+只有 `service` 执行配置允许 `workers` 在 1 至 64 之间。`isolated` 和 Component 应用要求 `workers = 1`。增加数量会成倍增加隔离实例内存预算，并不会让模块全局变量变为共享状态。
+
+## 理解准入许可
+
+HTTP 监听器共享 `max_in_flight`。Tysel 会在分派请求前尝试获取许可：
+
+- 没有许可时立即返回 HTTP `503`；
+- JSON 错误码为 `OVERLOADED`；
+- 响应包含 `Retry-After: 1`；
+- Tysel 不会创建无界等待队列；
+- 许可保持到响应正文完成或响应被丢弃；
+- 已接受的 WebSocket 会持续占用许可，直至升级后的连接关闭。
+
+将 `max_in_flight = 0` 会有意拒绝所有请求，可用作熔断器。零不表示无限制。
+
+## 选择初始值
+
+可使用测得的服务时间和目标吞吐量进行初步估算：
+
+```text
+in-flight demand ≈ peak requests/second × p95 service time in seconds
+```
+
+增加一个较小且明确的突发余量，再对完整部署进行负载测试。例如，每秒 200 个请求、p95 为 250 ms 时，可从约 50 个并发请求开始，再加上选定的突发余量。这只是容量估算假设，并非通用建议。
+
+如果 WebSocket 共用监听器，应为其预期并发生存期预留容量，或在运维层面拆分工作负载。少量持久套接字就可能长期耗尽较小的准入限额。
+
+## 验证过载行为
+
+运行服务，然后使用团队的负载工具生成超过配置限额的并发请求。直接检查响应约定：
+
+```sh
+curl -i http://127.0.0.1:3000/slow
+```
+
+过载期间，客户端应观察到如下响应：
+
+```http
+HTTP/1.1 503 Service Unavailable
+content-type: application/json
+retry-after: 1
+
+{"error":{"code":"OVERLOADED","message":"maximum in-flight request limit reached","requestId":"…"}}
+```
+
+只应自动重试幂等操作。调用方应使用有上限、带抖动的指数退避；`Retry-After: 1` 是最短时间提示，并非要求所有客户端同时重试。
+
+## 按正确顺序调优
+
+1. 限制请求和响应正文。
+2. 将请求截止时间设为短于调用方和 Ingress 的截止时间。
+3. 在具有代表性的 CPU、SQL、LLM 和流式工作负载下测量单个工作线程。
+4. 根据观察到的服务时间和可接受的排队程度设置准入限额。
+5. 只有处理程序无状态，且 CPU 或隔离实例调度已被证明是瓶颈时，才增加工作线程。
+6. 重新检查内存、启动时间、p95/p99 延迟、`503` 比例和 WebSocket 生存期。
+
+增加工作线程或 `max_in_flight` 可能加剧内存压力和尾延迟。两项设置都不能替代上游连接池、数据库边界、提供商并发限额或部署级 CPU 与内存控制。
+
+## 故障解读
+
+| 现象 | 可能的边界 | 处理方式 |
+| --- | --- | --- |
+| 立即返回 `503 OVERLOADED` | HTTP 准入已满 | 降低需求、缩短处理时间，或谨慎提高经过测量的限额。 |
+| `413 BODY_TOO_LARGE` | 请求正文限额 | 更早拒绝或分块；只有明确的载荷需求才提高限额。 |
+| `500 RESPONSE_TOO_LARGE` | 响应正文限额 | 分页、在边界内流式传输，或减少输出。 |
+| 运行时超时 | 处理程序截止时间 | 限制上游调用，并使 Ingress 截止时间长于 Tysel。 |
+| 增加工作线程后内存增长 | 每个隔离实例的预算倍增 | 减少工作线程或状态；确认外部存储和缓存策略。 |
+
+请参阅[应用限额](/reference/manifest/limits)、[限额与默认值](/reference/limits-and-defaults)以及[性能验证材料](/docs/performance)。
diff --git a/website/locales/zh-CN/content/docs/guides/container-image.mdx b/website/locales/zh-CN/content/docs/guides/container-image.mdx
new file mode 100644
index 0000000..4ce1b7d
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/container-image.mdx
@@ -0,0 +1,252 @@
+---
+title: "容器镜像"
+description: "最终镜像只包含一个 Tysel 可执行文件，运行时不需要 Tysel、Node.js、npm 或 node_modules。"
+---
+
+请选择以下一种镜像布局：
+
+| 布局 | 构建位置 | 适用场景 |
+| --- | --- | --- |
+| [多阶段 Dockerfile](#build-from-source-in-docker) | Docker 构建阶段 | 希望由 `docker build` 编译应用。 |
+| [仅运行时 Dockerfile](#package-an-existing-executable) | Docker 构建前的 Linux 构建作业 | 需要将已验证的可执行文件及其发布验证材料推进到部署阶段。 |
+| [`tysel image`](#generate-the-runtime-image) | Linux 宿主；使用 `--binary` 时除外 | 希望由 Tysel 生成仅运行时上下文。 |
+
+最终镜像只包含一个 Tysel 可执行文件，运行时不需要 Tysel、Node.js、npm 或 `node_modules`。
+
+## 容器清单
+
+Tysel 不会合并清单。复制完整的开发清单；如果其余生产设置完全相同，只修改监听地址：
+
+```sh
+cp tysel.toml tysel.container.toml
+```
+
+在 `tysel.container.toml` 中：
+
+```toml
+[server]
+listen = "0.0.0.0:3000"
+```
+
+不要用这段配置替换清单的其余部分。权限、限制、持久执行设置、可观测性和项目任务必须保留在完整文件中。`tysel build` 使用的清单会嵌入可执行文件。请参阅检入仓库的[开发清单](https://github.com/wangcch/tysel/blob/main/examples/hello-service/tysel.toml)和[容器清单](https://github.com/wangcch/tysel/blob/main/examples/hello-service/tysel.container.toml)。
+
+## 在 Docker 中从源码构建
+
+仓库中的 [Dockerfile](https://github.com/wangcch/tysel/blob/main/examples/hello-service/Dockerfile) 使用版本匹配的 Tysel 工具链镜像编译应用，然后只把可执行文件复制到运行时阶段：
+
+```dockerfile
+# syntax=docker/dockerfile:1
+ARG TYSEL_VERSION=VERSION
+ARG TYSEL_TOOLCHAIN_IMAGE=ghcr.io/wangcch/tysel-toolchain:${TYSEL_VERSION}
+ARG RUNTIME_IMAGE=gcr.io/distroless/cc-debian13:nonroot
+
+FROM ${TYSEL_TOOLCHAIN_IMAGE} AS build
+WORKDIR /src
+COPY . .
+
+RUN tysel task verify \
+    --manifest tysel.container.toml
+RUN tysel build --release \
+    --manifest tysel.container.toml \
+    --output /out/tysel-app
+
+FROM ${RUNTIME_IMAGE}
+# CI may add version, source, revision, and admitted artifact digest labels with
+# docker build --label. Do not substitute the registry image digest for the
+# executable digest from the verified .sha256 sidecar or `tysel image` output.
+WORKDIR /app
+COPY --from=build --chown=65532:65532 /out/tysel-app /app/tysel-app
+USER 65532:65532
+EXPOSE 3000
+ENTRYPOINT ["/app/tysel-app"]
+```
+
+从项目根目录构建：
+
+```sh
+docker build \
+  --build-arg TYSEL_VERSION=VERSION \
+  --tag hello-service:local .
+```
+
+将 `VERSION` 替换为准确的已发布 Tysel 版本。仓库中的 hello service 没有包依赖。工具链镜像包含 `tysel`、`tysel-service` 和 `tysel-worker`，不包含 Node.js 或 JavaScript 包管理器。
+
+如果应用包含 `package-lock.json`，请在独立的 Node 构建阶段安装锁定的依赖，并且只把 `node_modules` 复制到 Tysel 构建阶段：
+
+```dockerfile
+ARG TYSEL_VERSION
+FROM node:22-bookworm-slim AS dependencies
+WORKDIR /src
+COPY package.json package-lock.json ./
+RUN npm ci
+
+FROM ghcr.io/wangcch/tysel-toolchain:${TYSEL_VERSION} AS build
+WORKDIR /src
+COPY --from=dependencies /src/node_modules ./node_modules
+COPY . .
+RUN tysel task verify --manifest tysel.container.toml
+RUN tysel build --release \
+    --manifest tysel.container.toml \
+    --output /out/tysel-app
+```
+
+请使用项目要求的 Node 版本和锁定安装命令。不要跨操作系统复制宿主的 `node_modules`。
+
+对于包含工具链镜像支持的版本，发布工作流会将 `ghcr.io/wangcch/tysel-toolchain:VERSION` 发布为 Linux amd64/arm64 OCI 索引。它从同一批已签名的 Linux 发布归档组装而成，不会进行第二次 Cargo 构建。其 Debian 基础镜像通过多平台索引摘要固定。镜像仓库摘要是不可变的镜像标识；发布后解析版本标签，并在生产 Dockerfile 中固定该摘要。OCI 索引本身不受 Tysel 发布清单签名保护；镜像签名与镜像仓库准入仍属于独立的部署策略。
+
+GHCR 创建的新包默认为私有。在首次发布工具链镜像时，如果已发布的包无法匿名读取，工作流会有意停止。维护者必须在必要时将其关联到仓库，把可见性改为 Public，然后重新运行失败的发布作业。后续版本会沿用该包的可见性。
+
+这是构建镜像，并非应用运行时镜像。它以 root 身份运行，以便 Docker 构建在工作区中创建输出。不要将它部署为 HTTP 服务。上面的最终阶段仍以非 root 身份运行，且只包含生成的应用可执行文件。
+
+示例中检入仓库的 `.dockerignore` 如下：
+
+```text
+.git
+dist
+node_modules
+*.log
+.env*
+```
+
+多阶段布局不会把校验和、兼容性、SBOM、许可证和验证材料伴随文件导出到构建容器之外。如果这些文件是发布准入输入，请使用仅运行时布局。
+
+## 打包已有可执行文件
+
+面向部署架构构建完整产物集。这一步可以在 Linux 发布作业中运行，也可以在其他受支持的宿主上使用已验证的目标运行时：
+
+```sh
+tysel task verify --manifest tysel.container.toml
+tysel build --release \
+  --target linux-x64 \
+  --manifest tysel.container.toml \
+  --output dist/hello-service
+```
+
+hello-service 示例中检入了这个[仅运行时 Dockerfile](https://github.com/wangcch/tysel/blob/main/examples/hello-service/Dockerfile.runtime)：
+
+```dockerfile
+ARG RUNTIME_IMAGE=gcr.io/distroless/cc-debian13:nonroot
+FROM ${RUNTIME_IMAGE}
+WORKDIR /app
+COPY --chown=65532:65532 dist/hello-service /app/tysel-app
+USER 65532:65532
+EXPOSE 3000
+ENTRYPOINT ["/app/tysel-app"]
+```
+
+然后构建镜像：
+
+```sh
+docker build \
+  --file Dockerfile.runtime \
+  --tag registry.example/hello-service:VERSION .
+```
+
+在镜像外部将 `dist/hello-service` 与其五个发布伴随文件存放在一起。运行时镜像只需要可执行文件。
+
+## 生成运行时镜像
+
+`tysel image` 会生成同样的仅运行时 Dockerfile。
+
+| 调用方式 | 应用构建 | Docker 构建 |
+| --- | --- | --- |
+| `tysel image` | 是，在 Linux 上以发布模式构建 | 是 |
+| `tysel image --context-only` | 是，在 Linux 上以发布模式构建 | 否 |
+| `tysel image --binary PATH` | 否；复制 `PATH` | 是 |
+| `tysel image --binary PATH --context-only` | 否；复制 `PATH` | 否 |
+
+用一条命令构建应用和镜像：
+
+```sh
+tysel image \
+  --manifest tysel.container.toml \
+  --tag registry.example/hello-service:VERSION
+```
+
+生成上下文，以供检查或另行执行 Docker 构建：
+
+```sh
+tysel image \
+  --manifest tysel.container.toml \
+  --context-only \
+  --output-dir dist/image
+
+docker build --tag registry.example/hello-service:VERSION dist/image
+```
+
+打包已经准入的可执行文件，不重新构建：
+
+```sh
+tysel image \
+  --manifest tysel.container.toml \
+  --binary dist/hello-service \
+  --copy-sidecars \
+  --tag registry.example/hello-service:VERSION
+```
+
+`--binary` 要求提供带有嵌入式 TAP 元数据的 64 位小端 Linux x86-64 或 arm64 Tysel 可执行文件。嵌入的应用名称、执行配置和监听地址必须与所选清单一致。请使用 `tysel.container.toml` 构建 `dist/hello-service`；只把该清单传给 `tysel image` 并不充分。
+
+`--copy-sidecars` 会先验证校验和、兼容性、SBOM、许可证和验证材料文件，检查验证材料中的目标平台是否与可执行文件的 ELF 架构匹配，然后将这五个文件复制到生成的上下文中。Dockerfile 仍只把 `tysel-app` 复制到运行时镜像。此选项适用于需要在 Docker 构建上下文旁保留已准入验证材料的 CI 作业；它不会重新生成缺失的验证材料。
+
+可通过以下任一方式选择其他兼容 Docker 的构建器：
+
+```sh
+tysel image --builder podman --manifest tysel.container.toml
+DOCKER=/usr/local/bin/podman tysel image --manifest tysel.container.toml
+```
+
+`--builder` 的优先级高于 `DOCKER`；两者都只能指定一个可执行文件，不能包含内嵌参数。
+
+生成的 Dockerfile 会把可执行文件摘要、执行配置、运行时版本和应用标题记录为标签。有发布元数据时可一并添加：
+
+```sh
+tysel image \
+  --manifest tysel.container.toml \
+  --image-version VERSION \
+  --label org.opencontainers.image.source=https://github.com/OWNER/REPOSITORY
+```
+
+不要在标签中放入凭据或其他密钥。可执行文件摘要标签不能取代部署所用的镜像仓库摘要。标签值会按字面保留，包括 `$` 字符。
+
+`--base-image` 保持默认值时，`tysel image` 接受链接 glibc 的可执行文件和静态可执行文件，并拒绝 musl 解释器。使用自定义基础镜像时，Tysel 仍会验证 ELF 格式、架构和解释器结构，但无法推断该镜像包含哪些 libc 或共享库。此时兼容性由镜像作者负责。
+
+## 运行和探测
+
+```sh
+docker run --rm --publish 127.0.0.1:3000:3000 hello-service:local
+curl --fail http://127.0.0.1:3000/healthz
+```
+
+distroless 运行时不包含 shell 或 `curl`，因此请使用外部 HTTP 探针，而不要使用 exec 探针。Tysel 不会添加健康检查路由。
+
+## 运行时约定
+
+| 要求 | 设置 |
+| --- | --- |
+| 用户 | 保持数字用户/组 `65532:65532`。 |
+| 根文件系统 | 设为只读；只添加下述可写挂载。 |
+| 临时文件 | 挂载容量受限的 `tmpfs`，例如挂载到 `/tmp`。 |
+| SQLite 或相对文件系统路径 | 在以 `/app` 为基准解析出的路径挂载可写卷。 |
+| 密钥和数据库 URL | 在运行时注入环境变量，绝不要使用 Dockerfile `ARG` 或 `ENV`。 |
+| 健康检查 | 从容器外部通过 HTTP 探测应用路由。 |
+| 生产标识 | 推送版本标签，记录镜像仓库摘要，并按摘要部署。 |
+| 回滚 | 重新部署之前已准入的摘要；不要重新构建旧标签。 |
+
+不要把密钥放入 Dockerfile、构建参数、清单、镜像标签或源码树。
+
+## 错误
+
+| 错误 | 修复方式 |
+| --- | --- |
+| 服务必须监听 `0.0.0.0` 或 `[::]` | 使用容器清单构建，其中 `[server].listen` 使用未指定地址和非零端口。 |
+| 需要 Linux 可执行文件 | 运行 `tysel build --target linux-x64` 或 `--target linux-arm64`，然后通过 `--binary` 传入输出。 |
+| 可执行文件没有 TAP 元数据，或与所选清单不同 | 使用传给 `tysel image` 的同一份完整容器清单重新构建。 |
+| Component 执行配置被拒绝 | 使用 [Component 任务](/docs/operations/component-tasks)打包一次性可执行文件。 |
+| 发布伴随文件验证失败 | 使用 `tysel build --release` 重新构建产物；不要复制不完整或已修改的验证材料集。 |
+| 生成的文件已存在 | 选择其他输出目录，或检查后传入 `--force`。 |
+| 容器构建器无法启动 | 设置 `--builder` 或 `DOCKER`，或者添加 `--context-only` 并在其他位置构建上下文。 |
+| 容器启动但无法访问 | 对比嵌入的监听地址、`EXPOSE`、已发布端口和代理目标。 |
+| 可执行文件在运行时镜像中失败 | 确认其 ELF 解释器和原生库与所选基础镜像兼容。 |
+| 镜像架构错误 | 使 Tysel 构建目标、Docker `--platform` 和部署节点相匹配。 |
+
+另请参阅[构建与镜像命令](/reference/cli/delivery)、[可复现发布](/docs/guides/reproducible-release)和[生产运维](/docs/operations/production)。
diff --git a/website/locales/zh-CN/content/docs/guides/cron-queue.mdx b/website/locales/zh-CN/content/docs/guides/cron-queue.mdx
new file mode 100644
index 0000000..53f22bf
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/cron-queue.mdx
@@ -0,0 +1,104 @@
+---
+title: "Cron 与 Queue"
+description: "本指南注册一个 UTC 调度和一个具名 Queue 消费者，从 CLI 调用 Queue 路径，并在不引入第二种应用协议的情况下验证调度器。"
+---
+
+本指南注册一个 UTC 调度和一个具名 Queue 消费者，从 CLI 调用 Queue 路径，并在不引入第二种应用协议的情况下验证调度器。
+
+## 定义两个处理程序
+
+```ts
+import type { TyselApp } from "@tysel/types";
+
+interface Job {
+  id: string;
+  action: string;
+}
+
+export default {
+  async fetch() {
+    return Response.json({ queues: ["jobs"], cron: ["heartbeat"] });
+  },
+  tasks: {
+    heartbeat: {
+      kind: "cron",
+      expression: "*/5 * * * *",
+      async handler(context) {
+        console.log(JSON.stringify({
+          event: "heartbeat",
+          requestId: context.requestId,
+          deadlineMs: context.deadlineMs,
+        }));
+      },
+    },
+    processJob: {
+      kind: "queue",
+      name: "jobs",
+      async handler(message: Job, context) {
+        return {
+          accepted: true,
+          jobId: message.id,
+          action: message.action,
+          requestId: context.requestId,
+        };
+      },
+    },
+  },
+} satisfies TyselApp;
+```
+
+这个小型 HTTP 处理程序使模块在服务自有调度器运行时仍可通过 `tysel run` 启动；Queue 和 Cron 工作仍从任务平面进入，而不是通过该路由。
+
+导出键 `processJob` 是处理程序名称。`name: "jobs"` 是传给 `tysel queue` 的 Queue 地址。同一应用中，每个 Queue 名称只能注册一个消费者。
+
+## 验证并调用 Queue
+
+使用完整的[任务工作进程示例](https://github.com/wangcch/tysel/tree/main/examples/task-worker)：
+
+```sh
+cd examples/task-worker
+tysel check
+tysel queue jobs \
+  --input '{"id":"job_123","action":"reindex"}' \
+  --message-id msg_123
+```
+
+命令会打印 JSON 结果；输入格式错误、Queue 未知、超过截止时间或处理程序失败时以非零状态退出。消息和结果必须可序列化为 JSON，且各自限制为 1 MiB。
+
+`--message-id` 会成为任务幂等键。只有生产者表达同一条逻辑消息时才应复用它。处理程序副作用仍需由应用保证幂等；幂等键无法将任意外部写入变为恰好一次操作。
+
+## 运行调度器
+
+```sh
+tysel run
+```
+
+Cron 表达式包含五个字段，并按 UTC 计算：
+
+```text
+minute hour day-of-month month day-of-week
+```
+
+支持数字列表、范围和步长，不支持月份和星期名称。`0` 和 `7` 都表示星期日。日期和星期字段都受限制时，使用传统 Cron 的 OR 语义。
+
+快速验证时，可暂时把示例表达式改为 `* * * * *`，在下一个整分钟前启动服务，并观察 `heartbeat` 日志和运行时的 `cron task queued` 事件。随后恢复实际生产调度。
+
+本地调度器每秒轮询一次，每个 UTC 分钟对同一处理程序去重，最多补偿执行过去 24 小时的任务。有界 broker 已满时，它会保留游标，并随着容量恢复逐步准入到期工作。
+
+## 截止时间与故障
+
+Queue 和 Cron 任务使用 `limits.request_timeout_ms`。`context.deadlineMs` 是绝对 Unix 毫秒截止时间。开始可选的上游调用前应检查该值，并为每个依赖设置更短的超时。
+
+任务处理程序在有边界的任务工作进程路径上运行。进程重启不会使普通 Queue 或 Cron 处理程序具备持久性。需要持久化、回放、信号或恢复步骤时，请使用[持久 API](/reference/runtime/durable)。
+
+## 生产检查清单
+
+- 运维调度明确使用 UTC；
+- Queue 和 Cron 副作用具备幂等性；
+- 重试身份有意义时，由生产者提供稳定消息 ID；
+- 对处理程序失败、截止时间到期和到期工作延迟发出告警；
+- 不依赖超过 24 小时的本地 Cron 补偿执行；
+- 消息必须经受宿主丢失时，使用外部持久生产者；
+- 任务输入和输出保持在文档规定的协议限额内。
+
+请参阅[应用任务类型](/reference/runtime/application)、[`tysel queue`](/reference/cli/tasks#tysel-queue)和[任务限额](/reference/limits-and-defaults#application-task-and-mcp-bounds)。
diff --git a/website/locales/zh-CN/content/docs/guides/debugging.mdx b/website/locales/zh-CN/content/docs/guides/debugging.mdx
new file mode 100644
index 0000000..fecee1b
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/debugging.mdx
@@ -0,0 +1,96 @@
+---
+title: "调试"
+description: "本指南从 HTTP 错误信封追踪单个请求，定位开发源码信息和能力日志，然后用应用自行定义的生产响应替换不安全的运行时详情。"
+---
+
+本指南从 HTTP 错误信封追踪单个请求，定位开发源码信息和能力日志，然后用应用自行定义的生产响应替换不安全的运行时详情。
+
+## 在开发环境复现
+
+使用与故障部署相同的清单限额和权限运行服务：
+
+```sh
+tysel check
+tysel inspect
+tysel dev
+```
+
+`tysel dev` 会在打包 TypeScript 时生成源码映射，并用它解析处理程序故障。触发能够复现问题的最小请求，记录状态、响应错误码、固定宽度十六进制 `requestId`，以及匹配 JSON 日志中的 `rid`。
+
+未处理的抛出或被拒绝的处理程序会变为：
+
+```json
+{
+  "error": {
+    "code": "RUNTIME_ERROR",
+    "message": "...",
+    "requestId": "000000000000002a"
+  }
+}
+```
+
+响应 ID 使用十六进制，结构化日志的 `rid` 使用十进制。转换进制后，两者标识同一个进程本地请求。它们会在进程重启后重置，并非分布式追踪 ID。
+
+## 先判断边界
+
+| HTTP 状态与错误码 | 边界 | 首要处理 |
+| --- | --- | --- |
+| `413 BODY_TOO_LARGE` | 请求超过 `max_request_mb` | 在调用方拒绝或分块；只有明确测得的载荷需求才提高限额。 |
+| `500 RESPONSE_TOO_LARGE` | 缓冲响应超过 `max_response_mb` | 分页、在边界内流式传输，或减少输出。 |
+| `503 OVERLOADED` | `max_in_flight` 准入没有可用许可 | 对幂等工作退避，并检查服务时间和容量。 |
+| `500 RUNTIME_ERROR` | 处理程序、运行时、超时或能力失败 | 将请求与日志关联，并在相同权限下复现。 |
+| 正文最小化的 `500 INTERNAL_ERROR` | 错误信封序列化回退 | 保留宿主诊断，并按运行时故障处理。 |
+
+返回的 `Response` 由应用控制。只有未捕获的失败才使用运行时信封。能力日志会标识有边界的能力、操作，以及 `ok`、`denied` 或 `error` 结果，但不会公开 SQL、路径、URL 或密钥。
+
+## 理解源码映射范围
+
+源码映射在打包期间生成并嵌入应用程序包。目前开发服务器会解析映射并将其应用于 HTTP 故障。打包后的服务运行时尚未将嵌入映射接入 HTTP 分派器，因此生产环境的 `RUNTIME_ERROR` 可能包含生成的打包位置，而非原始 TypeScript 位置。
+
+每次部署都应保留确切的源码修订、锁文件、清单、可执行文件摘要和发布伴随文件。使用该修订在 `tysel dev` 下复现相同请求；不要依赖向客户端返回生产堆栈文本作为调试通道。
+
+Component 任务没有 HTTP 信封。成功时向 stdout 写入一个 JSON 值；ABI、策略、来宾、资源和输出验证失败写入 stderr，并以非零状态退出。来宾 WIT 错误文本是有长度限制、供人阅读的诊断，并非稳定错误码。
+
+## 在应用中映射预期错误
+
+应在应用可以选择安全状态和消息的最窄边界捕获失败。以下示例中，`route` 是应用现有路由器，记录的类别经过有意限制：
+
+```ts
+import type { TyselApp } from "@tysel/types";
+
+function safeCategory(error: unknown): "type" | "unexpected" {
+  return error instanceof TypeError ? "type" : "unexpected";
+}
+
+export default {
+  async fetch(request) {
+    try {
+      return await route(request);
+    } catch (error) {
+      console.error("request failed", safeCategory(error));
+      return Response.json(
+        { error: { code: "DEPENDENCY_UNAVAILABLE", message: "Try again later" } },
+        { status: 503 },
+      );
+    }
+  },
+} satisfies TyselApp;
+```
+
+`safeCategory` 必须保持有界；不要记录请求正文、Authorization 请求头、密钥值、连接 URL、SQL 或原始提供商响应。应将验证、未找到、冲突、拒绝和依赖失败映射为明确的应用错误码。开发期间让真正意外的故障保持未捕获，使其清晰可见。
+
+## 比较项目与打包后的行为
+
+关闭事件前，应测试两条执行路径：
+
+```sh
+tysel test --json
+tysel build --release --output dist/app
+./dist/app
+```
+
+项目命令从清单目录解析相对能力根目录；打包后的可执行文件从进程工作目录解析。`.env` 参与本地开发，但不会被打包。工作目录、注入密钥、Postgres URL、OTLP 配置、代理行为或操作系统权限的差异，通常可以解释“开发环境正常”的生产故障。
+
+CLI 和编辑器自动化应使用 `tysel --error-format json dev`。构建和运行时诊断更新以换行分隔的 JSON 写入 stderr；成功重新加载会发布空诊断数组，以清除过期错误。致命准备错误仍是一个 `TYSEL_CLI_ERROR` 对象，并以 `1` 退出。命令报告写入 stdout，因此应分别解析两个流。
+
+请参阅[错误与机器可读输出](/reference/errors-and-output)、[并发与背压](/docs/guides/concurrency-backpressure)和[生产事件响应](/docs/operations/production#incident-response)。
diff --git a/website/locales/zh-CN/content/docs/guides/examples.mdx b/website/locales/zh-CN/content/docs/guides/examples.mdx
new file mode 100644
index 0000000..fbd8cb3
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/examples.mdx
@@ -0,0 +1,98 @@
+---
+title: "示例库"
+description: "使用已安装 CLI 附带的模板创建新应用。模板会先创建项目，然后再进行验证或运行。"
+---
+
+使用已安装 CLI 附带的模板创建新应用。模板会先创建项目，然后再进行验证或运行：
+
+| 模板 | 用途 |
+| --- | --- |
+| `http` | Fetch 风格 HTTP 服务；推荐的默认选项。 |
+| `worker` | 包含一个具名 Queue 处理程序的服务。 |
+| `mcp` | 具有输入验证的隔离 MCP stdio 工具。 |
+| `minimal` | 用于自定义应用结构的最小 Fetch 处理程序。 |
+
+```sh
+tysel init my-service --template http --yes
+cd my-service
+tysel task verify
+tysel dev
+```
+
+可将 `http` 替换为 `worker`、`mcp` 或 `minimal`。使用 `tysel run` 运行 Worker；使用 `tysel mcp` 启动 MCP stdio 传输。包、清单格式、测试和现有项目选项请参阅 [`tysel init` 参考](/reference/cli/project#tysel-init)。
+
+下面是起始模板以外各项能力的完整参考应用。下载与已安装 Tysel 版本匹配的源码归档，然后进入所需示例：
+
+```sh
+version="$(tysel --version | awk '{print $2}')"
+curl -fsSL "https://github.com/wangcch/tysel/archive/refs/tags/v${version}.tar.gz" | tar -xz
+cd "tysel-${version}/examples/hello-service"
+```
+
+将 `hello-service` 替换为本页列出的其他示例目录。该命令下载版本匹配的应用源码，无需 fork、克隆仓库、构建 Tysel 或覆盖工作进程路径。Wasm Component 使用版本匹配的起始项目包。Postgres、LLM 和 MCP 示例需要 README 中说明的额外环境配置。
+
+## 按能力浏览
+
+标记为**可运行**的条目会链接到完整源码树。**参考配方**记录尚无独立仓库示例的受支持 API；不能把配方视为端到端验收路径。
+
+受信任的 `service` 执行配置目前公开 SQLite，其清单默认值为 `durable.store = "sqlite"` 和 `./data/tysel.db`。下表只列出各示例实际使用的能力，不重复未使用的执行配置默认值。将示例用于生产前，请使用 `tysel inspect` 审查完整的实际部署权限。
+
+| 能力 | 从这里开始 | 完整示例 | 覆盖范围 |
+| --- | --- | --- | --- |
+| HTTP 与 Fetch | [应用模块](/reference/runtime/application#http-handler) | [Hello service](https://github.com/wangcch/tysel/tree/main/examples/hello-service) | 可运行 |
+| Web API npm 路由器 | [npm 兼容性](/docs/compatibility) | [Hono API](https://github.com/wangcch/tysel/tree/main/examples/hono-api) | 可运行；扫描每项依赖 |
+| WebSocket | [服务网络](/docs/guides/service-networking) | [WebSocket service](https://github.com/wangcch/tysel/tree/main/examples/websocket-service) | 可运行 |
+| SQLite | [SQLite 指南](/docs/guides/sqlite) | [SQLite worker](https://github.com/wangcch/tysel/tree/main/examples/sqlite-worker) | 可运行 |
+| PostgreSQL | [PostgreSQL 指南](/docs/guides/postgresql) | [Postgres service](https://github.com/wangcch/tysel/tree/main/examples/postgres-service) | 可运行 |
+| Redis | [Redis 指南](/docs/guides/redis) | [Redis service](https://github.com/wangcch/tysel/tree/main/examples/redis-service) | 可运行 |
+| 文件系统 | [文件系统指南](/docs/guides/filesystem) | [Filesystem transform](https://github.com/wangcch/tysel/tree/main/examples/filesystem-transform) | 可运行 |
+| 密钥 | [宿主能力](/reference/runtime/capabilities#secrets) | [MCP tool](https://github.com/wangcch/tysel/tree/main/examples/mcp-tool) | 以代理句柄形式可运行 |
+| LLM | [LLM 网关](/docs/guides/llm-gateway) | [LLM service](https://github.com/wangcch/tysel/tree/main/examples/llm-service) / [Durable agent](https://github.com/wangcch/tysel/tree/main/examples/durable-agent) | 配置提供商后可运行 |
+| 测试 | [测试 API](/reference/runtime/testing) | — | 参考配方 |
+| Cron 与 Queue | [Cron 与 Queue 指南](/docs/guides/cron-queue) | [Task worker](https://github.com/wangcch/tysel/tree/main/examples/task-worker) | 可运行 |
+| MCP | [应用模块](/reference/runtime/application#mcp-tasks) | [MCP tool](https://github.com/wangcch/tysel/tree/main/examples/mcp-tool) | 可运行 |
+| 持久执行 | [持久 API](/reference/runtime/durable) | [Durable agent](https://github.com/wangcch/tysel/tree/main/examples/durable-agent) | 可运行 |
+| Wasm Component | [Component 参考](/reference/component) | [Rust echo](/docs/guides/wasm-component-rust) / [Go echo](/docs/guides/wasm-component-go) | 实验性可运行路径 |
+
+shell 执行、子进程、FFI 和动态库并不是缺失的示例，而是有意排除在 Tysel 应用约定之外。[能力矩阵](/docs/capabilities)记录了这些被拒绝的接口。
+
+## 从这里开始
+
+| 示例 | 演示内容 | 尝试 | 执行配置与实际使用的能力 |
+| --- | --- | --- | --- |
+| [Hello service](https://github.com/wangcch/tysel/tree/main/examples/hello-service) | Fetch 处理程序与单可执行文件构建 | 运行 `tysel run`，再执行 `curl http://127.0.0.1:3000/hello` | `service`；HTTP 与 Fetch |
+| [Hono API](https://github.com/wangcch/tysel/tree/main/examples/hono-api) | Web API 优先的 npm 路由器 | 安装 Hono 依赖，再运行 `tysel run` | `service`；HTTP 与 Hono；运行 `tysel compat` |
+| [WebSocket service](https://github.com/wangcch/tysel/tree/main/examples/websocket-service) | HTTP/1.1 升级与有边界的文本回显 | 运行 `tysel run`，再连接 `ws://127.0.0.1:3000/ws` | `service`；HTTP 与入站 WebSocket |
+
+## 任务
+
+| 示例 | 演示内容 | 尝试 | 执行配置与实际使用的能力 |
+| --- | --- | --- | --- |
+| [Task worker](https://github.com/wangcch/tysel/tree/main/examples/task-worker) | UTC Cron 注册与具名 Queue 消费者 | `tysel queue jobs --input '{"id":"job_123","action":"reindex"}'` | `service`；Cron 与 Queue |
+
+## 存储
+
+| 示例 | 演示内容 | 尝试 | 执行配置与实际使用的能力 |
+| --- | --- | --- | --- |
+| [SQLite worker](https://github.com/wangcch/tysel/tree/main/examples/sqlite-worker) | 持久计数器、相对于运行时的文件 | 运行 `tysel run`，再执行 `curl 'http://127.0.0.1:3000/?key=visits'` | `service`；SQLite |
+| [Postgres service](https://github.com/wangcch/tysel/tree/main/examples/postgres-service) | 具名授权；URL 保留在宿主中 | 设置 `TYSEL_POSTGRES_MAIN`，再运行 `tysel run` | `service`；PostgreSQL `main:read-write` |
+| [Redis service](https://github.com/wangcch/tysel/tree/main/examples/redis-service) | 具有有界操作的具名缓存授权 | 设置 `TYSEL_REDIS_CACHE`，再运行 `tysel run` | `service`；Redis `cache:read-write` |
+| [Filesystem transform](https://github.com/wangcch/tysel/tree/main/examples/filesystem-transform) | 独立固定根目录与有边界的 UTF-8 文件转换 | 运行 `tysel run`，请求 `/transform`，再检查 `output/result.json` | `service`；文件系统读写根目录 |
+
+## 智能体
+
+| 示例 | 演示内容 | 尝试 | 执行配置与实际使用的能力 |
+| --- | --- | --- | --- |
+| [Durable agent](https://github.com/wangcch/tysel/tree/main/examples/durable-agent) | LLM 副作用、暂停、重启、批准、单次保存 | 设置 LLM 端点后，在示例目录运行 `./demo.sh` | `service`；LLM、密钥、SQLite、持久执行 |
+| [MCP tool](https://github.com/wangcch/tysel/tree/main/examples/mcp-tool) | NDJSON MCP、验证、不透明机密信息句柄 | 在示例目录运行 `tysel mcp` | `isolated`；仅通过代理使用机密信息 |
+| [LLM service](https://github.com/wangcch/tysel/tree/main/examples/llm-service) | 宿主配置的提供商别名、token 用量、有边界 HTTP 适配器 | 设置提供商环境，再运行 `tysel run` | `service`；LLM 与提供商密钥 |
+
+## 隔离与 Wasm
+
+| 示例 | 演示内容 | 尝试 | 执行配置与实际使用的能力 |
+| --- | --- | --- | --- |
+| [Isolated plugin](https://github.com/wangcch/tysel/tree/main/examples/isolated-plugin) | 被拒绝的 fetch/fs 探测与工作进程替换 | 在示例目录运行 `tysel run` | `isolated`；面向宿主的能力保持拒绝 |
+| [Rust Component starter](/docs/guides/wasm-component-rust) | 一次性 JSON 任务，无隐式 WASI | `printf '{"value":42}' \| tysel run` | `component`；JSON 任务；无隐式 WASI；实验性 |
+| [Go Component starter](/docs/guides/wasm-component-go) | 使用已提交 Go 绑定的相同 world | `printf '{"value":42}' \| tysel run` | `component`；JSON 任务；无隐式 WASI；实验性 |
+
+将示例用于生产前，请审查[执行配置](/docs/concepts/execution-profiles)和[能力矩阵](/docs/capabilities)。
diff --git a/website/locales/zh-CN/content/docs/guides/filesystem.mdx b/website/locales/zh-CN/content/docs/guides/filesystem.mdx
new file mode 100644
index 0000000..c131206
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/filesystem.mdx
@@ -0,0 +1,116 @@
+---
+title: "文件系统"
+description: "本指南授予两个目录根，转换一个 UTF-8 JSON 文件，将结果写入独立输出根目录，并验证白名单之外的路径仍被拒绝。"
+---
+
+本指南授予两个目录根，转换一个 UTF-8 JSON 文件，将结果写入独立输出根目录，并验证白名单之外的路径仍被拒绝。
+
+## 准备根目录
+
+启动 Tysel 前先创建目录。运行时会将每个已配置根固定为目录，不会代为创建缺失的根目录：
+
+```sh
+mkdir -p input output
+printf '%s\n' '{"items":["alpha","beta"]}' > input/jobs.json
+```
+
+分别授予读写权限：
+
+```toml
+[app]
+name = "filesystem-transform"
+entry = "src/index.ts"
+profile = "service"
+
+[permissions]
+fs_read = ["./input"]
+fs_write = ["./output"]
+```
+
+项目命令从清单目录解析相对根目录，绝对根目录保持不变。打包后的可执行文件从进程工作目录解析相对运行时路径，因此生产环境必须设置稳定工作目录，或有意使用绝对部署根目录。
+
+`fs_read` 绝不隐含写权限，`fs_write` 也绝不隐含读权限。即使应用当前同时需要两者，也应保持分离。
+
+## 转换一个文件
+
+更新清单后生成能力环境：
+
+```sh
+tysel types
+```
+
+```ts
+import type { TyselApp } from "@tysel/types";
+import type { TyselEnv } from "../tysel-env.js";
+
+export default {
+  async fetch(_request, runtime) {
+    const source = await runtime.fs.read("input/jobs.json");
+    const input = JSON.parse(source) as { items: string[] };
+    const result = {
+      count: input.items.length,
+      items: input.items.map((item) => item.toUpperCase()),
+    };
+    await runtime.fs.write("output/result.json", JSON.stringify(result, null, 2));
+    return Response.json(result);
+  },
+} satisfies TyselApp<TyselEnv>;
+```
+
+运行完整的[文件系统转换示例](https://github.com/wangcch/tysel/tree/main/examples/filesystem-transform)：
+
+```sh
+cd examples/filesystem-transform
+tysel check
+tysel inspect
+tysel run
+```
+
+在另一个终端运行：
+
+```sh
+curl -sS http://127.0.0.1:3000/transform
+cat output/result.json
+```
+
+两个命令都会显示两个转换为大写的条目。
+
+## 理解路径限制
+
+该能力在 Unix 平台上只接受 UTF-8 普通文件。每次读写限制为 1 MiB。写操作会以模式 `0644` 创建或截断最终文件；父目录必须已存在。
+
+Tysel 会拒绝：
+
+- 空路径，或没有对应根目录的操作；
+- 位于所有已声明根目录之外的路径；
+- 根目录或请求路径中的 `..` 穿越；
+- 固定根目录下的符号链接和 magic link 穿越；
+- 目录、FIFO、设备、套接字和其他非普通文件；
+- 读取无效 UTF-8；
+- 大于 1 MiB 的读写。
+
+访问前会固定根目录描述符。启动后即使将已配置目录路径替换为符号链接，后续操作也不会被重定向到原根目录之外。
+
+无需修改清单即可验证拒绝行为：
+
+```ts
+try {
+  await tysel.fs.read("./tysel.toml");
+  throw new Error("unexpected filesystem grant");
+} catch (error) {
+  console.log(String(error)); // path is not permitted
+}
+```
+
+不要向不受信任的调用方返回原始文件系统错误。应结合请求 ID 记录有边界的能力失败，并返回应用自行定义的错误。
+
+## 执行配置与部署差异
+
+- `service` 可通过匹配的根目录使用 JavaScript 文件系统客户端。
+- `isolated` 即使列出根目录也会拒绝文件系统调用。
+- `component` 使用带版本的 WIT 导入，并且还需要明确的打包部署授权；请参阅 [Component 能力](/reference/component/capabilities)。
+- 原生 JavaScript 文件系统限制要求 Unix。Windows 用户应使用 WSL，不能依赖隐式 Win32 路径行为。
+
+应在操作系统层将生产根目录以只读或读写方式挂载，与清单保持一致；激活前创建输出目录；并将临时或不受信任的上传内容放在应用源码和可执行文件路径之外。
+
+请参阅[文件系统权限](/reference/manifest/permissions#filesystem)、[宿主能力](/reference/runtime/capabilities#filesystem)和[限额与默认值](/reference/limits-and-defaults#data-capabilities)。
diff --git a/website/locales/zh-CN/content/docs/guides/index.mdx b/website/locales/zh-CN/content/docs/guides/index.mdx
new file mode 100644
index 0000000..572afc7
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/index.mdx
@@ -0,0 +1,51 @@
+---
+title: "指南"
+description: "指南按目标组织。当你需要某个命令、清单字段或运行时 API 的完整约定时，请使用参考章节。"
+---
+
+指南按目标组织。当你需要某个命令、清单字段或运行时 API 的完整约定时，请使用参考章节。
+
+## 开始与开发
+
+| 目标 | 指南 | 你将验证的内容 |
+| --- | --- | --- |
+| 创建、测试、运行并打包 HTTP 服务 | [快速开始](/docs/getting-started) | 请求成功，且打包后的可执行文件无需 Node.js 即可运行。 |
+| 在不替换现有 Node 项目的情况下加入 Tysel | [创建或接入项目](/docs/concepts/projects-and-configuration#create-or-adopt-a-project) | 现有文件保持不变，Tysel 使用自己的编译器配置。 |
+| 查找或配置 `tysel.toml` 字段 | [完整清单字段索引](/reference/manifest#complete-field-index) | 类型、默认值、运行时状态、跨字段规则和起始配置。 |
+| 检查或转换 TOML 与 JSON 配置 | [检查并转换配置](/docs/concepts/projects-and-configuration#inspect-and-convert-configuration) | 展开的默认值和转换后的输出通过同一套 schema 验证。 |
+| 添加可复现的项目工作流 | [可复现的项目任务](/docs/concepts/projects-and-configuration#reproducible-project-tasks) | `tysel task verify` 运行有边界且不经过 shell 的步骤。 |
+
+## 服务、任务与智能体
+
+| 目标 | 从这里开始 | 必须遵守的边界 |
+| --- | --- | --- |
+| 构建 Fetch 风格的 JSON API | [第一个服务](/docs/getting-started#write-a-fetch-handler) | 使用 `service` 执行配置；本地响应不需要能力授权。 |
+| 配置 HTTP、h2c、WebSocket 和出站主机 | [服务网络](/docs/guides/service-networking) | 入站监听器和出站白名单是两道独立边界。 |
+| 确定服务工作线程数量并可预测地拒绝过载 | [并发与背压](/docs/guides/concurrency-backpressure) | 返回 `503 OVERLOADED`；WebSocket 会持续占用准入许可。 |
+| 注册 UTC 调度和 Queue 消费者 | [Cron 与 Queue](/docs/guides/cron-queue) | JSON 边界、截止时间、幂等性和有限补偿执行。 |
+| 在不暴露凭据的情况下路由 LLM 调用 | [LLM 网关](/docs/guides/llm-gateway) | 一个别名、宿主管理的密钥、超时和审计边界。 |
+| 转换限定根目录下的文件 | [文件系统](/docs/guides/filesystem) | 分离的 UTF-8 读写根目录；拒绝路径穿越和符号链接。 |
+| 持久保存本地应用状态 | [SQLite](/docs/guides/sqlite) | 一个由运行时管理的连接和稳定的部署卷。 |
+| 连接远程关系数据库 | [PostgreSQL](/docs/guides/postgresql) | 一个具名授权、宿主注入的 URL 和最小权限数据库角色。 |
+| 添加有边界的缓存和临时键值状态 | [Redis](/docs/guides/redis) | 一个具名授权、宿主注入的 URL 和受限命令集。 |
+| 将函数公开为 MCP 工具 | [MCP 示例](/docs/guides/examples#agents) | 注册 MCP 任务；隔离示例把密钥值保留在宿主中。 |
+| 运行生成或第三方 JavaScript | [隔离插件示例](/docs/guides/examples#isolation-and-wasm) | Linux 是生产隔离的安全目标。 |
+| 为重试、时间或人工批准暂停执行 | [持久执行](/docs/concepts/durable-execution) | 持久存储和回放安全边界。 |
+| 构建语言无关的一次性任务 | [Rust Component](/docs/guides/wasm-component-rust)或 [Go Component](/docs/guides/wasm-component-go) | 实验性的 `tysel:component/task@0.4.0`；受限 WASI。 |
+
+## 交付与运维
+
+| 目标 | 指南 | 关键限制 |
+| --- | --- | --- |
+| 选择产物与部署边界 | [部署选择](/docs/operations/deployment) | Tysel 输出可执行文件或 OCI 上下文；平台资源仍由部署方管理。 |
+| 构建单个可执行文件 | [构建单个可执行文件](/docs/getting-started#build-one-executable) | 为当前宿主或经过验证的 Linux/macOS x64/arm64 运行时构建。 |
+| 编写或生成容器镜像 | [容器镜像](/docs/guides/container-image) | 选择源码构建或仅运行时 Dockerfile；嵌入式监听器必须可从容器外访问。 |
+| 导出结构化日志、追踪和指标 | [可观测性](/docs/guides/observability) | OTLP 环境变量是当前生效的运行时控制。 |
+| 关联并安全定位生产故障 | [调试](/docs/guides/debugging) | 打包后的 HTTP 错误目前没有源码映射。 |
+| 验证并签名应用产物集 | [可复现发布](/docs/guides/reproducible-release) | 验证材料绑定单次构建；不保证跨宿主字节一致。 |
+| 诊断、升级或回滚工具链 | [安装生命周期](/docs/install#diagnose) | 托管操作会同时作用于三个开发工具。 |
+| 审查生产就绪状态 | [生产运维](/docs/operations/production) | 发布验证材料、平台范围、恢复和监控均属于准入检查。 |
+
+## 如何使用指南
+
+请针对你准备部署的版本运行命令。在每个边界验证结果，尽量减少清单权限，并沿链接进入 [API 参考](/reference)，查看默认值、错误和不支持的行为。单个片段不够时，[示例库](/docs/guides/examples)会指向完整源码目录。
diff --git a/website/locales/zh-CN/content/docs/guides/llm-gateway.mdx b/website/locales/zh-CN/content/docs/guides/llm-gateway.mdx
new file mode 100644
index 0000000..64d7264
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/llm-gateway.mdx
@@ -0,0 +1,97 @@
+---
+title: "LLM 网关"
+description: "本指南将一个面向应用的模型别名路由到 OpenAI 兼容的 Responses 端点，同时将提供商凭据保留在宿主中。"
+---
+
+本指南将一个面向应用的模型别名路由到 OpenAI 兼容的 Responses 端点，同时将提供商凭据保留在宿主中。
+
+## 声明凭据名称
+
+```toml
+[app]
+name = "llm-service"
+entry = "src/index.ts"
+profile = "service"
+
+[permissions]
+secrets = ["OPENAI_API_KEY"]
+
+[limits]
+request_timeout_ms = 30000
+```
+
+清单只包含密钥名称。Tysel 在宿主内部解析其值，不会向 JavaScript 暴露明文凭据。
+
+## 配置一条提供商路由
+
+```sh
+export OPENAI_API_KEY='replace-in-your-secret-manager'
+export TYSEL_LLM_ENDPOINT='https://api.openai.com/v1/responses'
+export TYSEL_LLM_MODEL='provider-model-name'
+export TYSEL_LLM_ALIAS='default'
+export TYSEL_LLM_SECRET='OPENAI_API_KEY'
+```
+
+`TYSEL_LLM_ENDPOINT` 用于启用网关。设置后必须同时提供 `TYSEL_LLM_MODEL`。端点必须使用 HTTP 或 HTTPS，并指向 OpenAI 兼容的 Responses API。`TYSEL_LLM_ALIAS` 默认为 `default`，也是应用唯一可以使用的模型字符串。当前打包配置公开一条提供商路由。
+
+`TYSEL_LLM_SECRET` 默认为 `OPENAI_API_KEY`。其值必须同时是已声明的 `permissions.secrets` 条目和宿主提供的环境变量。不要把凭据写入 `tysel.toml`、端点 URL、源码或日志。
+
+## 生成响应
+
+```ts
+const result = await tysel.llm.generate({
+  model: "default",
+  system: "Return one concise sentence.",
+  input: "Summarize the deployment status.",
+  maxOutputTokens: 128,
+  temperature: 0.2,
+});
+
+console.log(result.output);
+console.log(result.usage.input_tokens, result.usage.output_tokens);
+console.log(result.provider_request_id);
+```
+
+运行完整的 [LLM 服务示例](https://github.com/wangcch/tysel/tree/main/examples/llm-service)：
+
+```sh
+cd examples/llm-service
+tysel check
+tysel run
+```
+
+在另一个终端运行：
+
+```sh
+curl -sS http://127.0.0.1:3000/generate \
+  -H 'content-type: application/json' \
+  -d '{"prompt":"Explain bounded capabilities in one sentence."}'
+```
+
+响应包含提供商输出、token 用量和可选的提供商请求标识符。应用的 `Input` 和 `Output` 泛型可以改善静态类型，但不会在运行时验证提供商 JSON。
+
+## 理解边界
+
+- `temperature` 必须是 `0` 至 `2` 之间的有限数值；
+- 提供 `maxOutputTokens` 时，其值必须为正数；
+- 序列化后的网关输入和输出各自限制为 1 MiB；
+- 模型、提供商和提供商请求标识符限制为 128 字节；
+- 网关默认允许 16 个并发提供商调用；
+- 实际超时使用 `limits.request_timeout_ms`，并被限制在 1 ms 至网关最大值 10 分钟之间；
+- 未知别名会被拒绝，不会发送到上游。
+
+运行时审计事件会记录请求 ID、别名、提供商名称、输入/输出字节数、耗时和结果，不会记录凭据或提示词内容。宿主保留的提供商错误文本限制为 4 KiB；不要向不受信任的客户端返回原始提供商错误。
+
+## 诊断故障
+
+| 故障 | 检查项 |
+| --- | --- |
+| 网关已禁用 | `TYSEL_LLM_ENDPOINT` 未设置或为空。 |
+| 启动时配置失败 | 端点无效或缺少 `TYSEL_LLM_MODEL`。 |
+| 模型被拒绝 | 应用 `model` 不等于 `TYSEL_LLM_ALIAS`。 |
+| 凭据不可用 | 密钥名称未声明、未提供，或与 `TYSEL_LLM_SECRET` 不同。 |
+| 超时 | 准入或提供商处理超过应用请求超时。 |
+| 提供商失败 | 端点、协议兼容性、身份验证或上游响应失败。 |
+| 输入/输出过大 | 减少或分块请求；使结果保持在固定边界内。 |
+
+对于持久智能体，应将提供商调用放在 `ctx.effect` 内，避免回放期间重复已完成的调用。请参阅[持久智能体示例](https://github.com/wangcch/tysel/tree/main/examples/durable-agent)、[LLM API](/reference/runtime/capabilities#llm-generation)和[环境变量](/reference/environment#llm-provider)。
diff --git a/website/locales/zh-CN/content/docs/guides/meta.json b/website/locales/zh-CN/content/docs/guides/meta.json
new file mode 100644
index 0000000..5c6c679
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/meta.json
@@ -0,0 +1,21 @@
+{
+  "title": "指南",
+  "pages": [
+    "index",
+    "examples",
+    "service-networking",
+    "concurrency-backpressure",
+    "cron-queue",
+    "llm-gateway",
+    "filesystem",
+    "sqlite",
+    "postgresql",
+    "redis",
+    "container-image",
+    "observability",
+    "debugging",
+    "reproducible-release",
+    "wasm-component-rust",
+    "wasm-component-go"
+  ]
+}
diff --git a/website/locales/zh-CN/content/docs/guides/observability.mdx b/website/locales/zh-CN/content/docs/guides/observability.mdx
new file mode 100644
index 0000000..998812f
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/observability.mdx
@@ -0,0 +1,123 @@
+---
+title: "可观测性"
+description: "本指南启用结构化 JSON 日志和 OTLP/HTTP 追踪与指标，在采集器中验证每种信号，并维持 Tysel 的脱敏与低基数边界。"
+---
+
+本指南启用结构化 JSON 日志和 OTLP/HTTP 追踪与指标，在采集器中验证每种信号，并维持 Tysel 的脱敏与低基数边界。
+
+## 启用结构化日志
+
+JSON 日志由打包清单控制：
+
+```toml
+[observability]
+logs = "json"
+```
+
+每个 HTTP 请求会向 stderr 写入一个 JSON 对象，其中包含 `ts`、`app`、`method`、`path`、`status`、`ms` 和 `rid`。经过审计的能力调用使用 `capability`、`operation`、`result` 和相同的进程本地 `rid`，从而可以关联请求及其能力活动。
+
+日志记录器会省略查询字符串、请求与响应头、正文、SQL、文件系统路径、出站 URL 和密钥值。能力、操作和结果标签使用固定白名单；意外值会变为 `redacted`。即便如此仍应限制日志访问，因为路由名称和时间信息也属于运维数据。
+
+除不区分大小写的 `json` 外，其他 `logs` 值都会禁用这些 JSON 行，但不会禁用 OTLP。
+
+## 启用 OTLP 导出
+
+当前实际运维控制使用标准环境变量，而非清单中的 `observability.traces` 和 `observability.metrics` 字段。通过 OTLP/HTTP 采集器启用两种信号：
+
+```sh
+export OTEL_EXPORTER_OTLP_ENDPOINT=http://127.0.0.1:4318
+tysel run
+```
+
+只启用一种信号时，只设置对应端点：
+
+```sh
+export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://127.0.0.1:4318/v1/traces
+```
+
+```sh
+export OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=http://127.0.0.1:4318/v1/metrics
+```
+
+Tysel 使用带 protobuf 载荷的 OTLP over HTTP。端点必须以 `http://` 或 `https://` 开头，最长 2 KiB，且不能包含用户信息、查询参数或片段。身份验证信息应放入采集器集成使用的标准 OTLP headers 环境变量，绝不能写入端点 URL 或清单。
+
+设置 `OTEL_SDK_DISABLED=true` 会禁用追踪和指标，即使仍有过期端点变量。端点未设置或为空时，不会启用相应信号。通过验证后，共享端点和信号专用端点的解析由 OpenTelemetry exporter 处理；应针对采集器验证确切路径。
+
+## 了解输出约定
+
+Tysel 发布以下仪器：
+
+| 信号 | 名称 | 属性 |
+| --- | --- | --- |
+| Counter | `tysel.http.server.requests` | service、method、数字状态码、状态类别 |
+| Histogram（ms） | `tysel.http.server.duration` | 相同 HTTP 属性 |
+| Counter | `tysel.capability.calls` | service、capability、operation、result |
+| Histogram（ms） | `tysel.capability.duration` | 相同能力属性 |
+| Server span | `http.server.request` | HTTP 属性，以及可用时的 `tysel.request.id` |
+| Internal span | `tysel.capability` | 能力属性，以及可用时的 `tysel.request.id` |
+
+资源包含 `service.name` 和 Tysel 运行时 `service.version`。指标有意省略请求 ID，以避免高基数时间序列。Span 和 JSON 日志可以携带进程本地 ID；该 ID 不是全局唯一追踪或业务标识符。
+
+## 发布前验证
+
+Tysel 运行时不依赖 OpenTelemetry Collector。应选择符合环境的方式：
+
+- 已有 OTLP/HTTP 后端时，将 Tysel 端点变量指向它，并在该平台检查信号；
+- 可选的本地验证使用下述仓库 `otelcol-contrib` 配置；
+- 不需要遥测时，保持端点变量未设置，也不需要 Collector。
+
+本地配置只监听 `127.0.0.1:4318`，并使用 Collector 的详细 debug exporter。在仓库根目录验证并启动兼容的 `otelcol-contrib` 二进制文件：
+
+```sh
+otelcol-contrib validate --config examples/filesystem-transform/otel-collector.yaml
+otelcol-contrib --config examples/filesystem-transform/otel-collector.yaml
+```
+
+在另一个终端运行完整文件系统示例。其 `/transform` 路由执行一次文件读取和一次写入，因此会产生 HTTP 与能力遥测：
+
+```sh
+cd examples/filesystem-transform
+mkdir -p input output
+printf '%s\n' '{"items":["alpha","beta"]}' > input/jobs.json
+export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://127.0.0.1:4318/v1/traces
+export OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=http://127.0.0.1:4318/v1/metrics
+tysel run
+```
+
+从第三个终端调用路由：
+
+```sh
+curl --fail http://127.0.0.1:3000/transform
+```
+
+采集器 debug 输出应包含 `http.server.request`、`tysel.capability`、`tysel.http.server.requests`、`tysel.http.server.duration`、`tysel.capability.calls` 和 `tysel.capability.duration`。追踪会批量发送，指标会定期导出，因此不一定在 `curl` 后立即出现。应等待配置的导出间隔，再正常停止 Tysel 以发送两个遥测提供器中缓冲的数据，然后才能判断信号缺失。
+
+确认以下各项：
+
+1. 服务名称与 `[app].name` 一致；
+2. 请求和能力信号均已到达；
+3. 状态、方法、能力、操作和结果使用有界标签；
+4. 不包含 token、SQL 文本、正文、查询字符串、文件系统路径或出站 URL；
+5. 正常停止 Tysel 时，会在进程退出前发送遥测提供器中缓冲的数据。
+
+随后断开采集器并验证部署策略。导出失败必须在采集器或宿主监控中可见；不能只依靠遥测判断就绪状态。
+
+Debug exporter 是本地验证工具，不是生产遥测后端。生产环境应通过与其他基础设施相同的供应链策略固定并批准采集器版本和镜像。
+
+## 构建有效告警
+
+应针对持续 5xx 比例、相对于已配置请求超时的延迟、意外的 `denied` 或 `error` 能力结果、进程重启、内存压力和采集器导出缺失发出告警。数据库饱和度、距最近一次备份的时间和持久任务的逾期时长应由其所属系统监控；Tysel 目前不导出到期唤醒任务的逾期时长指标。
+
+不要从 `path`、`rid`、用户 ID、URL、SQL、异常消息或其他无界输入派生指标标签。应使用追踪和受限日志进行有边界的调查。
+
+## 排查导出问题
+
+| 现象 | 检查项 |
+| --- | --- |
+| 有 JSON 日志但没有 OTLP | 已明确设置端点，且 `OTEL_SDK_DISABLED` 不为 `true`。 |
+| 有追踪但没有指标 | 已配置共享或指标专用端点，且采集器已启用指标摄取。 |
+| 启动时报告 OTLP 配置无效 | 移除 URL 凭据、查询参数、片段、不支持的协议，或缩短过长端点。 |
+| 采集器返回未授权 | 将凭据移至 OTLP headers，并确认服务管理器注入时没有记录凭据。 |
+| 指标时间序列过多 | 移除下游基于路径或 ID 的重新标记；只使用输出的固定属性。 |
+
+请参阅[环境变量](/reference/environment#opentelemetry)、[可观测性清单字段](/reference/manifest/durable-observability#observability)和[生产监控](/docs/operations/production#monitoring-and-alerts)。
diff --git a/website/locales/zh-CN/content/docs/guides/postgresql.mdx b/website/locales/zh-CN/content/docs/guides/postgresql.mdx
new file mode 100644
index 0000000..1c2c800
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/postgresql.mdx
@@ -0,0 +1,100 @@
+---
+title: "PostgreSQL"
+description: "本指南授予一个具名 PostgreSQL 连接，由宿主注入 URL，使用参数化 SQL，验证只读强制检查，并为生产部署准备连接。"
+---
+
+本指南授予一个具名 PostgreSQL 连接，由宿主注入 URL，使用参数化 SQL，验证只读强制检查，并为生产部署准备连接。
+
+## 声明名称，而非 URL
+
+```toml
+[app]
+name = "postgres-service"
+entry = "src/index.ts"
+profile = "service"
+
+[permissions]
+postgres = ["main:read-write"]
+```
+
+授权格式为 `name:read-write` 或 `name:read-only`；省略模式表示 `read-write`。版本 1 最多接受一个 PostgreSQL 授权。名称以小写字母开头，后续使用小写字母、数字、`_` 或 `-`。
+
+URL 由部署环境提供：
+
+```sh
+export TYSEL_POSTGRES_MAIN='postgres://app:password@db.example.com:5432/app?sslmode=require'
+```
+
+将授权名称转为大写，并把 `-` 替换为 `_`：`review-ro` 映射到 `TYSEL_POSTGRES_REVIEW_RO`。`tysel dev` 可以从 `.env` 读取该选定值，但打包部署应通过服务管理器或密钥管理器注入。绝不要把 URL 写入清单、CLI 参数、构建产物或日志。
+
+## 执行参数化 SQL
+
+```ts
+await tysel.postgres.exec(
+  "INSERT INTO jobs (id, state) VALUES ($1, $2) " +
+    "ON CONFLICT (id) DO UPDATE SET state = EXCLUDED.state",
+  ["job_123", "ready"],
+);
+const rows = await tysel.postgres.query(
+  "SELECT id, state FROM jobs WHERE id = $1",
+  ["job_123"],
+);
+```
+
+`exec` 返回受影响行数，`query` 返回行对象。参数接受 `null`、布尔值、有限数值和字符串。数组和对象不能直接绑定。schema 使用 JSON、UUID、时间戳或其他数据库特有类型时，应有意进行类型转换或序列化。
+
+运行完整的 [Postgres 服务](https://github.com/wangcch/tysel/tree/main/examples/postgres-service)：
+
+```sh
+cd examples/postgres-service
+export TYSEL_POSTGRES_MAIN='postgres://app:password@127.0.0.1:5432/app'
+tysel config validate
+tysel check
+tysel run
+```
+
+访问 `http://127.0.0.1:3000/`。响应包含插入的问候行。
+
+## 强制只读访问
+
+只执行查询的应用可使用：
+
+```toml
+[permissions]
+postgres = ["main:read-only"]
+```
+
+宿主会在发送 SQL 前拒绝所有 `tysel.postgres.exec` 调用。每次 `query` 都在 `BEGIN READ ONLY` 中运行；尝试通过 `query` 执行写 SQL 同样会失败。PostgreSQL 只读违规使用安全消息 `postgres connection is read-only (SQLSTATE 25006)`。
+
+将示例授权切换为只读并调用处理程序，以验证该边界。其建表或 upsert 必须失败。只有实际负责 schema 或数据修改的部署角色才应恢复读写权限。
+
+只读强制检查属于应用边界，不能替代数据库角色。URL 使用的数据库用户应具有与清单模式匹配的 PostgreSQL 权限。
+
+## 连接池、类型与边界
+
+运行时为已配置授权维护最多四个 PostgreSQL 连接，并复用健康的空闲会话。获取连接会在应用调用截止时间内等待可用槽位。URL 要求 TLS 时，连接建立过程使用会验证证书的原生 TLS。
+
+| 接口项 | 边界 |
+| --- | ---: |
+| SQL 文本 | 1 MiB |
+| 参数数 | 999 |
+| 返回行数 | 10,000 |
+| 序列化结果 | 1 MiB |
+| 运行时连接数 | 4 |
+
+返回列目前支持 null、布尔值、整数、浮点数、文本兼容值和字节值。数据库特有类型不受支持时，应在 SQL 中将其转换为受支持的表示。数据库错误只公开有长度限制的 SQLSTATE，不会公开服务器的完整错误详情；连接和 TLS 失败仍属于运维诊断，不应直接返回给客户端。
+
+## 生产检查清单
+
+- 要求使用经过证书验证的 TLS，并验证部署 URL；
+- 将 URL 存储在密钥管理器中，防止其进入日志；
+- 使清单模式与最小权限 PostgreSQL 角色保持一致；
+- 将 schema 迁移作为独立、受控的部署步骤执行；
+- 按每个进程四个连接为数据库和外部代理确定容量；
+- 将语句和 Ingress 截止时间设置为短于调用方超时；
+- 监控连接获取延迟、SQLSTATE 类别、饱和度、行数和结果大小；
+- 使用确切驱动路径测试数据库故障转移和连接重建。
+
+应用 PostgreSQL 与持久事件存储变量 `TYSEL_DURABLE_POSTGRES_URL` 相互独立。即使两者指向同一服务器，也应根据各自的数据所有权进行配置和恢复。
+
+请参阅 [Postgres 权限](/reference/manifest/permissions#postgres)、[环境变量](/reference/environment#application-capabilities)和[数据能力限额](/reference/limits-and-defaults#data-capabilities)。
diff --git a/website/locales/zh-CN/content/docs/guides/redis.mdx b/website/locales/zh-CN/content/docs/guides/redis.mdx
new file mode 100644
index 0000000..c993046
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/redis.mdx
@@ -0,0 +1,48 @@
+---
+title: "Redis"
+description: "Tysel 提供一套有意保持精简的 Redis API，用于缓存条目、幂等键和短期协调状态。"
+---
+
+Tysel 提供一套有意保持精简的 Redis API，用于缓存条目、幂等键和短期协调状态。任意 Redis 命令、Lua 脚本、Pub/Sub、stream 和集群路由不属于版本 1 的支持范围。
+
+## 声明具名授权
+
+```toml
+[app]
+name = "redis-service"
+entry = "src/index.ts"
+profile = "service"
+
+[permissions]
+redis = ["cache:read-write"]
+```
+
+URL 由部署环境提供：
+
+```sh
+export TYSEL_REDIS_CACHE='rediss://app:password@redis.example.com:6380/0'
+```
+
+本地开发使用 `redis://`，生产环境使用经过证书验证的 `rediss://`。绝不要把 URL 或凭据写入清单或构建产物。
+
+## 使用有边界的 API
+
+```ts
+const previous = await tysel.redis.get("job:123");
+await tysel.redis.set("job:123", "running", { ttlSeconds: 300 });
+const present = await tysel.redis.exists("job:123");
+const extended = await tysel.redis.expire("job:123", 600);
+const removed = await tysel.redis.del("job:123", "job:124");
+```
+
+`get` 返回 UTF-8 字符串或 `null`。`set` 接受可选 TTL。`exists` 和 `expire` 报告键是否存在；`del` 返回删除的键数。`read-only` 授权只允许 `get` 和 `exists`。
+
+| 接口项 | 边界 |
+| --- | ---: |
+| 键 | 4 KiB |
+| 值 | 1 MiB |
+| 每次 `del` 的键数 | 128 |
+| TTL | 1 秒至 365 天 |
+| 并发操作数 | 4 |
+
+运行时复用一个多路复用连接，并在连接断开后自动重连。该 API 仅适用于 `service` 执行配置。除清单访问模式外，还应使用 Redis ACL，明确配置服务器端内存和淘汰策略；除非部署具备经过测试的持久化与恢复方案，否则应将 Redis 视为可丢弃存储。
diff --git a/website/locales/zh-CN/content/docs/guides/reproducible-release.mdx b/website/locales/zh-CN/content/docs/guides/reproducible-release.mdx
new file mode 100644
index 0000000..975f063
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/reproducible-release.mdx
@@ -0,0 +1,162 @@
+---
+title: "可复现发布"
+description: "面向生产环境的操作系统和架构进行构建。"
+---
+
+## 构建产物集
+
+面向生产环境的操作系统和架构进行构建：
+
+```sh
+tysel doctor --install
+tysel task verify
+tysel inspect
+tysel build --release --target linux-arm64 --output dist/orders
+```
+
+当请求的目标平台与宿主不同时，Tysel 会先对同版本的官方运行时存根进行身份验证并缓存，然后再打包。只有在该目标运行时已经验证并缓存后，才应使用 `--offline`。
+
+| 文件 | 准入用途 |
+| --- | --- |
+| `orders` | 嵌入了应用和清单的原生可执行文件。 |
+| `orders.sha256` | 可执行文件的 SHA-256。 |
+| `orders.compat.json` | 运行时与包的兼容性判定。 |
+| `orders.sbom.cdx.json` | CycloneDX 1.5 SBOM。 |
+| `orders.licenses.json` | 运行时组件许可证清单。 |
+| `orders.evidence.json` | 将产物、目标平台、应用、兼容性、SBOM、许可证和运行时清单关联起来的索引。 |
+
+将全部六个文件存放在以可执行文件摘要标识的位置。不要重命名或编辑其中任何文件，也不要单独重新生成某个伴随文件。
+
+## 签名
+
+在离线签名主机上创建新的私钥。以下命令会拒绝替换已有密钥：
+
+```sh
+set -eu
+key_path=/secure/offline-release.key
+test ! -e "$key_path"
+umask 077
+openssl rand -hex 32 > "$key_path"
+```
+
+私钥文件必须满足以下约定：
+
+| 属性 | 必需值 |
+| --- | --- |
+| 编码 | UTF-8 文本，恰好包含 64 个十六进制字符。 |
+| 密钥材料 | 32 个由密码学安全随机数生成器产生的字节。 |
+| 文件类型 | 普通文件，包含空白字符在内不超过 256 字节。 |
+| Unix 权限 | 组和其他用户的权限位必须全部取消；接受 `0600`。 |
+
+查看其公开身份信息：
+
+```sh
+tysel release key-info --key /secure/offline-release.key
+```
+
+JSON 输出包含 `key_id`、`algorithm` 和 `public_key`。将这些值加入发布授权方的信任策略，然后签名：
+
+```sh
+tysel release sign dist/orders \
+  --key /secure/offline-release.key
+```
+
+该命令会先验证产物集，再写入 `orders.evidence.sig.json`。私钥不得进入仓库、构建目录、命令日志或运行时主机。
+
+## 信任策略
+
+`deploy/trust.json` 是由部署方管理的输入，并非 `tysel build` 生成的文件。其结构如下：
+
+```json
+{
+  "policy_version": 1,
+  "issued_at_unix": 1788278400,
+  "expires_at_unix": 1790870400,
+  "keys": [
+    {
+      "key_id": "64_HEX_CHARACTERS_FROM_KEY_INFO",
+      "algorithm": "ed25519",
+      "public_key": "64_HEX_CHARACTERS_FROM_KEY_INFO",
+      "status": "active",
+      "valid_from_unix": 1788278400
+    }
+  ]
+}
+```
+
+请替换所有示例值。`key_id` 从公钥派生；请从 `tysel release key-info` 复制这两个值。
+
+| 字段 | 规则 |
+| --- | --- |
+| `policy_version` | 必须为 `1`。 |
+| `issued_at_unix` | 以 Unix 秒表示的策略签发时间。 |
+| `expires_at_unix` | 必须晚于签发时间，且与签发时间相差不超过 90 天。 |
+| `keys` | 不得为空，并按 `key_id` 排序。 |
+| `algorithm` | 必须为 `ed25519`。 |
+| `status` | `active`、`retired` 或 `revoked`。 |
+| `valid_from_unix` | 接受该密钥签名的最早时间。 |
+| `valid_until_unix` | 已停用密钥必须设置；活跃密钥可省略。 |
+
+将信任策略视为经过身份验证的部署配置。保留已撤销密钥的墓碑记录，并将密钥轮换作为只能向前推进的策略变更进行审查。
+
+## 验证
+
+```sh
+tysel release verify dist/orders \
+  --trust deploy/trust.json
+```
+
+验证内容包括：
+
+- 可执行文件及每个发布伴随文件；
+- 验证材料与签名的摘要；
+- 签名算法和密钥 ID；
+- 密钥状态及有效期；
+- 策略有效期和签名时间；
+- SBOM 与许可证清单的一致性。
+
+只要出现字节变更、伴随文件缺失、密钥已撤销、策略已过期、签名时间来自未来或清单不一致，验证就会以拒绝告终。
+
+## 验证部署目标
+
+`release verify` 会验证验证材料中的目标平台，但部署流程必须提供预期的目标平台：
+
+```sh
+expected_target=linux-x64
+test "$(jq -r '.artifact.target' dist/orders.evidence.json)" = "$expected_target"
+```
+
+arm64 部署请使用 `linux-arm64`。在复制可执行文件或构建镜像前，拒绝空值、未知值或不匹配的值。
+
+OCI 镜像签名是独立环节。构建镜像后，应用镜像仓库策略，并记录镜像摘要与可执行文件摘要之间的映射。
+
+## 发布记录
+
+记录以下信息：
+
+| 输入 | 值 |
+| --- | --- |
+| 源码 | 提交和清单修订版本 |
+| 依赖 | 锁文件摘要 |
+| 工具链 | 已安装的 Tysel 版本 |
+| 构建 | 规范目标平台和命令 |
+| 产物 | 可执行文件与验证材料索引的摘要 |
+| 容器 | 使用容器时，记录基础镜像和最终镜像的摘要 |
+| 签名 | 密钥 ID、信任策略摘要和验证时间 |
+
+不要记录私钥、密钥值、数据库 URL、OTLP 标头或提供方凭据。
+
+验证材料能够证明一个可执行文件及其伴随文件属于同一集合。它并不承诺任意构建主机生成的应用二进制文件逐字节相同。
+
+## 验证错误
+
+| 错误 | 必需响应 |
+| --- | --- |
+| 可执行文件或伴随文件摘要不匹配 | 隔离完整文件集并重新构建。 |
+| 兼容性报告不匹配 | 使用一个通过准入的 Tysel 版本重新构建。 |
+| 缺少 SBOM 或许可证清单 | 拒绝准入，并恢复不可变的完整文件集。 |
+| 已签名目标与部署目标不同 | 面向预期平台和架构重新构建。 |
+| 信任策略已过期 | 发布一份新的、经过身份验证且自当前时间起有效的策略。 |
+| 签名密钥已撤销 | 停止部署，离线轮换密钥，然后按策略重新构建，或为留存且已验证的产物重新签名。 |
+
+另请参阅[发布验证材料命令](/reference/cli/evidence)、[构建命令](/reference/cli/delivery#tysel-build)和[生产构建准入](/docs/operations/production#build-admission)。
diff --git a/website/locales/zh-CN/content/docs/guides/service-networking.mdx b/website/locales/zh-CN/content/docs/guides/service-networking.mdx
new file mode 100644
index 0000000..75a3e94
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/service-networking.mdx
@@ -0,0 +1,136 @@
+---
+title: "服务网络"
+description: "本指南以明确方式公开 Tysel 服务：选择监听器和 HTTP 协议，启用 WebSocket 升级，授予出站目标，并在部署前验证失败路径。"
+---
+
+本指南以明确方式公开 Tysel 服务：选择监听器和 HTTP 协议，启用 WebSocket 升级，授予出站目标，并在部署前验证失败路径。
+
+## 前置条件
+
+- 已安装 Tysel，且 `tysel doctor --install` 检查通过；
+- 入站 WebSocket 和出站网络访问使用 `service` 执行配置；
+- 公网 HTTPS 使用负责 TLS 终止的 Ingress 或反向代理；
+- 可选安装 `websocat` 或其他 WebSocket 客户端，用于验证升级。
+
+## 配置监听器
+
+开发期间从回环地址上的 HTTP/1.1 开始：
+
+```toml
+[app]
+name = "websocket-service"
+entry = "src/index.ts"
+profile = "service"
+
+[server]
+listen = "127.0.0.1:3000"
+http1 = true
+http2 = false
+websocket = true
+
+[permissions]
+fetch = ["api.example.com"]
+```
+
+`listen` 控制入站流量。`permissions.fetch` 控制出站 `fetch` 和 WebSocket 目标；两项设置互不隐含。只有在容器或主机中确实需要外部访问该端口时，才将监听器改为 `0.0.0.0:3000`。
+
+Tysel 提供明文 HTTP/2（h2c），不提供 TLS。同时启用两个版本时，会在同一监听器上选择协议。仅使用 HTTP/2 的客户端必须预先知道使用 h2c。WebSocket 升级要求 HTTP/1.1：
+
+```toml
+[server]
+http1 = true
+http2 = true
+websocket = true
+```
+
+应在 Ingress 终止 HTTPS，并在转发 HTTP/1.1 升级时保留 `Connection` 和 `Upgrade`。不能用公开的明文监听器代替 TLS 终止。
+
+## 实现入站 WebSocket
+
+编辑处理程序前，刷新清单限定的能力环境：
+
+```sh
+tysel types
+```
+
+```ts
+import type { TyselApp } from "@tysel/types";
+import type { TyselEnv } from "../tysel-env.js";
+
+export default {
+  async fetch(request, runtime) {
+    const url = new URL(request.url);
+    const upgrade = request.headers.get("upgrade")?.toLowerCase();
+    if (url.pathname !== "/ws" || upgrade !== "websocket") {
+      return Response.json({ websocket: "/ws" }, { status: 426 });
+    }
+
+    const socket = runtime.acceptWebSocket();
+    socket.addEventListener("message", async (event) => {
+      await socket.send(`echo:${event.data}`);
+    });
+    return new Response(null, { status: 101 });
+  },
+} satisfies TyselApp<TyselEnv>;
+```
+
+只有在处理符合条件的入站 HTTP/1.1 升级时，`acceptWebSocket()` 才有效。已接受的套接字支持文本消息，以及 [WebSocket 约定](https://tysel.dev/reference/javascript/websocket/)中记录的有边界事件接口。
+
+运行完整的 [WebSocket 服务示例](https://github.com/wangcch/tysel/tree/main/examples/websocket-service)：
+
+```sh
+cd examples/websocket-service
+tysel check
+tysel run
+```
+
+在另一个终端运行：
+
+```sh
+curl -i http://127.0.0.1:3000/
+websocat ws://127.0.0.1:3000/ws
+```
+
+HTTP 请求返回 `426`；通过 `websocat` 输入的文本会加上 `echo:` 前缀后返回。
+
+## 调用出站目标
+
+白名单只包含主机名，不包含协议、端口、路径或通配符：
+
+```toml
+[permissions]
+fetch = ["api.example.com"]
+```
+
+```ts
+const response = await fetch("https://api.example.com/v1/status");
+if (!response.ok) throw new Error(`upstream returned ${response.status}`);
+```
+
+每个重定向目标都会重新检查。IP 字面量会被拒绝；DNS 由宿主解析；私有地址和特殊用途地址会被拒绝；重定向无法逃逸已声明主机名集合。出站 WebSocket 使用相同白名单，每个隔离实例请求允许一个活动套接字。
+
+## 验证协议与拒绝行为
+
+```sh
+# HTTP/1.1
+curl --http1.1 -i http://127.0.0.1:3000/
+
+# h2c prior knowledge, when http2 is enabled
+curl --http2-prior-knowledge -i http://127.0.0.1:3000/
+
+# Effective profile and grants
+tysel inspect
+```
+
+还应测试未声明的出站主机名，并确认宿主将其拒绝。不要把主机拒绝错误转换为通用成功响应；应保留有边界的应用错误并记录请求标识符。
+
+## 生产检查清单
+
+- 只在预期网络策略之后绑定外部地址；
+- 终止 TLS，并保留 HTTP/1.1 升级请求头；
+- 声明确切的出站主机名，并测试重定向行为；
+- 根据工作负载设置正文、超时和准入限额；
+- 计算并发容量时包含长连接 WebSocket；
+- 使用应用自行提供的就绪端点。
+
+接下来请阅读[并发与背压](/docs/guides/concurrency-backpressure)、[服务器字段](/reference/manifest/app-server)和[网络能力约定](/reference/manifest/permissions#outbound-network)。
diff --git a/website/locales/zh-CN/content/docs/guides/sqlite.mdx b/website/locales/zh-CN/content/docs/guides/sqlite.mdx
new file mode 100644
index 0000000..0a93940
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/sqlite.mdx
@@ -0,0 +1,93 @@
+---
+title: "SQLite"
+description: "本指南配置由运行时管理的 SQLite 客户端，执行参数化语句，验证持久化，并将应用数据库与持久事件日志分开。"
+---
+
+本指南配置由运行时管理的 SQLite 客户端，执行参数化语句，验证持久化，并将应用数据库与持久事件日志分开。
+
+## 选择稳定路径
+
+持久存储为 `sqlite` 时，受信任的 `service` 执行配置可以使用 SQLite；这也是清单默认值。可部署应用应明确指定路径：
+
+```toml
+[app]
+name = "sqlite-worker"
+entry = "src/index.ts"
+profile = "service"
+
+[durable]
+store = "sqlite"
+path = "./data/application.db"
+```
+
+项目命令从清单目录解析相对路径。打包后的可执行文件从进程工作目录解析。运行时会创建缺失的父目录，但生产环境应挂载稳定的可写卷，并设置确定的工作目录。
+
+## 执行参数化 SQL
+
+```ts
+await tysel.sqlite.exec(
+  "CREATE TABLE IF NOT EXISTS counters (key TEXT PRIMARY KEY, value INTEGER NOT NULL)",
+);
+await tysel.sqlite.exec(
+  "INSERT INTO counters(key, value) VALUES (?, 1) " +
+    "ON CONFLICT(key) DO UPDATE SET value = value + 1",
+  ["visits"],
+);
+const rows = await tysel.sqlite.query(
+  "SELECT key, value FROM counters WHERE key = ?",
+  ["visits"],
+);
+```
+
+`exec` 解析为受影响行数，`query` 解析为行对象。参数必须是由 `null`、布尔值、有限数值或字符串组成的数组。绝不要把请求值插值到 SQL 文本中。
+
+运行完整的 [SQLite worker](https://github.com/wangcch/tysel/tree/main/examples/sqlite-worker)：
+
+```sh
+cd examples/sqlite-worker
+tysel config validate
+tysel check
+tysel run
+```
+
+在另一个终端运行：
+
+```sh
+curl 'http://127.0.0.1:3000/?key=visits'
+curl 'http://127.0.0.1:3000/?key=visits'
+```
+
+第二次响应会报告 `value: 2`。停止并重启进程，再次调用，确认该值仍保存在已配置数据库中。
+
+## 运行时行为与边界
+
+当前运行时在整个进程中管理一个 SQLite 连接，通过 mutex 串行化访问，并应用 5 秒的 SQLite busy timeout。多个 JavaScript 工作线程不会创建独立连接池，因此长时间运行的语句会延迟同一进程中的其他 SQLite 操作。
+
+当前固定边界如下：
+
+| 接口项 | 边界 |
+| --- | ---: |
+| SQL 文本 | 1 MiB |
+| 参数数 | 999 |
+| 返回行数 | 10,000 |
+
+SQL 操作失败时，Tysel 会尝试回滚打开的事务，使共享连接保持可用。应使用短事务，避免让一个事务跨越无关 HTTP 请求。
+
+`isolated` 执行配置拒绝 SQLite。SQLite 也不同于 Component 文件系统导入；Component 无法通过请求文件系统根目录获得 `tysel.sqlite`。
+
+## 分离应用数据与持久数据
+
+`durable.path` 选择面向应用的 SQLite 能力。如果模块还导出持久处理程序，除非 `TYSEL_DURABLE_SQLITE_PATH` 或 `TYSEL_DURABLE_POSTGRES_URL` 选择其他事件存储，否则 Tysel 会将 `durable-events.db` 放在该应用数据库旁。
+
+两项功能同时启用时，应备份两个文件。恢复时应将其作为一个应用一致性文件集，并在恢复调度器之前遵循[生产存储指南](/docs/operations/production#durable-postgres-backup-and-restore)。
+
+## 生产检查清单
+
+- 使用具有充足可用空间和 inode 容量的持久本地存储；
+- 除非已针对确切锁定模式完成部署测试，否则每个数据库只使用一个应用写入方；
+- 使用参数化语句并限制响应大小；
+- 监控查询延迟、busy 失败、磁盘延迟和文件系统容量；
+- 备份应用数据库并测试恢复；
+- 工作负载需要远程多宿主协调、更高并发或数据库管理的可用性时，使用 Postgres。
+
+请参阅 [SQLite API](/reference/runtime/capabilities#sql)、[持久配置](/reference/manifest/durable-observability)和[数据能力限额](/reference/limits-and-defaults#data-capabilities)。
diff --git a/website/locales/zh-CN/content/docs/guides/wasm-component-go.mdx b/website/locales/zh-CN/content/docs/guides/wasm-component-go.mdx
new file mode 100644
index 0000000..fb0e42f
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/wasm-component-go.mdx
@@ -0,0 +1,92 @@
+---
+title: "构建 Go Wasm Component"
+description: "本指南使用已发布的 Tysel Component 起始项目为 Go 来宾生成绑定，构建 Wasm Component，验证其 ABI，并将其打包为原生 Tysel 可执行文件。"
+---
+
+本指南使用已发布的 Tysel Component 起始项目为 Go 来宾生成绑定，构建 Wasm Component，验证其 ABI，并将其打包为原生 Tysel 可执行文件。
+
+## 前置条件
+
+安装：
+
+- 已发布的 Tysel [工具链](/docs/install)；
+- 与固定样例模块匹配的 Go `1.25.5`；
+- Bytecode Alliance `componentize-go` `0.4.1`。
+
+```sh
+go install github.com/bytecodealliance/componentize-go@v0.4.1
+tysel doctor --install
+```
+
+确保 Go 安装的二进制目录也在 `PATH` 中，使 `componentize-go` 可用。
+
+## 下载起始项目
+
+每个 Tysel GitHub Release 都包含版本匹配的起始项目包。下载并验证后，进入 Go 项目：
+
+```sh
+version="$(tysel --version | awk '{print $2}')"
+release="https://github.com/wangcch/tysel/releases/download/v${version}"
+curl -fsSLO "${release}/tysel-component-starters.tar.gz"
+curl -fsSLO "${release}/tysel-component-starters.tar.gz.sha256"
+curl -fsSLO "${release}/tysel-component-starters.tar.gz.sig.json"
+expected="$(tr -d '[:space:]' < tysel-component-starters.tar.gz.sha256)"
+actual="$(shasum -a 256 tysel-component-starters.tar.gz | awk '{print $1}')"
+test "$actual" = "$expected"
+tysel release verify-metadata \
+  tysel-component-starters.tar.gz \
+  tysel-component-starters.tar.gz.sig.json \
+  --trust "${TYSEL_HOME:-$HOME/.tysel}/trust.json"
+tar -xzf tysel-component-starters.tar.gz
+cd tysel-component-starters/go-echo
+```
+
+不可变标签来自已安装的 CLI，因此项目包与原生工具链保持在同一版本。项目包内置匹配的来宾 SDK 模块和 Component WIT 包，并固定经过测试的绑定生成器，无需检出 Tysel 仓库。如果 Tysel 安装在自定义托管前缀下且未设置 `TYSEL_HOME`，请将该前缀中的 `trust.json` 传给 `--trust`。
+
+## 生成并构建
+
+在 `tysel-component-starters/go-echo` 中运行：
+
+```sh
+componentize-go -d wit/component -w task bindings
+componentize-go -d wit/component -w task build \
+  -o echo.component.wasm
+```
+
+起始项目已包含 `wit_exports.go`，因此只有在验证固定工具链或修改 WIT 时才需要重新生成绑定。常规构建可直接使用附带的绑定。
+
+## 验证并运行
+
+```sh
+tysel check
+printf '{"language":"go","value":42}' | tysel run
+```
+
+预期 stdout：
+
+```json
+{"language":"go","value":42}
+```
+
+来宾通过 `tysel:component/task@0.4.0` 接收并返回 JSON。进程 stdin/stdout 由 Tysel 管理；来宾不会将其作为隐式 WASI 流继承。
+
+## 打包为单个可执行文件
+
+```sh
+tysel build --release
+printf '{"value":"packaged"}' | ./dist/go-echo-component
+```
+
+可执行文件会保留可移植 Component，并可包含兼容的宿主专用优化元数据。目标宿主无需 Go 或 `componentize-go` 即可运行；可移植性不依赖该可选元数据。
+
+## 故障排查
+
+| 现象 | 检查项 |
+| --- | --- |
+| 生成的包无法编译 | 将 `componentize-go` `0.4.1` 与起始项目的 `wit/component` 目录配合使用。 |
+| 输出 JSON 无效 | 返回可由 `encoding/json` 编码的值；不要手动构造 ABI 字符串。 |
+| 进程等待且没有输出 | 写入单个 JSON 输入后关闭 stdin。 |
+| WASI 套接字或 preopen 导入被拒绝 | Tysel 只公开其[受限 WASI 配置](/reference/component/runtime#restricted-wasi-02-profile)。 |
+| 文件系统导入被拒绝 | 满足 [Component 能力交集](/reference/component/capabilities)。 |
+
+接下来阅读 [Go SDK 参考](/reference/component/go-sdk)。
diff --git a/website/locales/zh-CN/content/docs/guides/wasm-component-rust.mdx b/website/locales/zh-CN/content/docs/guides/wasm-component-rust.mdx
new file mode 100644
index 0000000..79763f4
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/guides/wasm-component-rust.mdx
@@ -0,0 +1,102 @@
+---
+title: "构建 Rust Wasm Component"
+description: "本指南使用已发布的 Tysel Component 起始项目构建 Rust 来宾，验证其 ABI，运行一个 JSON 任务，并将其打包为原生可执行文件。"
+---
+
+本指南使用已发布的 Tysel Component 起始项目构建 Rust 来宾，验证其 ABI，运行一个 JSON 任务，并将其打包为原生可执行文件。
+
+## 前置条件
+
+安装：
+
+- 已发布的 Tysel [工具链](/docs/install)；
+- 稳定版 Rust 和 `wasm32-unknown-unknown` 目标；
+- Bytecode Alliance `wasm-tools` `1.247.0`。
+
+```sh
+cargo install wasm-tools --version 1.247.0 --locked
+rustup target add wasm32-unknown-unknown
+tysel doctor --install
+```
+
+## 下载起始项目
+
+每个 Tysel GitHub Release 都包含版本匹配的起始项目包。下载并验证后，进入 Rust 项目：
+
+```sh
+version="$(tysel --version | awk '{print $2}')"
+release="https://github.com/wangcch/tysel/releases/download/v${version}"
+curl -fsSLO "${release}/tysel-component-starters.tar.gz"
+curl -fsSLO "${release}/tysel-component-starters.tar.gz.sha256"
+curl -fsSLO "${release}/tysel-component-starters.tar.gz.sig.json"
+expected="$(tr -d '[:space:]' < tysel-component-starters.tar.gz.sha256)"
+actual="$(shasum -a 256 tysel-component-starters.tar.gz | awk '{print $1}')"
+test "$actual" = "$expected"
+tysel release verify-metadata \
+  tysel-component-starters.tar.gz \
+  tysel-component-starters.tar.gz.sig.json \
+  --trust "${TYSEL_HOME:-$HOME/.tysel}/trust.json"
+tar -xzf tysel-component-starters.tar.gz
+cd tysel-component-starters/rust-echo
+```
+
+不可变标签来自已安装的 CLI，因此项目包与原生工具链保持在同一版本。项目包内置匹配的 `tysel-component-sdk` 源码和 Component WIT 包，并固定经过测试的 `wit-bindgen` 版本，无需检出 Tysel 仓库。如果 Tysel 安装在自定义托管前缀下且未设置 `TYSEL_HOME`，请将该前缀中的 `trust.json` 传给 `--trust`。
+
+未使用起始项目时，应依赖公开 SDK crate，并将匹配的 WIT 包复制到项目中：
+
+```toml
+tysel-component-sdk = "0.2.0"
+```
+
+crate 版本跟随 Tysel 产品版本。WIT 约定使用独立的 `tysel:component/task@0.4.0` ABI 版本。
+
+## 构建来宾
+
+在 `tysel-component-starters/rust-echo` 中运行：
+
+```sh
+cargo build --target wasm32-unknown-unknown --release
+wasm-tools component new \
+  target/wasm32-unknown-unknown/release/tysel_rust_echo_component.wasm \
+  -o target/echo.component.wasm
+```
+
+第一条命令生成 Core Wasm 模块。`wasm-tools component new` 将其封装为 Tysel 接受的 Component Model 二进制文件。把 Core 模块直接传给 Tysel 会验证失败。
+
+## 验证并运行
+
+起始项目清单选择 `profile = "component"` 和生成的入口。
+
+```sh
+tysel check
+printf '{"value":42}' | tysel run
+```
+
+`run` 的预期 stdout：
+
+```json
+{"value":42}
+```
+
+`run` 等待 stdin EOF，调用 Component 一次，打印一个 JSON 值后退出。Component 应用不支持 `tysel dev`。
+
+## 打包为单个可执行文件
+
+```sh
+tysel build --release
+printf '{"value":"packaged"}' | ./dist/rust-echo-component
+```
+
+输出的可执行文件包含可移植 Component 和原生宿主，并可包含兼容的宿主专用优化元数据。目标宿主不需要 Rust、Go、单独安装的运行时引擎或来宾 SDK。构建目标仍是构建宿主。
+
+## 故障排查
+
+| 现象 | 检查项 |
+| --- | --- |
+| `run` 导出或 ABI 错误 | 使用匹配起始项目附带的 WIT 包和 `task` world。 |
+| Core 模块被拒绝 | 运行 `wasm-tools component new`，并让清单指向生成的 Component。 |
+| 输入 JSON 错误 | 只发送一个 JSON 值，并关闭 stdin。 |
+| Component 超出限额 | 查看 [Component 运行时限额](/reference/component/runtime#resource-bounds)。 |
+| 能力导入被拒绝 | 目前只实现了文档列出的[文件系统导入](/reference/component/capabilities)。 |
+
+接下来阅读 [Rust SDK 参考](/reference/component/rust-sdk)，将 echo 处理程序替换为类型化任务。
diff --git a/website/locales/zh-CN/content/docs/index.mdx b/website/locales/zh-CN/content/docs/index.mdx
new file mode 100644
index 0000000..7e28531
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/index.mdx
@@ -0,0 +1,94 @@
+---
+title: "Tysel 文档"
+description: "Tysel 是一个面向服务和 AI 智能体的轻量级原生 TypeScript 运行时。基于 Web API 编写应用，显式授予宿主能力，并在生产环境中交付无需 Node.js 或 node_modules 的单个可执行文件。"
+---
+
+Tysel 是一个面向服务和 AI 智能体的轻量级原生 TypeScript 运行时。
+基于 Web API 编写应用，显式授予宿主能力，并在生产环境中交付无需
+Node.js 或 `node_modules` 的单个可执行文件。
+
+## 从这里开始
+
+| 你的目标 | 从这里开始 | 然后阅读 |
+| --- | --- | --- |
+| 构建 HTTP 服务 | [创建第一个服务](/docs/getting-started) | [运行时 API](/reference/runtime) |
+| 将 Tysel 添加到现有项目 | [创建或接入项目](/docs/concepts/projects-and-configuration#create-or-adopt-a-project) | [npm 兼容性](/docs/compatibility) |
+| 运行生成的代码或第三方代码 | [选择执行配置](/docs/concepts/execution-profiles) | [安全模型](/docs/security) |
+| 构建 Rust 或 Go Wasm 任务 | [Wasm 组件指南](/docs/guides/wasm-component-rust) | [组件参考](/reference/component) |
+| 构建可在重启后恢复的任务 | [持久执行](/docs/concepts/durable-execution) | [持久智能体示例](https://github.com/wangcch/tysel/tree/main/examples/durable-agent) |
+| 部署应用 | [选择部署方式](/docs/operations/deployment) | [生产运维](/docs/operations/production) |
+| 评估 Tysel 是否适合生产环境 | [生产运维](/docs/operations/production) | [性能验证结果](/docs/performance) |
+
+你也可以浏览[按任务组织的指南地图](/docs/guides)、
+[可运行示例库](/docs/guides/examples)，或者在已经明确需求时直接查阅
+[API 参考](/reference)。
+
+## 五分钟上手
+
+[安装 Tysel](/docs/install) 后，创建并运行一个小型服务：
+
+```sh
+tysel init hello-tysel --yes
+cd hello-tysel
+tysel task verify
+tysel dev
+```
+
+访问服务器输出的地址，然后打包应用：
+
+```sh
+curl http://127.0.0.1:3000/hello
+tysel task release
+./dist/hello-tysel
+```
+
+开发工具安装包包含三个协同工作的工具，但最终应用产物仍然只有一个可执行文件。
+
+## 功能概览
+
+| 领域 | Tysel 提供的能力 | 主要命令或 API |
+| --- | --- | --- |
+| 开发 | 创建项目、验证、测试和自动重载 | `tysel init`、`check`、`test`、`dev` |
+| 交付 | 单个原生应用可执行文件和发布验证材料 | `tysel build --release` |
+| 限定权限 | 显式声明网络、密钥、数据库和文件系统授权 | `tysel inspect` 和清单 |
+| 运行服务 | Fetch 处理函数、Web API、HTTP 和 WebSocket | `export default { fetch() {} }` |
+| 运行任务 | 在统一且受限的任务模型上运行 Cron、Queue 和 MCP 处理函数 | `tasks` 导出 |
+| 运行 Wasm 组件 | 使用受限 WASI、与语言无关的单次 JSON 任务 | `profile = "component"` |
+| 恢复任务 | 持久化的步骤、副作用、休眠、重试和信号 | `durable` 导出 |
+
+## 理解运行约定
+
+Tysel 以 Web API 为先，并非通用的 Node.js 兼容层。Node 内置模块、原生扩展、
+子进程、动态库和隐式宿主访问都不属于应用运行约定。`service` 执行配置适用于
+可信的自有代码。`isolated` 执行配置使用独立工作进程；Linux 是它面向生产环境的
+安全目标。Tysel 不对原生运行时进行交叉编译，但 `build --target` 可以使用经过验证、
+版本相同的官方 Linux 或 macOS x64/arm64 运行时进行打包。
+
+请阅读 [Tysel 的工作原理](/docs/concepts/how-tysel-works)，浏览
+[JavaScript API 参考](/reference/javascript)，并在采用依赖前运行
+[`tysel compat`](/docs/compatibility)。
+
+## 按领域探索
+
+- **学习：**[Tysel 的工作原理](/docs/concepts/how-tysel-works)、
+  [项目与配置](/docs/concepts/projects-and-configuration)、
+  [执行配置](/docs/concepts/execution-profiles)和
+  [持久执行](/docs/concepts/durable-execution)。
+- **构建：**[运行时 API](/reference/runtime)、
+  [Wasm 组件](/reference/component)、
+  [能力矩阵](/docs/capabilities)和
+  [可运行示例](/docs/guides/examples)。
+- **查询：**[API 参考](/reference)、
+  [CLI](/reference/cli)、[清单](/reference/manifest)、
+  [兼容性](/docs/compatibility)和
+  [JavaScript API](/reference/javascript)。
+- **运维：**[安装与升级](/docs/install)、
+  [安全](/docs/security)、
+  [选择部署方式](/docs/operations/deployment)、
+  [生产运维](/docs/operations/production)和
+  [性能验证结果](/docs/performance)。
+
+机器可读文档提供三种形式：作为精简起点的
+[`llms-small.txt`](https://tysel.dev/llms-small.txt)、
+页面索引 [`llms.txt`](https://tysel.dev/llms.txt)，以及
+完整导出 [`llms-full.txt`](https://tysel.dev/llms-full.txt)。
diff --git a/website/locales/zh-CN/content/docs/install.mdx b/website/locales/zh-CN/content/docs/install.mdx
new file mode 100644
index 0000000..17c4934
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/install.mdx
@@ -0,0 +1,179 @@
+---
+title: "安装 Tysel"
+description: "一套 Tysel 安装包含同一版本发布的三个原生可执行文件。"
+---
+
+一套 Tysel 安装包含同一版本发布的三个原生可执行文件：
+
+- `tysel` — CLI；
+- `tysel-service` — 原生服务运行时和构建 stub；
+- `tysel-worker` — isolated 执行配置使用的工作进程。
+
+请将它们作为一个整体安装和升级。只复制 `tysel` 会造成安装不完整。
+
+## 安装
+
+在 Linux 或 macOS（x64 或 arm64）上安装最新发布版本：
+
+```sh
+curl -fsSL https://tysel.dev/install.sh | sh
+```
+
+托管安装不需要 Rust、Node.js、npm、管理员权限或 `sudo`。如果安装器修改了
+shell 启动文件，它会输出用于在当前 shell 中启用 `tysel` 的 `source`（或 `.`）
+命令。你也可以重新启动 shell。然后运行 `tysel doctor --install`。
+
+创建项目：
+
+```sh
+tysel init hello-tysel
+cd hello-tysel
+tysel check
+tysel test
+```
+
+每个原生版本都会发布匹配的 `@tysel/types`、`@tysel/test` 和 `@tysel/sdk` 包。
+安装这些可选的开发依赖可以获得编辑器类型声明、编译器反馈和 MCP schema 推断；
+Tysel 命令和打包后的生产可执行文件不需要 Node.js 或 `node_modules`。
+
+Rust Wasm 组件项目可以依赖 crates.io 中匹配版本的 `tysel-component-sdk` crate。
+它是客户程序开发库，不属于 Tysel 原生安装。签名的组件入门包也内置了 SDK，
+可用于版本匹配和离线构建。
+
+## 安装器选项
+
+选择一个不可变的已发布版本：
+
+```sh
+curl -fsSL https://tysel.dev/install.sh | sh -s -- --version VERSION
+```
+
+从持续更新的 canary 渠道安装。最终的 `MAJOR.MINOR.PATCH` 版本属于 `stable`；
+带有 SemVer 预发布后缀的版本属于 `canary`：
+
+```sh
+curl -fsSL https://tysel.dev/install.sh | sh -s -- --channel canary
+```
+
+指定 `--version` 时，会从经过认证且不可变的清单中读取该版本所属渠道。
+同时提供两个选项时，请求的渠道必须与清单一致。
+
+预览目标、路径和 URL，而不修改机器：
+
+```sh
+curl -fsSL https://tysel.dev/install.sh | sh -s -- --dry-run
+```
+
+使用其他绝对托管根目录，或不修改 shell 启动文件：
+
+```sh
+curl -fsSL https://tysel.dev/install.sh | sh -s -- \
+  --prefix "$HOME/Tools/tysel" --no-modify-path
+```
+
+`TYSEL_HOME` 也可以指定持久根目录。`TYSEL_DOWNLOAD_BASE` 仅保留给显式 CI fixture、
+可信镜像或企业发布端点使用。未知选项、相对根目录、不受支持的目标，以及属于其他
+用户的根目录都会被拒绝。
+
+默认目录布局如下：
+
+```text
+~/.tysel/
+  versions/vVERSION/bin/{tysel,tysel-service,tysel-worker}
+  build-targets/vVERSION/TARGET/bin/{tysel,tysel-service,tysel-worker}
+  bin -> versions/vVERSION/bin
+  state.json
+  trust.json
+  upgrade.lock
+```
+
+单个 `bin` 链接会同时启用三个可执行文件。系统会在启用前检查下载内容、校验和、
+签名、所选渠道指针、归档成员、发布清单、文件哈希、权限和二进制身份。健康的托管
+安装会先使用已安装的验证器，再执行下载的工具链。重新安装损坏的托管版本时，会用
+经过验证的暂存目录替换它。安装失败则恢复之前的链接、状态、信任策略、版本目录和
+shell 配置内容。只有当 `tysel build --target` 需要其他平台时才会创建
+`build-targets`；每套缓存工具链仍按版本保存，并可验证签名。
+
+## 诊断
+
+本地安装、平台和最近项目的检查不需要网络，也不会执行应用：
+
+```sh
+tysel doctor
+tysel doctor --install
+tysel doctor --project path/to/project
+tysel doctor --json
+```
+
+网络检查需要显式启用。它使用已安装的信任策略认证 stable 或 canary 渠道指针和
+不可变清单，然后检查目标资产：
+
+```sh
+tysel doctor --network
+```
+
+警告返回退出状态 0；检查失败返回 1。JSON 输出具有稳定的 schema 版本和检查 ID，
+适合支持工具使用。
+
+## 升级与回滚
+
+检查更新而不修改安装：
+
+```sh
+tysel upgrade --check
+```
+
+交互式升级，或在自动化中显式确认：
+
+```sh
+tysel upgrade
+tysel upgrade --yes --json
+```
+
+显式切换保存的滚动更新渠道：
+
+```sh
+tysel upgrade --channel canary
+tysel upgrade --channel stable
+```
+
+显式切换渠道可能回到数值上更低的 stable 版本；确认提示仍然适用。后续不带
+`--channel` 的升级会继续跟随已选渠道。已发布渠道按照 SemVer 优先级向前移动。
+
+如果原生版本已经是最新，但经过认证的信任策略发生了变化，`upgrade` 会在应用
+`trust-refresh` 前请求确认。JSON 输出使用 `action: "trust-refresh"` 和
+`changed: true` 报告这项修改；`--check` 绝不会更改 `trust.json`。
+
+选择一个不可变的已发布版本。降级还需要提供 `--force`：
+
+```sh
+tysel upgrade --version VERSION
+tysel upgrade --version OLDER_VERSION --force
+```
+
+回到保留的上一版本：
+
+```sh
+tysel upgrade --rollback
+```
+
+升级仅适用于托管安装。它会认证发布元数据和完整归档，在同一文件系统上暂存，
+原子切换唯一的 `bin` 链接，使用经过验证的暂存目录修复损坏的目标版本缓存，并在
+切换后运行安装诊断。失败时会恢复之前的版本及所有被替换的版本目录。解析发布元数据
+之前，升级会使用当前安装的策略认证独立于渠道的签名信任策略；升级成功时会在同一个
+回滚事务中轮换 `trust.json`。这条全局信任流可以防止从 canary 切回 stable 被误判
+为信任策略回滚。离线时间超过已安装策略有效期的系统必须通过官方 HTTPS bootstrap
+重新安装。策略资产缺失、元数据无效、信任过期或签名密钥不匹配时会以失败关闭，
+不会隐式修复。
+
+## 安全边界
+
+bootstrap 模型先使用 HTTPS 和发布版本的 SHA-256，再执行下载的 CLI；然后在启用前
+验证全局信任策略、清单和归档签名。内置的 bootstrap 信任根仍来自 HTTPS 分发源，
+因此这些检查无法独立防御该分发源本身遭到入侵。已有托管安装还要求每次替换信任策略
+都由已安装策略认证，并且版本单调递增。`tysel upgrade` 要求信任、渠道、清单和归档
+元数据均有有效签名。stable 只解析最终的 `MAJOR.MINOR.PATCH` 版本；canary 只解析
+预发布版本。每个原生版本都会配套发布匹配的 `@tysel/types`、`@tysel/test`、
+`@tysel/sdk` 应用 SDK 和 `tysel-component-sdk` 包。
+
+目前不支持 Windows 原生归档。请在 Windows 上使用 WSL。
diff --git a/website/locales/zh-CN/content/docs/meta.json b/website/locales/zh-CN/content/docs/meta.json
new file mode 100644
index 0000000..1606c72
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/meta.json
@@ -0,0 +1,20 @@
+{
+  "title": "Tysel",
+  "pages": [
+    "index",
+    "---开始---",
+    "install",
+    "getting-started",
+    "---指南---",
+    "guides",
+    "---概念---",
+    "concepts",
+    "---查阅---",
+    "capabilities",
+    "compatibility",
+    "---运维---",
+    "security",
+    "operations",
+    "performance"
+  ]
+}
diff --git a/website/locales/zh-CN/content/docs/operations/component-tasks.mdx b/website/locales/zh-CN/content/docs/operations/component-tasks.mdx
new file mode 100644
index 0000000..9a2ad21
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/operations/component-tasks.mdx
@@ -0,0 +1,50 @@
+---
+title: "部署 Component 任务"
+description: "本页适用于清单中 app.profile = 'component' 的应用。Component 是一次性 JSON 任务，不是 HTTP 服务。"
+---
+
+本页适用于清单中 `app.profile = "component"` 的应用。Component 是一次性 JSON 任务，不是 HTTP 服务。`tysel image` 会拒绝该执行配置，因为它生成的是包含监听器和暴露端口约定的 HTTP 服务镜像。
+
+## 构建约定
+
+为目标架构构建打包后的可执行文件。如果存在经过验证、版本相同的官方目标运行时，构建宿主可以与目标不同：
+
+```sh
+tysel build --release \
+  --target linux-x64 \
+  --manifest tysel.toml \
+  --output dist/task
+```
+
+请将可执行文件及其五个发布伴随文件放在一起，以供准入和回滚使用。可执行文件会从 stdin 读取一个 JSON 值直至 EOF，调用 Component 一次，向 stdout 写入一个 JSON 值并附加换行符，然后退出。输入和输出各自限制为 1 MiB。
+
+## 仅运行时容器
+
+需要容器调度器时，可以直接打包可执行文件：
+
+```dockerfile
+ARG RUNTIME_IMAGE=gcr.io/distroless/cc-debian13:nonroot
+FROM ${RUNTIME_IMAGE}
+WORKDIR /task
+COPY --chown=65532:65532 dist/task /task/task
+USER 65532:65532
+ENTRYPOINT ["/task/task"]
+```
+
+构建并在连接 stdin 的情况下调用：
+
+```sh
+docker build --tag registry.example/component-task:VERSION .
+printf '%s\n' '{"job":"example"}' \
+  | docker run --rm --interactive registry.example/component-task:VERSION
+```
+
+最终镜像只需要可执行文件。除非镜像仓库的准入流程明确要从构建上下文读取发布伴随文件，否则应将它们保留在运行时镜像之外。
+
+## 调度器集成
+
+进程监督器可以将 JSON 通过管道写入 stdin，并把退出状态和 stdout 作为任务结果。Kubernetes Job 清单无法直接为容器 stdin 提供任意 JSON 值。请使用由部署方维护的启动器，从队列、对象存储、挂载文件或其他受控来源读取输入，再调用打包后的可执行文件。Tysel 不提供该启动器。
+
+不要为 Component 任务配置 HTTP Service、Ingress、就绪探针或监听器。请在调度器中配置 CPU、内存、截止时间、重试、密钥和输出保留策略。
+
+调用方式和资源限额请参阅 [Component 运行时与 WASI](/reference/component/runtime)。构建来宾组件请使用 [Rust](/docs/guides/wasm-component-rust) 或 [Go](/docs/guides/wasm-component-go) 指南。
diff --git a/website/locales/zh-CN/content/docs/operations/continuous-delivery.mdx b/website/locales/zh-CN/content/docs/operations/continuous-delivery.mdx
new file mode 100644
index 0000000..a9a27dc
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/operations/continuous-delivery.mdx
@@ -0,0 +1,76 @@
+---
+title: "持续交付约定"
+description: "本页定义 CI、镜像仓库与部署平台之间的产物交接。Tysel 不创建晋级记录，也不部署到镜像仓库。"
+---
+
+本页定义 CI、镜像仓库与部署平台之间的产物交接。Tysel 不创建晋级记录，也不部署到镜像仓库。以下命令和记录字段属于运维方管理的约定。
+
+## 流水线阶段
+
+| 阶段 | 必需输入 | 必需输出 |
+| --- | --- | --- |
+| 验证 | 源码和完整部署清单 | 通过检查和测试 |
+| 构建 | 已验证源码及选定的受支持 Linux 目标 | 发布可执行文件及五个已验证伴随文件 |
+| 打包 | 已准入的可执行文件及匹配清单 | 包含该可执行文件的 OCI 镜像 |
+| 发布 | 带版本镜像 | 镜像仓库中的镜像或 OCI 索引摘要 |
+| 晋级 | 准入验证材料和镜像仓库摘要 | 固定到已准入摘要的平台变更 |
+
+不要在环境之间重新构建。应将同一可执行文件和镜像摘要从测试环境晋级到生产环境。
+
+## 构建并保存验证材料
+
+```sh
+tysel task verify --manifest tysel.container.toml
+tysel build --release \
+  --target linux-x64 \
+  --manifest tysel.container.toml \
+  --output dist/hello-service
+
+tysel image \
+  --manifest tysel.container.toml \
+  --binary dist/hello-service \
+  --copy-sidecars \
+  --image-version VERSION \
+  --context-only \
+  --output-dir dist/image
+```
+
+`--copy-sidecars` 会验证可执行文件及全部五个发布伴随文件，再确认记录的目标与 ELF 架构一致，然后将它们复制到生成的 Dockerfile 旁。Dockerfile 只将可执行文件复制进运行时镜像。应将伴随文件归档为 CI 验证材料，不能依赖从运行中的容器里找到它们。
+
+## 添加源码标签并发布
+
+生成的上下文已经标记应用标题、执行配置、运行时版本、应用版本和可执行文件摘要。构建时添加由源码方管理的元数据：
+
+```sh
+docker build \
+  --label org.opencontainers.image.source=https://github.com/OWNER/REPOSITORY \
+  --label org.opencontainers.image.revision=COMMIT \
+  --tag registry.example/hello-service:VERSION \
+  dist/image
+
+docker push registry.example/hello-service:VERSION
+docker buildx imagetools inspect registry.example/hello-service:VERSION
+```
+
+部署应使用镜像仓库检查返回的摘要。本地镜像 ID 和 `io.tysel.artifact.digest` 标签都不是镜像仓库摘要。镜像仓库身份验证、签名、漏洞策略和准入仍由平台负责。
+
+使用仓库内的多阶段 Dockerfile 时，通过 `docker build --label` 传入相同 OCI 标签。其源码构建阶段不会自动向外层 CI 作业公开经过验证的可执行文件摘要；除非 CI 已独立提取并验证该摘要，否则应省略对应标签。
+
+## 晋级记录
+
+记录格式由平台管理。至少保留下列值，并且不要将一种摘要写入其他摘要字段：
+
+| 字段 | 来源 |
+| --- | --- |
+| 源码修订 | 版本控制检出 |
+| 清单身份 | 构建使用的确切部署清单 |
+| 可执行文件 SHA-256 | `io.tysel.artifact.digest` 和已验证的 `.sha256` 伴随文件 |
+| 兼容性、SBOM、许可证、验证材料 | 四个匹配的发布伴随文件 |
+| 应用版本 | `org.opencontainers.image.version` |
+| 源码与修订标签 | OCI 镜像配置 |
+| 镜像或 OCI 索引摘要 | 发布后镜像仓库的响应 |
+| 上一个已准入镜像摘要 | 用于回滚的部署历史 |
+
+伴随文件验证失败、可执行文件摘要标签与已准入可执行文件不同，或缺少镜像仓库摘要时，晋级必须失败。回滚应选择上一个已准入的镜像仓库摘要，而不是重新构建旧源码标签。
+
+请参阅[容器镜像](/docs/guides/container-image)、[可复现发布](/docs/guides/reproducible-release)和[生产运维](/docs/operations/production)。
diff --git a/website/locales/zh-CN/content/docs/operations/deployment.mdx b/website/locales/zh-CN/content/docs/operations/deployment.mdx
new file mode 100644
index 0000000..854cb7d
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/operations/deployment.mdx
@@ -0,0 +1,61 @@
+---
+title: "部署方式选择"
+description: "在编写平台配置前，先确定产物边界。"
+---
+
+在编写平台配置前，先确定产物边界。
+
+| 部署目标 | 构建产物 | 从这里开始 |
+| --- | --- | --- |
+| Linux 进程监督器 | 发布可执行文件及五个伴随文件 | [生产运维](/docs/operations/production#build-admission) |
+| Docker 或其他 OCI 运行时 | OCI 镜像及外部发布伴随文件 | [容器镜像](/docs/guides/container-image) |
+| 一次性 Wasm Component | 发布可执行文件及五个伴随文件 | [Component 任务](/docs/operations/component-tasks) |
+
+生产应用可执行文件支持 `linux-x64` 和 `linux-arm64`。构建宿主无需与目标一致：`tysel build --target` 会使用经过验证、版本相同的官方目标运行时进行打包。Tysel 不会为任意目标三元组编译其原生运行时。
+
+## 平台边界
+
+Tysel 生成可执行文件或容器上下文，但不会生成：
+
+- systemd 单元；
+- Kubernetes 资源或 Helm chart；
+- Ingress、TLS、DNS 或负载均衡器配置；
+- 密钥管理器对象；
+- 镜像仓库身份验证或镜像签名。
+
+这些资源由部署平台负责。创建资源时，请遵守下面的运行时约定。
+
+## 必需的运行时约定
+
+| 关注点 | 要求 |
+| --- | --- |
+| 身份 | 使用专用的非特权账户运行。生成的容器使用 `65532:65532`。 |
+| 监听器 | 使用构建清单中嵌入的地址。容器需要使用 `0.0.0.0` 或 `[::]`。 |
+| 工作目录 | 保持稳定；相对文件系统路径和 SQLite 路径会在运行时以此为基准解析。 |
+| 可写存储 | 只允许清单声明的文件系统根目录和选定的 SQLite 路径。 |
+| 密钥 | 在运行时注入已声明的密钥和数据库环境变量。 |
+| 健康检查 | 探测由应用提供的 HTTP 路由；Tysel 不会自动添加。 |
+| 关闭 | 发送常规终止信号，并至少等待一个请求超时时间。 |
+| 晋级 | 部署已通过准入的可执行文件或镜像摘要，不要部署可变的重新构建结果。 |
+
+## 产物边界
+
+直接部署可执行文件时，请在产物存储中保留以下完整文件集：
+
+```text
+APP
+APP.sha256
+APP.compat.json
+APP.sbom.cdx.json
+APP.licenses.json
+APP.evidence.json
+```
+
+对于 `service` 执行配置，运行时宿主只需要 `APP`。`isolated` 应用还需要版本和平台均匹配的 `tysel-worker`，它应放在可执行文件旁边，也可以通过 `TYSEL_WORKER` 设置其路径。构建命令会报告该要求，但不会把工作进程复制到输出目录。请在部署产物集中将工作进程与应用放在一起；只复制隔离应用会在启动时以 `worker binary not found` 失败。准入和回滚仍依赖完整且不可变的文件集。使用容器时，请记录镜像摘要与已准入可执行文件摘要之间的映射。
+
+## 后续步骤
+
+- 使用[容器镜像](/docs/guides/container-image)构建或生成 OCI 镜像。
+- 使用[持续交付](/docs/operations/continuous-delivery)保存并晋级不可变身份。
+- 使用[应用发布](/docs/guides/reproducible-release)签名和验证产物集。
+- 按照[生产运维](/docs/operations/production)落实健康检查、备份、发布、监控和事件响应要求。
diff --git a/website/locales/zh-CN/content/docs/operations/meta.json b/website/locales/zh-CN/content/docs/operations/meta.json
new file mode 100644
index 0000000..439b5a5
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/operations/meta.json
@@ -0,0 +1,9 @@
+{
+  "title": "运维",
+  "pages": [
+    "deployment",
+    "component-tasks",
+    "continuous-delivery",
+    "production"
+  ]
+}
diff --git a/website/locales/zh-CN/content/docs/operations/production.mdx b/website/locales/zh-CN/content/docs/operations/production.mdx
new file mode 100644
index 0000000..bba4a0a
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/operations/production.mdx
@@ -0,0 +1,191 @@
+---
+title: "生产运维"
+description: "应用此运行手册前，请先在部署方案选择中确定以可执行文件还是 OCI 产物作为边界。"
+---
+
+应用此运行手册前，请先在[部署方案选择](/docs/operations/deployment)中确定以可执行文件还是 OCI 产物作为边界。
+
+支持的生产应用目标平台：
+
+| 目标平台 | 操作系统 | 架构 |
+| --- | --- | --- |
+| `linux-x64` | Linux | x86-64 |
+| `linux-arm64` | Linux | arm64 |
+
+构建默认使用宿主目标平台。受管理的 Tysel 安装可以从其他受支持的 macOS 或 Linux 宿主构建这些 Linux 产物：选择 `--target linux-x64` 或 `--target linux-arm64` 后，它会验证并缓存同版本的官方目标运行时。
+
+## 构建准入
+
+在应用项目中运行以下命令：
+
+```sh
+tysel doctor --install
+tysel config validate
+tysel task verify
+tysel inspect
+tysel build --release --target linux-x64 --output dist/APP
+```
+
+只有每一项都通过，才能准入该版本：
+
+| 检查项 | 必需结果 |
+| --- | --- |
+| 安装 | `tysel doctor --install` 报告一个包含三个二进制文件的有效发行版。 |
+| 项目任务 | `tysel task verify` 成功。 |
+| 权限 | `tysel inspect` 只包含获批能力。 |
+| 目标平台 | `APP.evidence.json` 记录了部署目标平台。 |
+| 产物集 | 可执行文件以及校验和、兼容性、SBOM、许可证和验证材料文件均存在。 |
+| 签名 | 要求签名时，`tysel release verify APP --trust TRUST.json` 成功。 |
+| 健康状态 | 完全相同的产物能在预发布端口启动，且其应用就绪路由成功。 |
+
+将可执行文件及其伴随文件作为一个不可变集合存储。对于容器，在部署记录中将最终镜像摘要与已准入的可执行文件摘要关联起来。请参阅[可复现发布](/docs/guides/reproducible-release)。
+
+## 运行时约定
+
+| 设置 | 生产值 |
+| --- | --- |
+| 账户 | 专用非特权用户；不共用应用账户。 |
+| 产物路径 | 不可变的版本或摘要目录。 |
+| 工作目录 | 保持稳定；仅在相对文件系统路径或 SQLite 路径需要的位置可写。 |
+| 监听地址 | 清单中的 `[server].listen`；通常位于终止 TLS 的代理或入口之后。 |
+| 启动信号 | 日志包含 <code>{"tysel listen <address>"}</code>。 |
+| 就绪状态 | 由应用提供、有时限且无副作用的 HTTP 路由。 |
+| 关闭信号 | 服务管理器发送其常规终止信号。 |
+| 关闭宽限期 | 至少等于应用请求超时时间；默认超时为 30 秒时应设为 35 秒。 |
+
+生产宿主运行打包后的可执行文件，不需要 Tysel、Node.js、npm 或应用源码树。
+
+## 配置与密钥
+
+| 值 | 来源 | 绝不能存放在 |
+| --- | --- | --- |
+| 清单配置 | 版本化的部署仓库 | 临时修改的宿主配置 |
+| 已声明的机密信息 | 服务管理器或密钥管理器 | 清单、CLI 参数、发布产物 |
+| PostgreSQL 授权 `NAME` | <code>{"TYSEL_POSTGRES_<NAME>"}</code> | 清单或镜像 |
+| 持久执行 PostgreSQL URL | `TYSEL_DURABLE_POSTGRES_URL` | 清单或镜像 |
+| OTLP 凭据 | 标准 OTLP 标头变量 | 端点用户信息或查询字符串 |
+| 签名私钥 | 离线发布系统 | 运行时宿主、仓库、构建日志 |
+
+设置 `OTEL_SDK_DISABLED=true` 可禁用导出。OTLP 端点必须使用 HTTP(S)，长度不超过 2 KiB，并且不能包含用户信息、查询参数或片段。
+
+只记录部署元数据：
+
+- 源码提交和清单修订版本；
+- 可执行文件、验证材料和镜像摘要；
+- 目标平台和 Tysel 版本；
+- 签名密钥 ID 和信任策略摘要；
+- 部署修订版本和时间。
+
+不要记录凭据、连接 URL、标头、SQL、请求正文或机密值。
+
+## 健康检查与关闭
+
+启动：
+
+1. 在非生产端口或金丝雀环境中启动已准入产物。
+2. 等待 `tysel listen <address>`。
+3. 通过客户端使用的同一代理路径探测就绪路由。
+4. 只有探测成功后才接入流量。
+
+就绪检查应只检查服务流量所需的依赖。端到端健康状态请使用外部合成检查；Tysel 不会添加平台健康端点。
+
+关闭：
+
+1. 停止接入新流量和持久任务认领。
+2. 发送服务管理器的常规终止信号。
+3. 等待配置的宽限期结束。
+4. 如果进程仍未退出，请在强制终止前捕获日志和进程状态。
+
+正常关闭时会将 OTLP 提供器中缓冲的遥测数据发送出去，并停止由服务管理的任务执行子系统。
+
+## 持久执行 PostgreSQL 的备份与恢复
+
+生产持久状态请使用 PostgreSQL。SQLite 适用于本地或单写入者存储，并非多副本共享的持久后端。
+
+### 备份
+
+1. 排空所有写入者，或为完整 Tysel 模式创建一个数据库原生的事务一致性快照。
+2. 记录源版本摘要、数据库标识和版本、备份摘要以及 `tysel_durable_metadata.schema_version`。
+3. 加密备份并限制访问。
+4. 按照保留计划测试恢复。
+5. 只有持久状态备份完成后才恢复写入者。
+
+备份必须包含所有 Tysel 持久执行表，包括元数据、程序、事件、唤醒、信号、任务锁和统计信息。不要只复制选定的任务行或个别表。
+
+### 恢复
+
+1. 阻止应用流量和持久调度器运行。
+2. 恢复完整快照，或恢复到一个时间点。
+3. 让同一 Tysel 版本连接到隔离的目标环境并启动。
+4. 验证运行时是否接受该数据库模式、程序摘要、代表性回放、信号交付以及唤醒任务的排他认领。
+5. 创建恢复后备份。
+6. 先准入调度器，再准入应用流量。
+
+对于 SQLite，请停止所有写入者并使用能够保证 SQLite 一致性的备份机制。直接复制正在使用的数据库不能构成恢复方案。
+
+## 升级与回滚
+
+升级顺序：
+
+1. 准入新版本并备份持久状态。
+2. 停止旧调度器认领新的持久任务；让活跃租约完成或过期。
+3. 在与生产等效的能力和存储上部署一个金丝雀实例。
+4. 测试 HTTP、任务分派、持久回放、信号、被拒能力和遥测数据脱敏。
+5. 逐步增加流量，同时对比错误、延迟、内存、数据库争用和到期任务的逾期时长。
+6. 租约过期/重新认领周期和进程正常重启均成功后，完成发布。
+
+回滚顺序：
+
+1. 停止新版本调度器。
+2. 按已验证的摘要恢复此前的不可变产物或镜像。
+3. 重复准入、金丝雀和就绪检查。
+4. 只有旧运行时不接受当前模式，或应用迁移不可逆时，才恢复升级前数据库。
+
+绝不要编辑 `tysel_durable_metadata`、伪造租约令牌，或在可变标签下重新创建旧镜像。
+
+## 默认容量限制
+
+以下清单默认值是限制，并非容量承诺：
+
+| 限制 | 默认值 |
+| --- | ---: |
+| 隔离实例内存 | 128 MiB |
+| 每轮 CPU 时间 | 50 ms |
+| 请求超时 | 30 秒 |
+| 进行中请求 | 1,000 |
+| 请求正文 | 16 MiB |
+| 响应正文 | 16 MiB |
+| 应用 PostgreSQL 连接池 | 每个进程最多 4 个连接；与持久执行 PostgreSQL 存储相互独立 |
+
+使用生产请求正文、任务组合、能力、依赖和遥测数据，对完全相同的版本执行负载测试。对所有副本的数据库连接总数进行预算，并为迁移、备份和运维人员预留容量。
+
+## 监控与告警
+
+| 信号 | 告警条件 |
+| --- | --- |
+| `tysel.http.server.requests` | 持续出现 5xx 错误，或流量意外消失。 |
+| `tysel.http.server.duration` | 延迟接近配置的请求超时时间。 |
+| `tysel.capability.calls` | 出现意外的 `denied` 结果，或持续出现 `error` 结果。 |
+| 进程状态 | 重启循环、强制终止或内存压力。 |
+| OTLP 导出 | 流量仍在继续，但收集器导出消失。 |
+| PostgreSQL | 可用性、连接池饱和、锁压力、复制延迟、存储空间、距最近一次备份的时间或证书过期。 |
+| 持久调度器 | 到期任务的逾期时长增长，或重新认领停止。 |
+
+Tysel JSON 日志会省略查询字符串、标头、正文、SQL、文件系统路径、URL 和机密值。即便如此，仍应限制访问。请使用 span 和日志中的进程本地关联 ID；不要根据用户输入创建指标标签。
+
+有关具体信号和脱敏规则，请参阅[可观测性](/docs/guides/observability)。
+
+## 事件响应
+
+保留产物和验证材料摘要、目标平台、信任策略摘要、部署修订版本、受影响的任务 ID、关联 ID、数据库时间线及脱敏日志。
+
+| 事件 | 第一响应 | 禁止的捷径 |
+| --- | --- | --- |
+| 签名密钥泄露 | 在经过身份验证的策略中撤销密钥，停止受影响的部署，离线轮换密钥，并为留存且已验证的产物重新签名。 | 为避免部署失败而让密钥保持活跃。 |
+| 机密信息泄露 | 在服务提供商处撤销泄露的凭据，创建新的机密信息版本，重启受影响的进程，并在元数据中排查影响范围。 | 将捕获的机密信息或请求正文复制到事件记录。 |
+| 数据库中断或争用 | 停止新的分派，保留进程直至租约过期，恢复服务，然后观察受租约隔离机制保护的重新认领和到期任务的逾期时长。 | 使用过期租约令牌完成工作。 |
+| 回放或历史记录冲突 | 隔离任务并保留其完整历史记录和程序摘要。 | 编辑事件、序列号或程序绑定。 |
+| 隔离实例崩溃或因资源限制终止 | 检查受限的错误元数据和宿主 cgroup 压力；修复工作负载或并发设置。 | 首先放宽 seccomp、Landlock 或能力授权。 |
+| 遥测中断 | 使用独立的健康检查和审计日志，恢复收集器，并通过合成请求验证。 | 将 OTLP 凭据加入端点 URL。 |
+
+恢复后，重新运行发布准入和一次持久重启/回放测试，然后再关闭事件。请参阅[调试](/docs/guides/debugging)。
diff --git a/website/locales/zh-CN/content/docs/performance/index.mdx b/website/locales/zh-CN/content/docs/performance/index.mdx
new file mode 100644
index 0000000..3a40e14
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/performance/index.mdx
@@ -0,0 +1,24 @@
+---
+title: "性能与验证材料"
+description: "Tysel 记录基准测试方法，使体积、启动、内存、隔离实例、持久执行、任务和 HTTP 的结果可以复现，而不是成为缺少依据的性能宣传。"
+---
+
+Tysel 记录基准测试方法，使体积、启动、内存、隔离实例、持久执行、任务和 HTTP 的结果可以复现，而不是成为缺少依据的性能宣传。请测量你准备部署的版本、应用和目标环境；公开的基准测试结果并非普遍保证。
+
+## 运行基准测试
+
+```sh
+tysel bench startup
+tysel bench all --format json
+tysel bench all --evidence dist/benchmark-evidence.json
+```
+
+完整的验证材料需要以发布模式、完整规模运行 `all`。材料会记录原始样本、产物摘要、源码提交、命令、CPU、操作系统、目标平台，以及可用的 p50/p95/p99 数值。短时或单样本测量会省略没有依据的尾部百分位数。
+
+Linux PSS 是正式采用的内存结果。macOS RSS 仅作为开发阶段的近似值。只有当产物、环境、命令和测量规模相同时，结果才适合比较。
+
+各套件的准备方法和结果解读见[基准测试 README](https://github.com/wangcch/tysel/tree/main/benchmarks)。只有同时提供产生该数值的产物、环境、命令和验证材料文档时，才应发布精确数值。
+
+特定能力的验证材料：
+
+- [Redis 提供程序与 QuickJS 端到端评估](/docs/performance/redis)
diff --git a/website/locales/zh-CN/content/docs/performance/redis.mdx b/website/locales/zh-CN/content/docs/performance/redis.mdx
new file mode 100644
index 0000000..05d096a
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/performance/redis.mdx
@@ -0,0 +1,90 @@
+---
+title: "Redis 性能评估"
+description: "本报告同时测量有边界的 Rust Redis 提供程序，以及公开 tysel.redis 路径经过 QuickJS、能力策略、宿主 I/O 反应器、Promise 结算、值转换和 HTTP 响应处理的性能。"
+---
+
+本报告同时测量有边界的 Rust Redis 提供程序，以及公开 `tysel.redis` 路径经过 QuickJS、能力策略、宿主 I/O 反应器、Promise 结算、值转换和 HTTP 响应处理的性能。
+
+这些结果是本地对比材料，并非生产容量承诺。
+
+## 环境
+
+- 日期：2026-08-27
+- 宿主：Apple M5 Pro、arm64、macOS 26.6
+- 容器虚拟机：Podman、8 个 CPU、4096 MiB 内存
+- Redis：7.4.9、Linux arm64、jemalloc，禁用 RDB 和 AOF
+- Rust Redis 客户端：0.32.7，发布构建
+- 传输：回环地址转发至 Podman 虚拟机；无 TLS、身份验证或集群
+- 方法：三个测量轮次，每轮轮换模式顺序；表格报告轮次中位数
+- 每轮提供程序样本：16 B 和 1 KiB 各 3,000 个；64 KiB 为 750 个
+- 每轮端到端样本：16 B 和 1 KiB 各 1,000 个；64 KiB 为 250 个
+
+每次基准测试都会创建限定于进程和时间范围的键。清理守卫会在成功或栈展开时删除这些键；运行后扫描确认没有遗留 `tysel:*` 键。
+
+## 提供程序微基准测试
+
+`bounded Redis` 使用与 Tysel 相同的原子 `GETRANGE + EXISTS` 事务，但不包含 Tysel 的验证、并发门禁和运行时值转换。
+
+### 顺序 GET
+
+| 值大小 | 原始 Redis ops/s | 有边界 Redis ops/s | Tysel 提供程序 ops/s | 提供程序 p50 | 提供程序 p95 |
+|---:|---:|---:|---:|---:|---:|
+| 16 B | 2,730 | 2,533 | 2,654 | 362.3 us | 412.0 us |
+| 1 KiB | 2,723 | 2,575 | 2,566 | 376.2 us | 415.0 us |
+| 64 KiB | 2,489 | 2,136 | 2,067 | 476.7 us | 542.6 us |
+
+原子有界读取语义造成了小值 GET 差异中的大部分。大值剩余开销包括 UTF-8 验证和运行时字符串实体化。
+
+### 顺序 SET
+
+| 值大小 | 原始 Redis ops/s | Tysel 提供程序 ops/s | 提供程序 p50 | 提供程序 p95 |
+|---:|---:|---:|---:|---:|
+| 16 B | 2,677 | 2,660 | 360.1 us | 399.1 us |
+| 1 KiB | 2,643 | 2,737 | 352.8 us | 397.4 us |
+| 64 KiB | 1,353 | 1,292 | 723.5 us | 861.9 us |
+
+SET 与原始客户端表现接近。正向差异来自测量波动，不能证明包装层使 Redis 更快。
+
+## QuickJS 端到端基准测试
+
+端到端处理程序会一次加载到包含四个工作线程的 `IsolatePool` 中。每个测量操作都通过复用的隔离实例分派 HTTP 请求。`runtime-noop` 路由执行相同的分派和响应处理，但不调用 Redis，用于对比运行时基线。
+
+### 顺序操作
+
+| 操作 | 值大小 | Runtime-noop p50 | `tysel.redis` p50 | `tysel.redis` p95 | ops/s |
+|---|---:|---:|---:|---:|---:|
+| GET | 16 B | 26.8 us | 362.4 us | 412.0 us | 2,486 |
+| GET | 1 KiB | 23.2 us | 358.5 us | 401.0 us | 2,723 |
+| GET | 64 KiB | 25.7 us | 394.6 us | 427.5 us | 2,508 |
+| SET | 16 B | 24.4 us | 355.3 us | 383.5 us | 2,793 |
+| SET | 1 KiB | 23.2 us | 358.0 us | 388.4 us | 2,772 |
+| SET | 64 KiB | 22.8 us | 620.2 us | 780.0 us | 1,447 |
+
+在该经虚拟机转发的本地环境中，可复用 QuickJS 请求路径在 p50 下约增加 20–30 us；Redis/网络时间主导端到端结果。
+
+### 四路并发吞吐量
+
+| 操作 | 16 B | 1 KiB | 64 KiB |
+|---|---:|---:|---:|
+| GET | 8,850 ops/s | 9,049 ops/s | 5,712 ops/s |
+| SET | 9,539 ops/s | 9,854 ops/s | 2,505 ops/s |
+
+四路并发调用覆盖受支持的 Redis 在途上限。更高并发有意不纳入本次基准测试。
+
+## 复现
+
+```sh
+podman run --rm -d --name tysel-redis-bench \
+  -p 127.0.0.1:16379:6379 \
+  docker.io/library/redis:7-alpine \
+  redis-server --save '' --appendonly no
+
+TYSEL_REDIS_BENCH_URL=redis://127.0.0.1:16379 \
+cargo run --release --locked -p tysel-cap-redis --example benchmark
+
+TYSEL_REDIS_BENCH_URL=redis://127.0.0.1:16379 \
+cargo run --release --locked -p tysel-engine-qjs \
+  --example redis_end_to_end_benchmark
+```
+
+两个工具都会输出每轮原始结果，并在其后输出 `median` CSV 行。需要不同测量规模时，可覆盖 `TYSEL_REDIS_BENCH_ROUNDS`、`TYSEL_REDIS_BENCH_ITERS` 或 `TYSEL_REDIS_E2E_BENCH_ITERS`。
diff --git a/website/locales/zh-CN/content/docs/security/index.mdx b/website/locales/zh-CN/content/docs/security/index.mdx
new file mode 100644
index 0000000..104fc08
--- /dev/null
+++ b/website/locales/zh-CN/content/docs/security/index.mdx
@@ -0,0 +1,52 @@
+---
+title: "安全模型"
+description: "Tysel 将宿主权限视为显式约定。"
+---
+
+Tysel 将宿主权限视为显式约定。网络目标、密钥名称、数据库授权、文件系统根目录、限额和执行配置均在带版本的 TOML 或 JSON 应用清单中声明，并由原生宿主强制实施。
+
+## Tysel 提供的保护
+
+- 拒绝访问未声明的宿主资源；
+- JavaScript 接收不透明句柄，而非原始密钥值；
+- 数据库和文件系统访问仅限具名授权和固定根目录；
+- 请求大小、响应大小、内存、CPU 轮次、截止时间和并发数均有边界；
+- 隔离 JavaScript 在服务进程之外运行；
+- 持久副作用和信号会保存，以支持恢复和审计。
+
+最终生效的权限是以下四项输入的交集：
+
+```text
+manifest grants ∩ deployment policy ∩ execution profile ∩ runtime support
+```
+
+在清单中添加权限无法绕过执行配置或部署施加的限制。
+
+## 信任边界
+
+`service` 执行配置适用于受信任的第一方代码。其 JavaScript 隔离实例受到能力限制，但与原生宿主共享进程。
+
+`isolated` 执行配置将应用移至 `tysel-worker` 中运行，并拒绝面向宿主的能力。在 Linux 上，工作进程还会应用 Landlock、seccomp、资源限额和尽力而为的 cgroup 内存限制。工作进程崩溃后，监督器会将其替换。macOS 隔离仅支持开发阶段检查，不作为生产沙箱的准入条件。
+
+实验性的 `component` 执行配置会在 `isolated-task` 信任模式下运行可移植 Wasm Component。它获得空的 WASI 上下文，默认不具备任何应用能力。只有来宾导入、清单根目录和部署策略三者相交时，文件系统访问才会生效。内存、燃料、时间、输入、输出和错误载荷均有边界。这并不承诺能够安全或兼容地运行任意 WASI 应用。
+
+Tysel 不会在该边界内运行任意原生插件或二进制文件。子进程、动态库、Node.js 内置模块和隐式操作系统访问都不属于应用约定。
+
+## 部署方的责任
+
+Tysel 无法替代操作系统加固或网络策略。生产运维人员仍需负责：
+
+- 使用专用的非 root 身份运行可执行文件；
+- 在持续维护的 Ingress 或反向代理上终止公网 TLS；
+- 在基础设施层限制出站流量；
+- 保护环境变量、数据库、签名密钥和持久存储；
+- 应用宿主更新并保留发布验证材料；
+- 监控访问拒绝、超时、工作进程崩溃和恢复行为。
+
+生产隔离工作负载应使用 Linux。请在目标环境中使用 `tysel doctor`、`tysel check`、`tysel inspect` 和应用测试套件，验证确切的产物和配置。
+
+## 报告漏洞
+
+不要创建包含漏洞利用细节或密钥的公开 issue。仓库提供私有安全报告渠道时，请使用该渠道。
+
+接下来可以阅读[能力矩阵](/docs/capabilities)、[执行配置](/docs/concepts/execution-profiles)、[Wasm Component 能力](/reference/component/capabilities)，或[生产运维](/docs/operations/production)。
diff --git a/website/locales/zh-CN/content/reference/cli/delivery.mdx b/website/locales/zh-CN/content/reference/cli/delivery.mdx
new file mode 100644
index 0000000..1900d9a
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/cli/delivery.mdx
@@ -0,0 +1,84 @@
+---
+title: "构建与镜像命令"
+description: "打包应用并输出一个原生可执行文件。"
+---
+
+## `tysel build`
+
+打包应用并输出一个原生可执行文件。
+
+```text
+tysel build [ENTRY] [OPTIONS]
+```
+
+| 选项 | 含义 |
+| --- | --- |
+| <code>{"--target <target>"}</code> | 为 `linux-x64`、`linux-arm64`、`darwin-x64` 或 `darwin-arm64` 构建。默认为当前宿主。 |
+| <code>{"--profile <profile>"}</code> | 覆盖清单中的执行配置。 |
+| `--release` | 构建优化后的输出并生成发布伴随文件。 |
+| <code>{"--stub <path>"}</code> | 使用明确指定的运行时存根。跨目标构建时，其字节必须与经过验证的官方运行时一致。 |
+| `--offline` | 要求托管缓存中已有经过验证的目标运行时；绝不访问网络。 |
+| <code>{"-o, --output <path>"}</code> | 选择可执行文件路径。 |
+| <code>{"--manifest <file>"}</code> | 选择一个清单。 |
+
+`ENTRY` 覆盖 `app.entry`。发布构建会在产物旁写入校验和、兼容性、SBOM、许可证和验证材料伴随文件。
+
+当 `ENTRY` 以 `.wasm` 结尾时，`build` 会验证 Component Model 任务 ABI 和导入，保留可移植 Component，并可包含兼容的宿主专用优化元数据。生成的可执行文件仍是一次性 JSON 任务，不是 HTTP 服务器。请参阅 [Wasm Component 运行时](/reference/component/runtime#portable-component-contract)。
+
+```sh
+tysel build --release --output dist/orders
+tysel build --release --target linux-arm64 --output dist/orders-linux-arm64
+```
+
+跨目标构建要求使用托管安装和信任策略。Tysel 会验证发布信任策略、清单、归档签名、目标、版本和文件哈希，再将运行时缓存在托管根目录的 `build-targets/` 下（默认为 `~/.tysel/build-targets/`）。
+
+## `tysel image`
+
+生成以非 root 身份运行的 Linux 容器上下文，并可选择调用 Docker 完成构建。
+
+```text
+tysel image [ENTRY] [OPTIONS]
+```
+
+| 选项 | 默认值 | 含义 |
+| --- | --- | --- |
+| <code>{"--binary <path>"}</code> | 未设置 | 复制现有 Linux Tysel 可执行文件，而不构建应用。其嵌入的应用、执行配置和监听器必须与所选清单一致。 |
+| <code>{"--stub <path>"}</code> | 附带的存根 | 选择构建时使用的运行时存根。 |
+| <code>{"--tag <name>"}</code> | <code>{"<app.name>:latest"}</code> | 生成上下文后构建带标签的镜像。 |
+| <code>{"--output-dir <path>"}</code> | `dist/image` | 生成的上下文文件目标目录。 |
+| <code>{"--base-image <image>"}</code> | `gcr.io/distroless/cc-debian13:nonroot` | 运行时基础镜像。 |
+| <code>{"--builder <path>"}</code> | `$DOCKER`，然后是 `docker` | 容器构建器可执行文件，例如 `podman`。不支持嵌入参数。 |
+| `--copy-sidecars` | 关闭 | 与 `--binary` 配合，验证并将五个发布伴随文件复制到构建上下文，以供 CI 准入。记录的目标必须与 ELF 架构一致。伴随文件不会复制到运行时镜像。 |
+| <code>{"--image-version <version>"}</code> | 未设置 | 设置 `org.opencontainers.image.version`。 |
+| <code>{"--label <KEY=VALUE>"}</code> | 无 | 添加镜像标签。多个标签可重复使用该选项。不能覆盖 Tysel 生成的键。 |
+| `--context-only` | 关闭 | 只生成文件，不调用 Docker。 |
+| `--force` | 关闭 | 替换已生成的上下文文件。未复制伴随文件时，从上下文中删除过期的生成伴随文件。 |
+| <code>{"--manifest <file>"}</code> | 自动发现 | 选择一个清单。 |
+
+```sh
+tysel image --context-only
+tysel image \
+  --binary dist/orders \
+  --copy-sidecars \
+  --image-version 1.4.0 \
+  --tag example/orders:1.4.0
+```
+
+发布前请审查生成的文件。命令生成的默认镜像以非 root 用户运行，但镜像仓库身份验证、镜像签名和部署策略仍由运维方负责。
+
+构建行为：
+
+| 命令 | 构建应用 | 运行 `docker build` |
+| --- | --- | --- |
+| `tysel image` | 是，发布模式 | 是 |
+| `tysel image --context-only` | 是，发布模式 | 否 |
+| `tysel image --binary PATH` | 否 | 是 |
+| `tysel image --binary PATH --context-only` | 否 | 否 |
+
+在非 Linux 宿主上必须使用 `--binary`。它必须指向有效嵌入 TAP 元数据的 64 位小端 Linux x86-64 或 arm64 Tysel 可执行文件。嵌入的应用名称、执行配置和监听器必须与所选清单一致。容器监听器必须使用 `0.0.0.0` 或 `[::]` 以及非零端口。`component` 执行配置会被拒绝；请使用 [Component 任务](/docs/operations/component-tasks)。
+
+每个生成的 Dockerfile 都包含 `io.tysel.artifact.digest`、`io.tysel.execution-profile`、`io.tysel.runtime.version` 和 `org.opencontainers.image.title`。这些标签包含标识符，不包含密钥。产物摘要描述打包后的可执行文件，并非镜像仓库中的镜像摘要。自定义标签值会按原样保留，包括 `$` 字符。
+
+默认基础镜像检查要求存在 glibc 解释器，或使用静态 ELF。通过 `--base-image` 选择其他镜像时，Tysel 会验证 Linux ELF、支持的架构和解释器结构，但不会声称自定义镜像包含所需 libc 或共享库。
+
+请参阅端到端的[容器镜像参考](/docs/guides/container-image)、[持续交付](/docs/operations/continuous-delivery)、[生产运维](/docs/operations/production)以及[基准测试与发布验证材料](/reference/cli/evidence)。
diff --git a/website/locales/zh-CN/content/reference/cli/development.mdx b/website/locales/zh-CN/content/reference/cli/development.mdx
new file mode 100644
index 0000000..63b8971
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/cli/development.mdx
@@ -0,0 +1,85 @@
+---
+title: "开发与测试命令"
+description: "本页所有命令都接受 --manifest <file>，用于选择一个清单，而不使用向上查找。"
+---
+
+本页所有命令都接受 `--manifest <file>`，用于选择一个清单，而不使用向上查找。
+
+## 静态验证
+
+| 命令 | 选项 | 约定 |
+| --- | --- | --- |
+| `tysel check` | `--manifest` | 验证清单、打包、TypeScript、能力使用和 Node 内置模块使用情况。 |
+| `tysel types` | `--output`、`--check`、`--manifest` | 生成或验证限定于清单的 TypeScript 能力环境。 |
+| `tysel compat` | `--json`、`--strict`、`--deny-unknown`、`--manifest` | 根据兼容性目录对导入和依赖进行分类。 |
+| `tysel inspect` | `--manifest` | 打印实际生效的能力和限额。 |
+
+`compat --strict` 应用该命令的严格兼容性策略；`--deny-unknown` 还会把未分类依赖视为失败。如果 CI 作业需要报告而非人类可读文本，请使用 `--json`。
+
+## `tysel types`
+
+```text
+tysel types [-o FILE] [--check] [--manifest FILE]
+```
+
+根据实际生效的清单生成 `tysel-env.d.ts`。导出的 `TyselEnv` 包含核心运行时工具，以及清单声明的 `service` 能力。密钥名称会成为字符串字面量；文件系统读写方法独立选择；只读 Postgres 只公开 `query`；只读 Redis 只公开 `get` 和 `exists`。`tysel init` 会为类型化项目生成该文件，并自动将入口模块连接到 `TyselApp<TyselEnv>`。
+
+使用生成的环境类型收窄应用处理程序：
+
+```ts
+import type { TyselApp } from "@tysel/types";
+import type { TyselEnv } from "../tysel-env.js";
+
+export default {
+  async fetch(_request, runtime) {
+    return Response.json({ isolateId: runtime.isolateId });
+  },
+} satisfies TyselApp<TyselEnv>;
+```
+
+`--output` 必须保持为项目根目录下的相对路径。`--check` 不会写入文件；声明缺失或过期时以非零状态退出。更改清单权限后应在 CI 中运行该命令。运行时强制检查始终是最终依据；生成的类型不会授予能力。LLM 提供商配置目前位于清单之外，因此不会自动加入 `TyselEnv`。全局 Web `fetch` 声明也无法收窄到清单中的主机名，仍必须依靠运行时白名单强制检查。
+
+## `tysel test`
+
+```text
+tysel test [PATHS]... [--filter TEXT] [--list] [--timeout-ms MILLISECONDS] [--json] [--manifest FILE]
+```
+
+`PATHS` 默认为 `tests/`。每个测试文件在新的 QuickJS 隔离实例中运行。单项测试超时默认为 `5000` 毫秒。`--json` 将测试报告写入 stdout；断言失败或超时会以非零状态退出。
+
+`--filter`（短形式 `-t`）运行名称包含 `TEXT` 的测试。它也接受 `--list --json` 返回的确切测试 ID，因此即使名称重复，工具仍可选择单项测试。没有匹配项时以非零状态退出。`--list` 只发现测试，不运行测试体。其 JSON 报告包含稳定的项目相对 ID 和源码位置，供编辑器集成使用。
+
+```sh
+tysel test
+tysel test -t "health endpoint"
+tysel test --list --json
+tysel test tests/http.test.ts --timeout-ms 10000 --json
+```
+
+测试声明和断言请参阅 [`@tysel/test` API](/reference/runtime/testing)。
+
+## `tysel dev`
+
+```text
+tysel dev [ENTRY] [--manifest FILE]
+```
+
+打包并提供应用服务，监视项目文件，并在成功重新构建后重新加载。显式 `ENTRY` 会覆盖本次运行的 `app.entry`。开发模式可以读取 `.env`，但只有声明的密钥以及具名 Postgres 和 Redis 连接会通过宿主能力暴露。
+
+启动和重新加载时，dev 会验证清单并同步默认的 `tysel-env.d.ts`，然后构建应用。输出相同时不会写入，生成的声明发生变化也不会触发再次重新加载。清单被拒绝时，会保留原声明和正在运行的应用。清单有效时，即使随后的源码构建失败，也可以更新类型。
+
+Dev 拒绝覆盖用户所有的声明文件，也不会沿输出符号链接写入。自定义的 `tysel types --output` 目标仍需手动维护。CI 中使用 `tysel types --check`，它绝不更新文件。`tysel run` 和 `tysel check` 同样不会改动生成的类型。
+
+`tysel dev` 拒绝 `.wasm` Component 入口。Component 是一次性任务；请使用 `tysel run`，并在 stdin 上提供一个 JSON 值。
+
+## `tysel run`
+
+```text
+tysel run [ENTRY] [--manifest FILE]
+```
+
+打包并提供应用服务，但不监视文件。显式 `ENTRY` 会覆盖本次运行的 `app.entry`。相对于运行时的路径从所选项目根目录解析。
+
+对于 `.wasm` Component，`run` 不会启动服务器。它验证 Component，通过有边界的 stdin/stdout 执行一次，然后退出。本地运行会根据已检查的清单推导 Component 文件系统部署权限。请参阅 [Wasm Component](/reference/component)。
+
+HTTP 和进程行为请参阅[应用与服务器](/reference/manifest/app-server)以及[错误与机器可读输出](/reference/errors-and-output)。
diff --git a/website/locales/zh-CN/content/reference/cli/evidence.mdx b/website/locales/zh-CN/content/reference/cli/evidence.mdx
new file mode 100644
index 0000000..7a94db7
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/cli/evidence.mdx
@@ -0,0 +1,42 @@
+---
+title: "基准测试与发布验证材料"
+description: "运行基准测试套件，并按需记录验证材料。"
+---
+
+## `tysel bench`
+
+运行基准测试套件，并按需记录验证材料。
+
+```text
+tysel bench <SUITE> [OPTIONS]
+```
+
+`SUITE` 可取 `startup`、`memory`、`isolate`、`task`、`durable`、`http` 或 `all`。
+
+| 选项 | 默认值 | 含义 |
+| --- | --- | --- |
+| <code>{"--format <human\|json>"}</code> | `human` | 选择报告格式。 |
+| <code>{"--evidence <path>"}</code> | — | 写入带版本的验证材料文档。 |
+| <code>{"--source-commit <sha>"}</code> | 尽可能自动发现 | 记录源码身份。 |
+| <code>{"--command <text>"}</code> | 自动生成的调用命令 | 记录用于复现的命令。 |
+| `--allow-unavailable` | — | 已弃用的兼容选项。 |
+
+完整的发布验证材料要求以发布模式、完整规模运行 `all`。当外部依赖不可用时，可选测量可以标记为 `skipped`；只有文档明确列出的准入指标会导致门禁失败。
+
+## `tysel release`
+
+签名和验证应用发布材料。
+
+| 子命令 | 必需参数 | 重要选项 |
+| --- | --- | --- |
+| `sign` | <code>{"<ARTIFACT> --key <key>"}</code> | 签名验证材料产物。 |
+| `verify` | <code>{"<ARTIFACT> --trust <key>"}</code> | 验证材料签名。 |
+| `key-info` | <code>{"--key <key>"}</code> | 打印公钥信息。 |
+
+`sign` 和 `verify` 接收一个应用可执行文件，验证其完整的发布伴随文件集，并创建或检查 `<artifact>.evidence.sig.json`。
+
+`sign` 和 `key-info` 接受的 `--key` 文件必须是 UTF-8 文本，其中包含一个以恰好 64 个十六进制字符编码的 32 字节 Ed25519 私钥。它必须是大小不超过 256 字节的普通文件。在 Unix 上，必须关闭所有组用户和其他用户权限；模式 `0600` 可以通过检查。
+
+私有签名材料不得存储在仓库中或通过日志传递。请使用子命令的 `--help` 查看已安装版本所采用的确切验证材料格式。
+
+完整产物流转请参阅[可复现的应用发布](/docs/guides/reproducible-release)，测量方法和准入策略请参阅[性能与验证材料](/docs/performance)。
diff --git a/website/locales/zh-CN/content/reference/cli/index.mdx b/website/locales/zh-CN/content/reference/cli/index.mdx
new file mode 100644
index 0000000..d8af5f0
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/cli/index.mdx
@@ -0,0 +1,47 @@
+---
+title: "CLI 参考"
+description: "tysel 可执行文件用于管理项目、验证兼容性、运行应用并生成交付验证材料。本节记录当前的命令界面；已安装的二进制文件始终是最终依据。"
+---
+
+`tysel` 可执行文件用于管理项目、验证兼容性、运行应用并生成交付验证材料。本节记录当前的命令界面；已安装的二进制文件始终是最终依据。
+
+## 全局语法
+
+```text
+tysel [GLOBAL OPTIONS] <COMMAND> [COMMAND OPTIONS]
+```
+
+| 选项 | 默认值 | 含义 |
+| --- | --- | --- |
+| <code>{"--error-format <human\|json>"}</code> | `human` | 设置 stderr 错误格式；JSON 模式还会输出 `dev` 诊断流。 |
+| <code>{"-C, --project <directory>"}</code> | 当前目录 | 从另一个项目目录发现并运行。`--project-dir` 是别名。 |
+| `-h, --help` | — | 打印帮助。 |
+| `-V, --version` | — | 打印已安装版本。 |
+
+全局选项可以写在子命令之前或之后。`-C` 不能与命令级的 `--manifest` 同时使用。
+
+## 项目选择
+
+项目命令会向上搜索唯一的 `tysel.toml` 或 `tysel.json`。如果同一目录中两者并存，发现过程会失败，而不会自行猜测。发现清单后，相对入口、存储和文件系统根目录均以清单所在目录为基准解析。
+
+```sh
+tysel -C services/worker check
+tysel run --manifest services/worker/tysel.toml
+```
+
+## 命令分组
+
+| 分组 | 命令 |
+| --- | --- |
+| 项目设置 | [`init`, `config`](/reference/cli/project) |
+| 开发 | [`check`, `types`, `compat`, `test`, `dev`, `run`, `inspect`](/reference/cli/development) |
+| 任务与协议 | [`task`, `queue`, `mcp`](/reference/cli/tasks) |
+| 交付 | [`build`, `image`](/reference/cli/delivery) |
+| 安装 | [`doctor`, `upgrade`](/reference/cli/installation) |
+| 验证材料 | [`bench`, `release`](/reference/cli/evidence) |
+
+## 退出状态与输出流约定
+
+成功的命令以状态 `0` 退出；验证、策略、测试、构建、基准门禁和运行时失败会以非零状态退出。人类可读诊断与致命 JSON 错误写入 stderr。通过 `test --json`、`compat --json` 和 `bench --format json` 等标志请求的命令报告写入 stdout。
+
+在自动化流程中解析 CLI 输出前，请先阅读[错误与机器可读输出](/reference/errors-and-output)。
diff --git a/website/locales/zh-CN/content/reference/cli/installation.mdx b/website/locales/zh-CN/content/reference/cli/installation.mdx
new file mode 100644
index 0000000..fc40f11
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/cli/installation.mdx
@@ -0,0 +1,49 @@
+---
+title: "安装生命周期命令"
+description: "诊断安装、平台和项目状态。"
+---
+
+## `tysel doctor`
+
+诊断安装、平台和项目状态。
+
+```text
+tysel doctor [-C PROJECT_OR_MANIFEST] [--install] [--network] [--json]
+```
+
+| 选项 | 行为 |
+| --- | --- |
+| `--install` | 重点检查托管安装的健康状态。 |
+| `--network` | 主动启用网络诊断；默认检查仅在本地进行。 |
+| `--json` | 将机器可读的诊断报告写入 stdout。 |
+
+为保持向后兼容，该命令还接受 `--project`，其值可以是项目目录或明确的清单路径。其他命令使用全局 `-C` 指定目录，并使用 `--manifest` 指定确切文件。
+
+## `tysel upgrade`
+
+以原子方式检查、更新或回滚托管安装。
+
+```text
+tysel upgrade [OPTIONS]
+```
+
+| 选项 | 默认值 | 行为 |
+| --- | --- | --- |
+| `--check` | 关闭 | 报告是否有可用更新，但不安装。 |
+| <code>{"--version <version>"}</code> | 当前渠道版本 | 选择一个确切且不可变的版本，并采用其清单渠道。 |
+| <code>{"--channel <stable\\\|canary>"}</code> | 已安装渠道 | 选择并持久保存一个滚动更新渠道。 |
+| `--yes` | 关闭 | 不提示，直接确认。 |
+| `--force` | 关闭 | 即使常规保护条件会跳过，也重新安装。 |
+| `--rollback` | 关闭 | 恢复之前的托管安装。 |
+| `--json` | 关闭 | 将机器可读结果写入 stdout。 |
+
+```sh
+tysel doctor --install
+tysel upgrade --check --json
+tysel upgrade --channel canary --yes
+tysel upgrade --channel stable --yes
+tysel upgrade --version 0.2.0 --yes
+tysel upgrade --rollback
+```
+
+`upgrade` 仅适用于托管安装。路径、校验和平台支持请参阅[安装](/docs/install)，镜像和安装根目录控制请参阅[环境变量](/reference/environment)。
diff --git a/website/locales/zh-CN/content/reference/cli/meta.json b/website/locales/zh-CN/content/reference/cli/meta.json
new file mode 100644
index 0000000..4d37393
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/cli/meta.json
@@ -0,0 +1,12 @@
+{
+  "title": "命令行",
+  "pages": [
+    "index",
+    "project",
+    "development",
+    "tasks",
+    "delivery",
+    "installation",
+    "evidence"
+  ]
+}
diff --git a/website/locales/zh-CN/content/reference/cli/project.mdx b/website/locales/zh-CN/content/reference/cli/project.mdx
new file mode 100644
index 0000000..0475655
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/cli/project.mdx
@@ -0,0 +1,72 @@
+---
+title: "项目与配置命令"
+description: "创建项目，或安全地向现有目录添加 Tysel 文件。"
+---
+
+## `tysel init`
+
+创建项目，或安全地向现有目录添加 Tysel 文件。
+
+```text
+tysel init [PATH] [OPTIONS]
+```
+
+在交互式终端中省略 `PATH` 时，`init` 会询问项目目录，并建议 `my-tysel-app`。非交互模式默认为 `.`。使用全局 `-C` 时，相对路径从所选基础目录解析。
+
+| 选项 | 接受的值 | 行为 |
+| --- | --- | --- |
+| `--template` | `http`、`worker`、`mcp`、`minimal` | 选择生成的应用内容。 |
+| `--manifest-format` | `toml`、`json` | 只选择清单序列化格式；两者使用同一 schema，并可与其他所有选项组合。 |
+| <code>{"--entry <path>"}</code> | 项目相对路径 | 复用现有 JavaScript 或 TypeScript 入口。新生成的入口必须使用 `.ts`、`.tsx` 或 `.mts`；由于 `init` 尚不生成 Component 项目，因此拒绝 `.wasm`。 |
+| `--package-json` | `auto`、`create`、`reuse`、`none` | 只控制可选 npm 伴随文件。`auto` 复用现有文件或创建新文件；`create` 要求文件不存在；`reuse` 要求文件存在；`none` 保持文件不存在或不改动。 |
+| `--add-scripts` | 标志 | 向复用的 `package.json` 添加 Tysel scripts。 |
+| `--package-manager` | `npm`、`pnpm`、`yarn`、`bun` | 选择为生成包显示或执行的安装命令。省略时使用最近的锁文件。 |
+| `--install` | 标志 | 创建项目文件后运行所选包管理器。要求 `init` 创建 `package.json`。 |
+| `--verify` | 标志 | 创建和可选安装后运行 `tysel check`。新生成的包要求同时使用 `--install`，避免跳过 TypeScript。 |
+| `--no-tests` | 标志 | 不创建起始测试、测试依赖/script，也不在生成的 `verify` 任务中加入 `test` 步骤。 |
+| `--dry-run` | 标志 | 打印计划，不写入文件。 |
+| `--json` | 标志 | 将 dry-run 计划序列化为 JSON，包括文件变更前后的内容。要求 `--dry-run`。 |
+| `--diff` | 标志 | 在人类可读的 dry-run 输出中包含完整统一 diff。要求 `--dry-run`。 |
+| `-y, --yes` | 标志 | 接受建议的计划。 |
+| `--no-interactive` | 标志 | 禁用提示，对省略的选择使用文档规定的默认值。 |
+
+`init` 不会静默覆盖现有文件。在现有仓库中应使用 `--dry-run`，并在接受前审查接入计划。现有 `.gitignore` 只会补充缺少的 Tysel 生成路径，其余条目保持不变。
+
+不提供路径时，第一个交互选择会明确区分创建新项目与向当前目录添加 Tysel。其他选择支持方向键和 Enter；不具备光标控制的终端会回退到编号选项。项目目标和入口路径会在对应提示处验证，使无效值可以在向导继续前得到修正。
+
+对于接入的项目，默认计划会报告将添加的各个 package script 和忽略模式。`--diff` 展示精确内容变更，包括重写 `package.json` 导致的格式变化；`--json` 为自动化提供相同的变更前后内容。
+
+模板、清单格式、入口、包集成和测试彼此独立。没有 npm 依赖的应用无需 `package.json` 也可以运行、测试或构建。新项目会获得 `tsconfig.json`；已有 JavaScript 或 TypeScript 配置的项目会在需要时获得独立的 `tsconfig.tysel.json`。如果该 Tysel 专用配置已有显式 `files` 列表，`init` 要求其中包含选定入口和所有生成的类型化测试。验证时支持 TypeScript 配置文件允许的注释和尾随逗号。
+
+Wasm Component 应从已发布的 Rust 或 Go Component 起始项目及其版本匹配清单开始；请使用 [Rust](/docs/guides/wasm-component-rust) 或 [Go](/docs/guides/wasm-component-go) 指南，而不是 `tysel init`。
+
+```sh
+tysel init api --template http --manifest-format toml --yes
+tysel init . --package-json reuse --add-scripts --dry-run
+tysel init . --package-json reuse --add-scripts --dry-run --diff
+tysel init worker --template worker --manifest-format json --package-json none --yes
+tysel init tool --template mcp --package-json none --no-tests --yes
+```
+
+## `tysel config`
+
+定位、验证、检查、转换清单，或打印其 schema。
+
+| 子命令 | 语法 | 输出与行为 |
+| --- | --- | --- |
+| `path` | `tysel config path [--manifest FILE]` | 打印发现的路径。即使清单格式错误也可以定位。 |
+| `validate` | `tysel config validate [--manifest FILE]` | 加载并验证配置。 |
+| `show` | `tysel config show [--format toml\|json] [--manifest FILE]` | 打印实际配置，并展开省略的默认值。 |
+| `convert` | `tysel config convert --to toml\|json [-o FILE] [--manifest FILE]` | 转换已验证的清单。默认写入 stdout。 |
+| `schema` | `tysel config schema` | 打印附带的 Draft 2020-12 JSON Schema；无需项目。 |
+
+`config convert --output` 使用仅新建语义：绝不覆盖文件，父目录必须已经存在，文件扩展名必须与 `--to` 匹配。
+
+```sh
+tysel config validate
+tysel config show --format json
+tysel config convert --to json --output generated/tysel.json
+tysel config schema
+```
+
+所有字段请参阅[清单参考](/reference/manifest)，发现与接入工作流请参阅[项目与配置](/docs/concepts/projects-and-configuration)。
diff --git a/website/locales/zh-CN/content/reference/cli/tasks.mdx b/website/locales/zh-CN/content/reference/cli/tasks.mdx
new file mode 100644
index 0000000..f6028d1
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/cli/tasks.mdx
@@ -0,0 +1,54 @@
+---
+title: "任务与协议命令"
+description: "列出或执行清单原生工作流。"
+---
+
+## `tysel task`
+
+列出或执行清单原生工作流。
+
+```text
+tysel task [NAME] [--list] [--manifest FILE]
+```
+
+使用 `--list` 时，命令会打印已配置的任务。指定 `NAME` 时，它会按照依赖顺序解析一次依赖并执行每个 argv 步骤。任何步骤失败都会停止工作流。步骤继承选定的项目根目录和清单。
+
+```sh
+tysel task --list
+tysel task verify
+```
+
+任务步骤是参数数组，并非 shell 命令。可接受的命令和验证规则请参阅[清单任务](/reference/manifest/tasks)。
+
+## `tysel queue`
+
+向已注册的队列处理程序提交一条 JSON 消息，并打印结果。
+
+```text
+tysel queue <NAME> [ENTRY] [--input JSON] [--message-id ID] [--manifest FILE]
+```
+
+| 参数 | 默认值 | 含义 |
+| --- | --- | --- |
+| `NAME` | 必填 | 已注册的队列名称。 |
+| `ENTRY` | 清单入口 | 可选的入口覆盖值。 |
+| `--input` | `null` | 传递给处理程序的 JSON 值。 |
+| `--message-id` | 自动生成 | 由调用方提供的稳定消息标识符。 |
+
+JSON 格式错误、队列未知或处理程序失败时，命令会以非零状态退出。
+
+```sh
+tysel queue orders --input '{"id":"ord_123"}' --message-id msg_1
+```
+
+## `tysel mcp`
+
+通过有边界、以换行分隔的标准输入输出提供已注册的 MCP 工具。
+
+```text
+tysel mcp [ENTRY] [--manifest FILE]
+```
+
+`ENTRY` 会覆盖 `app.entry`。协议输入和输出专用于 MCP 消息；人类可读的诊断信息会单独写出。工具注册来自应用 `tasks` 导出中 `kind: "mcp"` 的条目。
+
+队列和 MCP 处理程序类型请参阅[应用模块](/reference/runtime/application)，协议边界请参阅[限额与默认值](/reference/limits-and-defaults)。
diff --git a/website/locales/zh-CN/content/reference/component/abi.mdx b/website/locales/zh-CN/content/reference/component/abi.mdx
new file mode 100644
index 0000000..8846571
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/component/abi.mdx
@@ -0,0 +1,55 @@
+---
+title: "Component ABI"
+description: "Tysel 的公开 Component 入口点是带版本的 world：tysel:component/task@0.4.0。"
+---
+
+Tysel 的公开 Component 入口点是带版本的 world：`tysel:component/task@0.4.0`。
+
+## WIT 约定
+
+```wit
+package tysel:component@0.4.0;
+
+world task {
+    export run: func(input: string) -> result<string, string>;
+}
+```
+
+唯一事实来源：`wit/component/task.wit`。
+
+输入字符串和成功输出字符串都必须包含一个有效的 UTF-8 JSON 值。宿主在实例化前验证输入，并在来宾完成 canonical ABI 清理后验证输出。JSON 可以是对象、数组、字符串、数字、布尔值或 `null`。
+
+错误分支是有长度限制、供人阅读的诊断字符串，无需包含 JSON。
+
+## 必需的导出结构
+
+Component 必须导出名为 `run` 的顶层函数，其参数和结果必须与上文完全一致。以下情况无法通过验证：
+
+- 输入是 Core WebAssembly 模块，而非 Component 二进制文件；
+- Component 没有 `run`；
+- `run` 的参数或结果有增减或不同；
+- 宿主边界上的 JSON 格式错误或超过大小限制。
+
+仅有文件扩展名并不能通过验证。`.wasm` 路径会选择 Component 构建流程，随后 Tysel 会解析并验证 Component Model 二进制文件。
+
+宿主从结构上验证导出函数。顶层 Component 函数不会保留来源 WIT 包的身份，因此 Tysel 无法区分产生完全相同 `run` 结构的其他包或版本。Tysel 包中记录的 `0.4.0` 标识其打包器使用的约定；该版本无法单独从来宾中提取。
+
+## 版本兼容性
+
+| 约定 | 当前值 | 兼容规则 |
+| --- | --- | --- |
+| Component 任务 ABI | `0.4.0` | 宿主要求与上文完全一致的 `run` 结构；打包器记录该约定版本。 |
+| 文件系统能力 ABI | `0.4.0` | 只准入确切实现的导入。 |
+| 受限 WASI 导入 | `0.2.x` | 只接受白名单中的语言运行时接口。 |
+
+Component ABI 仍处于实验阶段。版本变化应视为来宾和打包应用的重新构建边界。Tysel 会在可执行文件中保留可移植源码，但这无法使不兼容的 WIT 导入或导出变得兼容。
+
+## SDK 分派
+
+宿主会在调用前验证输入。生成的来宾绑定收到字符串后，Rust 和 Go SDK 辅助函数会在处理程序解码和结果编码前后再次实施相同的 JSON 与字节边界：
+
+```text
+JSON string → decode → typed/raw handler → encode → JSON string
+```
+
+这些辅助函数不会生成 WIT 绑定。绑定生成仍取决于来宾语言和工具链。请参阅 [Rust SDK](/reference/component/rust-sdk) 和 [Go SDK](/reference/component/go-sdk)。
diff --git a/website/locales/zh-CN/content/reference/component/capabilities.mdx b/website/locales/zh-CN/content/reference/component/capabilities.mdx
new file mode 100644
index 0000000..fc3843d
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/component/capabilities.mdx
@@ -0,0 +1,69 @@
+---
+title: "Component 能力"
+description: "Component 默认不获得任何应用能力。最终权限是三个独立检查层的交集。"
+---
+
+Component 默认不获得任何应用能力。最终权限是三个独立检查层的交集：
+
+```text
+actual Component import
+  ∩ manifest permission
+  ∩ deployment policy
+  = effective capability
+```
+
+缺少任意一层都会拒绝实例化或链接。未知能力导入和未知部署策略值会直接失败，而不会被忽略。
+
+## 已实现的导入
+
+当前 Component 宿主只实现以下应用接口：
+
+```wit
+package tysel:fs@0.4.0;
+
+interface read {
+    call: func(input: string) -> result<string, string>;
+}
+
+interface write {
+    call: func(input: string) -> result<string, string>;
+}
+```
+
+| 导入 | 清单请求 | 部署授权 | 输入 | 成功输出 |
+| --- | --- | --- | --- | --- |
+| `tysel:fs/read@0.4.0` | 非空 `permissions.fs_read` | `tysel:fs` 或 `tysel:fs/read` | 包含路径的 JSON 字符串 | 包含 UTF-8 文件内容的 JSON 字符串 |
+| `tysel:fs/write@0.4.0` | 非空 `permissions.fs_write` | `tysel:fs` 或 `tysel:fs/write` | `{"path": string, "data": string}` | JSON `null` |
+
+每个导入接口都导出名为 `call` 的函数。文件仍限制为 1 MiB，且必须解析到固定的清单根目录之下。
+
+## 清单与部署配置
+
+```toml
+[permissions]
+fs_read = ["./input"]
+fs_write = ["./output"]
+```
+
+对于打包后的可执行文件，除非明确设置，否则部署策略为空：
+
+```sh
+export TYSEL_COMPONENT_CAPABILITIES=tysel:fs/read,tysel:fs/write
+printf '{"path":"./input/job.json"}' | ./dist/file-component
+```
+
+可接受的策略标记如下：
+
+| 标记 | 效果 |
+| --- | --- |
+| `tysel:fs` | 当清单请求且来宾导入时，允许两个已实现的文件系统接口。 |
+| `tysel:fs/read` | 只允许读取。 |
+| `tysel:fs/write` | 只允许写入。 |
+
+标记以逗号分隔，空白会被忽略。拼写错误或任何其他能力都会导致错误。本地执行 `tysel run` 时，Tysel 从清单推导部署授权，使通过检查的项目可以运行；构建后的可执行文件仍然默认拒绝部署权限。
+
+对于 Component 执行配置，`tysel check` 和 `tysel inspect` 只会在能力列表中显示文件系统请求。HTTP、密钥、数据库、LLM、WebSocket 和持久处理程序会列在 `Denied` 下；`tysel build` 同样不会在能力摘要中包含它们。
+
+HTTP、SQLite、LLM、密钥、MCP 和持久 Component 能力目前不可用。当前应用约定只有 `tysel:component/task@0.4.0` 和上面的两个文件系统导入。
+
+请参阅[清单权限](/reference/manifest/permissions)、[安全模型](/docs/security)和[运行时与 WASI](/reference/component/runtime)。
diff --git a/website/locales/zh-CN/content/reference/component/go-sdk.mdx b/website/locales/zh-CN/content/reference/component/go-sdk.mdx
new file mode 100644
index 0000000..9cbf364
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/component/go-sdk.mdx
@@ -0,0 +1,53 @@
+---
+title: "Go Component SDK"
+description: "请使用已安装 Tysel 版本的 Component 起始包中附带的来宾 SDK 源码和 WIT 包。起始模块已经使用本地替换。"
+---
+
+状态：**实验性且带版本**。请使用已安装 Tysel 版本的 Component 起始包中附带的来宾 SDK 源码和 WIT 包。起始模块已经使用本地替换：
+
+```text title="go.mod"
+require github.com/wangcch/tysel/sdk/component-go v0.0.0
+
+replace github.com/wangcch/tysel/sdk/component-go => ./sdk/component-go
+```
+
+该 SDK 目前未作为独立 Go 模块版本发布。
+
+## 来宾接口
+
+```go
+type Handler func(json.RawMessage) (any, error)
+
+func Dispatch(input string, handler Handler) (string, error)
+```
+
+`Dispatch` 检查输入 JSON、调用处理程序、编码结果，并强制实施 1 MiB 输入、1 MiB 输出和 4 KiB UTF-8 安全错误信息的边界。
+
+## 生成的绑定适配器
+
+Component Model 绑定仍由来宾应用负责。发布起始项目使用 Bytecode Alliance 的 `componentize-go`，并适配其生成的结果类型：
+
+```go
+package export_wit_world
+
+import (
+    "encoding/json"
+
+    component "github.com/wangcch/tysel/sdk/component-go"
+    witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+func Run(input string) witTypes.Result[string, string] {
+    output, err := component.Dispatch(input, func(input json.RawMessage) (any, error) {
+        return input, nil
+    })
+    if err != nil {
+        return witTypes.Err[string, string](err.Error())
+    }
+    return witTypes.Ok[string, string](output)
+}
+```
+
+起始项目由 `componentize-go` `0.4.1` 生成，并已包含生成的 `wit_exports.go`，因此常规构建无需重新生成绑定。
+
+经过测试的工作流请参阅[构建 Go Component](/docs/guides/wasm-component-go)；添加导入前请阅读 [Component 能力](/reference/component/capabilities)。
diff --git a/website/locales/zh-CN/content/reference/component/index.mdx b/website/locales/zh-CN/content/reference/component/index.mdx
new file mode 100644
index 0000000..7553bdb
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/component/index.mdx
@@ -0,0 +1,60 @@
+---
+title: "Wasm Component"
+description: "Tysel 通过 WebAssembly Component Model 运行与语言无关的一次性任务。它不执行任意 Core WebAssembly 模块，也不提供通用 WASI 应用宿主。"
+---
+
+状态：**实验性**。Tysel 通过 WebAssembly Component Model 运行与语言无关的一次性任务。它不执行任意 Core WebAssembly 模块，也不提供通用 WASI 应用宿主。
+
+## 产品约定
+
+Component 应用具有三个决定性特征：
+
+1. 清单使用 `profile = "component"`，入口为 `.wasm` 文件；
+2. 入口实现 `tysel:component/task@0.4.0`；
+3. 从 stdin 输入一个 JSON 值，并向 stdout 输出一个 JSON 值。
+
+```toml
+[app]
+name = "echo-component"
+entry = "echo.component.wasm"
+profile = "component"
+```
+
+Component 执行配置适合使用 Rust、Go 或其他具备 Component Model 工具链的语言编写有边界的函数。其范围有意小于 Tysel 的 TypeScript 服务运行时。
+
+## 命令行为
+
+| 命令 | Component 行为 |
+| --- | --- |
+| `tysel check` | 验证 Component 二进制文件、任务 ABI、WASI 导入、能力导入和清单授权。不执行 TypeScript 检查和 Node 扫描。 |
+| `tysel dev` | 失败。Component 是一次性任务，不能作为支持重新加载的 HTTP 服务运行。 |
+| `tysel run` | 从 stdin 读取一个 JSON 值，调用 Component 一次，向 stdout 写入一个 JSON 值和换行符，然后退出。 |
+| `tysel build` | 将可移植 Component 打包为一个原生可执行文件，并可包含兼容的宿主专用优化元数据。 |
+| 构建后的可执行文件 | 使用相同的一次性 stdin/stdout 约定。部署能力策略默认拒绝访问。 |
+
+```sh
+printf '{"value":42}' | tysel run
+tysel build
+printf '{"value":42}' | ./dist/echo-component
+```
+
+## 不提供的功能
+
+- 不提供 HTTP 监听器、Fetch 处理程序、Cron、Queue、MCP 或持久处理程序；
+- 不提供 `tysel init` Component 模板，请从 Rust 或 Go SDK 固定样例开始；
+- 不提供 `tysel dev` 监视模式；
+- 不提供 JavaScript 全局对象或 `globalThis.tysel` 对象；
+- 不通过 WASI 提供隐式参数、环境变量、继承的标准输入输出、预打开目录或网络访问；
+- 不普遍支持 Core Wasm、WASI CLI 应用或任意 WIT world。
+
+## 参考索引
+
+| 需求 | 参考 |
+| --- | --- |
+| 确切的任务 world 和 JSON 边界 | [Component ABI](/reference/component/abi) |
+| 可移植执行、受限 WASI、优化元数据和限额 | [运行时与 WASI](/reference/component/runtime) |
+| 文件系统导入和三层授权 | [Component 能力](/reference/component/capabilities) |
+| Rust 来宾类型和分派器 | [Rust SDK](/reference/component/rust-sdk) |
+| Go 来宾分派器和生成的绑定 | [Go SDK](/reference/component/go-sdk) |
+
+可运行流程请参阅[构建 Rust Component](/docs/guides/wasm-component-rust)或[构建 Go Component](/docs/guides/wasm-component-go)。已安装的二进制文件及其源码版本附带的 WIT 文件是最终依据。
diff --git a/website/locales/zh-CN/content/reference/component/runtime.mdx b/website/locales/zh-CN/content/reference/component/runtime.mdx
new file mode 100644
index 0000000..39a559c
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/component/runtime.mdx
@@ -0,0 +1,64 @@
+---
+title: "Component 运行时与 WASI"
+description: "Tysel 在有边界的 isolated-task 信任模式下执行可移植 Wasm Component。应用兼容性由公开 Component ABI、允许的 WASI 导入和已记录的资源限额定义。"
+---
+
+Tysel 在有边界的 `isolated-task` 信任模式下执行可移植 Wasm Component。应用兼容性由公开 Component ABI、允许的 WASI 导入和已记录的资源限额定义。嵌入式引擎及其依赖版本既不是应用 API，也不构成可移植兼容性保证。
+
+## 调用生命周期
+
+```text
+read bounded stdin
+  → validate JSON
+  → compile portable Component
+  → validate imports and policy
+  → instantiate restricted WASI
+  → call run(string)
+  → validate bounded JSON output
+  → write stdout + newline
+```
+
+每次进程执行只运行一次调用。`tysel run` 和打包后的可执行文件会读取 stdin 直至 EOF，因此调用方写入 JSON 值后必须关闭 stdin。
+
+## 受限 WASI 0.2 配置
+
+仅当来宾语言运行时需要时，Tysel 才接受以下 WASI 接口族：
+
+| 接口族 | 允许的接口 | 实际权限 |
+| --- | --- | --- |
+| CLI | environment、exit、stdin/stdout/stderr、terminal input/output 变体 | 不继承参数或环境；标准输入输出不会作为应用通道继承。JSON 任务通道由 Tysel 管理。 |
+| 时钟 | monotonic clock、wall clock | 供语言运行时使用的时钟支持。 |
+| 文件系统运行时 | types、preopens | 没有预打开目录。 |
+| I/O | error、poll、streams | 仅用于语言运行时内部连接。 |
+| 随机数 | random | 供语言运行时使用的随机数。 |
+
+导入必须使用 WASI `0.2.x`。其他 WASI 接口会在实例化前被拒绝，尤其不提供套接字和网络访问。应用的文件系统访问使用 Tysel 自己的能力 ABI，而非 WASI preopen。
+
+## 资源边界
+
+| 资源 | 默认或实际边界 | 最大值 |
+| --- | ---: | ---: |
+| 可移植 Component | 16 MiB | 16 MiB |
+| 线性内存 | `limits.memory_mb`，上限收紧至 64 MiB | 64 MiB |
+| 燃料 | 10,000,000 单位 | 100,000,000 单位 |
+| 执行时间 | `limits.request_timeout_ms`，默认 30 秒 | 60 秒 |
+| JSON 输入 | 1 MiB | 1 MiB |
+| JSON 输出 | 1 MiB | 1 MiB |
+| 保留的来宾错误 | 4 KiB | 4 KiB |
+| 宿主专用优化元数据 | — | 64 MiB |
+| Component 实例/内存/表 | 32 / 8 / 8 | 固定实现边界 |
+
+字节限制按 UTF-8 编码后的大小计算，而非字符数。燃料和 epoch 中断会限制 CPU 循环；宿主文件系统调用也共用本次调用的截止时间。
+
+## 可移植 Component 约定
+
+`tysel build` 将可移植 Component 保留为应用产物。宿主专用优化元数据如果存在，只有绑定以下信息时才会被接受：
+
+- Component ABI 版本；
+- 运行时引擎兼容性身份；
+- 宿主架构和操作系统；
+- 可移植源码的 SHA-256。
+
+运行时会拒绝不兼容或被篡改的优化元数据，并可使用保留的可移植 Component 执行。可移植性和正确性由可移植 Component 约定定义；可选的宿主专用元数据不代表启动性能保证。
+
+跨运行时清单请参阅[限额与默认值](/reference/limits-and-defaults)，来宾导出约定请参阅 [Component ABI](/reference/component/abi)。
diff --git a/website/locales/zh-CN/content/reference/component/rust-sdk.mdx b/website/locales/zh-CN/content/reference/component/rust-sdk.mdx
new file mode 100644
index 0000000..0e1b8d6
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/component/rust-sdk.mdx
@@ -0,0 +1,72 @@
+---
+title: "Rust Component SDK"
+description: "Rust Component 项目应使用与已安装 Tysel 次版本匹配的已发布 crate。"
+---
+
+状态：**实验性且带版本**。Rust Component 项目应使用与已安装 Tysel 次版本匹配的已发布 crate：
+
+```toml
+tysel-component-sdk = "0.2.0"
+```
+
+发布起始项目同样是自包含的：它内置相同版本的 SDK，并使用 `tysel-component-sdk = { path = "sdk/tysel-component-sdk" }`。自己的项目可以使用 crates.io 依赖；如果可复现或离线构建起始项目更重要，则保留内置的路径依赖。
+
+## 来宾接口
+
+```rust
+pub trait Task {
+    type Input: serde::de::DeserializeOwned;
+    type Output: serde::Serialize;
+
+    fn run(input: Self::Input) -> Result<Self::Output, String>;
+}
+
+pub fn dispatch<T: Task>(input: &str) -> Result<String, String>;
+```
+
+`dispatch` 验证并解码 JSON、调用 `Task::run`、序列化结果，并强制实施 1 MiB 输入、1 MiB 输出和 4 KiB 错误信息的边界。
+
+## WIT 绑定
+
+SDK 不生成绑定。来宾使用 `wit-bindgen` 处理 `wit/component`，并将生成的 `Guest::run` 连接到 `dispatch`：
+
+```rust
+use serde::{Deserialize, Serialize};
+use tysel_component_sdk::{dispatch, Task};
+
+wit_bindgen::generate!({
+    path: "wit/component",
+    world: "task",
+});
+
+#[derive(Deserialize)]
+struct Input { value: serde_json::Value }
+
+#[derive(Serialize)]
+struct Output { value: serde_json::Value }
+
+struct Echo;
+
+impl Task for Echo {
+    type Input = Input;
+    type Output = Output;
+
+    fn run(input: Input) -> Result<Output, String> {
+        Ok(Output { value: input.value })
+    }
+}
+
+struct Component;
+
+impl Guest for Component {
+    fn run(input: String) -> Result<String, String> {
+        dispatch::<Echo>(&input)
+    }
+}
+
+export!(Component);
+```
+
+发布起始项目固定使用 `wit-bindgen` `0.57.1`，先构建 `wasm32-unknown-unknown` 核心模块，再由 `wasm-tools` `1.247.0` 封装为 Component。这些是经过验证的固定样例版本，不代表开放式的工具链兼容性承诺。
+
+经过测试的命令请参阅[构建 Rust Component](/docs/guides/wasm-component-rust)，宿主验证规则请参阅 [Component ABI](/reference/component/abi)。
diff --git a/website/locales/zh-CN/content/reference/environment.mdx b/website/locales/zh-CN/content/reference/environment.mdx
new file mode 100644
index 0000000..a4f1e79
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/environment.mdx
@@ -0,0 +1,75 @@
+---
+title: "环境变量"
+description: "环境变量用于配置宿主和安装，而不是应用 JavaScript。"
+---
+
+环境变量用于配置宿主和安装，而不是应用 JavaScript。运行时会过滤应用访问：声明密钥只会通过 `tysel.secrets` 提供不透明引用，而不会通过 `process.env` 暴露。
+
+## 安装与工具链
+
+| 变量 | 默认值 | 作用域 |
+| --- | --- | --- |
+| `TYSEL_HOME` | `$HOME/.tysel` | 托管安装及其状态的绝对根目录。 |
+| `TYSEL_DOWNLOAD_BASE` | 官方发布端点 | 安装、doctor 和 upgrade 使用的受信任镜像或 CI 固定资源。 |
+| `TYSEL_STUB` | 位于 CLI 旁或构建树中 | `build`、`image` 和基准测试工具使用的运行时存根。 |
+| `TYSEL_WORKER` | 位于 CLI 旁或构建树中 | 隔离工作进程可执行文件覆盖值。 |
+| `DOCKER` | `docker` | `tysel image` 使用的容器构建器可执行文件；`--builder` 优先级更高。 |
+
+`TYSEL_DOWNLOAD_BASE` 会改变可执行产物的来源。只应将其设为具有同等验证策略的受控镜像。仅针对一次调用的覆盖值，优先使用 `build --stub` 等命令选项。`DOCKER` 必须指定一个不含附加命令参数的可执行文件。单次调用需要替代工具时，使用 `tysel image --builder podman`。
+
+## 应用能力
+
+| 变量 | 必需条件 | 说明 |
+| --- | --- | --- |
+| <code>{"TYSEL_POSTGRES_<NAME>"}</code> | 清单授予具名 Postgres 访问权限 | 唯一已配置授权的连接 URL。将名称转为大写，并把 `-` 替换为 `_`。 |
+| <code>{"TYSEL_REDIS_<NAME>"}</code> | 清单授予具名 Redis 访问权限 | 唯一已配置授权的连接 URL。将名称转为大写，并把 `-` 替换为 `_`。 |
+| `permissions.secrets` 中的名称 | 宿主能力需要该密钥 | 名称和值由部署方管理；JavaScript 只会收到 `SecretReference`。 |
+
+名为 `review-ro` 的授权对应宿主键 `TYSEL_POSTGRES_REVIEW_RO`；Redis 使用相同映射。连接 URL 和密钥值不得写入清单、命令行、构建产物或日志。
+
+在 `tysel dev` 下，`.env` 参与本地解析，但只会导入已声明的密钥名称以及选定的 Postgres 和 Redis 连接。无关变量不会成为应用全局变量。
+
+## 持久存储
+
+| 变量 | 优先级 | 含义 |
+| --- | ---: | --- |
+| `TYSEL_DURABLE_POSTGRES_URL` | 1 | 选择 Postgres 持久存储。非空值优先。 |
+| `TYSEL_DURABLE_SQLITE_PATH` | 2 | 覆盖 SQLite 持久事件日志路径。 |
+| 清单 `[durable].path` 所在目录 | 3 | 未设置宿主覆盖值时，将 `durable-events.db` 放在应用 SQLite 数据库旁。 |
+
+生产 Postgres 应使用经过证书验证的 TLS，并将连接 URL 保存在服务管理器或密钥管理器中。
+
+## LLM 提供商
+
+| 变量 | 默认值 | 含义 |
+| --- | --- | --- |
+| `TYSEL_LLM_ENDPOINT` | 未设置 | 在该 responses 端点启用 OpenAI 兼容提供商。 |
+| `TYSEL_LLM_MODEL` | 设置端点时必需 | 上游提供商模型。 |
+| `TYSEL_LLM_ALIAS` | `default` | `generate` 接受的面向应用的模型别名。 |
+| `TYSEL_LLM_SECRET` | `OPENAI_API_KEY` | 用作提供商凭据的已声明密钥名称。 |
+
+如果 `TYSEL_LLM_ENDPOINT` 未设置或为空，LLM 能力会被禁用。`TYSEL_LLM_SECRET` 指定的密钥还必须出现在 `permissions.secrets` 中，并由宿主提供。
+
+## OpenTelemetry
+
+| 变量 | 含义 |
+| --- | --- |
+| `OTEL_SDK_DISABLED=true` | 即使端点仍已设置，也禁用追踪和指标导出。 |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | 共享 OTLP/HTTP 端点。 |
+| `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` | 追踪专用端点。 |
+| `OTEL_EXPORTER_OTLP_METRICS_ENDPOINT` | 指标专用端点。 |
+
+按信号指定的端点会根据 OpenTelemetry exporter 规则覆盖或补充共享导出配置。清单中的 `traces` 和 `metrics` 字段尚未传递到打包执行环境。端点必须使用 HTTP(S)，最长 2 KiB，且不能包含用户信息、查询参数或片段。采集器凭据应放入标准 OTLP headers 配置，绝不能写入 URL。
+
+## 高级宿主集成
+
+| 变量 | 平台 | 用途 |
+| --- | --- | --- |
+| `TYSEL_CGROUP` | Linux | 用于挂接隔离工作进程的 cgroup v2 子树。 |
+| `TYSEL_COMPONENT_CAPABILITIES` | Component 宿主 | 以逗号分隔的 `tysel:fs`、`tysel:fs/read` 或 `tysel:fs/write` 部署授权。未知值会以默认拒绝方式失败。 |
+
+这些变量是部署集成点，不是应用输入。仅用于测试的变量和仓库发布签名变量有意不纳入应用参考。
+
+对于打包后的 Component，该变量默认未设置，因此即使清单请求了应用能力，访问仍会被拒绝。三层交集和本地 `tysel run` 行为请参阅 [Component 能力](/reference/component/capabilities)。
+
+另请参阅[权限](/reference/manifest/permissions)、[宿主能力](/reference/runtime/capabilities)、[可观测性指南](/docs/guides/observability)和[生产运维](/docs/operations/production)。
diff --git a/website/locales/zh-CN/content/reference/errors-and-output.mdx b/website/locales/zh-CN/content/reference/errors-and-output.mdx
new file mode 100644
index 0000000..97c872b
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/errors-and-output.mdx
@@ -0,0 +1,106 @@
+---
+title: "错误与机器可读输出"
+description: "Tysel 将人类可读诊断与稳定 JSON 信封分离。自动化流程应明确选择机器可读模式，并分别解析 stdout 和 stderr。"
+---
+
+Tysel 将人类可读诊断与稳定 JSON 信封分离。自动化流程应明确选择机器可读模式，并分别解析 stdout 和 stderr。
+
+## CLI 退出状态
+
+| 状态 | 含义 |
+| --- | --- |
+| `0` | 命令成功完成。 |
+| 非零 | 验证、兼容性策略、测试、构建、基准门禁、运行时或命令用法失败。 |
+
+不要仅根据数字状态推断具体失败类型。请使用选定的 JSON 报告或致命错误信封。
+
+## CLI 致命错误
+
+该选项为全局选项，可出现在命令之前或之后：
+
+```sh
+tysel --error-format json check
+```
+
+致命错误以单个 JSON 对象写入 stderr。当 Oxc 提供 span 时，构建失败还会包含带原始源码位置的 `diagnostics` 数组：
+
+```json
+{
+  "error": {
+    "code": "TYSEL_CLI_ERROR",
+    "message": "manifest validation failed: ..."
+  },
+  "diagnostics": [{
+    "code": "TYSEL_PARSE_ERROR",
+    "message": "...",
+    "severity": "error",
+    "phase": "parse",
+    "file": "src/index.ts",
+    "start": { "line": 4, "column": 7, "byteOffset": 52 },
+    "end": { "line": 4, "column": 8, "byteOffset": 53 }
+  }]
+}
+```
+
+`code` 目前统一为 `TYSEL_CLI_ERROR`；`message` 用于人类诊断，不能作为稳定的程序化判别字段。该致命错误路径以状态 `1` 退出。
+
+单项静态诊断使用以下稳定错误码：
+
+| 错误码 | 含义 |
+| --- | --- |
+| `TYSEL_MANIFEST_PARSE_ERROR` | TOML/JSON 语法分析或反序列化失败。 |
+| `TYSEL_MANIFEST_INVALID` | 清单语义规则验证失败。 |
+| `TYSEL_NODE_BUILTIN_UNSUPPORTED` | 运行时导入请求 Node 内置模块。 |
+| `TYSEL_IMPORT_UNRESOLVED` | 无法解析运行时导入。 |
+
+清单诊断使用 `manifest` 阶段；导入诊断使用 `resolve`。清单验证报告第一个失败，并在可用时提供字段范围。缺失字段可能没有范围，解析器错误也可能指向插入位置或所在表。导入诊断覆盖构建解析器可达的模块，包括依赖，并指向原始 TypeScript 源码，而非生成的 JavaScript。已擦除的纯类型导入不会包含在内。TypeScript 类型检查输出仍是编译器文本，不属于该结构化协议。
+
+## 开发诊断流
+
+服务器持续运行期间，`tysel --error-format json dev` 会在每次诊断更新时向 stderr 写入一个 JSON 对象。重新加载失败时发布非空数组；下一次成功重新加载会发布空数组，使编辑器可以清除过期诊断。`generation` 随每次重新加载尝试递增，当前 `schemaVersion` 为 `1`。
+
+未处理的处理程序失败会发布独立的 `runtimeDiagnostic` 事件，其中包含一项经过源码映射的诊断和十六进制 `requestId`。它表示一次事件，并不会替换当前构建诊断快照。运行时堆栈限制为 64 KiB，并通过容量为 64 项的有界队列传递。队列溢出时，Tysel 会在恢复输出后发出 `TYSEL_DIAGNOSTICS_DROPPED`。行号和列号从一开始；编译器提供的 `byteOffset` 是从零开始的 UTF-8 偏移量。
+
+## 命令报告
+
+机器可读命令报告写入 stdout：
+
+```sh
+tysel test --json
+tysel compat --json
+tysel bench all --format json
+tysel doctor --json
+tysel upgrade --check --json
+```
+
+命令完成分析但发现策略或测试失败时，JSON 报告可以与非零状态同时出现。必须同时检查两者。应保留 stderr，以接收阻止报告生成的致命准备错误。
+
+## HTTP 错误信封
+
+未处理的运行时失败返回 HTTP `500` 和以下 JSON：
+
+```json
+{
+  "error": {
+    "code": "RUNTIME_ERROR",
+    "message": "...",
+    "requestId": "000000000000002a"
+  }
+}
+```
+
+过大的入站正文返回 HTTP `413`，结构相同，错误码为 `BODY_TOO_LARGE`。`requestId` 是固定宽度的十六进制关联值。内部序列化回退可能只返回 `{"error":{"code":"INTERNAL_ERROR"}}`。
+
+`tysel dev` 使用生成的源码映射解析应用堆栈信息。虽然打包时会嵌入映射，但打包后的 HTTP 分派器目前不会应用它，因此生产消息可能包含打包位置。所有运行时消息都应视为运维诊断：向公共客户端暴露前，应将错误映射为应用自行定义的响应，以免泄露敏感内部信息。
+
+## 应用错误
+
+Tysel 不会对 fetch 处理程序返回的响应强制规定错误 schema。应明确设计应用状态码和 JSON 信封，并包含安全的关联标识符。返回的 `Response` 属于应用响应；处理程序抛出异常或返回被拒绝的 Promise 时，会转为运行时 `500` 信封。
+
+## Component 进程输出
+
+Component 调用成功时，向 stdout 写入恰好一个 JSON 值和一个换行符，并以 `0` 退出。编译、ABI、策略、来宾错误、资源限额或输出验证失败属于 stderr 上的致命 CLI/运行时错误，并以非零状态退出；它们不使用 HTTP 错误信封。
+
+Component 来宾的 WIT 错误分支会保留为最长 4 KiB 的 UTF-8 诊断。该文本供人阅读，不应作为稳定错误码。请参阅 [Component ABI](/reference/component/abi)和 [Component 运行时限额](/reference/component/runtime#resource-bounds)。
+
+另请参阅[调试服务故障](/docs/guides/debugging)、[应用模块](/reference/runtime/application)、[应用限额](/reference/manifest/limits)和[生产运维](/docs/operations/production)。
diff --git a/website/locales/zh-CN/content/reference/index.mdx b/website/locales/zh-CN/content/reference/index.mdx
new file mode 100644
index 0000000..cda4405
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/index.mdx
@@ -0,0 +1,94 @@
+---
+title: "概览"
+description: "参考页面描述精确接口：接受的值、默认值、副作用、错误和稳定性边界。如果需要的是工作流而非约定，请从指南开始。"
+---
+
+参考页面描述精确接口：接受的值、默认值、副作用、错误和稳定性边界。如果需要的是工作流而非约定，请从[指南](/docs/guides)开始。
+
+网站的 `/reference` 索引呈现扁平的模块目录。可使用侧边栏或以下章节进入具体约定页面。
+
+## 运行时
+
+| 模块 | 说明 |
+| --- | --- |
+| [运行时](/reference/runtime) | 导出和 `globalThis.tysel` 概览 |
+| [核心类型](/reference/runtime/types) | `JsonValue`、执行配置、信任模式 |
+| [应用模块](/reference/runtime/application) | `fetch`、cron、queue、MCP 导出 |
+| [宿主能力](/reference/runtime/capabilities) | 密钥、SQL、文件系统、LLM、WebSocket |
+| [持久 API](/reference/runtime/durable) | 副作用、休眠、信号、恢复 |
+| [测试 API](/reference/runtime/testing) | `test`、`assert`、`invokeFetch` |
+
+## Web API
+
+| 模块 | 说明 |
+| --- | --- |
+| [JavaScript API](/reference/javascript) | 索引与兼容性清单 |
+| [fetch](https://tysel.dev/reference/javascript/fetch) | 受白名单控制的出站 HTTP |
+| [Request 与 Response](https://tysel.dev/reference/javascript/request) | Web 标准消息类型 |
+| [Headers](https://tysel.dev/reference/javascript/headers) | 不区分大小写的请求头映射 |
+| [URL](https://tysel.dev/reference/javascript/url) | URL 与 URLSearchParams |
+| [WebSocket](https://tysel.dev/reference/javascript/websocket) | 客户端和服务器套接字子集 |
+| [Crypto](https://tysel.dev/reference/javascript/crypto) | Web Crypto 子集 |
+| [Timers](https://tysel.dev/reference/javascript/timers) | setTimeout 与 setInterval |
+| [Event](https://tysel.dev/reference/javascript/event) | Event 与 EventTarget |
+| [AbortController](https://tysel.dev/reference/javascript/abortcontroller) | 用于 fetch 和任务的 AbortSignal |
+| [TextEncoder](https://tysel.dev/reference/javascript/textencoder) | UTF-8 编码与解码 |
+
+## Wasm Component
+
+| 模块 | 说明 |
+| --- | --- |
+| [Wasm Component](/reference/component) | 执行配置、信任模式、任务边界 |
+| [Component ABI](/reference/component/abi) | `tysel:component/task` world |
+| [运行时与 WASI](/reference/component/runtime) | 可移植执行限额与受限 WASI |
+| [Component 能力](/reference/component/capabilities) | 文件系统 WIT 导入 |
+| [Rust SDK](/reference/component/rust-sdk) | 来宾类型与分派器 |
+| [Go SDK](/reference/component/go-sdk) | 生成的绑定 |
+
+## CLI
+
+| 模块 | 说明 |
+| --- | --- |
+| [CLI](/reference/cli) | 全局语法与命令索引 |
+| [项目命令](/reference/cli/project) | `init`、`config`、schema |
+| [开发与测试](/reference/cli/development) | `check`、`compat`、`test`、`dev`、`run`、`inspect` |
+| [任务与协议](/reference/cli/tasks) | `task`、`queue`、`mcp` |
+| [构建与镜像](/reference/cli/delivery) | `build`、`image` |
+| [安装](/reference/cli/installation) | `doctor`、`upgrade` |
+| [验证材料](/reference/cli/evidence) | `bench`、`release` |
+
+## 清单与宿主
+
+| 模块 | 说明 |
+| --- | --- |
+| [清单](/reference/manifest) | 完整配置字段索引、默认值、约束、模板与验证 |
+| [应用与服务器](/reference/manifest/app-server) | 应用身份与入站服务器 |
+| [权限](/reference/manifest/permissions) | 网络、密钥、SQL、文件系统 |
+| [应用限额](/reference/manifest/limits) | 正文大小、并发数、超时 |
+| [持久存储与可观测性](/reference/manifest/durable-observability) | 存储、日志、遥测 |
+| [清单任务](/reference/manifest/tasks) | 项目工作流定义 |
+| [环境变量](/reference/environment) | 安装器、CLI、宿主适配器 |
+| [限额与默认值](/reference/limits-and-defaults) | 固定边界 |
+| [错误与输出](/reference/errors-and-output) | 退出码与 JSON 信封 |
+
+## 相关指南
+
+| 主题 | 链接 |
+| --- | --- |
+| 能力矩阵 | [docs/capabilities](/docs/capabilities) |
+| npm 兼容性 | [docs/compatibility](/docs/compatibility) |
+| 示例库 | [docs/guides/examples](/docs/guides/examples) |
+
+## 当前版本的最终依据
+
+本参考描述生成这些文档的源码树。对于已安装的二进制文件，其帮助和附带 schema 是最终依据：
+
+```sh
+tysel --version
+tysel --help
+tysel config schema
+tysel config show --format json
+tysel inspect
+```
+
+未知清单字段会导致错误。这里没有列出的 API 或环境变量应视为实现细节，除非发布说明明确将其提升为公开约定。
diff --git a/website/locales/zh-CN/content/reference/javascript/abortcontroller.mdx b/website/locales/zh-CN/content/reference/javascript/abortcontroller.mdx
new file mode 100644
index 0000000..b8666f4
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/javascript/abortcontroller.mdx
@@ -0,0 +1,25 @@
+---
+title: "AbortController 与 AbortSignal"
+description: "Tysel JavaScript 运行时支持的 AbortController 与 AbortSignal 约定。"
+---
+
+状态：`partial`。本页描述受支持的服务端子集，而非完整的浏览器规范。
+下列清单以外的行为不属于兼容性约定。
+
+事实来源：`runtime-js/web-api/compatibility.json`
+（稳定的 `tysel-server-web-subset`）。
+
+## 支持
+
+- 中止原因
+- throwIfAborted
+- AbortSignal.abort
+- AbortSignal.timeout
+- 取消 fetch 和响应正文
+
+## 不支持
+
+- AbortSignal.any
+
+另请参阅 [JavaScript API 索引](/reference/javascript)和
+[npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/crypto.mdx b/website/locales/zh-CN/content/reference/javascript/crypto.mdx
new file mode 100644
index 0000000..b9b253e
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/javascript/crypto.mdx
@@ -0,0 +1,26 @@
+---
+title: "Crypto"
+description: "Tysel JavaScript 运行时支持的 Crypto 约定。"
+---
+
+状态：`partial`。本页描述受支持的服务端子集，而非完整的浏览器规范。
+下列清单以外的行为不属于兼容性约定。
+
+事实来源：`runtime-js/web-api/compatibility.json`
+（稳定的 `tysel-server-web-subset`）。
+
+## 支持
+
+- getRandomValues
+- SHA-256/384/512 摘要
+- 导入原始 HMAC 密钥以及签名和验证
+
+## 不支持
+
+- randomUUID
+- 导出密钥
+- 加密
+- 非对称算法
+
+另请参阅 [JavaScript API 索引](/reference/javascript)和
+[npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/event.mdx b/website/locales/zh-CN/content/reference/javascript/event.mdx
new file mode 100644
index 0000000..0a8dc81
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/javascript/event.mdx
@@ -0,0 +1,26 @@
+---
+title: "Event 与 EventTarget"
+description: "Tysel JavaScript 运行时支持的 Event 与 EventTarget 约定。"
+---
+
+状态：`partial`。本页描述受支持的服务端子集，而非完整的浏览器规范。
+下列清单以外的行为不属于兼容性约定。
+
+事实来源：`runtime-js/web-api/compatibility.json`
+（稳定的 `tysel-server-web-subset`）。
+
+## 支持
+
+- 函数和对象监听器
+- 监听器去重和移除
+- once 和 AbortSignal 选项
+- preventDefault 和立即停止传播
+
+## 不支持
+
+- DOM 事件树
+- 捕获和冒泡阶段
+- 浏览器异常报告
+
+另请参阅 [JavaScript API 索引](/reference/javascript)和
+[npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/fetch.mdx b/website/locales/zh-CN/content/reference/javascript/fetch.mdx
new file mode 100644
index 0000000..872e20d
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/javascript/fetch.mdx
@@ -0,0 +1,27 @@
+---
+title: "fetch"
+description: "Tysel JavaScript 运行时支持的 fetch 约定。"
+---
+
+状态：`partial`。本页描述受支持的服务端子集，而非完整的浏览器规范。
+下列清单以外的行为不属于兼容性约定。
+
+事实来源：`runtime-js/web-api/compatibility.json`
+（稳定的 `tysel-server-web-subset`）。
+
+## 支持
+
+- 宿主策略允许的 HTTP 方法
+- 请求头和缓冲的请求正文
+- 重定向策略
+- 以流方式消费响应
+- 通过 AbortSignal 取消请求
+
+## 不支持
+
+- 流式请求正文
+- multipart/form data
+- 浏览器的缓存、凭据和 mode 语义
+
+另请参阅 [JavaScript API 索引](/reference/javascript)和
+[npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/headers.mdx b/website/locales/zh-CN/content/reference/javascript/headers.mdx
new file mode 100644
index 0000000..dccf121
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/javascript/headers.mdx
@@ -0,0 +1,25 @@
+---
+title: "Headers"
+description: "Tysel JavaScript 运行时支持的 Headers 约定。"
+---
+
+状态：`partial`。本页描述受支持的服务端子集，而非完整的浏览器规范。
+下列清单以外的行为不属于兼容性约定。
+
+事实来源：`runtime-js/web-api/compatibility.json`
+（稳定的 `tysel-server-web-subset`）。
+
+## 支持
+
+- 使用 record、Headers 和键值对初始化
+- get/set/append/delete/has
+- 稳定迭代
+
+## 不支持
+
+- 浏览器请求头守卫
+- 拆分 Set-Cookie
+- 完整的 HTTP token 验证
+
+另请参阅 [JavaScript API 索引](/reference/javascript)和
+[npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/index.mdx b/website/locales/zh-CN/content/reference/javascript/index.mdx
new file mode 100644
index 0000000..4ebaa77
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/javascript/index.mdx
@@ -0,0 +1,23 @@
+---
+title: "JavaScript API"
+description: "受支持的服务端 Web API 子集。每个页面都定义一个全局对象的兼容性约定。"
+---
+
+Tysel 实现了一个有明确边界的服务端 Web API 执行配置。需要查询全局对象时使用这些页面；
+需要完成具体工作流时，请使用[指南](/docs/guides)。
+
+`partial` 表示列出的行为属于受支持约定，并不表示完整实现了对应的浏览器规范。
+机器可读清单位于 `runtime-js/web-api/compatibility.json`。
+
+| API | 状态 |
+| --- | --- |
+| [URL 与 URLSearchParams](/reference/javascript/url) | `partial` |
+| [Headers](/reference/javascript/headers) | `partial` |
+| [Request 与 Response](/reference/javascript/request) | `partial` |
+| [TextEncoder 与 TextDecoder](/reference/javascript/textencoder) | `partial` |
+| [定时器](/reference/javascript/timers) | `supported` |
+| [Event 与 EventTarget](/reference/javascript/event) | `partial` |
+| [AbortController 与 AbortSignal](/reference/javascript/abortcontroller) | `partial` |
+| [Crypto](/reference/javascript/crypto) | `partial` |
+| [fetch](/reference/javascript/fetch) | `partial` |
+| [WebSocket](/reference/javascript/websocket) | `partial` |
diff --git a/website/locales/zh-CN/content/reference/javascript/meta.json b/website/locales/zh-CN/content/reference/javascript/meta.json
new file mode 100644
index 0000000..eb265a4
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/javascript/meta.json
@@ -0,0 +1,16 @@
+{
+  "title": "JavaScript",
+  "pages": [
+    "index",
+    "url",
+    "headers",
+    "request",
+    "textencoder",
+    "timers",
+    "event",
+    "abortcontroller",
+    "crypto",
+    "fetch",
+    "websocket"
+  ]
+}
diff --git a/website/locales/zh-CN/content/reference/javascript/request.mdx b/website/locales/zh-CN/content/reference/javascript/request.mdx
new file mode 100644
index 0000000..4d6d7b4
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/javascript/request.mdx
@@ -0,0 +1,28 @@
+---
+title: "Request 与 Response"
+description: "Tysel JavaScript 运行时支持的 Request 与 Response 约定。"
+---
+
+状态：`partial`。本页描述受支持的服务端子集，而非完整的浏览器规范。
+下列清单以外的行为不属于兼容性约定。
+
+事实来源：`runtime-js/web-api/compatibility.json`
+（稳定的 `tysel-server-web-subset`）。
+
+## 支持
+
+- 字符串、Uint8Array 和 ArrayBuffer 响应正文
+- 单次使用的 json/text/arrayBuffer 消费
+- bodyUsed
+- 克隆缓冲的请求和响应
+- 流式宿主请求和响应正文
+
+## 不支持
+
+- 公开的 ReadableStream 正文
+- formData/blob 辅助方法
+- 流 tee 和克隆流式响应
+- 浏览器的缓存、凭据和 mode 语义
+
+另请参阅 [JavaScript API 索引](/reference/javascript)和
+[npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/textencoder.mdx b/website/locales/zh-CN/content/reference/javascript/textencoder.mdx
new file mode 100644
index 0000000..28aa756
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/javascript/textencoder.mdx
@@ -0,0 +1,22 @@
+---
+title: "TextEncoder 与 TextDecoder"
+description: "Tysel JavaScript 运行时支持的 TextEncoder 与 TextDecoder 约定。"
+---
+
+状态：`partial`。本页描述受支持的服务端子集，而非完整的浏览器规范。
+下列清单以外的行为不属于兼容性约定。
+
+事实来源：`runtime-js/web-api/compatibility.json`
+（稳定的 `tysel-server-web-subset`）。
+
+## 支持
+
+- UTF-8 编码和解码
+
+## 不支持
+
+- 旧式字符编码
+- 流式解码选项
+
+另请参阅 [JavaScript API 索引](/reference/javascript)和
+[npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/timers.mdx b/website/locales/zh-CN/content/reference/javascript/timers.mdx
new file mode 100644
index 0000000..f1f89e1
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/javascript/timers.mdx
@@ -0,0 +1,25 @@
+---
+title: "定时器"
+description: "Tysel JavaScript 运行时支持的定时器约定。"
+---
+
+状态：`supported`。本页描述受支持的服务端子集，而非完整的浏览器规范。
+下列清单以外的行为不属于兼容性约定。
+
+事实来源：`runtime-js/web-api/compatibility.json`
+（稳定的 `tysel-server-web-subset`）。
+
+## 支持
+
+- setTimeout
+- clearTimeout
+- setInterval
+- clearInterval
+- 重置隔离实例时清理定时器
+
+## 不支持
+
+- 兼容性清单中没有列出不支持的功能。
+
+另请参阅 [JavaScript API 索引](/reference/javascript)和
+[npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/url.mdx b/website/locales/zh-CN/content/reference/javascript/url.mdx
new file mode 100644
index 0000000..fad5893
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/javascript/url.mdx
@@ -0,0 +1,27 @@
+---
+title: "URL 与 URLSearchParams"
+description: "Tysel JavaScript 运行时支持的 URL 与 URLSearchParams 约定。"
+---
+
+状态：`partial`。本页描述受支持的服务端子集，而非完整的浏览器规范。
+下列清单以外的行为不属于兼容性约定。
+
+事实来源：`runtime-js/web-api/compatibility.json`
+（稳定的 `tysel-server-web-subset`）。
+
+## 支持
+
+- 基于 authority 的绝对和相对 URL
+- 规范化路径中的点号段
+- 实时同步 search 与 searchParams 的修改
+- 使用可迭代对象和 record 初始化 URLSearchParams
+
+## 不支持
+
+- 完整的 WHATWG 解析
+- IDNA
+- username/password 属性
+- file 和 blob URL
+
+另请参阅 [JavaScript API 索引](/reference/javascript)和
+[npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/websocket.mdx b/website/locales/zh-CN/content/reference/javascript/websocket.mdx
new file mode 100644
index 0000000..8f3fada
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/javascript/websocket.mdx
@@ -0,0 +1,28 @@
+---
+title: "WebSocket"
+description: "Tysel JavaScript 运行时支持的 WebSocket 约定。"
+---
+
+状态：`partial`。本页描述受支持的服务端子集，而非完整的浏览器规范。
+下列清单以外的行为不属于兼容性约定。
+
+事实来源：`runtime-js/web-api/compatibility.json`
+（稳定的 `tysel-server-web-subset`）。
+
+## 支持
+
+- 出站连接和已接受的 socket
+- 文本消息
+- open/message/error/close 监听器
+- once 和移除监听器
+- 复用隔离实例时清理原生资源
+
+## 不支持
+
+- 子协议协商
+- 扩展
+- Blob 消息
+- bufferedAmount
+
+另请参阅 [JavaScript API 索引](/reference/javascript)和
+[npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/limits-and-defaults.mdx b/website/locales/zh-CN/content/reference/limits-and-defaults.mdx
new file mode 100644
index 0000000..c7be1ba
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/limits-and-defaults.mdx
@@ -0,0 +1,104 @@
+---
+title: "限额与默认值"
+description: "本页汇总分散在清单、协议和宿主实现中的限额。清单值属于配置约定。"
+---
+
+本页汇总分散在清单、协议和宿主实现中的限额。清单值属于配置约定。标记为**实现边界**的条目描述当前运行时，未来版本可能调整；应用应能处理拒绝情况，不能依赖精确上限。
+
+## 应用默认值
+
+| 设置 | 默认值 | 来源 |
+| --- | ---: | --- |
+| 监听地址 | `127.0.0.1:3000` | `server.listen` |
+| HTTP/1.1 / HTTP/2 / WebSocket | 开 / 关 / 关 | `server` |
+| 内存 | 128 MiB | `limits.memory_mb` |
+| 每轮 JavaScript 的 CPU 时间 | 50 ms | `limits.cpu_ms_per_turn` |
+| 请求超时 | 30,000 ms | `limits.request_timeout_ms` |
+| 并发 HTTP 请求数 | 1,000 | `limits.max_in_flight` |
+| 请求/响应目标大小 | 16 MiB / 16 MiB | `limits.max_request_mb`、`max_response_mb` |
+| 应用 SQLite 路径 | `./data/tysel.db` | `durable.path` |
+| 测试超时 | 5,000 ms | `tysel test --timeout-ms` |
+
+单位和验证规则请参阅[清单限额](/reference/manifest/limits)。当前运行时会强制实施 `max_request_mb`、`max_response_mb` 和 `max_in_flight`。缓冲响应超过限额时会在发送响应头之前失败；流式响应的累计正文大小一旦超过限额就会中止。
+
+## 网络与执行配置边界
+
+| 接口项 | 当前实现边界 |
+| --- | ---: |
+| 出站 `fetch` 正文 | 16 MiB |
+| 出站重定向次数 | 20 |
+| `isolated` 执行配置 HTTP 正文 | 32 KiB |
+| 单个出站 WebSocket | 每个隔离实例请求 1 个活动套接字 |
+
+`isolated` 执行配置的正文上限比默认清单请求限额更严格。多个边界适用时取较小值。
+
+## 数据能力
+
+| 接口项 | 当前实现边界 |
+| --- | ---: |
+| SQLite SQL 文本 | 1 MiB |
+| SQLite 参数数 | 999 |
+| SQLite 行数 | 10,000 |
+| Postgres SQL 文本 | 1 MiB |
+| Postgres 参数数 | 999 |
+| Postgres 行数 | 10,000 |
+| Postgres 序列化结果 | 1 MiB |
+| Postgres 连接数 | 4 |
+| Redis 键 | 4 KiB |
+| Redis 值 | 1 MiB |
+| 每次 `del` 的 Redis 键数 | 128 |
+| Redis TTL | 1–31,536,000 秒 |
+| Redis 并发操作数 | 4 |
+| 文件系统读或写 | 每次操作 1 MiB |
+| 文件系统根目录 | 64 个读条目和 64 个写条目 |
+
+## 应用任务与 MCP 边界
+
+| 接口项 | 当前实现边界 |
+| --- | ---: |
+| 每个模块的任务或持久导出数 | 256 |
+| 任务/导出名称 | 128 字节 |
+| 任务元数据 | 64 KiB |
+| 任务输入/结果 | 1 MiB / 1 MiB |
+| JavaScript 任务模块源码 | 64 MiB |
+| MCP 消息 | 64 KiB |
+| MCP 工具数 | 256 |
+| MCP 工具名称 | 128 字节 |
+| MCP 描述 | 4 KiB |
+| MCP 参数 | 32 KiB |
+
+## 持久执行边界
+
+| 接口项 | 当前实现边界 |
+| --- | ---: |
+| 边界或信号键 | 256 字节 |
+| 事件或信号载荷 | 1 MiB |
+| 历史 | 10,000 个事件且总计 16 MiB |
+| 待处理信号收件箱 | 1,000 个信号且总计 16 MiB |
+| 单个持久程序 | 1 MiB |
+| 程序目录 | 10,000 个程序且总计 64 MiB |
+| 并发持久轮询数 | 16 |
+
+## LLM 边界
+
+| 接口项 | 当前实现边界 |
+| --- | ---: |
+| 模型或提供商标识符 | 128 字节 |
+| 提供商请求标识符 | 128 字节 |
+| 输入/输出 | 1 MiB / 1 MiB |
+| 保留的提供商错误 | 4 KiB |
+| 超时 | 最长 10 分钟 |
+| 并发提供商调用数 | 默认 16 |
+
+## Component 边界
+
+| 接口项 | 默认值 | 最大值 |
+| --- | ---: | ---: |
+| Component 产物 | — | 16 MiB |
+| 线性内存 | 64 MiB | 64 MiB |
+| 执行时间 | 30 秒 | 60 秒 |
+| 输入/输出 | 1 MiB / 1 MiB | 1 MiB / 1 MiB |
+| 保留的来宾错误 | — | 4 KiB |
+| 宿主专用优化元数据 | — | 64 MiB |
+
+限额通常按字节而非 Unicode 字符计算。调用能力前应拒绝或分块处理过大的输入，并且不要向不受信任的客户端直接暴露原生错误消息。
diff --git a/website/locales/zh-CN/content/reference/manifest/app-server.mdx b/website/locales/zh-CN/content/reference/manifest/app-server.mdx
new file mode 100644
index 0000000..28e5e81
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/manifest/app-server.mdx
@@ -0,0 +1,54 @@
+---
+title: "应用与服务器"
+description: "必需的 app 表标识产物、入口模块和执行配置。"
+---
+
+## `[app]`
+
+必需的 `app` 表标识产物、入口模块和执行配置。
+
+| 字段 | 是否必需 | 默认值 | 接受的值 |
+| --- | --- | --- | --- |
+| `name` | 是 | — | 字母、数字、`.`、`_` 和 `-`；首字符必须是字母或数字。 |
+| `entry` | 是 | — | 项目相对的 TypeScript、JavaScript 或 WebAssembly Component 路径。 |
+| `profile` | 否 | `service` | `service`、`isolated` 或 `component`。 |
+
+`entry` 不能是绝对路径，不能使用 `..` 穿越目录，不能带 Windows 驱动器前缀，也不能包含反斜杠或控制字符。执行配置会改变信任边界和宿主能力边界，并非单纯的优化预设。
+
+对于 `component` 执行配置，应使用实现 `tysel:component/task@0.4.0` 的 `.wasm` Component Model 二进制文件。Core Wasm 模块会被拒绝。应用是一次性 stdin/stdout 任务，因此监听器和 WebSocket 字段不会创建 HTTP 服务；`server.workers` 必须保持为 `1`。`.wasm` 入口必须使用 `component` 执行配置，该配置也必须使用 `.wasm` 入口。CLI 命令收到显式 `ENTRY` 覆盖值时，同样执行此项检查。
+
+```toml
+[app]
+name = "orders-api"
+entry = "src/index.ts"
+profile = "service"
+```
+
+请参阅[执行配置](/docs/concepts/execution-profiles)和[能力矩阵](/docs/capabilities)。Component 特有行为见 [Wasm Component 参考](/reference/component)。
+
+## `[server]`
+
+可选的 server 表控制入站监听器和协议。
+
+| 字段 | 默认值 | 接受的值与行为 |
+| --- | --- | --- |
+| `listen` | `127.0.0.1:3000` | 套接字地址。容器需要接受外部流量时使用 `0.0.0.0`。 |
+| `workers` | `1` | `service` 应用的 QuickJS 隔离实例数，范围为 `1` 至 `64`。`isolated` 和 `component` 执行配置拒绝大于 `1` 的值。 |
+| `http1` | `true` | 启用 HTTP/1.1。 |
+| `http2` | `false` | 启用明文 HTTP/2。 |
+| `websocket` | `false` | 允许入站 HTTP/1.1 WebSocket 升级。 |
+
+`http1` 和 `http2` 至少启用一个。`websocket = true` 要求启用 HTTP/1.1。两个 HTTP 版本都启用时，监听器接受 HTTP/1.1 和 h2c；仅启用 HTTP/2 时要求客户端预先知道使用 h2c。Tysel 不终止公网 TLS，因此 HTTPS 部署需要使用 Ingress 或反向代理。
+
+每个服务工作线程都有独立的 JavaScript 全局作用域和运行时内存限额。只有处理程序无状态，或应用状态已明确外置时，才应增加 `workers`。更多工作线程可以提高并行吞吐量，但会成倍增加隔离实例内存，并可能恶化启动或尾延迟。默认值保持为一，以维持单一全局状态语义。
+
+```toml
+[server]
+listen = "0.0.0.0:3000"
+workers = 2
+http1 = true
+http2 = true
+websocket = true
+```
+
+服务器正文和并发设置位于[限额](/reference/manifest/limits)下；处理程序响应和错误约定见[错误与机器可读输出](/reference/errors-and-output)。
diff --git a/website/locales/zh-CN/content/reference/manifest/durable-observability.mdx b/website/locales/zh-CN/content/reference/manifest/durable-observability.mdx
new file mode 100644
index 0000000..39905c3
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/manifest/durable-observability.mdx
@@ -0,0 +1,44 @@
+---
+title: "持久存储与可观测性"
+description: "可选的 durable 表选择持久处理程序使用的事件存储。"
+---
+
+## `[durable]`
+
+可选的 `durable` 表选择持久处理程序使用的事件存储。
+
+| 字段 | 默认值 | 当前实现 |
+| --- | --- | --- |
+| `store` | `sqlite` | `sqlite` 启用应用 SQLite 能力。其他字符串可以通过 schema 验证，但不会配置由清单支持的存储。 |
+| `path` | `./data/tysel.db` | 相对于运行时的应用 SQLite 数据库路径。 |
+
+```toml
+[durable]
+store = "sqlite"
+path = "./data/workflows.db"
+```
+
+在项目命令中，相对路径从清单目录解析。在打包后的可执行文件中，相对路径从进程工作目录解析。模块导出持久处理程序时，默认持久事件日志位于该应用数据库旁，名称为 `durable-events.db`。设置 `TYSEL_DURABLE_SQLITE_PATH` 可以明确选择持久事件日志文件。
+
+宿主通过 `TYSEL_DURABLE_POSTGRES_URL` 配置时，运行时也可使用由 Postgres 支持的持久存储。这属于宿主配置，不是版本 1 清单中的 `store` 值。
+
+回放和备份要求请参阅[持久 API](/reference/runtime/durable)、[持久执行](/docs/concepts/durable-execution)和[生产运维](/docs/operations/production)。
+
+## `[observability]`
+
+| 字段 | 默认值 | 当前实现 |
+| --- | --- | --- |
+| `logs` | `json` | 不区分大小写的 `json` 启用结构化运行时日志；其他字符串会禁用该 JSON 日志记录器。 |
+| `traces` | 未设置 | 清单 schema 记录的可空端点意图。 |
+| `metrics` | 未设置 | 清单 schema 记录的可空端点意图。 |
+
+```toml
+[observability]
+logs = "json"
+traces = "http://otel-collector:4318/v1/traces"
+metrics = "http://otel-collector:4318/v1/metrics"
+```
+
+当前包清单会携带 `logs`，但尚未将 `traces` 或 `metrics` 传递给打包后的运行时。请使用标准 OpenTelemetry 环境变量配置实际导出。参考文档有意区分这两点：这些字段可以通过 schema 验证，但当前运维控制仍是环境配置。不要把身份验证令牌放入清单；请使用包含密钥的部署配置。
+
+支持的 OpenTelemetry 控制请参阅[环境变量](/reference/environment)，采集器和监控指南请参阅[生产运维](/docs/operations/production)。
diff --git a/website/locales/zh-CN/content/reference/manifest/index.mdx b/website/locales/zh-CN/content/reference/manifest/index.mdx
new file mode 100644
index 0000000..345670f
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/manifest/index.mdx
@@ -0,0 +1,308 @@
+---
+title: "清单参考"
+description: "每个应用都有一个 tysel.toml 或 tysel.json。两种格式使用相同的模式和验证规则。未知字段会被拒绝。"
+---
+
+每个应用都有一个 `tysel.toml` 或 `tysel.json`。两种格式使用相同的模式和验证规则。未知字段会被拒绝。
+
+清单是唯一的 Tysel 项目配置文件。`package.json` 是可选的依赖/脚本伴随文件，`tsconfig.json` 和 `tsconfig.tysel.json` 则配置可选的 TypeScript 编译器检查。这些文件都不能替代或覆盖清单。项目可以按需组合使用；请参阅[配置组合](/docs/concepts/projects-and-configuration#choose-the-files-you-need)。
+
+## 根对象
+
+| 字段 | 是否必需 | 默认值 | 参考 |
+| --- | --- | --- | --- |
+| `schema_version` | 否 | `1` | 清单模式版本。只接受版本 `1`。 |
+| `app` | 是 | — | [应用标识与入口](/reference/manifest/app-server#app)。 |
+| `server` | 否 | 应用默认值 | [入站服务器](/reference/manifest/app-server#server)。 |
+| `permissions` | 否 | 所有列表为空 | [宿主能力授权](/reference/manifest/permissions)。 |
+| `limits` | 否 | 应用默认值 | [应用限制](/reference/manifest/limits)。 |
+| `durable` | 否 | SQLite 默认值 | [持久存储](/reference/manifest/durable-observability#durable)。 |
+| `observability` | 否 | JSON 日志 | [遥测](/reference/manifest/durable-observability#observability)。 |
+| `tasks` | 否 | 空映射 | [项目工作流](/reference/manifest/tasks)。 |
+
+为兼容早期版本 1 清单，可以省略 `schema_version`。不受支持的新版本会失败，并给出升级诊断。
+
+## 完整字段索引
+
+下表是模式版本 1 的精简字段清单。“默认值”是字段或其父表被省略时，`tysel config show` 显示的有效值。字段通过模式验证并不一定表示所有运行时执行配置都可以使用它；请按照链接章节了解强制规则和部署详情。
+
+### 应用和服务器字段
+
+| 字段 | 类型 | 必需/默认值 | 含义 |
+| --- | --- | --- | --- |
+| `schema_version` | 整数 | `1` | 选择清单约定。版本 1 是唯一接受的值。 |
+| `app.name` | 字符串 | 必需 | 产物标识。以字母或数字开头；其余字符还可以包含 `.`、`_` 和 `-`。 |
+| `app.entry` | 字符串 | 必需 | 项目相对的 TypeScript、JavaScript 或 Component `.wasm` 入口。绝对路径、反斜杠和 `..` 路径穿越会被拒绝。 |
+| `app.profile` | 枚举 | `service` | 执行和信任边界：`service`、`isolated` 或 `component`。 |
+| `server.listen` | 字符串 | `127.0.0.1:3000` | 入站套接字地址。只有外部接口应接收流量时才使用 `0.0.0.0`。 |
+| `server.workers` | 整数 | `1` | QuickJS 隔离实例数量，范围为 1 至 64。多个工作线程要求使用 `service`。 |
+| `server.http1` | 布尔值 | `true` | 启用 HTTP/1.1。入站 WebSocket 升级需要启用它。 |
+| `server.http2` | 布尔值 | `false` | 启用明文 HTTP/2（h2c），并非面向公网的 TLS 终止。 |
+| `server.websocket` | 布尔值 | `false` | 允许入站 HTTP/1.1 WebSocket 升级。它不会授予出站网络访问权限。 |
+
+有关路径验证、协议行为、工作线程状态、Component 限制和部署指南，请参阅[应用与服务器](/reference/manifest/app-server)。
+
+### 权限字段
+
+每个权限列表的默认值都是 `[]`。权限取清单请求、执行配置和部署策略的交集；向清单添加值无法覆盖执行配置层面的拒绝。
+
+| 字段 | 类型 | 接受的值 | 启用的能力 |
+| --- | --- | --- | --- |
+| `permissions.fetch` | 唯一字符串数组 | `api.example.com` 等主机名 | 到匹配主机的出站 `fetch` 和出站 WebSocket 连接。 |
+| `permissions.secrets` | 唯一字符串数组 | 环境变量名 | `tysel.secrets.ref` 返回的不透明句柄；它不会暴露明文值。 |
+| `permissions.postgres` | 数组，最多一项 | `name`、`name:read-only` 或 `name:read-write` | 由部署注入 URL 的具名 Postgres 授权。 |
+| `permissions.redis` | 数组，最多一项 | `name`、`name:read-only` 或 `name:read-write` | 由部署注入 URL 的具名 Redis 授权。 |
+| `permissions.fs_read` | 唯一字符串数组，最多 64 项 | 目录根路径 | 在固定根路径下读取 UTF-8 普通文件。相对根路径以项目根目录为基准解析；绝对根路径保持不变。 |
+| `permissions.fs_write` | 唯一字符串数组，最多 64 项 | 目录根路径 | 在固定根路径下写入 UTF-8 普通文件。相对根路径以项目根目录为基准解析；绝对根路径保持不变。不会隐式授予读取权限。 |
+
+有关主机名语义、Postgres 和 Redis 环境变量映射、文件系统限制以及执行配置特有的拒绝行为，请参阅[权限](/reference/manifest/permissions)。
+
+### 限制字段
+
+所有限制字段都是非负整数。零是有效值，并按字面生效；例如，`max_in_flight = 0` 会拒绝所有 HTTP 请求，而不是表示“不限量”。
+
+| 字段 | 单位 | 默认值 | 运行时含义 |
+| --- | --- | ---: | --- |
+| `limits.memory_mb` | MiB | `128` | QuickJS 或隔离工作进程的内存预算。Component 上限为 64 MiB。 |
+| `limits.cpu_ms_per_turn` | 毫秒 | `50` | 一轮 JavaScript 执行的 CPU 预算。Component 改用 fuel 和 epoch 中断。 |
+| `limits.request_timeout_ms` | 毫秒 | `30000` | 调用截止时间，以及已配置 LLM 调用的时限。Component 上限为 60 秒。 |
+| `limits.max_in_flight` | 请求数 | `1000` | 已准入的 HTTP 请求，持续占用直至响应完成或 WebSocket 关闭。 |
+| `limits.max_response_mb` | MiB | `16` | HTTP 响应正文累计大小上限。 |
+| `limits.max_request_mb` | MiB | `16` | 入站请求正文限制；过大的请求会收到 HTTP 413。 |
+
+有关整数边界、过载行为、当前传递状态和固定能力限制，请参阅[应用限制](/reference/manifest/limits)。
+
+### 持久执行、可观测性和任务字段
+
+| 字段 | 类型 | 默认值 | 含义与当前状态 |
+| --- | --- | --- | --- |
+| `durable.store` | 字符串 | `sqlite` | 选择由清单配置的持久存储。目前只有 `sqlite` 能够配置存储。 |
+| `durable.path` | 字符串 | `./data/tysel.db` | 相对于运行时的应用 SQLite 路径。持久事件日志的位置还受宿主控制。 |
+| `observability.logs` | 字符串 | `json` | 不区分大小写的 `json` 会启用结构化运行时日志器；其他值会禁用它。 |
+| `observability.traces` | 字符串或 null | 未设置 | 通过模式验证的 OTLP 端点意图。目前尚未传递到打包后的运行时配置。 |
+| `observability.metrics` | 字符串或 null | 未设置 | 通过模式验证的 OTLP 端点意图。目前尚未传递到打包后的运行时配置。 |
+| <code>{"tasks.<name>.description"}</code> | 字符串或 null | 未设置 | 任务发现中显示的易读任务说明。 |
+| <code>{"tasks.<name>.depends"}</code> | 唯一字符串数组 | `[]` | 必须先完成的其他清单任务；未知名称和循环依赖会被拒绝。 |
+| <code>{"tasks.<name>.steps"}</code> | 参数数组的数组 | `[]` | 按顺序执行的 Tysel CLI 调用。不允许 shell 展开、管道、重定向或覆盖项目选择。 |
+
+有关有效的宿主配置、任务名称规则和允许使用的步骤命令，请参阅[持久存储与可观测性](/reference/manifest/durable-observability)和[清单任务](/reference/manifest/tasks)。
+
+## 跨字段规则
+
+除各字段类型外，还会验证以下关系：
+
+| 配置 | 要求 | 原因 |
+| --- | --- | --- |
+| `app.entry` 以 `.wasm` 结尾 | `app.profile = "component"` | Tysel 接受 Component Model 任务，而不是任意 Core Wasm。 |
+| `app.profile = "component"` | `app.entry` 必须以 `.wasm` 结尾 | Component 执行不会加载 JavaScript 或 TypeScript。 |
+| `server.websocket = true` | `server.http1 = true` | 协议升级使用 HTTP/1.1。 |
+| `server.http1 = false` | `server.http2 = true` | 模式要求至少保留一种入站 HTTP 协议。 |
+| `server.workers > 1` | `app.profile = "service"` | Isolated 和 Component 执行配置只接受 `workers = 1`。 |
+| 出站 `fetch` 或 WebSocket | 匹配的 `permissions.fetch` 主机名，以及允许它的执行配置 | 仅有清单授权并不构成权限。重定向目标会再次检查。 |
+| 使用 Postgres | 最多一个具名授权以及 <code>{"TYSEL_POSTGRES_<NAME>"}</code> | 连接 URL 和凭据保留在清单之外。 |
+| 使用 Redis | 最多一个具名授权以及 <code>{"TYSEL_REDIS_<NAME>"}</code> | 连接 URL 和凭据保留在清单之外。 |
+| Component 文件系统导入 | 匹配的 `fs_read` 或 `fs_write` 根路径以及部署能力 | Component 导入、清单请求和部署策略必须全部一致。 |
+| 清单任务 | 至少有一个非空 `depends` 或 `steps` 值 | 空工作流会被拒绝。 |
+
+编辑后运行 `tysel config validate`。如果问题不只是语法是否有效，而是所选执行配置实际会获得哪些能力，请使用 `tysel inspect`。
+
+## 选择起始配置
+
+请从能够表达工作负载的最小清单开始。省略的表会采用默认值；复制所有可能的字段会增加后续审查难度。
+
+### 最小 HTTP 服务
+
+```toml
+schema_version = 1
+
+[app]
+name = "hello"
+entry = "src/index.ts"
+```
+
+该配置使用 `service` 执行配置，通过 HTTP/1.1 监听 `127.0.0.1:3000`，且不请求任何宿主能力。
+
+### 可从外部访问且存储受限的服务
+
+```toml
+schema_version = 1
+
+[app]
+name = "orders-api"
+entry = "src/index.ts"
+profile = "service"
+
+[server]
+listen = "0.0.0.0:3000"
+workers = 2
+
+[permissions]
+postgres = ["main:read-write"]
+secrets = ["PAYMENTS_API_KEY"]
+
+[limits]
+memory_mb = 256
+request_timeout_ms = 15000
+max_in_flight = 200
+max_request_mb = 4
+```
+
+应用使用 Postgres 授权时，部署必须提供 `TYSEL_POSTGRES_MAIN`。如果应用代码调用 `tysel.secrets.ref("PAYMENTS_API_KEY")`，部署还必须提供该密钥；缺少已声明的值会在请求句柄时报告，而不是在加载清单时报告。请在入口或反向代理处终止 TLS。
+
+### 隔离 MCP 工具
+
+```toml
+schema_version = 1
+
+[app]
+name = "customer-lookup"
+entry = "src/index.ts"
+profile = "isolated"
+
+[permissions]
+secrets = ["CUSTOMER_API_KEY"]
+
+[limits]
+memory_mb = 32
+request_timeout_ms = 5000
+
+[tasks.verify]
+steps = [["check"], ["test"]]
+```
+
+清单选择执行配置并请求具名密钥；应用源码仍须导出 MCP 任务。在 isolated 执行配置中，`tysel.secrets.ref("CUSTOMER_API_KEY")` 只返回由代理提供的不透明句柄；即使权限中列出，直接网络和文件系统访问仍会被拒绝。请从 [MCP 工具示例](https://github.com/wangcch/tysel/tree/main/examples/mcp-tool)开始，并查阅[应用模块](/reference/runtime/application#mcp-tasks)和[执行配置](/docs/concepts/execution-profiles)。
+
+### Wasm Component 任务
+
+```toml
+schema_version = 1
+
+[app]
+name = "rust-transform"
+entry = "target/transform.component.wasm"
+profile = "component"
+
+[permissions]
+fs_read = ["./input"]
+fs_write = ["./output"]
+```
+
+Component 只能导入已经实现的接口。打包后的可执行文件还需要显式部署授权，例如 `TYSEL_COMPONENT_CAPABILITIES=tysel:fs/read,tysel:fs/write`；请参阅 [Component 能力](/reference/component/capabilities)。
+
+## 完整示例
+
+```toml
+schema_version = 1
+
+[app]
+name = "orders"
+entry = "src/index.ts"
+profile = "service"
+
+[server]
+listen = "127.0.0.1:3000"
+http1 = true
+http2 = false
+websocket = false
+
+[permissions]
+fetch = ["api.example.com"]
+secrets = ["API_TOKEN"]
+postgres = ["main:read-write"]
+fs_read = ["./data/imports"]
+fs_write = ["./data/exports"]
+
+[limits]
+memory_mb = 128
+cpu_ms_per_turn = 50
+request_timeout_ms = 30000
+max_in_flight = 1000
+max_request_mb = 16
+
+[durable]
+store = "sqlite"
+path = "./data/tysel.db"
+
+[observability]
+logs = "json"
+
+[tasks.verify]
+description = "Check and test"
+steps = [["check"], ["test"]]
+```
+
+## JSON 形式
+
+JSON 表示使用相同的字段名和值：
+
+```json
+{
+  "schema_version": 1,
+  "app": {
+    "name": "orders",
+    "entry": "src/index.ts",
+    "profile": "service"
+  },
+  "server": {
+    "listen": "127.0.0.1:3000",
+    "http1": true,
+    "http2": false,
+    "websocket": false
+  }
+}
+```
+
+## 发现与路径解析
+
+未提供 `--manifest` 时，项目命令会从所选目录逐级向上搜索。同一目录中同时保留两种格式会导致错误。清单目录会成为项目根目录；`app.entry`、持久存储和相对文件系统根路径都以它为基准解析。绝对文件系统根路径保持不变。打包后的可执行文件没有外部清单根目录，因此相对运行时路径以其进程工作目录为基准解析。
+
+## 模式与编辑器集成
+
+已安装的 CLI 内置了与其验证器匹配的模式。编辑器或 CI 作业需要文件时，请将其保存到项目中：
+
+```sh
+mkdir -p .tysel
+tysel config schema > .tysel/tysel-manifest-v1.schema.json
+```
+
+对于 JSON 清单，VS Code 工作区可以在 `.vscode/settings.json` 中关联该本地模式：
+
+```json
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["/tysel.json"],
+      "url": "./.tysel/tysel-manifest-v1.schema.json"
+    }
+  ]
+}
+```
+
+TOML 模式关联方式取决于编辑器扩展。支持时，请将它指向同一份生成的 Draft 2020-12 模式。不要向 `tysel.json` 添加 `$schema` 成员：`$schema` 不是版本 1 清单字段，未知字段会被拒绝。升级 Tysel 后请重新生成该文件。
+
+JSON Schema 能发现字段名、类型、枚举、数值范围和若干跨字段规则。`tysel config validate` 仍是权威依据，因为它还会应用编辑器可能不执行的运行时验证。
+
+## 常见验证失败
+
+| 诊断形式 | 可能原因 | 修正方式 |
+| --- | --- | --- |
+| 未知字段 | 拼写错误、所在表错误，或使用了其他模式版本的字段 | 查阅[完整字段索引](#complete-field-index)；未知键绝不会被忽略。 |
+| 找到两份清单 | 同一项目根目录中存在 `tysel.toml` 和 `tysel.json` | 只保留一份根清单，或将转换结果写到根目录之外。 |
+| 入口必须相对于项目 | 使用绝对路径、反斜杠、驱动器前缀或 `..` 路径穿越 | 使用 `/` 分隔符以及清单目录下的路径。 |
+| WebSocket 要求 HTTP/1.1 | `server.websocket = true` 且 `server.http1 = false` | 启用 HTTP/1.1 或禁用 WebSocket 升级。 |
+| 多个工作线程要求 service | `isolated` 或 `component` 的 `workers` 大于 1 | 设置 `workers = 1`，或改用兼容的工作负载执行配置。 |
+| `.wasm` 与执行配置不一致 | Component 入口使用其他执行配置，或 Component 执行配置使用非 Wasm 入口 | 同时设置 Component 约定的两端。 |
+| 权限值必须唯一 | 列表成员重复或为空 | 删除重复项和空白项。 |
+| 任务依赖失败 | 未知依赖、循环、重复依赖或空任务 | 修复任务图，并保留至少一个依赖或步骤。 |
+
+如果无效清单导致常规项目命令无法显示发现了哪个文件，请先使用 `tysel config path`。
+
+使用已安装的二进制文件检查确切模式和展开后的值：
+
+```sh
+tysel config schema
+tysel config show --format json
+tysel config validate
+```
+
+有关转换，请参阅[项目与配置命令](/reference/cli/project)；有关发现流程，请参阅[项目与配置](/docs/concepts/projects-and-configuration)。
diff --git a/website/locales/zh-CN/content/reference/manifest/limits.mdx b/website/locales/zh-CN/content/reference/manifest/limits.mdx
new file mode 100644
index 0000000..e30f1eb
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/manifest/limits.mdx
@@ -0,0 +1,37 @@
+---
+title: "应用限额"
+description: "可选的 [limits] 表定义应用级资源预算。所有字段均为非负整数；省略的字段使用下列默认值。"
+---
+
+可选的 `[limits]` 表定义应用级资源预算。所有字段均为非负整数；省略的字段使用下列默认值。
+
+| 字段 | 默认值 | 单位 | 当前运行时用途 |
+| --- | ---: | --- | --- |
+| `memory_mb` | `128` | MiB | QuickJS 或隔离工作进程的内存预算。 |
+| `cpu_ms_per_turn` | `50` | ms | 单轮 JavaScript 执行的 CPU 预算。 |
+| `request_timeout_ms` | `30000` | ms | 调用截止时间；也限制已配置的 LLM 调用。 |
+| `max_in_flight` | `1000` | 请求 | 允许同时进入的 HTTP 请求上限，许可保持到响应正文完成。 |
+| `max_response_mb` | `16` | MiB | HTTP 响应正文的累计大小上限。 |
+| `max_request_mb` | `16` | MiB | 入站请求正文上限。 |
+
+```toml
+[limits]
+memory_mb = 256
+cpu_ms_per_turn = 100
+request_timeout_ms = 15000
+max_in_flight = 200
+max_response_mb = 8
+max_request_mb = 4
+```
+
+schema 允许相应字段使用完整的无符号整数范围（内存、并发请求和正文限额为 `u32`；CPU 和请求超时为 `u64`）。平台或运行时上限仍可能拒绝或收紧这些值。
+
+通过 schema 验证与受到运行时强制约束是两件事。在当前包格式中，`memory_mb`、`cpu_ms_per_turn`、`request_timeout_ms`、`max_in_flight`、`max_request_mb` 和 `max_response_mb` 都会传递给运行时。缓冲响应超过限额时会在发送响应头之前失败；流式响应则会在越过限额时中止。
+
+没有可用准入许可时，HTTP 服务器立即返回 `503`，错误码为 `OVERLOADED`，并包含 `Retry-After: 1`；它不会创建无界等待队列。缓冲或流式响应到达流末尾，或者响应被丢弃后，许可才会释放。将值设为零会有意拒绝所有 HTTP 请求，可用作熔断器。已接受的 WebSocket 会持续占用许可，直至升级后的连接关闭。
+
+各宿主能力还有固定安全边界，例如 SQL、文件系统、LLM、协议和持久载荷的最大大小。完整清单请参阅[限额与默认值](/reference/limits-and-defaults)。
+
+过大的入站请求返回 HTTP `413` 和 `BODY_TOO_LARGE`。其他限额失败通过相应宿主 API 或标准运行时错误信封报告。提高预算无法替代背压、有边界的输入验证或部署级资源限制。
+
+对于 Component 应用，`memory_mb` 会收紧到 Component 的 64 MiB 上限，`request_timeout_ms` 会收紧到 60 秒。`cpu_ms_per_turn` 不适用于 Wasm；引擎使用固定燃料预算和 epoch 中断。HTTP 正文和并发限额不适用于一次性 stdin/stdout 任务。请参阅 [Component 资源边界](/reference/component/runtime#resource-bounds)。
diff --git a/website/locales/zh-CN/content/reference/manifest/meta.json b/website/locales/zh-CN/content/reference/manifest/meta.json
new file mode 100644
index 0000000..2eb5f64
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/manifest/meta.json
@@ -0,0 +1,11 @@
+{
+  "title": "清单",
+  "pages": [
+    "index",
+    "app-server",
+    "permissions",
+    "limits",
+    "durable-observability",
+    "tasks"
+  ]
+}
diff --git a/website/locales/zh-CN/content/reference/manifest/permissions.mdx b/website/locales/zh-CN/content/reference/manifest/permissions.mdx
new file mode 100644
index 0000000..5748fe3
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/manifest/permissions.mdx
@@ -0,0 +1,55 @@
+---
+title: "权限"
+description: "可选的 [permissions] 表授予宿主能力。所有列表默认为空，因此未声明时拒绝访问。"
+---
+
+可选的 `[permissions]` 表授予宿主能力。所有列表默认为空，因此未声明时拒绝访问。
+
+| 字段 | 值形式 | 当前 schema 边界 | 启用的能力 |
+| --- | --- | --- | --- |
+| `fetch` | 唯一主机名 | — | 到匹配主机的出站 `fetch` 和 WebSocket 连接。 |
+| `secrets` | 唯一环境变量名 | — | 通过 `tysel.secrets` 使用不透明机密信息引用。 |
+| `postgres` | 一个唯一具名授权 | 1 项 | 具名 Postgres 连接及访问模式。 |
+| `redis` | 一个唯一具名授权 | 1 项 | 具名 Redis 连接及访问模式。 |
+| `fs_read` | 唯一目录根 | 64 项 | 读取固定根目录下的 UTF-8 普通文件。 |
+| `fs_write` | 唯一目录根 | 64 项 | 写入固定根目录下的 UTF-8 普通文件。 |
+
+空条目和重复条目会被拒绝。存在授权也不能覆盖执行配置对相应能力的禁止。
+
+```toml
+[permissions]
+fetch = ["api.example.com"]
+secrets = ["API_TOKEN"]
+postgres = ["main:read-only"]
+redis = ["cache:read-write"]
+fs_read = ["./fixtures"]
+fs_write = ["./data/output"]
+```
+
+## 出站网络
+
+`fetch` 条目是主机白名单值，不是任意 URL 前缀。授权中不能包含协议、路径、查询参数或凭据。重定向目标会单独根据白名单检查。
+
+## 机密信息
+
+每一项指定宿主可以公开为不透明引用的环境变量。`tysel.secrets.ref("API_TOKEN")` 返回 `secret:API_TOKEN` 句柄；应用 JavaScript 不会获得明文环境变量值。声明名称不会创建或填充该变量。
+
+## Postgres
+
+授权格式为 `name:read-write` 或 `name:read-only`；省略模式时默认为 `read-write`。名称以小写字母开头，后续可包含小写字母、数字、`_` 或 `-`。目前最多接受一个授权。
+
+连接 URL 不应写入清单。对于 `main`，请设置 `TYSEL_POSTGRES_MAIN`；授权名称中的连字符会映射为环境变量中的下划线。
+
+参数类型、只读验证、连接池、TLS 和部署检查请参阅 [PostgreSQL 指南](/docs/guides/postgresql)。
+
+## Redis
+
+Redis 授权采用相同的具名 `read-write` 或 `read-only` 格式。名为 `cache` 的授权只从 `TYSEL_REDIS_CACHE` 解析；连接 URL 不应写入清单。只读模式允许 `get` 和 `exists`，并在建立连接前拒绝修改操作。请参阅 [Redis 指南](/docs/guides/redis)。
+
+## 文件系统
+
+根目录从项目根目录解析，并在访问前固定。读写仅限对应根目录下的 UTF-8 普通文件；声明 `fs_read` 并不隐含写入权限。
+
+根目录准备、路径限制、执行配置差异、拒绝检查和可运行转换示例请参阅[文件系统指南](/docs/guides/filesystem)。
+
+方法签名请参阅[宿主能力](/reference/runtime/capabilities)，宿主配置请参阅[环境变量](/reference/environment)，强制实施边界请参阅[安全模型](/docs/security)。
diff --git a/website/locales/zh-CN/content/reference/manifest/tasks.mdx b/website/locales/zh-CN/content/reference/manifest/tasks.mdx
new file mode 100644
index 0000000..12be85f
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/manifest/tasks.mdx
@@ -0,0 +1,52 @@
+---
+title: "清单任务"
+description: "可选的 [tasks] 映射以 Tysel 参数向量定义项目工作流，无需平台 shell 或 package.json scripts。"
+---
+
+可选的 `[tasks]` 映射以 Tysel 参数向量定义项目工作流，无需平台 shell 或 `package.json` scripts。
+
+```toml
+[tasks.verify]
+description = "Check and test"
+steps = [
+  ["check"],
+  ["test"],
+]
+
+[tasks.release]
+depends = ["verify"]
+steps = [["build", "--release"]]
+```
+
+## 任务对象
+
+| 字段 | 是否必需 | 约定 |
+| --- | --- | --- |
+| `description` | 否 | 人类可读字符串或 `null`。 |
+| `depends` | `depends` 或 `steps` 至少一个 | 在当前任务之前执行的唯一任务名称。 |
+| `steps` | `depends` 或 `steps` 至少一个 | 有序且非空的 argv 数组。 |
+
+任务名称以字母或数字开头，后续可包含字母、数字、`:`、`_` 或 `-`。`depends` 和 `steps` 至少有一个非空。加载清单时会拒绝未知依赖、依赖环、重复依赖和空步骤。
+
+## 步骤命令
+
+每个步骤的第一个参数必须是以下命令之一：
+
+```text
+check  test  build  inspect  compat  run  dev  mcp  queue  image
+```
+
+步骤不能调用 `init`、`config`、`task`、`doctor`、`upgrade`、`bench` 或 `release`。同时禁止 `--`、`-C`、`--project`、`--project-dir` 和 `--manifest`，防止步骤脱离选定项目。
+
+运行器不会调用 shell。每个字符串都是一个参数，因此管道、重定向、展开和 shell 引号规则均不适用。
+
+## 执行
+
+```sh
+tysel task --list
+tysel task verify
+```
+
+依赖按依赖顺序执行一次。步骤按声明顺序执行，并继承任务的项目根目录和清单。第一个失败步骤会停止工作流，并使命令以非零状态退出。
+
+调用方式请参阅 [`tysel task`](/reference/cli/tasks)，工作流设计指南请参阅[项目与配置](/docs/concepts/projects-and-configuration)。
diff --git a/website/locales/zh-CN/content/reference/meta.json b/website/locales/zh-CN/content/reference/meta.json
new file mode 100644
index 0000000..a47f258
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/meta.json
@@ -0,0 +1,16 @@
+{
+  "title": "参考手册",
+  "pages": [
+    "index",
+    "javascript",
+    "runtime",
+    "component",
+    "cli",
+    "manifest",
+    "environment",
+    "limits-and-defaults",
+    "errors-and-output",
+    "[能力矩阵](/docs/capabilities)",
+    "[npm 兼容性](/docs/compatibility)"
+  ]
+}
diff --git a/website/locales/zh-CN/content/reference/runtime/application.mdx b/website/locales/zh-CN/content/reference/runtime/application.mdx
new file mode 100644
index 0000000..494e339
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/runtime/application.mdx
@@ -0,0 +1,124 @@
+---
+title: "应用模块"
+description: "应用默认导出一个 TyselApp 对象。它必须声明至少一组 HTTP、任务注册表或持久注册表入口；所选命令或协议仍要求该组中存在具体处理程序。"
+---
+
+应用默认导出一个 `TyselApp` 对象。它必须声明至少一组 HTTP、任务注册表或持久注册表入口；所选命令或协议仍要求该组中存在具体处理程序。
+
+应导出普通对象并使用 `satisfies TyselApp`（生成的能力类型可用时使用 `TyselApp<TyselEnv>`）。这是默认方式，不需要导入运行时 SDK。只有当一个属性需要根据另一个属性进行上下文推断时才使用 `defineApp`，例如根据输入 schema 推断 MCP 处理程序。
+
+```ts
+interface TyselAppMembers {
+  fetch?: RuntimeFetchHandler;
+  tasks?: Record<string, CronTask | QueueTask | McpTask>;
+  durable?: Record<string, DurableHandler>;
+}
+
+type TyselApp = RequireAtLeastOne<TyselAppMembers>;
+```
+
+## HTTP 处理程序
+
+```ts
+type FetchHandler = (request: Request) => Response | Promise<Response>;
+
+type RuntimeFetchHandler = (
+  request: Request,
+  runtime: TyselRuntime,
+) => Response | Promise<Response>;
+```
+
+运行时为入站 HTTP 请求调用 `fetch`，并以 `runtime` 参数注入公开能力宿主。单参数处理程序仍然有效；为保持兼容性，`globalThis.tysel` 也仍然可用。处理程序必须返回 `Response` 或其 Promise。请求与响应正文根据 [Request 和 Response 约定](https://tysel.dev/reference/javascript/request/)受到大小和单次使用限制。
+
+```ts
+import type { TyselApp } from "@tysel/types";
+
+export default {
+  async fetch(request, runtime) {
+    const url = new URL(request.url);
+    return Response.json({
+      method: request.method,
+      path: url.pathname,
+      isolateId: runtime.isolateId,
+    });
+  },
+} satisfies TyselApp;
+```
+
+应优先使用 `satisfies TyselApp`，避免重复参数和返回值注解。它会检查完整的默认导出约定，为每个处理程序提供上下文类型，同时保留应用的精确推断类型，供测试和适配器使用。如果处理程序只应公开一组明确的运行时能力子集，请使用 `TyselApp<TyselRuntimeWith<...>>`。
+
+## 请求上下文
+
+非 HTTP 任务处理程序会收到：
+
+```ts
+interface RequestContext {
+  requestId: string;
+  deadlineMs: number;
+}
+```
+
+`deadlineMs` 是以毫秒表示的绝对截止时间，并非持续时长。关联任务时，应将 `requestId` 传递到应用日志。
+
+## Cron 任务
+
+```ts
+interface CronTask {
+  kind: "cron";
+  expression: string;
+  handler(context: RequestContext): void | Promise<void>;
+}
+```
+
+```ts
+tasks: {
+  cleanup: {
+    kind: "cron",
+    expression: "0 * * * *",
+    async handler(context) {
+      console.log("cleanup", context.requestId);
+    },
+  },
+}
+```
+
+## Queue 任务
+
+```ts
+interface QueueTask {
+  kind: "queue";
+  name: string;
+  handler(message: JsonValue, context: RequestContext): unknown | Promise<unknown>;
+}
+```
+
+消息和结果必须可序列化为 JSON。可使用 [`tysel queue`](/reference/cli/tasks#tysel-queue) 从 CLI 调用已注册的处理程序。
+
+## MCP 任务
+
+MCP 是 `defineApp` 发挥价值的主要场景：它将字面量 `input` schema 作为处理程序参数类型的唯一来源。因此，`tysel init --template mcp` 会添加匹配的 `@tysel/sdk` 依赖。
+
+```ts
+import { defineApp } from "@tysel/sdk";
+
+export default defineApp({
+  tasks: {
+    lookup: {
+      kind: "mcp",
+      description: "Look up a customer",
+      input: { customerId: "string" },
+      async handler(input) {
+        return { customerId: input.customerId };
+      },
+    },
+  },
+});
+```
+
+`defineApp()` 使 `input` 保持为唯一事实来源，并据此推断处理程序参数。`InferMcpInput<Schema>` 仍可用于高级类型组合，但普通处理程序无需显式引用它。处理程序输入和结果必须可序列化为 JSON。TypeScript 会拒绝 `McpInputType` 词汇表之外的 schema 值。当前协议适配器要求每个声明的属性都必须提供。[`tysel mcp`](/reference/cli/tasks#tysel-mcp) 通过以换行分隔的标准输入输出提供已注册工具。
+
+对于单个 MCP 任务，或混合 MCP 与 cron/queue 任务的注册表，可选的 `mcp({...})` 构造函数可以在局部提供相同的推断能力。它是便捷辅助函数，不是默认的文档化应用结构。
+
+## 持久处理程序
+
+持久处理程序接收 `DurableContext` 和 JSON 输入，并返回 JSON 值。其回放规则比普通任务处理程序更严格；修改已部署工作流前，请阅读[持久 API](/reference/runtime/durable)。
diff --git a/website/locales/zh-CN/content/reference/runtime/capabilities.mdx b/website/locales/zh-CN/content/reference/runtime/capabilities.mdx
new file mode 100644
index 0000000..bc3ef4a
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/runtime/capabilities.mdx
@@ -0,0 +1,107 @@
+---
+title: "宿主能力"
+description: "HTTP 处理程序通过 runtime 参数接收宿主方法。为保持兼容性，并供任务或持久处理程序使用，同一对象仍可通过 globalThis.tysel 访问。"
+---
+
+HTTP 处理程序通过 `runtime` 参数接收宿主方法。为保持兼容性，并供任务或持久处理程序使用，同一对象仍可通过 `globalThis.tysel` 访问。类型可用并不等于获得权限：执行配置、清单权限和宿主配置都必须允许该调用。
+
+## 能力摘要
+
+| 成员 | 主要操作 | 所需权限 |
+| --- | --- | --- |
+| `tysel.secrets` | `ref(name)` | `permissions.secrets` 中声明的名称。 |
+| `tysel.sqlite` | `exec(sql, params?)`、`query(sql, params?)` | 受信任执行配置。 |
+| `tysel.postgres` | `exec(sql, params?)`、`query(sql, params?)` | 具名 `permissions.postgres` 授权和连接 URL。 |
+| `tysel.redis` | `get`、`set`、`del`、`exists`、`expire` | 具名 `permissions.redis` 授权和连接 URL。 |
+| `tysel.fs` | `read(path)`、`write(path, contents)` | 匹配的 `fs_read` 或 `fs_write` 根目录。 |
+| `tysel.llm` | `generate(options)` | 提供商配置和已声明的提供商密钥。 |
+| `tysel.acceptWebSocket()` | 接受当前入站升级 | 已启用 HTTP/1.1 WebSocket，且使用受信任执行配置。 |
+| `new WebSocket(url)` | 出站连接 | 受信任执行配置和匹配的 `permissions.fetch` 主机。 |
+
+## 运行时工具
+
+```ts
+interface TyselRuntime {
+  readonly isolateId: number;
+  sleep(milliseconds: number): Promise<void>;
+  echo(value: string): Promise<string>;
+  httpGet(url: string): Promise<Response>;
+  // capability clients are listed below
+}
+```
+
+`isolateId` 标识当前原生隔离实例。`sleep` 是临时定时器，不属于持久暂停。应用 HTTP 应优先使用标准 `fetch`；`httpGet` 是范围有限的宿主辅助方法。`echo` 主要用于验证宿主桥接。
+
+各执行配置的完整矩阵请参阅[能力](/docs/capabilities)。
+
+## 机密信息
+
+```ts
+const token = await tysel.secrets.ref("API_TOKEN");
+```
+
+`ref` 返回类似 `secret:API_TOKEN` 的不透明标记类型 `SecretReference`，绝不会返回明文环境变量值。该引用只能传给明确接受它的宿主 API。
+
+## SQL
+
+两个 SQL 客户端都接受位置参数数组。`exec` 解析为受影响行数；`query` 解析为行对象数组。
+
+```ts
+await tysel.sqlite.exec(
+  "create table if not exists jobs (id text primary key, state text)",
+);
+await tysel.sqlite.exec(
+  "insert into jobs (id, state) values (?, ?)",
+  ["job_1", "ready"],
+);
+const jobs = await tysel.sqlite.query("select id, state from jobs");
+
+const remote = await tysel.postgres.query(
+  "select id, state from jobs where id = $1",
+  ["job_1"],
+);
+```
+
+只读 Postgres 授权会拒绝写入。SQL 文本、参数数、行数和结果字节数均有边界；请参阅[限额与默认值](/reference/limits-and-defaults)。端到端部署流程见 [SQLite](/docs/guides/sqlite) 或 [PostgreSQL](/docs/guides/postgresql) 指南。
+
+## Redis
+
+```ts
+await tysel.redis.set("session:123", "active", { ttlSeconds: 300 });
+const state = await tysel.redis.get("session:123");
+```
+
+值为 UTF-8 字符串。键、值、TTL、批量删除数和并发连接数均有边界。请参阅 [Redis 指南](/docs/guides/redis)。
+
+## 文件系统
+
+```ts
+const source = await tysel.fs.read("./fixtures/input.json");
+await tysel.fs.write("./data/output/result.json", source);
+```
+
+操作使用 UTF-8 字符串，并且只处理固定根目录下的普通文件。路径无法通过目录穿越或符号链接替换逃逸已声明根目录。根目录准备以及允许和拒绝路径的验证方法请参阅[文件系统指南](/docs/guides/filesystem)。
+
+## LLM 生成
+
+```ts
+const response = await tysel.llm.generate({
+  model: "default",
+  system: "Answer with one sentence.",
+  input: "Summarize the queued job.",
+  maxOutputTokens: 128,
+  temperature: 0.2,
+});
+
+console.log(response.output, response.usage, response.provider_request_id);
+```
+
+`model` 和 `input` 为必填项。`system`、`maxOutputTokens` 和 `temperature` 可选。响应包含 `output`、必需的 token 用量元数据，以及可选的提供商请求标识符。提供商端点、模型别名和密钥选择来自[环境变量](/reference/environment)。
+
+## WebSocket
+
+只有在处理符合条件的入站升级时才能调用 `tysel.acceptWebSocket()`。对于出站连接，`WebSocket.opened` 是连接 Promise。当前运行时支持文本帧和二进制帧，但不支持浏览器子协议、扩展、`Blob` 或 `bufferedAmount`；每个隔离实例请求最多可以有一个活动出站套接字。
+
+已接受的入站套接字具有 `readyState`、`onmessage`、`onclose`、`onerror`、`send(string)`、`close()`，以及针对 `message`、`close` 和 `error` 的 `addEventListener` / `removeEventListener`。`send` 和 `close` 返回 Promise。已接受套接字类型与出站 Web `WebSocket` 全局对象相互独立。
+
+确切支持范围请参阅 [WebSocket 约定](https://tysel.dev/reference/javascript/websocket/)和 [fetch 约定](https://tysel.dev/reference/javascript/fetch/)。
diff --git a/website/locales/zh-CN/content/reference/runtime/durable.mdx b/website/locales/zh-CN/content/reference/runtime/durable.mdx
new file mode 100644
index 0000000..8a1d7ec
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/runtime/durable.mdx
@@ -0,0 +1,78 @@
+---
+title: "持久 API"
+description: "持久处理程序记录副作用边界，使中断的工作可以恢复，而不会重复已经提交的外部操作。"
+---
+
+持久处理程序记录副作用边界，使中断的工作可以恢复，而不会重复已经提交的外部操作。
+
+```ts
+interface DurableContext {
+  step<T>(name: string, operation: () => MaybePromise<T>): Promise<T>;
+  effect<T>(name: string, operation: () => MaybePromise<T>): Promise<T>;
+  sleep(duration: number | string): Promise<void>;
+  waitForSignal<T = JsonValue>(name: string): Promise<T>;
+  retry<T>(policy: DurableRetryPolicy,
+    operation: (attempt: number) => MaybePromise<T>): Promise<T>;
+  now(): Date;
+  random(): number;
+}
+```
+
+## 边界
+
+| 方法 | 记录的约定 |
+| --- | --- |
+| `step` | 持久化可回放的计算结果。 |
+| `effect` | 持久化外部副作用的结果。 |
+| `sleep` | 按数字或字符串时长持久化暂停状态。 |
+| `waitForSignal` | 暂停，直至收到具名 JSON 信号。 |
+| `retry` | 根据重试策略记录每次有界尝试。 |
+| `now` | 返回回放安全的 `Date`。 |
+| `random` | 返回回放安全的随机值。 |
+
+传给 `step` 和 `effect` 的名称以及信号名称都属于持久化历史。应保持这些名称稳定，并按顺序 `await` 持久边界。输入、边界结果、信号和处理程序结果都必须可序列化为 JSON。
+
+## 重试策略
+
+```ts
+interface DurableRetryPolicy {
+  maxAttempts?: number;
+  delay?: number | string;
+  factor?: number;
+  maxDelay?: number | string;
+}
+```
+
+数字形式的 `delay` 和 `maxDelay` 以毫秒为单位；两者也接受运行时的时长字符串格式。`factor` 控制退避增长系数。
+
+## 处理程序示例
+
+```ts
+import type { DurableContext, TyselApp } from "@tysel/types";
+
+const app: TyselApp = {
+  durable: {
+    async provision(ctx: DurableContext, input) {
+      const id = await ctx.step("allocate-id", () => ({ value: cryptoValue() }));
+      await ctx.effect("notify", () => notifyOwner(id));
+      const approval = await ctx.waitForSignal("approval");
+      return { id, approval };
+    },
+  },
+};
+
+export default app;
+```
+
+示例中的应用函数如果其结果没有被记录边界包裹，就必须自身具备确定性。
+
+## 控制 API
+
+```ts
+const status = tysel.durable.start("provision", input);
+tysel.durable.sendSignal(status.taskId, "approval", { approved: true });
+```
+
+`start` 返回已完成结果或暂停状态。`sendSignal` 为等待中的工作流追加一个 JSON 信号。
+
+持久输入和结果限制为 1 MiB；其他历史、信号和程序边界列在[限额与默认值](/reference/limits-and-defaults)中。修改存在运行中实例的处理程序之前，请阅读[持久执行](/docs/concepts/durable-execution)。
diff --git a/website/locales/zh-CN/content/reference/runtime/index.mdx b/website/locales/zh-CN/content/reference/runtime/index.mdx
new file mode 100644
index 0000000..6f2875e
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/runtime/index.mdx
@@ -0,0 +1,42 @@
+---
+title: "运行时参考"
+description: "Tysel 应用导出处理程序并使用浏览器风格的全局对象。HTTP 处理程序通过第二个参数接收 Tysel 能力宿主；为兼容旧代码和非 HTTP 处理程序，globalThis.tysel 仍然可用。"
+---
+
+Tysel 应用导出处理程序并使用浏览器风格的全局对象。HTTP 处理程序通过第二个参数接收 Tysel 能力宿主；为兼容旧代码和非 HTTP 处理程序，`globalThis.tysel` 仍然可用。`@tysel/types` 为编辑器和静态检查提供公开声明；它不会安装 JavaScript polyfill。
+
+```ts
+import type { TyselApp } from "@tysel/types";
+
+const app = {
+  async fetch(request, runtime) {
+    return new Response(`isolate ${runtime.isolateId} received ${request.method}`);
+  },
+} satisfies TyselApp;
+
+export default app;
+```
+
+## 界面索引
+
+| 界面 | 参考 |
+| --- | --- |
+| JSON 值、执行配置、信任模式和共享值类型 | [核心类型](/reference/runtime/types) |
+| 默认导出、HTTP 处理程序、cron、队列和 MCP 任务 | [应用模块](/reference/runtime/application) |
+| 密钥、SQLite、Postgres、Redis、文件系统、LLM 和 WebSocket API | [宿主能力](/reference/runtime/capabilities) |
+| 回放安全的工作流和信号 | [持久执行 API](/reference/runtime/durable) |
+| 测试声明、断言和处理程序调用 | [测试 API](/reference/runtime/testing) |
+| `Request`、`Response`、`Headers`、`fetch`、加密、定时器和其他全局对象 | [JavaScript API 参考](/reference/javascript) |
+
+## 稳定性边界
+
+公开应用代码应只使用：
+
+- 此处描述的默认应用导出；
+- 兼容性清单中列出的 Web 全局对象；
+- `@tysel/types` 声明的 `globalThis.tysel` 成员；
+- 测试模块中为 `@tysel/test` 记录的导出。
+
+以下划线开头的宿主钩子，以及来自内部运行时文件的导入，都不属于公开约定。`@tysel/types` 中的声明描述可接受的 TypeScript 结构；实际可用性仍取决于执行配置、清单授权和宿主配置。
+
+这三项可用性检查请参阅[能力矩阵](/docs/capabilities)，固定载荷边界请参阅[限额与默认值](/reference/limits-and-defaults)。
diff --git a/website/locales/zh-CN/content/reference/runtime/meta.json b/website/locales/zh-CN/content/reference/runtime/meta.json
new file mode 100644
index 0000000..55dd837
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/runtime/meta.json
@@ -0,0 +1,11 @@
+{
+  "title": "运行时",
+  "pages": [
+    "index",
+    "types",
+    "application",
+    "capabilities",
+    "durable",
+    "testing"
+  ]
+}
diff --git a/website/locales/zh-CN/content/reference/runtime/testing.mdx b/website/locales/zh-CN/content/reference/runtime/testing.mdx
new file mode 100644
index 0000000..7a7d493
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/runtime/testing.mdx
@@ -0,0 +1,73 @@
+---
+title: "测试 API"
+description: "@tysel/test 为 tysel test 执行的文件提供精简的测试注册与断言接口。"
+---
+
+`@tysel/test` 为 `tysel test` 执行的文件提供精简的测试注册与断言接口。
+
+## `test`
+
+```ts
+test(name: string, body: () => unknown | Promise<unknown>): void
+```
+
+注册具名测试。每个测试文件都在新的 QuickJS 隔离实例中运行，因此模块状态不会跨文件共享。
+
+## `assert`
+
+```ts
+assert(condition: unknown, message?: string): asserts condition
+assert.equal(actual: unknown, expected: unknown, message?: string): void
+assert.deepEqual(actual: unknown, expected: unknown, message?: string): void
+```
+
+`assert` 检查真值，`equal` 检查标量相等，`deepEqual` 比较结构化值。断言失败会使测试失败，并使 CLI 以非零状态退出。
+
+## `invokeFetch`
+
+```ts
+invokeFetch(
+  handler: (request: Request) => Response | Promise<Response>,
+  input: Request | string | URL,
+  init?: RequestInit,
+): Promise<Response>
+```
+
+无需启动监听器即可调用应用 fetch 处理程序。
+
+使用注入运行时的处理程序可以通过显式 mock 进行测试：
+
+```ts
+invokeFetchWithRuntime(
+  handler: (request: Request, runtime: Runtime) => Response | Promise<Response>,
+  runtime: Runtime,
+  input: Request | string | URL,
+  init?: RequestInit,
+): Promise<Response>
+```
+
+`invokeFetchWithRuntime` 对运行时结构使用泛型，因此聚焦单一行为的测试只需提供其处理程序声明的能力。
+
+```ts
+import { assert, invokeFetch, test } from "@tysel/test";
+import app from "../src/index.ts";
+
+test("health endpoint", async () => {
+  assert(app.fetch, "fetch handler is registered");
+  const response = await invokeFetch(app.fetch, "http://local/health");
+
+  assert.equal(response.status, 200);
+  assert.deepEqual(await response.json(), { ok: true });
+});
+```
+
+运行测试套件：
+
+```sh
+tysel test
+tysel test --filter "health endpoint"
+tysel test --list --json
+tysel test tests/health.test.ts --timeout-ms 10000 --json
+```
+
+默认路径为 `tests/`，每项测试的默认超时为 `5000` 毫秒。`--filter` 根据名称子串或 `--list --json` 返回的确切 ID 选择测试。列出测试只会发现已注册测试，不会运行测试体。CLI 输出和退出行为请参阅 [`tysel test`](/reference/cli/development#tysel-test)。
diff --git a/website/locales/zh-CN/content/reference/runtime/types.mdx b/website/locales/zh-CN/content/reference/runtime/types.mdx
new file mode 100644
index 0000000..c88e521
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/runtime/types.mdx
@@ -0,0 +1,119 @@
+---
+title: "核心运行时类型"
+description: "本页索引 @tysel/types 导出的共享声明。请使用 import type 导入；该包仅包含声明。"
+---
+
+本页索引 `@tysel/types` 导出的共享声明。请使用 `import type` 导入；该包仅包含声明。
+
+## JSON 值
+
+```ts
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+
+interface JsonObject {
+  readonly [key: string]: JsonValue;
+}
+
+type MaybePromise<T> = T | Promise<T>;
+```
+
+宿主协议会序列化 JSON 值。`undefined`、函数、symbol、循环结构和类实例都不是可移植协议值。
+
+## 执行与信任
+
+```ts
+type ExecutionProfile = "service" | "isolated" | "component";
+type TrustMode = "trusted-service" | "isolated-task";
+
+interface CapabilityRequirement {
+  readonly id: string;
+  readonly resources: readonly string[];
+}
+```
+
+`ExecutionProfile` 与 `app.profile` 对应。`TrustMode` 描述宿主集成使用的实际 JavaScript 信任边界。`CapabilityRequirement` 标识一项能力及其资源选择器；它描述所需权限，但不会授予权限。
+
+请参阅[执行配置](/docs/concepts/execution-profiles)和[能力矩阵](/docs/capabilities)。
+
+## 请求上下文
+
+```ts
+interface RequestContext {
+  readonly requestId: string;
+  readonly deadlineMs: number;
+}
+```
+
+Queue、cron 和 MCP 处理程序会收到该上下文。`deadlineMs` 是以毫秒表示的绝对截止时间。HTTP 处理程序只接收 `Request`。
+
+## SQL 值
+
+```ts
+type SqlParameter = JsonPrimitive;
+type SqlRow = Readonly<Record<string, JsonValue>>;
+```
+
+应用已知查询列时，`SqlClient.query<Row>()` 可以提供更具体的行类型。该泛型属于静态断言，不会在运行时验证行。
+
+## Redis 值
+
+`RedisClient` 接受 UTF-8 字符串键和值。`RedisSetOptions` 携带可选且有边界的 `ttlSeconds` 值；操作和限额请参阅 [Redis 能力](/reference/runtime/capabilities#redis)。
+
+## 密钥引用
+
+```ts
+declare const secretReferenceBrand: unique symbol;
+type SecretReference = string & {
+  readonly [secretReferenceBrand]: "TyselSecretReference";
+};
+```
+
+私有品牌类型可以防止普通字符串被误认为不透明宿主密钥引用。应用无法导入 `secretReferenceBrand` 或读取密钥值。
+
+## LLM 值
+
+```ts
+interface LlmGenerateOptions<Input = JsonValue> {
+  readonly model: string;
+  readonly input: Input;
+  readonly system?: string;
+  readonly maxOutputTokens?: number;
+  readonly temperature?: number;
+}
+
+interface LlmUsage {
+  readonly input_tokens: number;
+  readonly output_tokens: number;
+}
+
+interface LlmResponse<Output = JsonValue> {
+  readonly output: Output;
+  readonly usage: LlmUsage;
+  readonly provider_request_id?: string;
+}
+```
+
+泛型 `Input` 和 `Output` 可以改善应用类型体验；协议仍要求值能够被已配置的提供商和有边界的宿主适配器接受。请参阅[宿主能力](/reference/runtime/capabilities#llm-generation)。
+
+## 已弃用别名
+
+`DurableHost` 作为 `DurableContext` 的已弃用别名保留。新代码应直接从 `@tysel/types` 导入 `DurableContext`。
+
+## 完整导出清单
+
+以下清单列出 `@tysel/types` 导出的每项声明。链接的约定页面包含行为细节；文档 CI 还会将该清单与包源码比较，确保新的公开声明不会无法被发现。
+
+| 领域 | 导出的声明 | 约定 |
+| --- | --- | --- |
+| JSON | `JsonPrimitive`、`JsonValue`、`JsonObject`、`MaybePromise` | [JSON 值](#json-values) |
+| 执行 | `ExecutionProfile`、`TrustMode`、`CapabilityRequirement`、`RequestContext` | [执行与信任](#execution-and-trust) |
+| 应用 | `FetchHandler`、`RuntimeFetchHandler`、`CronTask`、`QueueTask`、`McpInputType`、`McpInputSchema`、`InferMcpInput`、`McpTask`、`AppTask`、`TyselApp` | [应用模块](/reference/runtime/application) |
+| 持久处理程序 | `DurableHandler`、`DurableDuration`、`DurableRetryPolicy`、`DurableContext`、`DurableHost` | [持久 API](/reference/runtime/durable) |
+| 持久控制 | `DurableSuspendedResult`、`DurableCompletedResult`、`DurableStartResult`、`DurableControlClient` | [持久控制](/reference/runtime/durable#control-api) |
+| SQL 与文件 | `SqlParameter`、`SqlRow`、`SqlClient`、`FileSystemClient` | [宿主能力](/reference/runtime/capabilities) |
+| Redis | `RedisSetOptions`、`RedisClient` | [Redis](/reference/runtime/capabilities#redis) |
+| 密钥 | `SecretReference`、`SecretClient` | [密钥](/reference/runtime/capabilities#secrets) |
+| LLM | `LlmGenerateOptions`、`LlmUsage`、`LlmResponse`、`LlmClient` | [LLM 生成](/reference/runtime/capabilities#llm-generation) |
+| 已接受的 WebSocket | `AcceptedWebSocketEvent`、`AcceptedWebSocketEventType`、`AcceptedWebSocketListener`、`AcceptedWebSocket` | [WebSocket](/reference/runtime/capabilities#websockets) |
+| 运行时宿主 | `TyselRuntime`、`TyselRuntimeWith`、`Tysel` | [运行时概览](/reference/runtime) |
diff --git a/website/locales/zh-CN/glossary.json b/website/locales/zh-CN/glossary.json
new file mode 100644
index 0000000..7de8ad8
--- /dev/null
+++ b/website/locales/zh-CN/glossary.json
@@ -0,0 +1,34 @@
+{
+  "TypeScript runtime": "TypeScript 运行时",
+  "native executable": "原生可执行文件",
+  "capability": "能力",
+  "grant": "授权",
+  "manifest": "清单",
+  "execution profile": "执行配置",
+  "service profile": "service 执行配置",
+  "isolated profile": "isolated 执行配置",
+  "durable execution": "持久执行",
+  "effect": "副作用",
+  "resume": "恢复",
+  "replay": "回放",
+  "worker": "按上下文译为工作线程、工作进程或任务处理器；不得一律译为工作进程",
+  "isolate": "隔离实例",
+  "admission gate": "准入检查",
+  "release evidence": "发布验证材料",
+  "Component Model": "组件模型",
+  "Wasm Component": "Wasm 组件",
+  "host": "宿主",
+  "host capability": "宿主能力",
+  "deny by default": "默认拒绝访问",
+  "allowlist": "白名单",
+  "secret handle": "机密信息句柄",
+  "backpressure": "背压",
+  "toolchain": "工具链",
+  "service worker": "服务工作线程（同一进程内的 QuickJS 隔离实例）",
+  "isolated worker": "隔离工作进程",
+  "secret": "机密信息；密码学密钥使用 key，API key 可译为 API 密钥",
+  "backup age": "距最近一次备份的时间",
+  "due-work age": "到期任务的逾期时长",
+  "flush": "将缓冲数据发送出去或写入目标（按上下文）",
+  "secret reference": "机密信息引用"
+}
diff --git a/website/locales/zh-CN/manifest.json b/website/locales/zh-CN/manifest.json
new file mode 100644
index 0000000..548ff51
--- /dev/null
+++ b/website/locales/zh-CN/manifest.json
@@ -0,0 +1,2377 @@
+{
+  "version": 1,
+  "messages": {
+    "nav.home": {
+      "sourceHash": "3a78695388b38b5cceefaf6796b0137877514593543b91af2752d5a17e3d736c",
+      "translationHash": "203c08e0d44ac3753a3c5b96644a6e10403bc0cbc5770b55cd1f775745a0a978",
+      "status": "reviewed"
+    },
+    "nav.docs": {
+      "sourceHash": "7af023c43013b9a53fbff7dd4b5821588bba3319308878229740489152c43f6d",
+      "translationHash": "2687ccdbb1d2288a8c7867ab8a17e3a70eade5d774aafd0d7eb7b12cbf8165cd",
+      "status": "reviewed"
+    },
+    "nav.blog": {
+      "sourceHash": "8c6bc099534a0251b576f6b88bd2db124ae9497c64bd9242e92a6aec23e6a73a",
+      "translationHash": "7855e5e9727ea5b77bf16577249e0534584a5dd4e27259cbef138467154e1803",
+      "status": "reviewed"
+    },
+    "nav.reference": {
+      "sourceHash": "71bf90935fc231d20126e2087eeb583c6aa419fc3dd1b6847bfe376b9200eaa0",
+      "translationHash": "63e51325a41ffa3e76da38b0e104e00727207b6b3251c38524908b16181a7cb4",
+      "status": "reviewed"
+    },
+    "nav.examples": {
+      "sourceHash": "e68ee04dff59551b7d1ae07a2f8a00dc61d841628948da3d2781630706a05e92",
+      "translationHash": "0d53f08678d8101b0c7e5053b30224fc671c55051770ba18207435ead7ad37bd",
+      "status": "reviewed"
+    },
+    "nav.benchmarks": {
+      "sourceHash": "9f2e7732a6956e5b4fde5b5b46048b4e2fdefaa13539a3e64b5d5dee878f6ae7",
+      "translationHash": "7c185a12004ed29dce6d99e71f553484ca1dcd517be703711ab3aa8a06ef4245",
+      "status": "reviewed"
+    },
+    "ui.product": {
+      "sourceHash": "fb9ef894175c327470f768d95ca7bee65e19853a0eaace3805f8a7b8a12270da",
+      "translationHash": "aea82737cc01867d9d23f2930e810d0544d4ebab02f0eb5a75857481a4e54228",
+      "status": "reviewed"
+    },
+    "ui.source": {
+      "sourceHash": "0e570ca6fabe24f94e52c1833f3ffd25567022beb826fa16891f3322051bc221",
+      "translationHash": "41b50a9198f43fa3e6ab9ab165af12004a655480bd9d045337891d2b4ed3d896",
+      "status": "reviewed"
+    },
+    "common.getStarted": {
+      "sourceHash": "61e8d44ad423a4a0951b21b9d11440a1c23a881fe79335c367f63be251c64800",
+      "translationHash": "715ee9dc842f34e48f267f0bf3261d7980e544b26eb3d2f0ff20e19b121c4a99",
+      "status": "reviewed"
+    },
+    "ui.a.native.typescript.runtime.for.services.and.agents": {
+      "sourceHash": "bbf42448684c6a87d9145780a1207b24527d501619fb8441cb79fbdc87213298",
+      "translationHash": "b01b6229be8ca0da273d78c3a415e194f294512c8dfc0550e1c9d17f88e82b7f",
+      "status": "reviewed"
+    },
+    "home.hero.title": {
+      "sourceHash": "57dd57575413757d7169e5b6fef49cd436b1332a0ede228172596296633e13c8",
+      "translationHash": "e5a6d2a8e877ccad57ed41ffe0d647133b7b6750c21f802b5ba7adbf54316325",
+      "status": "reviewed"
+    },
+    "home.hero.ship": {
+      "sourceHash": "8a1b000300728e5f71ad9ded52e2655457f0aeb654f6faffe8812dd22940a155",
+      "translationHash": "18b18356f89f4ca2b117e1d8838a138535d4a8480f19aa91480282782659f1d2",
+      "status": "reviewed"
+    },
+    "home.hero.binary": {
+      "sourceHash": "9a3a45d01531a20e89ac6ae10b0b0beb0492acd7216a368aa062d1a5fecaf9cd",
+      "translationHash": "8db734884f7fdcd18075d8cb72cd59630d727b458addfe7610d148fe8d27162b",
+      "status": "reviewed"
+    },
+    "ui.a.native.runtime.for.services.and.ai.agents": {
+      "sourceHash": "842f81dbbef3281e535bdab64d591212749f7a7cf8ab00974922191370e6c242",
+      "translationHash": "3a28a443b6b820e8455999107e795ee065e22eaf70254382b9aa339662eefe7f",
+      "status": "reviewed"
+    },
+    "ui.read.the.docs": {
+      "sourceHash": "559b1cc46027e5bcdba787721ecd5735e1b0977234b6848452ea173f8d7bf93d",
+      "translationHash": "ac5c3de1e8bafdf9337afb07c98d319dfa1f622c2a467a015ad7a800e2c12e33",
+      "status": "reviewed"
+    },
+    "ui.web.api.first": {
+      "sourceHash": "200036f8f49021bde6d396bc9e2f028addb308423b59ab79a616a62c7aced586",
+      "translationHash": "cc424023722e9e167feb13a268a439b37768855d00268de299076c3019322108",
+      "status": "reviewed"
+    },
+    "ui.request.response.fetch.streams.and.web.crypto.not": {
+      "sourceHash": "f0c9936c640f8ccd117b7af07d8255a20ce33ea6805850182d37f0b3570fbf34",
+      "translationHash": "2bc5f6d930c8f5806758a96cc62c94cfc6b919d2b4c9786c84e0912dc18f07a6",
+      "status": "reviewed"
+    },
+    "ui.no.node.in.production": {
+      "sourceHash": "6b62639528a372a649563769ea8a854082dc9869eb59874f09f500a3ee6c86af",
+      "translationHash": "19efc51fd20c0f01304bcaf88f504d31be1e8fe91ec9cd20c79b3b6d6ba352dc",
+      "status": "reviewed"
+    },
+    "ui.the.packaged.executable.embeds.the.runtime.targets.do": {
+      "sourceHash": "f7e9d908f983667f9d5e9357eac8fb4346555957b732c26928bccb8cfba47a48",
+      "translationHash": "2012a76aeb21a77036194229d32d1ed7eb5a6ba3c420ece3f707e5e7ebd0ce67",
+      "status": "reviewed"
+    },
+    "ui.deny.by.default": {
+      "sourceHash": "26eb1bc45b534b9163b06b0f6ef8512fccfd99fe13bb603910c4e0e6905a4f8b",
+      "translationHash": "87190d1c0f80b62193e7f9e68818389cc44a03bb246046346a603f5b51d7711f",
+      "status": "reviewed"
+    },
+    "ui.network.secrets.files.and.databases.stay.closed.until": {
+      "sourceHash": "b483aed4d60269c45aa2ceeac0a7a273cbb228a3e92a2a4ab40c2f1063ffbf3e",
+      "translationHash": "03d3d85babd827b11af2cf4093886af69f165edb831a91da4eba12b27798332d",
+      "status": "reviewed"
+    },
+    "ui.durable.resume": {
+      "sourceHash": "c3bb65c1cf2535d026d07bc3e3a4653dba6f21804f1a073ff4ab2ffbe42e9295",
+      "translationHash": "f8528c3105f2419a1921aa20b2f30831bb40c4819730dc3fccf562a5acf3983c",
+      "status": "reviewed"
+    },
+    "ui.steps.effects.sleep.and.signals.persist.restarts.replay": {
+      "sourceHash": "901c7c206f8c219655bce438c2d63e62e8cf27bdecbf573e1d53556313e7489d",
+      "translationHash": "fe9bfeee3494f3b54ce9fe4b29cb700c6cfceee4890ae93b3a5d70bad471f5ac",
+      "status": "reviewed"
+    },
+    "ui.ship.one.executable": {
+      "sourceHash": "2f8517f2f7001fbb67c6a0ed1727a7c4bf4dcc04cf92e6f8cbcd7777ce1c89cb",
+      "translationHash": "873dba11128041efe3f62754238bfa6b33dd71442aca9dff8df2a38d56bda4e6",
+      "status": "reviewed"
+    },
+    "ui.typescript.becomes.an.application.package.then.a.native": {
+      "sourceHash": "efbb4a6845c2e8777213c5a74a12eb4208ebe1b56f40d14080344edd180f1c0c",
+      "translationHash": "ecb62badecf2da248e00889f72e9e62209b218caf03893187858610796a74736",
+      "status": "reviewed"
+    },
+    "ui.bound.every.capability": {
+      "sourceHash": "b7cde3fc2371f8682ad97730226151316f386e6624d1d692a042c3e6aa6a9162",
+      "translationHash": "7ce7fdc124ce6b77da13e8e0f074888e49e09739760126f78c4151e2f87455d3",
+      "status": "reviewed"
+    },
+    "ui.the.manifest.requests.authority.the.execution.profile.and": {
+      "sourceHash": "f1bfb8bf9afb9e04ec4255a80615f515a434a41e76ea8422098cf554085ed609",
+      "translationHash": "527be55cd6f0626c95ecf13e448a4df3882a469e9486041c58c390e24de760d5",
+      "status": "reviewed"
+    },
+    "ui.resume.durable.work": {
+      "sourceHash": "bf526705d7dd79221f0e41728d175ddba0ccdf80202383d3d868f6f1285dd06a",
+      "translationHash": "c0b4d2e31dab8f8bd1252dccf772b6b966e6de26a7e9aa841990a3f7f368eec3",
+      "status": "reviewed"
+    },
+    "ui.llm.call.persisted.effect.approval.restart.resume.save": {
+      "sourceHash": "f3fb4e1bc6ab80a7dd7a3b5591ab5e9b01a0c1c975e30a59cca1dac1bec3e2d6",
+      "translationHash": "69330ca1790f54025184dd547be5350b96f20ec0e9f5aefd74beb78ece416e91",
+      "status": "reviewed"
+    },
+    "ui.three.product.contracts": {
+      "sourceHash": "13fc3b3ad31ae8c776d7ff0b9774ec90c5d1ead72aac851aafc21e2b3ee627b5",
+      "translationHash": "d7360750796bb25b4185cc3e7d2f72203e8d56d417a289c7dd0e66595986188f",
+      "status": "reviewed"
+    },
+    "ui.bun.and.deno.optimize.a.general.javascript.toolchain": {
+      "sourceHash": "c2cc52ff5b034e3e7caef955985463511a7425d9dca0dd2bc54abe139426f8f0",
+      "translationHash": "e7a337c6003d351d0ccca8969ceb9171d82dd3961e3c85554880980f89800f76",
+      "status": "reviewed"
+    },
+    "ui.workloads": {
+      "sourceHash": "84bd9e2accdbd0d686efb9581b38f31553f96f6e7066a8525e9f959face102ad",
+      "translationHash": "63c2b006b0bc9cd639070c81ea6ebb841d4ba660f22ac07b906f0057fa68c32f",
+      "status": "reviewed"
+    },
+    "ui.services.agents.and.wasm.each.with.a.named": {
+      "sourceHash": "3e798bb334d16eb06e854d152f7a58943b32ad6af1d71a2978fe60d4f89debf1",
+      "translationHash": "d3b770bb5506cdd36ebf89f4954de898675dc7561520be57b302a7beb884d5db",
+      "status": "reviewed"
+    },
+    "ui.a.narrow.host.surface.not.a.kitchen.sink": {
+      "sourceHash": "4712024425bcc9639425e5525cb96f8da5c1f909b1f12c5a4d1f5362ac5d963e",
+      "translationHash": "8584a228eda58681fd818cf2e3cd4632ac3f6bf70cc137bb0a9d78c1fb7dc63b",
+      "status": "reviewed"
+    },
+    "ui.five.minutes.with.tysel": {
+      "sourceHash": "95a6bbe318a6824124c2514bcc4d89f35c0264a4bc738a86bc08a1b421cbc508",
+      "translationHash": "82bae069af079928e954a1fe90e36a434d19f8a9ab677e6eaf3102fabd2105a2",
+      "status": "reviewed"
+    },
+    "ui.one.loop.from.source.to.an.executable": {
+      "sourceHash": "0c92a3d6bbe1a9dc9088206bf09c227242e55de7ab55fe830bb1448853213dc8",
+      "translationHash": "499780e9f6c5a19e83ac3db85152f56caf9bb884e184ccc32903b232aaff788c",
+      "status": "reviewed"
+    },
+    "ui.ship.with.proof": {
+      "sourceHash": "4e295e6ad9cd2f99fd6a310ca4d9bb0d3389726741779068b9a223ee943c3f7a",
+      "translationHash": "b8da7a0091b6b6d4b43db32692735261029c06b874056e14d5f9a520141d7259",
+      "status": "reviewed"
+    },
+    "ui.every.release.carries.evidence.not.just.a.binary": {
+      "sourceHash": "d6ef02f8baf7a1c28a5d66884b8162d39cfe82e15aa03c5c312e4ec6dc440cea",
+      "translationHash": "af8a1b42098c188f5728068418f416f08cee36f1ebf60f879118909d04d4c0d5",
+      "status": "reviewed"
+    },
+    "ui.compatibility.reports.sboms.checksums.and.ci.admission.gates": {
+      "sourceHash": "64506a75ac7d5151b1dac4dee2b5486f07a17b9512c41bd9cf060d8dab50d557",
+      "translationHash": "82c7c86ee3f4cc4bf120ea86b34550f1d57404df41620ea617f516411f7fb9b6",
+      "status": "reviewed"
+    },
+    "ui.from.the.blog": {
+      "sourceHash": "47c53aa6db0a5937894f1d10bcc15abc141a14ae82646b37ce32818251a549b2",
+      "translationHash": "85be6a7cbc0c4253f09075e416d258340a57835b347ff0661afacbbfd18e73f9",
+      "status": "reviewed"
+    },
+    "ui.why.tysel.ships.a.narrower.production.contract": {
+      "sourceHash": "39f9591fa1576217c27ee170c261e7cf0d40a45b868f960187400a19be88feb7",
+      "translationHash": "3a655bf8c2726b82baf7b87bff6ed38a9d09a6ed73af87b40a88a99918c35673",
+      "status": "reviewed"
+    },
+    "ui.all.posts": {
+      "sourceHash": "7b957c9b86ed47a2cbd19e30c0f579cc84f5544f370bd1fcdf9683da25186501",
+      "translationHash": "4758179d46ff04a9afa2f8ce4f809bbfa50249d71a18f1720f55b1904fa13c08",
+      "status": "reviewed"
+    },
+    "ui.release": {
+      "sourceHash": "766c8373b9dd0be0b89657a640010806d8a4a91f38c7983c35956ef1173075db",
+      "translationHash": "5043198f477e9c2e75fd3c550a0558a7b039a6bd3820ae6b8f1aa8060d38d9da",
+      "status": "reviewed"
+    },
+    "ui.read.the.announcement": {
+      "sourceHash": "6c3d5875d96f39ce86ba2745de5a25e835e5a376e3100f3ae1eebcfeb51334fb",
+      "translationHash": "41f5ce95704da1c508fcbe8bfa0d36f9617cfd8798377b4c5ef7b8e725f8b241",
+      "status": "reviewed"
+    },
+    "ui.from.typescript.source.to.one.production.artifact": {
+      "sourceHash": "f73c4d7a44066a7dbfe619e483e08a8c54ae279652fe1aec851e2521a8699893",
+      "translationHash": "66c90ba9af6ecd5ee74ebdc54af623446d68f8800cc74cee47d9f1054e67ddd5",
+      "status": "reviewed"
+    },
+    "ui.build.your.first.service": {
+      "sourceHash": "f00343e105843754b60fe6adccae3d6596d733bde448fc39def5e12cee0896e2",
+      "translationHash": "b825f70170945ebf0056fc02406e9bb01d907f5bf46793688fdfd2000a6a9fb2",
+      "status": "reviewed"
+    },
+    "ui.run.the.durable.agent.example": {
+      "sourceHash": "14c618c0505a6e089b48832f077de8c35029f8958d711fc26d8fdb50d7157330",
+      "translationHash": "29e9e119dc0beefa0487afc4cd1b45b0f7f189c27cac84dfe15177d2683e53ea",
+      "status": "reviewed"
+    },
+    "ui.compatibility.evidence": {
+      "sourceHash": "34115cfbabdbf1bc493e2722aed1489c5c521eb761bede190b5a21908049e1f3",
+      "translationHash": "fc70102d620913e12696f0fbb788f03a9b6d703069a389036dd102a92815ad40",
+      "status": "reviewed"
+    },
+    "ui.security.model": {
+      "sourceHash": "b84c8b60d8ab4881122ef838a4f553e5a49fd4c0a7c219e31966a63689359129",
+      "translationHash": "e3d111da2cc29ee8f49a3d0489b4a31fe28cd8f4ecfc11fb6df4f7753df02682",
+      "status": "reviewed"
+    },
+    "ui.production.operations": {
+      "sourceHash": "d49e2ee43b4814f079886cd620eba0b86e3d4d32661e5a181a50d14584416035",
+      "translationHash": "53475bc157513476538f845961e5c0bee47ade4827f7b8d4bd430fb943d516fb",
+      "status": "reviewed"
+    },
+    "ui.ci.admission": {
+      "sourceHash": "ee0aadccc5fd47566230ae2ed12368dd3e8f6ecff74e8f6d217b09145f099933",
+      "translationHash": "eec7dae9acaad857451e1020d9fe596b42887bda67bfb92406d3dceb44a6d384",
+      "status": "reviewed"
+    },
+    "ui.a.fetch.handler.is.the.whole.application": {
+      "sourceHash": "e01809e2941ca73286735b8641a472a6309e711a73625bb4ed479c38a1d318c6",
+      "translationHash": "52b9fc01efb1521e00c6a97aea4bc5d706097e3391465ea3aaff970718caac5c",
+      "status": "reviewed"
+    },
+    "ui.package.the.app.and.native.runtime.together": {
+      "sourceHash": "16fefbc16b7757e1ee329efbc7ffe125cfed8513513c1ac163709c75f9f930c4",
+      "translationHash": "b4e43520fc10d5aa8a1e9590248541b37b930537ac90f82a66076e9cc7509668",
+      "status": "reviewed"
+    },
+    "ui.no.node.js.v8.or.node.modules.on": {
+      "sourceHash": "96333d7454964d41fe17c34751c739039dec98761c6b3d96a33a7ccfd4ac03fc",
+      "translationHash": "156292255531e91082e60803d0cbc1668d127d127401b6516a8d8efe2d661d4c",
+      "status": "reviewed"
+    },
+    "ui.paused": {
+      "sourceHash": "a7a9dc5bcf71adb2edc202814060a5ab6fca515382e9f1133dcc47d52d9090a2",
+      "translationHash": "eb0c326b60ae897a19080c0b21565029be8da614a7dd6ecad97da24f4cb8fc90",
+      "status": "reviewed"
+    },
+    "ui.replay": {
+      "sourceHash": "ac203c9843b5bd8c883e07039ff82820c94422010be6108bb82403ca25376a22",
+      "translationHash": "dfca64c65c59de371c4ca1d70452f2f157e0d32c3cfa6003076ea7de51b34ac3",
+      "status": "reviewed"
+    },
+    "ui.verify.the.toolchain": {
+      "sourceHash": "f6b2a3964102dd77dbb1ca5ec5914232aa4e31a7300d836162cf89a99bb62098",
+      "translationHash": "082eebaceab3e11151f9e2e7a6061d2087eec47d8b068d14c3f4e773be57eab7",
+      "status": "reviewed"
+    },
+    "ui.confirm.tysel.tysel.service.and.tysel.worker.are": {
+      "sourceHash": "ad36fb97239f2266b8989851d54ee241af052974e9a8ff90181461077cba007e",
+      "translationHash": "396b6a998c0233f4e83d26cb2727af2f51593642f9e41b5e0838b2b659cc6e20",
+      "status": "reviewed"
+    },
+    "ui.create.a.project": {
+      "sourceHash": "c52af048cebf3e0aab5a0ecbe1f83e7dee6f3b9eb1bd640768f61d6f50b3a1bb",
+      "translationHash": "43d7d2b51d75fa42d80c78b14b15b4adf4bb68483603b60972dc07ab76705ad9",
+      "status": "reviewed"
+    },
+    "ui.writes.src.index.ts.tests.and.tysel.toml": {
+      "sourceHash": "9667126a45fbffefb6a1dd0367761b759b5292766266408a8179196439117b12",
+      "translationHash": "c848ba44eb348a3391639a1305c57d29d27166c5a76afc5ec6f285f25905f9d9",
+      "status": "reviewed"
+    },
+    "ui.validate.configuration": {
+      "sourceHash": "756353471d10bffc57aca52f66fe672af778369053ff84b4e0fedf7bf59bb84a",
+      "translationHash": "5a1511251eb03d49e9d8a7e5c787e4016b84e4dbc7c4736d5f69f8a7271052bd",
+      "status": "reviewed"
+    },
+    "ui.the.manifest.is.the.contract.entry.profile.permissions": {
+      "sourceHash": "5769a82ed68c1065d1c32f621f233c2756894b8021f5940691dfb6a5fac233a7",
+      "translationHash": "04dc33b4ec06c95cb372fb63a76dfcb4114bfb0126d660559b97fa157516a9f4",
+      "status": "reviewed"
+    },
+    "ui.check.and.test": {
+      "sourceHash": "21797aea1025d4ad52f9f9a4fbe002de5153e62764057b2312a01fddc3f78f1c",
+      "translationHash": "38e7cc9d806658684af6d69e0f9fa6cdb5fae7e9a69e55e71fb7f2846abd7cbd",
+      "status": "reviewed"
+    },
+    "ui.type.capability.import.and.isolate.tests.before.you": {
+      "sourceHash": "5ff25669737a73ee48a1aaa5c83514ed76dbd9caf64210dd135ff205b3ad41f1",
+      "translationHash": "0b49421227a045fcd5b4bdd91823e669f8bf808ea4caee5ba76bc93a851ed3ca",
+      "status": "reviewed"
+    },
+    "ui.run.then.ship.one.file": {
+      "sourceHash": "b7def3a36b30f1b8922393f44fa60f327a7ce621e454d3793ea64059cb18c2a6",
+      "translationHash": "351edcb7119f273a35cdb86358a3a0c770c5833b2c9983d874d939526f9030d8",
+      "status": "reviewed"
+    },
+    "ui.reload.in.development.then.emit.one.executable.plus": {
+      "sourceHash": "905a5f4ee42dc40850a08749e637c1e07a8fe3256f819f1be05eeb546217ad97",
+      "translationHash": "b21eabf69e481f0a0c2d6089d6058bf5b8c497dac9583b14bbfa8ea7ae479f04",
+      "status": "reviewed"
+    },
+    "ui.node.js.is.optional.for.editor.declarations.the": {
+      "sourceHash": "17338faff076868f29cdfac8c5cd057bcec44232c057cc5b67f75ea7b4574240",
+      "translationHash": "70bb8a178dcc4545f726ce0ef7de15693acd932892ecb739331def9f21322b14",
+      "status": "reviewed"
+    },
+    "ui.paused.67": {
+      "sourceHash": "af0ecb7fcc51ed23deb562eaa5db4ccd9013d11b6ebeb98e1228b024fd398b04",
+      "translationHash": "de6243cf24a452e3e03f458925a0c558363f72b1d87fc13928f2e2e0cf2afd91",
+      "status": "reviewed"
+    },
+    "ui.hover.to.pause": {
+      "sourceHash": "14b554a3c3b51a08e377b511faae95042b02161c06004a96e79f15c706c9d267",
+      "translationHash": "0b15eb6a7d6fb2ddd384891e7bea5ca0502d43e8351738dce990a2e265caf05a",
+      "status": "reviewed"
+    },
+    "ui.then.run": {
+      "sourceHash": "05e8dff94109b9d4588febb3558654615f19bdf5d0aef4b0fb9ccae99e361586",
+      "translationHash": "054bff18b61a059f8a5be942096157ceb297235ab3e8c5c4b2aa303962d3002a",
+      "status": "reviewed"
+    },
+    "ui.no.rust.node.js.or.npm.on.the": {
+      "sourceHash": "9833d62805d89d5465edb6b88edc64012098963a5fe14850642a7bf93936ff4c",
+      "translationHash": "3ba0954197ab649fce1ee34c21f76631e5ed0ae46caf05cbc8860f84d5df5a52",
+      "status": "reviewed"
+    },
+    "ui.http.service": {
+      "sourceHash": "da69c27936851e07ffdd00e8302381f74f982fecf4a28dafb17d9cb28adfb740",
+      "translationHash": "66c2a80a47c7d4a8814807fa66a1e4c1ef80bd0f81cd71fabd71020923f62813",
+      "status": "reviewed"
+    },
+    "ui.a.fetch.handler.is.enough.for.a.first": {
+      "sourceHash": "3712c8ec77f549c8bde1b15bf59c148651168a41eca9cfae749e7dfed1fbe7b6",
+      "translationHash": "c219c3c53e98521f851bf987e7790a3d324a04676f55c397f0c2890b3737fc5b",
+      "status": "reviewed"
+    },
+    "ui.service.no.host.capability.required": {
+      "sourceHash": "4b694c06c3eb0fa73025fd860a4a763582f7c6a24c9ac4e31d0fc59bb9972286",
+      "translationHash": "d280971236dca7eb257db5d56fcbfc0c799b7377fa5448ab6a58e6f2a05386ae",
+      "status": "reviewed"
+    },
+    "ui.durable.agent": {
+      "sourceHash": "c8ec3f252eb6e3ad1c5d86fddf6ffb93330a071666f56994b4fd9f08198dc766",
+      "translationHash": "13478be3e70a2a40351291e30cbe5e0db11260280d0bc4f7c7778d4d6d8c2962",
+      "status": "reviewed"
+    },
+    "ui.llm.call.human.approval.then.resume.after.restart": {
+      "sourceHash": "931b5820a505aa33a9e5a5f2398fd79bb3eabc03b93e7bfc6598f5bf85af23ed",
+      "translationHash": "40f52e9f1dab49f96beaa66c4d73e340e87b1d0693fc7092d6b01c9ddd5d0788",
+      "status": "reviewed"
+    },
+    "ui.service.durable.store.llm.declared.secret": {
+      "sourceHash": "be9897120433d9578d524829e4754d933aba9d817ab4d59ed2de9e05c100ab97",
+      "translationHash": "6b60220b52d8575c6c318344a2c0fb3c385f2809d87666f64590de38c027ac38",
+      "status": "reviewed"
+    },
+    "ui.llm.call": {
+      "sourceHash": "0559f37ab89bb009218de905cade14ff1175e19fa0175e639c28eef3a59b7aa2",
+      "translationHash": "e3fee05f688708b4d123021d765a08d10d30ebdbdb6a018fc9c5b7ab127919c2",
+      "status": "reviewed"
+    },
+    "ui.generation.goes.through.the.host.model.aliases.and": {
+      "sourceHash": "9ba8cd6f7aa9d346bad5913270dc8135cc41ec3ea1ffeb7dbf27deb97cf3dea0",
+      "translationHash": "e52fa7593c889d0b363ef77199e835a65d75f4838b06f12677fa7249310140b1",
+      "status": "reviewed"
+    },
+    "ui.service.provider.config.declared.secret": {
+      "sourceHash": "9959e7fa184004c6d8d4e4af82cee1d5fa05351e7efd50782d155daf2ee29948",
+      "translationHash": "17a69691f7e818010947298ee0dbca57bb586d89b59f51e0d1c1671bfdbf502d",
+      "status": "reviewed"
+    },
+    "ui.mcp.tool": {
+      "sourceHash": "24bb4cb114e4143db8212def8eaeb96f05f9696dbbd0a17131552c4aaf8e502d",
+      "translationHash": "7d7f913591343652d0db0be36b76c2a1d0eb1b0a0540b99d90588de4a6669f19",
+      "status": "reviewed"
+    },
+    "ui.validated.json.tools.over.bounded.stdio.isolated.workers": {
+      "sourceHash": "36e48e9b8717fddc162565cf6b6a2a8654bc26363b4e0b2a535e86211b602f9c",
+      "translationHash": "f34d29890dd846019d7405a8ef8838b655434287b6d21511065cda08c938f606",
+      "status": "reviewed"
+    },
+    "ui.isolated.brokered.secret.handle.only": {
+      "sourceHash": "f098f6c16ed11d2a73f9f99b41c26b2ccc6d1fb17ef0a635f3241ba200a5dd3f",
+      "translationHash": "bb0999aa27d29877a1e20cf41ecf16a64e237c4c1297f50f0ce99e4d54bf5c66",
+      "status": "reviewed"
+    },
+    "ui.sqlite.worker": {
+      "sourceHash": "7bb7db015f47c633744ed465314cc315052c0597979aa2b3448be3e11d2c6048",
+      "translationHash": "75b1d7109b2ec92e554699306f04f193ea2225da7df2899d8a73f9443b0e3fbf",
+      "status": "reviewed"
+    },
+    "ui.local.state.through.a.runtime.owned.client.the": {
+      "sourceHash": "3f1cca10fa1691a1e54904b41532bc03ee8cb61c88d1851243eebc7942bda678",
+      "translationHash": "b9ac22db4ff3bad2cf6ff2ebf65590695868ade70edb677cfd2b389dfdb3c914",
+      "status": "reviewed"
+    },
+    "ui.service.runtime.relative.sqlite.grant": {
+      "sourceHash": "f5a156451832df39bff6f42c38bd10a3d9e4b46928b8111986d55da44b59c165",
+      "translationHash": "7e599ca113cc62d07716dcff7727477362050d111d1efd4debcf40d614654ac7",
+      "status": "reviewed"
+    },
+    "ui.postgres.service": {
+      "sourceHash": "ce127e85084df768d60a48fd08bc45b2a8a7f73e1e896f6714f5501fe85541be",
+      "translationHash": "52317b87d99cb3d6062a489d40fe827bcf7289ccc4ff399d893e71825cb33d51",
+      "status": "reviewed"
+    },
+    "ui.query.a.named.database.the.connection.url.stays": {
+      "sourceHash": "45ba38f443a710f084733c3727ebd77a4cf22f4161a717602809975a33b4fc7f",
+      "translationHash": "cc554f1659d60bf3829eee4890121042c000ea1f110db277069a6f45a092985d",
+      "status": "reviewed"
+    },
+    "ui.service.named.postgres.grant.e.g.main.read": {
+      "sourceHash": "59f8b73304ae8e27c6f98f733a786b53ca6bb59afc99e00aa3f1a98437c7e164",
+      "translationHash": "b3472ef157ed15bee4aec101e154ecd051a2d7db91e39d49864e9cddf511e448",
+      "status": "reviewed"
+    },
+    "ui.inbound.upgrades.need.an.explicit.server.flag.outbound": {
+      "sourceHash": "759300a2b7201da27ff78040dd4d6077544160db003d29f81af1ca7106996b52",
+      "translationHash": "cec23894fae68f18910a4dbef3eff1a6fd23c8ede3851765a34f52d9fd4d1eed",
+      "status": "reviewed"
+    },
+    "ui.filesystem": {
+      "sourceHash": "8230c68a6158c8ba8c1b7d5b8e0557be9564e129e15806f60dc2205a9ca5bfe7",
+      "translationHash": "47b6174788b64db59e598cc1c289856821f88550c4c4fea174c3ef031b06f6b1",
+      "status": "reviewed"
+    },
+    "ui.utf.8.read.and.write.only.beneath.manifest": {
+      "sourceHash": "25bcea61e6daee5f05dd563bd7599efc09eab6ae0cbda5dcaa273958f1e5493f",
+      "translationHash": "89ba92954be5862cc20b453a7dc1eeb0fa36444c0e90295a4fe604c59fc68fbe",
+      "status": "reviewed"
+    },
+    "ui.service.matching.fs.read.fs.write.roots": {
+      "sourceHash": "5596edde395c136312be6861fa9b5b00a9ca44b8bbd66e8604f0056c84698a20",
+      "translationHash": "5ff0e23143eea86542cd2e011319ccf5b23a5a5f642c326c54e7027a79089805",
+      "status": "reviewed"
+    },
+    "ui.wasm.component": {
+      "sourceHash": "029cb00227416d104ed05f5b6cd3aafeb1d08d16d7ba5d2c2c46edc19d37f017",
+      "translationHash": "5814672f60150245e201b1212ff652170338a8f3a7e4edf9417d40e0022861d3",
+      "status": "reviewed"
+    },
+    "ui.a.language.neutral.one.shot.json.task.through": {
+      "sourceHash": "0685d7a14916575e078cfb453df1bce947569cb255e7e5bbd7185b8eab0d0aba",
+      "translationHash": "81839dce920318e34e5ef12131d0fd69f88008fcf129d9f8369e9108c2784139",
+      "status": "reviewed"
+    },
+    "ui.component.experimental.isolated.task.trust": {
+      "sourceHash": "cede779a437b3f56c0c1e7a78334242c2bccf8f54fb1ccff737887ed56d3d68c",
+      "translationHash": "dfdf5f79c8cc2705932ba657d2066f7601d5a51649315e02a52ee89b11e232ce",
+      "status": "reviewed"
+    },
+    "ui.services": {
+      "sourceHash": "604dce445e326d952308addc99bd3d0e3ffb0ed9a455e4aa0190641fc5facccc",
+      "translationHash": "ec309ab207ef7fa31b139a743e5bf864ae84aa1ae2cdebb5d304ac05a67c58fd",
+      "status": "reviewed"
+    },
+    "ui.web.request.response.entrypoint": {
+      "sourceHash": "6375822357c7a70e470d2dc504be8bddc9e9014362f808a15881f564316cf5bd",
+      "translationHash": "816beb87d0bf183126b288ca3973b81cc6654a527f667c20d2d0bbbc9378248c",
+      "status": "reviewed"
+    },
+    "ui.inbound.upgrade.or.allowlisted.client": {
+      "sourceHash": "d7bb3100b83d6bd3abd11acff06b4fb23602c82dec00b216a61c5263df195cc2",
+      "translationHash": "1e566fe7715aa3c48872b46883cfff8adc54323a8d8624828b3abcd36a6c1599",
+      "status": "reviewed"
+    },
+    "ui.scheduled.and.queued.task.handlers": {
+      "sourceHash": "ca1f182b73222435b5d03974e1a90c58923bbd264ed7567664d97a821f24144b",
+      "translationHash": "8d50fadeaea805f17a060c6ef9cbdc2d637b4b02d843978687364b5977c9a52d",
+      "status": "reviewed"
+    },
+    "ui.agents": {
+      "sourceHash": "279b44d2ab4b40c0fc132f8f3051293544cca91de9c8aa14f2cd29adb132b0ee",
+      "translationHash": "2df7697dbb6128781c7871082454bcfa03686558e5afe7f28f6ca66ecc3b2d1d",
+      "status": "reviewed"
+    },
+    "ui.effects.sleep.signals.resume": {
+      "sourceHash": "26d90e867875f3a0676d78319334426dd51846637bca1586d3ad5dde5f259667",
+      "translationHash": "ec8bb57c948d852b9aebd24bd4043aa83a96bc1f0639748a0c8592cc7b389ba2",
+      "status": "reviewed"
+    },
+    "ui.host.brokered.model.generation": {
+      "sourceHash": "53607d65ae8e0c56c504c25779bf18c121b328799705a8360e2d645305252800",
+      "translationHash": "c9104a971c91be12fc69bf1c244f03f63752516ed65bb5f7e3703518b15a8fdf",
+      "status": "reviewed"
+    },
+    "ui.mcp.tasks": {
+      "sourceHash": "57dd7f80a40e9157bdb37b4a704956b040e4818a934c131151dddc6be0019c4d",
+      "translationHash": "b1bc5d78c6018ab7244bf0d7bbba55bbfba1a5c57db5b31e4b05e405c6157f8d",
+      "status": "reviewed"
+    },
+    "ui.bounded.stdio.tools.with.validation": {
+      "sourceHash": "911b5517e1fc57543d6b4fea3166399513b141e4d46a99ca424a2524e60f755b",
+      "translationHash": "9ec12be4df6215fd068e35732bdd277d17a7debefa3df1ff44d2230b862c9de1",
+      "status": "reviewed"
+    },
+    "ui.host.grants": {
+      "sourceHash": "710a2414d6f457c8d339aad9520c3eb79ba4f77f8ba7d21c71d06361bffb6503",
+      "translationHash": "d048f3747d72e4c209b224b0311815385cb9dfd3a8fc09a6ce574914adfb7269",
+      "status": "reviewed"
+    },
+    "ui.opaque.handles.never.plaintext.env": {
+      "sourceHash": "7ff16fe4814a62df08124e87825b510cf8724864b41e3f47de7f5d400a8e1023",
+      "translationHash": "94c26e728b00b116d78c056df2ee3639e9f98a75357d14475ec15c44ba92c61a",
+      "status": "reviewed"
+    },
+    "ui.named.grant.bound.sql.clients": {
+      "sourceHash": "4a02e72af59f28b348cb4181b962a671549323a0459fb6b446c37fdf1dc40417",
+      "translationHash": "8ca4eb00adbb52a6e0cb9f378c8d8c6f9696a88393ac3f057b9b464de9506c40",
+      "status": "reviewed"
+    },
+    "ui.read.write.under.pinned.roots": {
+      "sourceHash": "e1c7d925d6fe680c341b27f943277ffe3b5c8dffc2fa171ce29acb927d539773",
+      "translationHash": "3256ec81a7a015f59455fd5ae7e96e513de4981b017cf7fd5cccf035cb2ddedf",
+      "status": "reviewed"
+    },
+    "ui.web.api.first.application.surface": {
+      "sourceHash": "ff525377c4b3f2a87fd0aba81f12fb2c3810a756623003e9b4ae543c873a8e27",
+      "translationHash": "b384d39cc62a93fd6d14a6eaf2be89c6479b38f6d4fa9b782fe6eefe4b216a98",
+      "status": "reviewed"
+    },
+    "ui.outbound.http.on.an.allowlist": {
+      "sourceHash": "6e1482ecd6d0b5de50f3c946d923a14f842bee41575776966029dabfa254d0dd",
+      "translationHash": "17266b523976a42a1b2dfbf3532bf5eaff2f7f0713981c41d40eb8946ecce9b7",
+      "status": "reviewed"
+    },
+    "ui.web.crypto.subset.no.node.crypto": {
+      "sourceHash": "5f107dc604a00fcff488f5e346ae7b7a97e5730e548cfb8f06d6b1f4e16ac02b",
+      "translationHash": "df57abc2cb4329e2466f8bca6db81a8fd7d5ec35dab109e7e80f7e3a0665af11",
+      "status": "reviewed"
+    },
+    "ui.wasm.components": {
+      "sourceHash": "cf0b73755c07a7ff96654eab120b2ee83d935bb475d4d882b5e93f607fd5773c",
+      "translationHash": "5814672f60150245e201b1212ff652170338a8f3a7e4edf9417d40e0022861d3",
+      "status": "reviewed"
+    },
+    "ui.one.shot.json.task.world": {
+      "sourceHash": "914eaed37b8c70679c442c9e15c0e6efdffe5f9a43eb7c689b54181167df6a9d",
+      "translationHash": "680ad4b3f363a7831d41ab37b17163ae75f4e177dd6229c1e6701329b09fcf02",
+      "status": "reviewed"
+    },
+    "ui.guest.types.and.dispatcher": {
+      "sourceHash": "4e093a9e66aeb90d5cc1d0eb4014b1c89a5020aee99b9ba2a284e3ada8d172e2",
+      "translationHash": "9e56cb668b4b03fa5b9d7c740794c39c84c00d07c2c1ed6a943edd63a02a23c8",
+      "status": "reviewed"
+    },
+    "ui.generated.bindings": {
+      "sourceHash": "dcfe8753d4ae296ce56b8b14c9cc003cab0687005c722e24d08159f0d3a54690",
+      "translationHash": "083b5f36e2e4a2c90a6c61555e48315433ee7727074e1559bfd69bd331c21946",
+      "status": "reviewed"
+    },
+    "ui.contracts": {
+      "sourceHash": "0488acc63d8b513587cc45e2d7dd7c17cb873266452b23273c6dedb651764243",
+      "translationHash": "1ff420ba0a81995a0e82d49c242b3f756592e6a3120b746a8e52c184bd9a31d1",
+      "status": "reviewed"
+    },
+    "ui.manifest.grants.and.reductions": {
+      "sourceHash": "c8842d45b26e03999907286eb25ded29d879d197e5ce7b6f6ef33caedf8cbf86",
+      "translationHash": "1e9b33e6f55ce8dda17574970398fbcfe81255d14671f470f947636e36c4cdba",
+      "status": "reviewed"
+    },
+    "ui.effective.authority.and.limits": {
+      "sourceHash": "de0f8cc21a84db4209bf4326fa0c80c70e2e1cb191a6e963e53d9961ef18d1e9",
+      "translationHash": "abce3126b6674fdde88d5f3e2f49bf1e03631549eee6fb4883fecfc838a0a930",
+      "status": "reviewed"
+    },
+    "ui.handlers.in.a.fresh.isolate": {
+      "sourceHash": "c5f76a07b6a1f4cdbda18dda3229a283f45edd3046a19479caf03be62c11f781",
+      "translationHash": "ce23cc29328bd8aa73fdaf00383141d5226d0c2bbe609012c94af8473157185e",
+      "status": "reviewed"
+    },
+    "ui.docs": {
+      "sourceHash": "e4c03b402774360f190dd276f64c35e31da74d5be25159fd3b9cbcf187ea0382",
+      "translationHash": "db01dac2e66e083ed5ea43e87d47c9e89d03c367a3f7334f381d15be48adaedc",
+      "status": "reviewed"
+    },
+    "ui.grant": {
+      "sourceHash": "4720809b310662058d7b2e39d09d099a889fcd0d55112ebe40505c408f0fc0f3",
+      "translationHash": "df29c6296d9c5d3f96b4705cbddb5b18122080b075bd695b9c43cd26d36dc6c3",
+      "status": "reviewed"
+    },
+    "ui.reference.recipe": {
+      "sourceHash": "10108e718e781016495d4d5b94b010033328ad9391ab1d2754e4b31f4ec280b9",
+      "translationHash": "9e5a64a26e2b385edfaad1dc7815c4f2fdd1b57a90edb0226ae5409629e09846",
+      "status": "reviewed"
+    },
+    "ui.lookup.by.contract": {
+      "sourceHash": "17a33b02ee66fa4004cf466f46e6783c2e71bde362d16bc5a9b90d09c07c4e24",
+      "translationHash": "209598cb7ceca4b60403335e4139ed738da02e90f1c0d7599177a74011cc94f1",
+      "status": "reviewed"
+    },
+    "ui.each.link.is.an.exact.interface.page.accepted": {
+      "sourceHash": "b8ca57ade6c423b37eff342bec7e95cf1118975e606f6c87067cb18869fbe00c",
+      "translationHash": "fd2be8a811670879ed3c62c928efa434d80fd9972f82b038d5c203494e83f3fc",
+      "status": "reviewed"
+    },
+    "ui.api.reference": {
+      "sourceHash": "80255f6096dd724d8a1af8df3e16a950c8f911e39b64b13fca9f37b6b4703dd9",
+      "translationHash": "4bd67d729e87e946cd02ed43dc8f5224cbac66b785870c425cc64069cf3f6130",
+      "status": "reviewed"
+    },
+    "ui.shell.child.processes.ffi.and.dynamic.libraries.are": {
+      "sourceHash": "8f05e766900a5f88504dc72056b8abd2e805fa7e85869c910dd8285e12406685",
+      "translationHash": "2f431640092d4ca1ca4852334bb3e8e088bb05c50857d2aa852e3f29792ddd66",
+      "status": "reviewed"
+    },
+    "ui.capability.matrix": {
+      "sourceHash": "eb92341736203e17a83c424aec01817ee196070e2b9ac7f33fa0f18c860164c8",
+      "translationHash": "6c84c4dc33e5923cbf9c69c3cc1d7adc7998a3253dbf2a9891d8f21b2cd141f2",
+      "status": "reviewed"
+    },
+    "ui.execution.profiles": {
+      "sourceHash": "3badecfaa655b088d63b8a50535ff087f58712367a8afc33608c8a9cbb7b8cfb",
+      "translationHash": "90979262caffb0bde4364d3443b673a082da20e42759414f4387fb264bcc4d56",
+      "status": "reviewed"
+    },
+    "ui.and": {
+      "sourceHash": "4aa9bfd2f175a94ad5a7cb321e1aea9790c73eb366a3415b47a00aeaa9fbf24a",
+      "translationHash": "c3828f02baf2d420a6769dbeb9f10a009d58af940521140b78cdb5318be85a23",
+      "status": "reviewed"
+    },
+    "ui.example.gallery": {
+      "sourceHash": "215c7926902602c17bc9873067ed2af24519419323645064ce51a4fa698d9b72",
+      "translationHash": "d57ab7fec9863f7dad29113b83a500158aa4c2060ccf7e59c625a6ba7d07829e",
+      "status": "reviewed"
+    },
+    "ui.open.example": {
+      "sourceHash": "4221bd94eddfd0c3e59239c077221a0bdd13b1277894db1e85de45e3af78a47c",
+      "translationHash": "e599ca46519382d4f7ea8a259160396f58fae34bd3777afbed93bfe1286741ac",
+      "status": "reviewed"
+    },
+    "ui.ci.admission.linux.x64": {
+      "sourceHash": "f6511781966a1cc6e991b4249f3eaaba293a18459a5a3dde2307412928047499",
+      "translationHash": "be7853927c46ead80023f56d8f775ffbf56370f5124d6f6abf981d0754648641",
+      "status": "reviewed"
+    },
+    "ui.clear": {
+      "sourceHash": "913a4cb91be20332f3559f8070255d7ac3e6228bb423f4441551d3f783e7d4f4",
+      "translationHash": "1e9f2561b7cf43c495c3417ea97bdebc53321d66be975b811d3bc0022c72197d",
+      "status": "reviewed"
+    },
+    "ui.sample.layout": {
+      "sourceHash": "6938543acf259ea6151fc3644b0dd6b5c3557c12572961225e78cf15765e570e",
+      "translationHash": "a0619d95793ce3c0a8346a579b1ecb03f97d9b3b7bcaa6408bad09e383720194",
+      "status": "reviewed"
+    },
+    "ui.waiting.on.ci": {
+      "sourceHash": "9062b1a5aa67db895657af0ce7617de866e65b6df04aa81bd8914eeeaeebc423",
+      "translationHash": "68e9e05455b49e451e3ce945d4bcaf35ea6f01b8d871b82ddd7bc3f34770f621",
+      "status": "reviewed"
+    },
+    "ui.not.a.ci.claim": {
+      "sourceHash": "fc92b4477445eed4e658b6ec68b9fb34c94e7b60bc3a0674d10e498d1cea4a7e",
+      "translationHash": "e7e1d4facbb12d60dc3b5d41810dbe590b9d530c7d8ec34d60552a1e19cc631d",
+      "status": "reviewed"
+    },
+    "ui.illustrative.snapshot": {
+      "sourceHash": "9318bafaf436bb5f2d33d94eb039e317b3da342ea481b68e13c7b20dedf87c6c",
+      "translationHash": "e9167cd69434044b737e049de164cb68f03ccc181c79195b3f540084b6201888",
+      "status": "reviewed"
+    },
+    "ui.ci.run": {
+      "sourceHash": "16d690be242dcd3f480a67a74158c37881bcf10b4e8d2170e72da83355271c25",
+      "translationHash": "e6c7c139aa3b27bf20c1d9ca0d340a9679ac5201c59dfb01b5c4c4aa4fa4282b",
+      "status": "reviewed"
+    },
+    "ui.fetched": {
+      "sourceHash": "0c7fcf412c36e9e1cfc3cca37cec9afedcfca86e1943f6827c36e88dfda41642",
+      "translationHash": "1aed7ae9b02052e67adb4cd3846cbd78e20a1a71a969634156c583ae0203a34a",
+      "status": "reviewed"
+    },
+    "ui.gates.stay.public.measured.cells.fill.from": {
+      "sourceHash": "d87ae556d631fbd6ae8c9b748f4aa84851078c40ed0c7c520b0bfe7f7a57fd09",
+      "translationHash": "21c5572507297ed643de735a8ca5ae2fda0321c11a52d272dbbcd6ed61bad180",
+      "status": "reviewed"
+    },
+    "ui.admit.on.p50.linux.pss.regression.budget.not": {
+      "sourceHash": "44b3448d43bfc64e0dfcff59381a28bc03e17e9a323a68f4b5046323b6263e5f",
+      "translationHash": "d94736481c9e9d824273ed3256f6be8775bf763d4826d604e2702404e1eefb66",
+      "status": "reviewed"
+    },
+    "ui.runtime.microbenchmarks": {
+      "sourceHash": "459aeab58cc38106e8d6a54c1a28177f4f5c4a7d811b1a11c8ae441e49c296ac",
+      "translationHash": "3c4cc82918f49086a5054f277cec31218f137008e2139684ffdf9e46bd7b9015",
+      "status": "reviewed"
+    },
+    "ui.same.run.not.release.gates": {
+      "sourceHash": "b3651347574a85c6688ece704730996a5aa7e4186c8dc5195aa17d0bd455657d",
+      "translationHash": "2dee81a5623311717c160dc9dc399dd25e8ee0cff3963ddf75586185267db68f",
+      "status": "reviewed"
+    },
+    "ui.observational.only.they.never.fail.a.release.and": {
+      "sourceHash": "7a26a8766baba5acede6588b6d99c770829f93b0e43b9ade0584144391b19179",
+      "translationHash": "163f17aa54395afae6b34b67f5e72ed7c09e450ca5bdd83c38a1e927fcd55752",
+      "status": "reviewed"
+    },
+    "ui.metric": {
+      "sourceHash": "2d275a74912cca2e02e6d41f9cae3a75ceef3ed0ef734eff3710e10eb7112228",
+      "translationHash": "b87e67c7dae039910f79b50feeae0daee49f29066618cf35637550c34f5a625e",
+      "status": "reviewed"
+    },
+    "ui.on.this.page": {
+      "sourceHash": "b5658fc8edda24f9c94eabac9e536e0a18e3055a8ca255f9d1b8f256ea02a6cc",
+      "translationHash": "a610e0c62b3e1e39e09d7f9d5d9e352a0770d302b31f614c5d11daf6da5e315f",
+      "status": "reviewed"
+    },
+    "ui.lock.the.environment": {
+      "sourceHash": "6efa9dcff13b5dce0b8dacc544948cd2baa9f9c8e731ea654dffe254d0f551a7",
+      "translationHash": "419ae10febd4dc3d6a75d42cdad5f40a9ef64871ecaf7c09fecd8eb4c4a057be",
+      "status": "reviewed"
+    },
+    "ui.pin.runtime.versions.and.hashes.reject.dirty.trees": {
+      "sourceHash": "a98957412275c04de56bf9ce810490a27d1236604e9e75cb20eb238ca989d686",
+      "translationHash": "57056da006793950b22dcd44e7fc55ac41246402f3a37fefd282f6ce8f441ce2",
+      "status": "reviewed"
+    },
+    "ui.rotate.every.runtime": {
+      "sourceHash": "ea5615ce7d1d5984481af5177ba84b4937dc61fc61645e5a1b1e6dd83722be0e",
+      "translationHash": "917a8c6feb19673997966737b17e348284ba90d7535c521d823d49b4677f128e",
+      "status": "reviewed"
+    },
+    "ui.run.node.js.bun.deno.and.tysel.in": {
+      "sourceHash": "fd9811e7e848e77e48ea534772fbbb1f270967c9f13dd76e87b4e019f2daa884",
+      "translationHash": "5a214bd59ff1d4ffee3551ff18853c850b181efc9faa6a92bb7e1be025723f96",
+      "status": "reviewed"
+    },
+    "ui.prove.both.architectures": {
+      "sourceHash": "7531b705e822c12c77f057f211311bb3abec079575c269d3c1489b3a1b01e6fd",
+      "translationHash": "bce2a54c6e5638660f2f785db0ee16e3a7423f31c7e845ff6dfa2d0c3343a24d",
+      "status": "reviewed"
+    },
+    "ui.complete.three.record.cycles.on.dedicated.linux.x86": {
+      "sourceHash": "4bb78e658a7b0c612eed48f69c260e4fef1c16139a054e47afd8cdfb35a07564",
+      "translationHash": "cd4723d68f7180a2546a33dc90a6360c00b2bd4903ae7b864bd182f198ddbf17",
+      "status": "reviewed"
+    },
+    "ui.replicate.externally": {
+      "sourceHash": "c20458881cdc75781cc149333632a925d18432f9647e79232f2f57caea43fc9d",
+      "translationHash": "e8e36d21cef3f634b193f7de58d74f5762ef44ffa49cbf5e83fe1bac47fa516c",
+      "status": "reviewed"
+    },
+    "ui.repeat.the.workload.from.a.separate.load.host": {
+      "sourceHash": "8284962e90724c08b616a01d870e20ed09a21864e5ced587d0b82fdf015853d1",
+      "translationHash": "aeff97c5836604973ab1f99bb2c7c9581aa25697c1a7ba71d7def96b956f725b",
+      "status": "reviewed"
+    },
+    "ui.release.guards": {
+      "sourceHash": "0439b87b137be668032149880b8ab96ed35f633abbeb017f4c4b4c7fab3e7ec0",
+      "translationHash": "5fe8a5bc4fdc76d3fee8873c84e171ffb8d44273abe6d4472e77c7aff83d5d85",
+      "status": "reviewed"
+    },
+    "ui.shown": {
+      "sourceHash": "6ba2a0e0afd03fb083223d57fd1b4497d5a6bdc48471816d2d9d82ee31481117",
+      "translationHash": "2d8911321b03b967cedca6b266889e5cda1a2998e0bef94422ff3aca0f29fa09",
+      "status": "reviewed"
+    },
+    "ui.runtime.suites": {
+      "sourceHash": "9c2c1f2e13bcb06f6cca5c38336f4d6398eb5e2dd1e124c2d3f2c8ce269be29d",
+      "translationHash": "c152e222d280ffcb5c7d61b6ac1e010c67571ae17351c82bf26bf92be5d2119b",
+      "status": "reviewed"
+    },
+    "ui.observe": {
+      "sourceHash": "744ea732e226adc1edb73aa06f0aa3e38b1f75cb52d644deadc6f2528af97853",
+      "translationHash": "b47316c0087844a78a69282a22536f45224baebdbac58a9647616e7a298caf4b",
+      "status": "reviewed"
+    },
+    "ui.cross.runtime": {
+      "sourceHash": "e398e517b2794768e213740d37445fc6710d5a11130e81117720ad59bcf24bdc",
+      "translationHash": "f5783c54e0012253cafdc4bb6ddf8770e176d89925f9935c2c44820d85132b10",
+      "status": "reviewed"
+    },
+    "ui.withheld": {
+      "sourceHash": "7f5ad98195ddf9d5da5f3bc2a67f39ed865f94200ecae8c874fac12159ca84d5",
+      "translationHash": "7019d8065b32a31a6358bde91ae3e9ab990c422997df23ee3f09dcf8c64f5f25",
+      "status": "reviewed"
+    },
+    "ui.seven.gates.ci.measured": {
+      "sourceHash": "e13e1c01a9c34499cd6f68c8d2e38d300adcfc725668782ef962494add4c2883",
+      "translationHash": "39bf2fe3a7acafbf6d26c632efc68cc23d6f1725d6a93e6be14f7aabfae1b370",
+      "status": "reviewed"
+    },
+    "ui.seven.gates.sample.layout": {
+      "sourceHash": "6f06e2763e46b1fb24e1e40d39f85a87bfdaa66626532e57b3de8bf1633cc18f",
+      "translationHash": "6eac00fed0f19daacb2e6595ec609a0e0be89c49c8abdaecb7c87de252ca8524",
+      "status": "reviewed"
+    },
+    "ui.seven.gates.waiting.on.data": {
+      "sourceHash": "c23c688c5a9d00716269c679ecbde8c8924aa00d9c8e85b914c119bb890768de",
+      "translationHash": "8c43022d72218820e16b95cef16654040b3fa3976d67d72d4ee58b6889777682",
+      "status": "reviewed"
+    },
+    "ui.illustrative.layout.only.not.a.published.ci.claim": {
+      "sourceHash": "de22b350d174aeef43d891e0767373af353c65edea634837dec6f49f3e62868b",
+      "translationHash": "b26a7013ceda3d214103a28cf56f633bb2bacdc8ece4c9112efa5417130d067a",
+      "status": "reviewed"
+    },
+    "ui.fixed.runner.regression.gates.not.a.production.performance": {
+      "sourceHash": "7ace2a6d3109d390568b67dc4a2094743d87d295952eff5fba2a04883b32f5a6",
+      "translationHash": "f86781a19eef084d5a4cd5914b7a679c473e5735a57605cc9342b7a9324a24bd",
+      "status": "reviewed"
+    },
+    "ui.ladder": {
+      "sourceHash": "df0663641d3ef583bb62c3224436d3aa97453f9c2d02e4b5a9137bf3d4332c32",
+      "translationHash": "7026276bb8e71392cf2dbc66ea1c8cb57683c890fc19fadcc7c6f2d31ba4d536",
+      "status": "reviewed"
+    },
+    "ui.reproduce.locally": {
+      "sourceHash": "3085789e06eb45405149bfaf8740e87aa81e8acc2937bcf8d2b2a32a5aa276c7",
+      "translationHash": "9e0d3d57ac8baea8f1c6a918a9a746cb1a128d369443d926985ade4457f2c1f8",
+      "status": "reviewed"
+    },
+    "ui.release.mode.clean.tree.time.gates.admit.on": {
+      "sourceHash": "28b77b6d5d35addbfb7485c0878539dff7bb0fb82e29bf5a19f07cfbf646f5b8",
+      "translationHash": "c2e9287dcba8c64813f6686a2c0ff64555c96268da5f2012816a13724664f528",
+      "status": "reviewed"
+    },
+    "ui.release.evidence": {
+      "sourceHash": "55721654f9f5ee40e2acd466f488de43bcf890ee0d7fcb20272c5bfd0708ea8c",
+      "translationHash": "9315de492d69d924f3368691e7e4469bcba0f9dfa9cd526ee56f424cb2881655",
+      "status": "reviewed"
+    },
+    "ui.performance.documentation": {
+      "sourceHash": "a1467972cbc5f4316402678b9c645ebc79b8d49e28f490586cab02e57c8e9868",
+      "translationHash": "7a3592a6fcdac023b548e1c05b56a63591bcb7cbd6a1dc990eea5127dc7c1f7f",
+      "status": "reviewed"
+    },
+    "ui.benchmark.source": {
+      "sourceHash": "a4c484f45dd2499a0651a9e83c43b8d222c84cdf80f612448753a818b61116cb",
+      "translationHash": "442282bcdf66aacc1946a87554e300056eefb3a4b04de109bde6f470ac42f8bd",
+      "status": "reviewed"
+    },
+    "ui.raw.evidence.json": {
+      "sourceHash": "f9c58cf763ac8618e83407e29fc00f4f4a1dbe47b213a62e0962dd74f7990471",
+      "translationHash": "115807bc32efff04b8832a47a8a1c674e44d62abbbde68c4d9e3f85ba88b3c9a",
+      "status": "reviewed"
+    },
+    "ui.evidence.reference": {
+      "sourceHash": "6a37785498cb7607c3d077b0884c31cc4f03beb925ab0bdaef4ed71893358643",
+      "translationHash": "e73b85b72dc84e194b83c71d9405316246b8adf37bfc3991c829d65f7f972c24",
+      "status": "reviewed"
+    },
+    "ui.cross.runtime.publication.contract": {
+      "sourceHash": "9ee489b53fba137fee0239a1bec27dc3b66dca044da12868222abbf7e3bc9d92",
+      "translationHash": "5ca938c20b4bc64f9215bed964375fdf4b642d6bfff7830e49be6fcf30b1bf42",
+      "status": "reviewed"
+    },
+    "ui.separate.bar.for.public.comparisons.not.these.ci": {
+      "sourceHash": "c11278ce947bdc509b60b3ed9bcd38d28a471db49cadaa2353a3960257605913",
+      "translationHash": "c5cce1271c8febeb7afd03380216ca5bb7f70e5e1531a152363507d3f3e46f4e",
+      "status": "reviewed"
+    },
+    "ui.expand": {
+      "sourceHash": "3532fb18834ebc5fc94c4d1c517cada1d4370cd9596ea3d42c7b2ab37381a649",
+      "translationHash": "e8dbfa14ec41a3425888152377a1a6d836fac8fca8d873fe66815fecfcc86425",
+      "status": "reviewed"
+    },
+    "ui.collapse": {
+      "sourceHash": "be6eb1fc3b05bf9dceebad2eac7841d1b2f40bda9aa2da34df8ca22af02bc3ed",
+      "translationHash": "afd4b783536b8297bb2506836727af1ccae7626a7d04e89de7ad402360e0a970",
+      "status": "reviewed"
+    },
+    "ui.no.cross.runtime.winner.is.published.yet.the": {
+      "sourceHash": "58aa9a7188761870640b58fc00b72e4235895e0bda2ccff80c7a558430391084",
+      "translationHash": "c7bd0f87b3db67e45ea21009e153b02d212e2d607c8dabd2af52535bcfedab41",
+      "status": "reviewed"
+    },
+    "ui.comparison.protocol": {
+      "sourceHash": "a0b009b08f7bc27a8f1a7601507582727f749bff3dd05c5b29290db2417a0bd7",
+      "translationHash": "68376c983def12530c4512298a9fc1b78347f06984b5d2f47181fcb27ab6b6f6",
+      "status": "reviewed"
+    },
+    "ui.looking.for.the.product.story.start.on": {
+      "sourceHash": "6954f3bcd2968bdc3e184c3a6193c6b7d4c7d7a35a6ac9d301d51694d30e51a1",
+      "translationHash": "3d2409f6905b57a15a0f520d3794fa6d33a507ae6cf11b4abcde00a8adf9c5b1",
+      "status": "reviewed"
+    },
+    "ui.post": {
+      "sourceHash": "a5554622c655c7a7e470c115f374d92595fa3b1f431dc6ee3d1edfbc103846ed",
+      "translationHash": "7d5a89f6b1894c6eb1746a11d031ad99392fbb279cc3160e153a1a1ff62597c7",
+      "status": "reviewed"
+    },
+    "ui.min.read": {
+      "sourceHash": "96e191f8496f60e94720512b8a98e046c8ea99e6da796f9e65b8bf3447757c75",
+      "translationHash": "a2aee41a94a730b1341763adfb450e3b70db05e542e40f5a65cb806b26ff8b58",
+      "status": "reviewed"
+    },
+    "ui.next": {
+      "sourceHash": "1ff57a29d7c9d11bdf61c1b80f2b289b44c1ea844824d4b94a0d52b6ba5fc858",
+      "translationHash": "acfc4e74a650e7dfce69a54bc74065931f029c9d80e78e3e024f1474c5f2950a",
+      "status": "reviewed"
+    },
+    "ui.get.started": {
+      "sourceHash": "0ded1aba19a492beb4722449c229816b84474016a9e6165a915519a996cbf15f",
+      "translationHash": "98f5f85523380007c2c8757faafbf00d01d985023cf7ead686b6b031c60356d2",
+      "status": "reviewed"
+    },
+    "ui.install.the.toolchain.and.ship.a.hello.service": {
+      "sourceHash": "9e37d1a5935cbebb3bc3d974851db2767de24ea1f1c5f68ecdfd01d2ad4f4b6e",
+      "translationHash": "5514937a501d4e299dec44f5c72ef259a64644dfa34796c7320e611e69ee51fb",
+      "status": "reviewed"
+    },
+    "ui.read.the.docs.186": {
+      "sourceHash": "412b59669150e05afaf4671cae2d9708750732c55d290efffeec7dcf7fef80e7",
+      "translationHash": "0c25540b85ce880525f1a222f2ffc4b2a4c0326d4bcd2ee20b5f79b828428dee",
+      "status": "reviewed"
+    },
+    "ui.concepts.capabilities.durable.work.and.operations": {
+      "sourceHash": "4b8538ddea364878b545c4d77590772b4ded0496661b737286457e6253282b4c",
+      "translationHash": "d04916774268be17dc0bf6bd130369dac93af07caf79f3190652dcaa0d069156",
+      "status": "reviewed"
+    },
+    "ui.browse.the.runtime.examples.and.release.evidence": {
+      "sourceHash": "e06cc54ab8a9626bb97fab3fbd85d12dd078597028c53785b8d44a7101362146",
+      "translationHash": "a3a4a9efe1fd1066e3de1e002299b16a910376896ecd8aff5e6caf33d0a679bc",
+      "status": "reviewed"
+    },
+    "ui.all.posts.189": {
+      "sourceHash": "fcd841acd69d53eb8be1a0b20595bfcb47eba30191add482d66bb5b38b407aa0",
+      "translationHash": "dbfb8e8cb2fbc6c449cb14bff2bbfdfd87a363587d0cf76715d1433b1b1dd095",
+      "status": "reviewed"
+    },
+    "ui.tysel.blog": {
+      "sourceHash": "c4781a69f9946453fda8bfc072ae3f7cdc10489b18212fe2d05c7afe488281d1",
+      "translationHash": "174c64a6f8002bb9e85f756e3fe6f42e8ec2d07f063230e17fee1c0cdc8ad460",
+      "status": "reviewed"
+    },
+    "ui.notes.on.shipping.typescript.as.a.binary": {
+      "sourceHash": "d55523c59b2b4dd140190d5a32fd04c69bbeea2d7e436aeff02a5d3b3c8def8c",
+      "translationHash": "d61511037acb38762fab58aa64048715f6acc01f7ba4a84af1f1b8585bec5209",
+      "status": "reviewed"
+    },
+    "ui.rss.feed": {
+      "sourceHash": "c66fc686fcbea1fefcaf58cfd8fe39afbc549b5db3db7c6805f47345dbdc968d",
+      "translationHash": "729eb52a684fa315610c2ab86eead479e2d8d700491d02c25eabc40f806ea68a",
+      "status": "reviewed"
+    },
+    "ui.featured": {
+      "sourceHash": "2c8f9493f6913a4a501e7cf3e2fcbcd8685e0a3d08e864ac02a9f26228c0715a",
+      "translationHash": "24d025cb5dd1aa574c2f5a5bece362c14f49b62f5a8ac96ee55035ede8beeef7",
+      "status": "reviewed"
+    },
+    "ui.min.read.194": {
+      "sourceHash": "b337c94500c5a161f3ff55c770cf6f1df25f5e276d3b5be573aedd9a92f3a949",
+      "translationHash": "76ec1d17ead361a093441336dc3d269ad9cf695fece82510c9ca29430bb02b6e",
+      "status": "reviewed"
+    },
+    "ui.read.the.post": {
+      "sourceHash": "0ea38e24d08fe29beac39f8277aa5682dc226c563fd95019af003034a7b1fad8",
+      "translationHash": "2f8c6aabde29656f7fb7255b8e3e8d66381b0464e1fa06d65e8619a7633b6aa9",
+      "status": "reviewed"
+    },
+    "ui.earlier": {
+      "sourceHash": "e10ae990740118886b011c218c7d0777c5c203954e0038747965ddbe5aea1744",
+      "translationHash": "be1d537c0042deba644e682c297fe019521afc7ebc30ce9df410cd3ef89b2ad7",
+      "status": "reviewed"
+    },
+    "ui.fetch.style.service.on.the.web.api.runtime": {
+      "sourceHash": "0bf8224586eb87d5e339f124c0960e9214c7d330f35079a0b3dec9644e0e3385",
+      "translationHash": "155e97873ca9ed9c0f859ddb4f55e99853415889465cfc3982b7ec7fca5877ac",
+      "status": "reviewed"
+    },
+    "ui.queue.worker": {
+      "sourceHash": "9a3a9d41dba4b2372cfe8922f77b8c07efbed1767684a0e5a1569b98a0fcff1d",
+      "translationHash": "377c764f7e095722820c219b27c44269a7fe25d86bb82dc5036478f16623c8c6",
+      "status": "reviewed"
+    },
+    "ui.service.with.one.named.queue.handler": {
+      "sourceHash": "d59645140489e4d910d9953e743fff8d9b96cadcfd0743c1197abd77bdd8aaa4",
+      "translationHash": "3f95b39f8a934587f443a82f098d70f21a7fdeeec446f60ed07e5bde9426c1d3",
+      "status": "reviewed"
+    },
+    "ui.isolated.mcp.stdio.tool.with.validated.input": {
+      "sourceHash": "0d4ba324f4922a3a5d762473d12b5844b1410dad0477878792d28ea173e14d73",
+      "translationHash": "836006f11ab8c2b7e1a50713a6117f106834154c06990227f2191190a7347a18",
+      "status": "reviewed"
+    },
+    "ui.minimal.service": {
+      "sourceHash": "0677c8e7cc59722b1033b413b5fceb779568c6b3f39d0e2c1e93c5839e719d90",
+      "translationHash": "70a68fde1eb893bed56c660d7ba05f3684946dbdccf694305f39e9582ec6bea1",
+      "status": "reviewed"
+    },
+    "ui.smallest.fetch.handler.for.custom.application.structure": {
+      "sourceHash": "c88cf19ac521b40ff9f66367c8e6926df8e19e77886998400291e92a9efb2609",
+      "translationHash": "b93464b948db84b50cd0feefcbb131dcea2be44cd7ed2f9eca3e4ea9fe6a230b",
+      "status": "reviewed"
+    },
+    "ui.guide": {
+      "sourceHash": "8dd65d0952ed144ccf6e76ebf8aa45644afb2b9236762c414d07e813d42f588e",
+      "translationHash": "6eadeddb7e7047ab68755c3e205a8443064a8dc6e26ff4e39ad67209132b6319",
+      "status": "reviewed"
+    },
+    "ui.contract": {
+      "sourceHash": "a6f5b0e592fa68e4ba8014ad5f62214f41153de6a5d51c78fc6148c54a1d6deb",
+      "translationHash": "1ff420ba0a81995a0e82d49c242b3f756592e6a3120b746a8e52c184bd9a31d1",
+      "status": "reviewed"
+    },
+    "ui.create.a.starter.or.open.an.exact.example": {
+      "sourceHash": "1a947e2ea0f0c0ce15f104f03699947e64116a5dba74cce71a8247d8226a384d",
+      "translationHash": "4241d3f707225293831963511b4e155ea4730a42836c49727bdac0bfd7fc6f15",
+      "status": "reviewed"
+    },
+    "ui.use.a.built.in.template.when.starting.a": {
+      "sourceHash": "307b7b94ee3822db48622b9380591a169ff65ae0da1d71e0ae2ddfcf1fdd628e",
+      "translationHash": "aea338f13bc50801522f5216540494ab47355172d4a023753bcea441db5302cc",
+      "status": "reviewed"
+    },
+    "ui.start.from.a.built.in.template": {
+      "sourceHash": "6157896aba798d5edab6b86cf3e4ede2382e96d2f9d46d9ef7594c3f9961a5cc",
+      "translationHash": "39408b58d2656610e7f10b670c199faaa60d5f8ac317e39d499fa7ef8e70229b",
+      "status": "reviewed"
+    },
+    "ui.these.commands.create.the.project.before.validating.and": {
+      "sourceHash": "e5cd77bd4545caefe192f20bb0fb939d108d1813c5444b44a848c257f1a7e239",
+      "translationHash": "dacd3ebc90600239f7d73ea6ec62cd4e4a2cec276eb488921fc879532eafd2c2",
+      "status": "reviewed"
+    },
+    "ui.init.reference": {
+      "sourceHash": "6997ee560afb5d174273dbc1ef7c83b0a8a22e9e9b5dfd8c97b053222b445bde",
+      "translationHash": "e5e9c398c36624773d85d928206591b79465f4cefeaca8d131130f76aa4f6eb7",
+      "status": "reviewed"
+    },
+    "ui.download.version.matched.examples": {
+      "sourceHash": "f71256033c9dd5bd28c1a54edcd6d9331010c784fe3ded4f70e68c6549811598",
+      "translationHash": "b6e6366ddf806233852b9a757ef8534d1ffad6c39959e4a8dcfd400af4be8d50",
+      "status": "reviewed"
+    },
+    "ui.replace": {
+      "sourceHash": "95e154398a4bc0091aa4d6b607472ac5a89e41fbc84a3a49f823314d6de9eebc",
+      "translationHash": "75527e5b5cba4a88fed0a32427f2de96e38eb6c0e55eda07eeb57bac38550d8d",
+      "status": "reviewed"
+    },
+    "ui.with.another.directory.listed.below.this.downloads.application": {
+      "sourceHash": "e7c3bb9b8378416951b157466526fe004e43f0e44aea97bca887af64b94e69d6",
+      "translationHash": "c84c55b905c48b86ffc649d8cb769eee0aa27d639b0ac78ffbe971204c0f400e",
+      "status": "reviewed"
+    },
+    "ui.start.with.the.durable.path": {
+      "sourceHash": "69a73e079d4287cf4ef55b9273dabe931ad1ccba3d802beef23e37aaa89447bc",
+      "translationHash": "c264a672d5f19964a00f9df7179708227a794884016ddd147d389ebfda3bfa87",
+      "status": "reviewed"
+    },
+    "ui.requires.a.real.openai.compatible.endpoint.see.the": {
+      "sourceHash": "28bceecd78329f7fef56faf8f1fbb8cd9813dd0438ddb9fc7be5a3255aaaa611",
+      "translationHash": "aed80ac6c34f1d45b830ae0c79ec4a30ad79410178883d36f0443df0b88143d8",
+      "status": "reviewed"
+    },
+    "ui.development.source": {
+      "sourceHash": "fd06326eb8d1db59a2601f8c1a5875ef8228289c33f3a10fdb4112af56e7d16f",
+      "translationHash": "489ace6b5141cd711afea8658249dd3a9fc6cda07fc1213fcd6709d7dfa9223c",
+      "status": "reviewed"
+    },
+    "ui.durable.execution": {
+      "sourceHash": "b227a68dbe788dcb31076f562c0d1e5b318d093873d68136848ed90c636b5604",
+      "translationHash": "f82387b0a59c177e91c9f2fb0b89f98d81b8efbdb3cfbfe0beebddea03e0a94a",
+      "status": "reviewed"
+    },
+    "ui.durable.api": {
+      "sourceHash": "7000443298e68364d7b76d4f4dd50485fd0b5756052aee3c56e9db45901b7133",
+      "translationHash": "66c9a5bcd01922825c2b8fde3bf0ce8b78f36612248112a934aec5b79e040b94",
+      "status": "reviewed"
+    },
+    "ui.one.installed.toolchain": {
+      "sourceHash": "c78e24a3aa46af2cabb66ed78d1073aa582a544c1e85a325502c99f534371a0b",
+      "translationHash": "0b092780435e892b2da7c488afd2fcd39fe7c874322265260b57a537bf8cac99",
+      "status": "reviewed"
+    },
+    "ui.install.tysel.once.then.use.the.same": {
+      "sourceHash": "1543e67b8929aab0fdb463daf7cd14c7329373d50ccfb7ceca8f3271f61a37e2",
+      "translationHash": "9f66a8baec3aecb32d1596762c8b18338fb12087e62bc82b9ec1ef9897db0eb1",
+      "status": "reviewed"
+    },
+    "ui.command.in.every.example.project.the.managed.installation": {
+      "sourceHash": "58d60773d71bdf146a7b64370a721c46722663344841bb19bb50894af79dec02",
+      "translationHash": "c5e678f88f70c39e3e0ee5fdfe4730f861ff0057e1905fec5d0e1eeb2b8b9b6d",
+      "status": "reviewed"
+    },
+    "ui.installation.guide": {
+      "sourceHash": "d334745b85acdbfcbfe8396dfa2c463e3ba6dcd372ff3ce4ab93a1d2aca8277d",
+      "translationHash": "533e0d86c743f2a9caec9ab09028d2df55654f3c661230a65e052f5f123f7750",
+      "status": "reviewed"
+    },
+    "ui.effective.profile.default": {
+      "sourceHash": "91d045d018efbac85a1f10ad1c99b8aa3fe966074d52ba3566722f06a84dca06",
+      "translationHash": "86ee3347b2a7bdb6def163a3c95189b9880f10d368e7f75d9c976ecdf316f878",
+      "status": "reviewed"
+    },
+    "ui.supported.no.dedicated.tree.yet": {
+      "sourceHash": "084de0d0796c00154f716d048b217f722c2087239d872e287164adb0080585a0",
+      "translationHash": "5756fc7bf23d205e644794f65069e7e50089ec498238e3f4abd49c8d22adb208",
+      "status": "reviewed"
+    },
+    "ui.these.apis.ship.today.they.are.reference.recipes": {
+      "sourceHash": "ee20a2bfc89d2a7e6ef90044d8c2234d647764dc0be1e78a01b79d15826e2c1f",
+      "translationHash": "caa980760f7dd32feb9783c888d3f2b4e2e12593004fa5ac00f5f70b0804706d",
+      "status": "reviewed"
+    },
+    "ui.recipe.contract.only": {
+      "sourceHash": "1b1f633a3931c9df2a9af51660a45497cc74bd0aa6aff9a0dbdb31a5c5408260",
+      "translationHash": "ec79bbce747461eeacb7634920f9928b7e60dca8984a2c6c09a151735c19f666",
+      "status": "reviewed"
+    },
+    "ui.shell.child.processes.ffi.and.dynamic.libraries.stay": {
+      "sourceHash": "0f5cbe2227809db542955277bc012e8f3e3421547e57303ebff7bc23e838d979",
+      "translationHash": "2f431640092d4ca1ca4852334bb3e8e088bb05c50857d2aa852e3f29792ddd66",
+      "status": "reviewed"
+    },
+    "ui.and.227": {
+      "sourceHash": "6201111b83a0cb5b0922cb37cc442b9a40e24e3b1ce100a4bb204f4c63fd2ac0",
+      "translationHash": "de1d5dd076fb7a704745fca1d49d20599e9bbf5c7e859408d38d6be1260be00d",
+      "status": "reviewed"
+    },
+    "ui.docs.gallery": {
+      "sourceHash": "2749efca74dee59ebe2f12e2a1d544fda7f3809c56b3ed9695b4e766580e5505",
+      "translationHash": "a8d0c99bb51cad3c9959eceab204749152f1c8988a50f7547a0ad8ebdc1068de",
+      "status": "reviewed"
+    },
+    "ui.runnable": {
+      "sourceHash": "c687f9d17a223fc2248605e025395c9750a4a818bddbb15f463e44e87722f8fa",
+      "translationHash": "897b6105e2a58d3a15f583610c81dbb3e2743108bac357057dcfe2dfd959cc12",
+      "status": "reviewed"
+    },
+    "ui.experimental": {
+      "sourceHash": "3dc9f569422dcfdadcb2c33f3eb2ee6fcebc8ba679bd63e690f9ddd0ff7c24be",
+      "translationHash": "001a51a407db9f9a06e80c066482a107a6c1bbfb7027859805bb39564b80ae6a",
+      "status": "reviewed"
+    },
+    "ui.recipe": {
+      "sourceHash": "aec69352b5b97ce21b850a7bc1f33d93054b531e13b116f1f4ca193a33c13cbd",
+      "translationHash": "9e5a64a26e2b385edfaad1dc7815c4f2fdd1b57a90edb0226ae5409629e09846",
+      "status": "reviewed"
+    },
+    "ui.after.opening.the.example.directory": {
+      "sourceHash": "8e78901ea9f6a0040789c31cc96293c08bd58014fde06c8a92e3fddd7e429195",
+      "translationHash": "09a8af72d645ade36cedaa4c3459c30041747728fd0ae48b8890aba48d564372",
+      "status": "reviewed"
+    },
+    "common.copy": {
+      "sourceHash": "e21f935f11d7e966dbbae78da9daa378fe8142a14e7c0cd7434183005faa6c5c",
+      "translationHash": "63d90d977348ab1f9aa34ebb42b103216ce161feb0a1c08e237607bf42c3cf79",
+      "status": "reviewed"
+    },
+    "common.copied": {
+      "sourceHash": "8d525e5f158b9afe05f3122af363ac67763bdc4e1395b46597b320c289766ce3",
+      "translationHash": "8f6f8d979c981ced1cf17ae96e27690b8a33b9dff1c98c8ce651764ffe9cf235",
+      "status": "reviewed"
+    },
+    "nav.openMenu": {
+      "sourceHash": "b40b3713b43dc702682dc967ea5c2dbe20ae414c30baf100d162a8250a928065",
+      "translationHash": "edb98581834ca7fd97b73392d43fda6afe40b44b6b8d0acd7d05da1bee57b098",
+      "status": "reviewed"
+    },
+    "nav.closeMenu": {
+      "sourceHash": "6ccd5c7856042d36476ffd35a41b54518be95621cc741ac3ed55b8108ea41586",
+      "translationHash": "be0d5706c694fe18c78373a3ae36323adee9716bb1bdf45bd93ad517c6942b68",
+      "status": "reviewed"
+    },
+    "theme.light": {
+      "sourceHash": "2f740f4cf6888e99dfe73f3d6208323cb350b33a37016e1ae3367a90b3e93c84",
+      "translationHash": "a52d332cfafb32ee53a39a33b3a4b2d9de9f88a17156d627d4b14346b84232d3",
+      "status": "reviewed"
+    },
+    "theme.dark": {
+      "sourceHash": "8abe9e0ba6b6f3834c2e48d2f858557641277e2c17463e526685fe3f95967843",
+      "translationHash": "a3538a688840f49446a5ff0a1f700e024a861503a5b94f28a1052a9c6ca1ac0c",
+      "status": "reviewed"
+    },
+    "ui.tysel.workload.examples": {
+      "sourceHash": "94955e52c514165c8401812c0ce4285e4f942a27deedf38442e4e9413f939097",
+      "translationHash": "d25ed14d3c432d3295968ae987df51af694b90de5176b5ec07559db34594f460",
+      "status": "reviewed"
+    },
+    "ui.start.an.llm.draft.suspend.for.human.approval": {
+      "sourceHash": "3180a52d261b68d494408ba0ad3bd2797d2f2a0ba85099bb88c1354e11464b6a",
+      "translationHash": "a6696bcdb379d64ad53f306a8f0532e745f20c47c141f66c3917c029ee83b83d",
+      "status": "reviewed"
+    },
+    "ui.llm.secret.sqlite.durable.execution": {
+      "sourceHash": "7c9728e385ecc103c1e8d97c16494116a2ae6311dabc4910d4b9fa683c5fe507",
+      "translationHash": "477ab4e0dd9bdac609eb3b9a273293a9e3fbb010a437c6ac176f6955ea11f8ce",
+      "status": "reviewed"
+    },
+    "ui.trusted.first.party.http.apps.labels.name.the": {
+      "sourceHash": "2ee90b79dfb7dbfc27c9f88905e26e1e98b7b5612c806b834d67df91f19ec566",
+      "translationHash": "ff839f63ec68ae6365cdbe823abdc9ffc62d41ccfba1bbfed307e51850b41ae4",
+      "status": "reviewed"
+    },
+    "ui.the.service.profile.currently.defaults.to.durable.store": {
+      "sourceHash": "4469dd111df70f1c5d23c232be7904887a797c0e6a52582c487dd49eacb765e4",
+      "translationHash": "dfdb6f694d531b1b17500bc4310e4a95524b6d6820d81877b835b04d1a020c40",
+      "status": "reviewed"
+    },
+    "ui.hello.service": {
+      "sourceHash": "64c10aa4433991509ede54a05ddb8fc4b3f506fe0e347e8e5f05d635e98d19a5",
+      "translationHash": "98782b35ec3619f533bd2d7fdca0c7fe1fa576ec5df6368dd3872b1c842de8c3",
+      "status": "reviewed"
+    },
+    "ui.minimal.fetch.handler.and.one.executable.build": {
+      "sourceHash": "fe118e778973e9c3c6c15ce3e8e9b6afb2faf095e1fbddd5c4b89d1ee63f287a",
+      "translationHash": "ac4b807352e1fceb23f41ed8e7a0087ed5163f13d8ff673923adbc3ca3e7b399",
+      "status": "reviewed"
+    },
+    "ui.web.api.first.npm.router.compatibility.is.scanned": {
+      "sourceHash": "08a515cfef874e1abb16dd3935087fae9714879091676a472f733f470d8e3ef2",
+      "translationHash": "8ef56c8b4a3fdc1fbb7c1333051f085c3fabd758bdf945ebbc361c01008a01f5",
+      "status": "reviewed"
+    },
+    "ui.websocket.service": {
+      "sourceHash": "e595dd84fbca835ee0f76b9113d0cdd261ee49d6b0fa028ceb1ccc4406228ace",
+      "translationHash": "7b6d86b7064849dde16d5ba9634f97c29d40bda8f1a4b4bd782ce8d34a54de88",
+      "status": "reviewed"
+    },
+    "ui.http.1.1.upgrade.and.bounded.text.echo": {
+      "sourceHash": "6fc53f86e4899fca242b6f453f2a004171bd576f8e1ec85ecce514f83fd57157",
+      "translationHash": "d27838f0c06544981c48f84fb78905b611c348e1e544f968794f3059d4a74903",
+      "status": "reviewed"
+    },
+    "ui.http.inbound.websocket": {
+      "sourceHash": "1c7ce3a2998c9ccea71934676ab474181668742bde633274c678bec89ced7614",
+      "translationHash": "95130df1405a12b3bcf3e4e260c9b387e9c44b03f9f1c79fb6a55afe0c8233c9",
+      "status": "reviewed"
+    },
+    "ui.persistent.counter.through.a.runtime.owned.grant.bound": {
+      "sourceHash": "930c58fc444bfc940e290d051a8cab2b94df9ab21dbae296cd16e799750759bd",
+      "translationHash": "531e57eb4ac47d22392fade198dc9d7b4ec28918f7e84584b56d63dbe01e4424",
+      "status": "reviewed"
+    },
+    "ui.named.database.grant.the.url.stays.in.the": {
+      "sourceHash": "07315813db72ba2ca563eb9c7516f385a5ab90690687a5bba9b8d7a45ba426a3",
+      "translationHash": "356854c9b60a16100725f051c4e3a6ba4a0de8833359ff809dae502216caecbe",
+      "status": "reviewed"
+    },
+    "ui.redis.service": {
+      "sourceHash": "968ee1ec430ae49de7677ff8e944bec608a481392c1d5203dfdc77f2fd203be0",
+      "translationHash": "dfb31e2bb7caa7712140846e792cd9f5932109f50606d1ffeb16fc2d60ccff0e",
+      "status": "reviewed"
+    },
+    "ui.bounded.cache.operations.through.a.named.host.injected": {
+      "sourceHash": "b532a2e5160ad20a3e1c2a6ee69e7518a4355ac792cc75d79727d82acd5b4e11",
+      "translationHash": "888e08444838dfe16c3d6d6fb0dd1fbe37cb4f08ecc0bd006f3fd6f2bfd4e7ec",
+      "status": "reviewed"
+    },
+    "ui.filesystem.transform": {
+      "sourceHash": "4a881bae52f1e2f03af91ddc54f5b27d8b26b51c032c9904bef31bfea736a206",
+      "translationHash": "9cb4bb7bb9d4719163cd77f8d10420abe55527bdcacf446fdc93c75d8bd8b5d9",
+      "status": "reviewed"
+    },
+    "ui.read.and.write.utf.8.files.beneath.separate": {
+      "sourceHash": "4343845b938df4381093fe31fb231a406536e5bd8cc189751c22e54999540c10",
+      "translationHash": "88e2adc4484080ccb1ae9b2ca27b9c05d8bcaaf9a29d56949f19f4e9cdf20ce8",
+      "status": "reviewed"
+    },
+    "ui.filesystem.read.filesystem.write": {
+      "sourceHash": "64ec536b7d76d0f898c0bdfe59a38c102b2be0c79949f9a247deb6315066db6b",
+      "translationHash": "3cb4219a635c3e942e1cc84541d5630e95f8142cdf0cf08b0d814a9bae82c59d",
+      "status": "reviewed"
+    },
+    "ui.cron.and.queue": {
+      "sourceHash": "987dd3ee2485199741ef743f92a521db888ce46d139517ffe56fee4fa9ed37ea",
+      "translationHash": "48fe48acefb3bbf0c6f74b54e4d9829f4f9a8e91cc24cd71bda8366b7d9db193",
+      "status": "reviewed"
+    },
+    "ui.scheduled.and.produced.json.work.on.the.bounded": {
+      "sourceHash": "09c2c7eaa436d38711f62fa34d4aa206269d4c92399505f34ba69f4c21a26275",
+      "translationHash": "616cf9872d8495b7fac69b55b64534d5399060f461516f09eae849cae52a7866",
+      "status": "reviewed"
+    },
+    "ui.task.worker": {
+      "sourceHash": "bd398df79a9c7bca7056487902842afd5f3825da2c3500cdcd0815ef5f22339c",
+      "translationHash": "08e70042e55618407b47839d1f7fadd816dfe8b7d48f7a1c10aa1c512192c1d6",
+      "status": "reviewed"
+    },
+    "ui.utc.cron.registration.and.one.named.queue.consumer": {
+      "sourceHash": "c3c97e9db02b2db59023fc82cf88e96d444783e8ceb8597d8bcb81ccc2f867de",
+      "translationHash": "4976eba74eb6a1e8a74cccd50b27ce8054580b47ade977e84bcd8b9250e5ac75",
+      "status": "reviewed"
+    },
+    "ui.agents.and.tools": {
+      "sourceHash": "38e53cacd6b5d1619e53197f8f477080707eed3a0df086d1f87404b91c03c9cc",
+      "translationHash": "75454098975010904f282f25359acc27383b811e9f48e1dd748eb567925619f4",
+      "status": "reviewed"
+    },
+    "ui.work.that.must.survive.restarts.or.run.as": {
+      "sourceHash": "637add1d78bf742702bddd8754901937d76d875307a7d48fa7ccc9aeb71c1f16",
+      "translationHash": "cd1158ab312f26013aaf2d36a7bf09bff06f271940312098c2b2c3146bbef3bd",
+      "status": "reviewed"
+    },
+    "ui.llm.service": {
+      "sourceHash": "f7a13a7e08f1e3745f65fb3ad496f90c034460bd636ee42783bf8d985461d895",
+      "translationHash": "73e364f5db60b4251cf2e9c40a8377184aedc8b6f7707b2747d9802d7819ab3d",
+      "status": "reviewed"
+    },
+    "ui.host.configured.provider.alias.with.credential.isolation.and": {
+      "sourceHash": "a35c4594aa015ef8e2f3b27e8fa02c991d1d61f84cd97f0e7793f21a6a7f2b3c",
+      "translationHash": "02e7dd0ff57c6d4de46186ed5f38d6a2ef32ea6a616005d13f9610466cf2b9f1",
+      "status": "reviewed"
+    },
+    "ui.llm.provider.secret": {
+      "sourceHash": "8f5f5654327e2f22a5284076bfbd650086f2364e4a1878f640be98429e5e6411",
+      "translationHash": "8636ad9676a7b20ce747b29f93972d12e0e8a397e1e06691e85a8c18e0aee256",
+      "status": "reviewed"
+    },
+    "ui.validated.json.tool.over.bounded.stdio.returns.an": {
+      "sourceHash": "3d7662e29ea91fef18a86102b5746fd8b847ba6cac891e62f98213d7189f9a34",
+      "translationHash": "0365c604ee440555808585653e4ec85cc259419f41284e08889c1061ef68c88b",
+      "status": "reviewed"
+    },
+    "ui.mcp.brokered.secret": {
+      "sourceHash": "70dae95d2878b4eb014e9b3c240621071030c946b31dcbf4414fbafdcec23069",
+      "translationHash": "80920d1bf2cdfda026fc7e4164d49483fff65e923f64b9ee7867a809340008bb",
+      "status": "reviewed"
+    },
+    "ui.isolation.and.wasm": {
+      "sourceHash": "929adee0d85dda026106ab0b11ebacf038d8f30005c4dc1b5c4c7da5c2ccaf29",
+      "translationHash": "c2799ad1cf0062ca4ef3f5c6535dbcaf32d337a6f6b311b1032150821c6549ba",
+      "status": "reviewed"
+    },
+    "ui.separate.worker.process.or.a.language.neutral.one": {
+      "sourceHash": "9c6da4d30ebb3b1c668490fcead91091982c2adb501bdda29d4858c0ac76e5e0",
+      "translationHash": "cef5aa8e2eb4c7d54f876a2d23e11d6d34766426c78fd8da1c71daf48f833074",
+      "status": "reviewed"
+    },
+    "ui.isolated.plugin": {
+      "sourceHash": "b0cb0a03edea8cb33791e8e9f643c9a57105a09fe162f602f050af1896c62ade",
+      "translationHash": "bc1f9d8dc739e1948f4f07ec8ed3e5662718d65509608c01b87322502bf8acf0",
+      "status": "reviewed"
+    },
+    "ui.fetch.handler.under.the.isolated.profile.manifest.grants": {
+      "sourceHash": "2253cb9f8e26a0d06544b9ba8906c7292d4b327cc6b6fe0c4870f33fc4cb2061",
+      "translationHash": "bff96dd1d46125f53aaeb0eadbfd8924ebf422e441d6ea3d104d489db9dded6f",
+      "status": "reviewed"
+    },
+    "ui.host.capabilities.denied": {
+      "sourceHash": "87cc7b46f9710676ae92887f3d432bcc594e611f5da9de67e6267407f335cd6a",
+      "translationHash": "aa8ab23c3b53d9c856aab393bed3b443350317066ec3104edaac7d9f9510c8b5",
+      "status": "reviewed"
+    },
+    "ui.rust.component": {
+      "sourceHash": "a8586d9f45293a546b19b1f18a55837d224219367b35318e2fccfa4d7859e540",
+      "translationHash": "01dbfa49d39b3bdcfeac4ccc8a432d570de3eee5a4519d2ed36b84ab8373c944",
+      "status": "reviewed"
+    },
+    "ui.one.shot.json.task.via.tysel.component.task": {
+      "sourceHash": "b8aa50be91eae853a0bf1521a0bcaf3cc2c450d6c2f39ce377561acd20c8a94c",
+      "translationHash": "0258e34a6ba789ec91ab578b897dc2c798af9858cd187dd11c9dc7a712aa14d8",
+      "status": "reviewed"
+    },
+    "ui.json.task.no.ambient.wasi": {
+      "sourceHash": "c3db0df415e5be0ebb0a920f98e3255b936e310d1a415afa4d3315baae240421",
+      "translationHash": "9db287f464f011749da2bb63c72f44a63fd31ec2f426090960549eb4ae344b8f",
+      "status": "reviewed"
+    },
+    "ui.after.building.the.rust.starter": {
+      "sourceHash": "d7132b52f16b3a7d3829c565fa19ef4b02e3288136d27f6a9d939555c47b4e14",
+      "translationHash": "ae08c027c3172eb53d797e59a75ea2a3d99f553d81c72abf1af8cfc497cdccdb",
+      "status": "reviewed"
+    },
+    "ui.starter.guide": {
+      "sourceHash": "2aa9b6d97eb12f0fed81176947b6abfa94c3640ad27863f30188314902069369",
+      "translationHash": "a2497faee1604a96b299faede92fe3f949a37da21c25b9daca65b0a71db27db1",
+      "status": "reviewed"
+    },
+    "ui.go.component": {
+      "sourceHash": "4fa84cfdbeaab45187f676c0f71803968c73dd3909c7ffb37fd7a8463eb7a9c8",
+      "translationHash": "0567e2a608a84c8cd2feafe6e8f69d7c3da766eacc4a5d158eceb03aadfb3cf6",
+      "status": "reviewed"
+    },
+    "ui.same.component.world.with.committed.go.bindings": {
+      "sourceHash": "3e7d23cfc20ed894c438f563d0a464f2598154bc0a791838272be67c9462424d",
+      "translationHash": "96e29b0427d23332b7b5365721f6c3d61cffdac8972d45625860a9194fc0bd00",
+      "status": "reviewed"
+    },
+    "ui.after.building.the.go.starter": {
+      "sourceHash": "5bb8eefe9bd356562e4bc099aeafc82c53d95e0300452cb482fd4b587358b0c2",
+      "translationHash": "8e026add4b26c329843765c4d1cca1a85beef965be9e0959aaa87e623d638e17",
+      "status": "reviewed"
+    },
+    "ui.handler.tests": {
+      "sourceHash": "f220544341503c301de64e87b89173a85b0977cd6e9869252fd5300d23a6ac42",
+      "translationHash": "3e0af9dfb7c4bee19b90a5f1df3206e5486a111be09b26f7591aa01ce67cdeb4",
+      "status": "reviewed"
+    },
+    "ui.invoke.fetch.handlers.in.a.fresh.isolate": {
+      "sourceHash": "a8a9366abf38de2a14e5c064b2fc646c4bea8e7662fd251bbad6beea929c4dc3",
+      "translationHash": "0c2452ac5b752ea7136aa8646c05298a099fe8551227f8799e49cbb0ac53c690",
+      "status": "reviewed"
+    },
+    "ui.fresh.startup": {
+      "sourceHash": "690a6e39e681a7c28f0e64ee6bad81778d962d1f4848a106981d9747065b471e",
+      "translationHash": "4cb1fa51c81d3f1de9d8474b26a645b239f6abb53a77922373f25e074cda7a75",
+      "status": "reviewed"
+    },
+    "ui.p50.spawn.listen.2.warm.ups.11.samples": {
+      "sourceHash": "02d63b0ffa9796fc33ec4d6de242b98468e204bef95b6bcd3a8d0c1b4eb1b475",
+      "translationHash": "f1987f9c181773af192a8a7ad69a7d921866fe43e7fb679a82c325b524fbbcf0",
+      "status": "reviewed"
+    },
+    "ui.idle.pss": {
+      "sourceHash": "281b79106e55cb2c5a6e2b8c5168ee4f3636bb73be696ba1f9bc49957df5c674",
+      "translationHash": "3f28f5b161833c043876086c9b73cfda1c777a1e270034d1a56676c29474fbd7",
+      "status": "reviewed"
+    },
+    "ui.single.pss.sample.400ms.after.listen": {
+      "sourceHash": "782e20dfbb0dc8cf007377214a60a6606d25d4f6173ad10a8fc73fb0edb2c434",
+      "translationHash": "bdde2a89ef37865fb0be9fe26dbde8fae42702b5c07044d124d2f5d566c371d4",
+      "status": "reviewed"
+    },
+    "ui.executable.size": {
+      "sourceHash": "5f4a73eb02cd08f2d7217d2d24b330a5c8d8ddbfeb0b5ebe04f9d9bcd06a955e",
+      "translationHash": "a592d8919177b0a29e362e23949c4d88be19eec2c9dbf04bc5aee0f33a4fc8c6",
+      "status": "reviewed"
+    },
+    "ui.uncompressed.on.disk.hello.service.binary": {
+      "sourceHash": "435bc11a6ae28fca29fc9d09f865a2adf23146244cab2d0895f685ae169cbac0",
+      "translationHash": "d7798166148f331855bf7634b311cfec1bf17230338090a110ae442dc6f49f1b",
+      "status": "reviewed"
+    },
+    "ui.isolate.create": {
+      "sourceHash": "633d19c400f5f6ca291be3fbe187d4dc88be3fedda1854822b7c0439942ef550",
+      "translationHash": "9aa821be53f3010efd3679d110296b64847b05f3182d1fc92ae2dc6a657e4060",
+      "status": "reviewed"
+    },
+    "ui.p50.in.process.create.not.pool.reuse": {
+      "sourceHash": "46e53e712e504e1e1dd331353c98aee4abea804c0a83158786277646ce09a169",
+      "translationHash": "a0060b725ac7a74dec828ecdefb58cbcf2370d3e4b1d68493169261c85b12a8d",
+      "status": "reviewed"
+    },
+    "ui.reuse.growth": {
+      "sourceHash": "7e6924afc477ebf15f4005b2b007e808890b498bae2f296386907245da826917",
+      "translationHash": "ddae6b3f1b004536e877a3da02fbfda734f04922c497724bf6b8af1f274e5ecd",
+      "status": "reviewed"
+    },
+    "ui.single.before.after.pss.delta.1.000.reuses": {
+      "sourceHash": "de49aab07b53d910112e617781929aba85f6328c3647151c6cb0cec86a444dda",
+      "translationHash": "aee703b9178915002b4f0df508b1e6e193411d2639934a0e3d59b162ec18dcef",
+      "status": "reviewed"
+    },
+    "ui.queue.delta": {
+      "sourceHash": "f0264f5c561ed00f0e52e89905538180d134ac517e56d2f18b331bf844f4c924",
+      "translationHash": "102869ad30485df28df68b98ed440b08799a9da8efbcffaf2e72407287da5490",
+      "status": "reviewed"
+    },
+    "ui.in.memory.scheduler.pss.delta.10k.tasks": {
+      "sourceHash": "af38273f9dc0c978c88214a7ecd34442b76b789cde012ccd2ecfbd231b4470ef",
+      "translationHash": "61fc5e4eb5e8a1be53e66bf358544e9e3d068f0281cf5a1bdaff854fa104924d",
+      "status": "reviewed"
+    },
+    "ui.p50.on.in.memory.sqlite.not.disk.or": {
+      "sourceHash": "04013450cd9d2418aed9cb5a370a87dcd2336e96b512494fe6b04db7a5c0f330",
+      "translationHash": "c7d8c9cd1752634019d1097b4ead265da4e96516226a067fd9f82d1952c333b1",
+      "status": "reviewed"
+    },
+    "ui.isolates": {
+      "sourceHash": "9197b0aceafb13b0584337ce4a5d942961322fb5da85ada63f9d27163893675d",
+      "translationHash": "8584932e293ef8638bedc956b1e0f846d4c7295b710770b10fa7cdb2176b9a62",
+      "status": "reviewed"
+    },
+    "ui.single.host.lifecycle.microbenchmarks.process.spawn.request.dispatch": {
+      "sourceHash": "4f6b340d948ab84032d7f8f8bb69c35c7c493074387caa07b07426c1e4efff55",
+      "translationHash": "ed7d7b4894a44ea42e01e6f91505223c84d22f3e76438e86fbdf7ee1ee97d248",
+      "status": "reviewed"
+    },
+    "ui.worker.process.spawn": {
+      "sourceHash": "42afa3c930c54bc5e963ae6ab48a725af7e907a817d1a6e1796a2d2837a3f824",
+      "translationHash": "6f94568adacb226de6e35d993573e65d9a7f2564eb8a11d9e5ec7cecec725373",
+      "status": "reviewed"
+    },
+    "ui.p50.supervisor.spawn.worker.ready": {
+      "sourceHash": "a287b5db00694956343bbe498e032e043cad71c04dd9da6d094f6ea00c038c40",
+      "translationHash": "7781b513dff38093ed8e8f42bff620cd5021cf359c489fe76899f641b23b037e",
+      "status": "reviewed"
+    },
+    "ui.warm.pool.request": {
+      "sourceHash": "b20c267e10dddd5ff262d81d4271197f9b2523a4b19c33a72be90943cafae916",
+      "translationHash": "5e4806a6465f7105866878c9f695e2ba2c80edb3f45b2a00e3249f323a88cfb7",
+      "status": "reviewed"
+    },
+    "ui.p50.full.request.through.a.pre.warmed.isolated": {
+      "sourceHash": "6d6282761ff2ea8eeb16b35b41b2ca8279ab67bc985f0d64852d42161d2efa58",
+      "translationHash": "5880983c0f69183d99474767611575c57768198093ebe87376693d1febe9956d",
+      "status": "reviewed"
+    },
+    "ui.crash.replace": {
+      "sourceHash": "45a7a41a9dccb9dad9b8e162b94978ba87eaad35a3a5cdb171f55019f52dedb4",
+      "translationHash": "2718a45df494eebb7eb67b0b7dee7021851c52d74518dc285b4760cb1aceb15b",
+      "status": "reviewed"
+    },
+    "ui.p50.replacement.after.isolate.crash": {
+      "sourceHash": "a81d54a1a899d1fff27cc3b6b47fe0824aa77536e8ef8496be01725617926bc1",
+      "translationHash": "45f2d09db47e4320f812a1f784277500fb549a7dc067c571f9cc6793a4283889",
+      "status": "reviewed"
+    },
+    "ui.tasks": {
+      "sourceHash": "b3a60e61a5233d0506ac737405a2a45280349683cac68722f18d0b73eb495ef4",
+      "translationHash": "5253040db8643c857d0bd7823551422f0c2f91855d0d3656b4efd8b30b3edb95",
+      "status": "reviewed"
+    },
+    "ui.in.memory.scheduler.microbenchmarks.not.database.or.distributed": {
+      "sourceHash": "9b5917394eed1cbfa507b6af4323817b76ad0b3b161223f005bc772945df8e92",
+      "translationHash": "d82c8e55974c840d908fa98f0614a5b856f5dcdc6dde4c3cc6ac7c4b0bc83023",
+      "status": "reviewed"
+    },
+    "ui.enqueue.10k": {
+      "sourceHash": "2f3db5f08348dbb574f885ccec766b70d1733711763dbc622fd0df0ec8923ee4",
+      "translationHash": "167d55f651179dc8aaee39928278e7955940ea86825fb511ba3c10abde599a22",
+      "status": "reviewed"
+    },
+    "ui.p50.time.to.enqueue.10.000.in.memory": {
+      "sourceHash": "5285834090b74cf06ca2715f8059b6115dc9a8c3a00bf0845bf3462dbbc8ef65",
+      "translationHash": "70be4f02d06aa5590449242108fe3bf02a63db5727d02f4de9635b13fce4c9d8",
+      "status": "reviewed"
+    },
+    "ui.claim.commit": {
+      "sourceHash": "9d191caf917851a362148cb4bec07ab5c4e7ae184f3245cb3af7bfe8d7923a84",
+      "translationHash": "d0e8419044560f4564a955d82e08a6241f43cb8b59d337fb476fe54d9965027e",
+      "status": "reviewed"
+    },
+    "ui.p50.claim.commit.for.1.000.in.memory": {
+      "sourceHash": "6f7c8b470ecf6e04a93f7ffbeea291fc894792b355c7d96d0764f43de7c40c46",
+      "translationHash": "46c450aa0d67b3a71aa733e222370c6a77758e29980d507a2a201d188ac190a9",
+      "status": "reviewed"
+    },
+    "ui.crash.requeue": {
+      "sourceHash": "eaac42d5a4e09c081550cc1856cd7a269fb537fefc31b50f2e1cdaed2735de13",
+      "translationHash": "4f89fc1043ef2a32f3fb68b6be20756c0f64c58ab9f127a05c43cf872f1a576b",
+      "status": "reviewed"
+    },
+    "ui.p50.requeue.after.worker.crash": {
+      "sourceHash": "90f85e69f2057715df7717d10b1b620937a98bc1b9b24e66dc9ec158fedd189a",
+      "translationHash": "9297a4ad40e48bffe77150a46efeb1e4682e0880ec69a0a492ac6fafaf7dd078",
+      "status": "reviewed"
+    },
+    "ui.durable": {
+      "sourceHash": "37c6e47e54638c39a92ff4beef364a5c857df2ae8b732997d242969f2b211d66",
+      "translationHash": "f82387b0a59c177e91c9f2fb0b89f98d81b8efbdb3cfbfe0beebddea03e0a94a",
+      "status": "reviewed"
+    },
+    "ui.in.memory.sqlite.except.the.explicitly.file.backed": {
+      "sourceHash": "7beef663edbad358e4fdb3404946e7f772d6d16ef0c7a05de5d285a3fb41da52",
+      "translationHash": "ef556109975c4b08d1c15968d871dac8e2d1524dd18441068e14637dc0cb84c9",
+      "status": "reviewed"
+    },
+    "ui.sqlite.append.32.events": {
+      "sourceHash": "f788095db07b354d39ddd0358f45963d8e9bbf87777f748bacc5335af925f8e7",
+      "translationHash": "949c018564839d1709f1fbf3d8178502cdc9618c2851c25e84c4fa983a868ee7",
+      "status": "reviewed"
+    },
+    "ui.p50.append.on.in.memory.sqlite": {
+      "sourceHash": "291e975afb332c8b0b3f27fa688283b50f0653c03bf150fc57346f2e7e476815",
+      "translationHash": "bae93e7c71c0263b97904647df626c4cab91f4d87b68364d93a4fefdeded2823",
+      "status": "reviewed"
+    },
+    "ui.replay.1.000.effects": {
+      "sourceHash": "fbb6a347f52d93117dd9c4ab85c50af719fe1c4d84298f630e356d40e865bfbf",
+      "translationHash": "ce9e5112862622063c9600f8cbeac40b6e88787180ce7de5d8f33f2d883cf8a4",
+      "status": "reviewed"
+    },
+    "ui.p50.replay.on.in.memory.sqlite": {
+      "sourceHash": "465708f028810fb9ebaddc183b00622581b8b445ec79bd07d72be33c56f0969e",
+      "translationHash": "a9dca5327546f96830e6a7ac59c61131e3b72a8c0ed44297610e599b2ec6a04c",
+      "status": "reviewed"
+    },
+    "ui.file.backed.restart": {
+      "sourceHash": "4b7d1d68fa49dd30e2b8de292ce0350a3516a5812a9d2e72e0732251b1095a64",
+      "translationHash": "e05783dadbd2be39d460eedba7248f3e7d802748d7ddb101f9e919367f90cb03",
+      "status": "reviewed"
+    },
+    "ui.p50.reopen.replay.of.16.events.on.temporary": {
+      "sourceHash": "e625257e716e19905d3832a6d162e52dab3ed81b209ca74aa2a8393aa412199f",
+      "translationHash": "58e50692caf2371aea278d36303b8bbfaa94276d5665cb04cc621330ad113c1a",
+      "status": "reviewed"
+    },
+    "ui.loopback.microbenchmarks.with.explicit.connection.and.batch.boundaries": {
+      "sourceHash": "b002a4ff0d13ef0c1d867239c97ef952c0d97f231d18d9349c18c760672e4b81",
+      "translationHash": "f3aa48f20719aba34dd1574064dfc2a86d440b297df627421d76442b0aaaa269",
+      "status": "reviewed"
+    },
+    "ui.json.1.kib.new.h1": {
+      "sourceHash": "6f707513e6f7273d1b5b2c42ac734cd803d275db9adf366c78f06fc02e99fd02",
+      "translationHash": "ad658a0f8ef68942ac5e3cc8e202241cb15cde20ffbc8d061d0137a74ab42b82",
+      "status": "reviewed"
+    },
+    "ui.p50.tcp.connect.request.full.response": {
+      "sourceHash": "58cf6618eab338437a7f94ed40c879199c890a43c2f2425b6803593fa66a1c6a",
+      "translationHash": "e0f3feb955496506198edece5b8d54303b85cb61430251740c59addd5e54a7de",
+      "status": "reviewed"
+    },
+    "ui.websocket.connect.echo": {
+      "sourceHash": "cb29a19c09802fc4a2366617c201ce87d4f20f5f9b3e9ecbc5e61f543e3fd5b1",
+      "translationHash": "5e8824d8557290b8386fd047134d8ce7073e8feb94b0ceb5c7464884a7f81767",
+      "status": "reviewed"
+    },
+    "ui.p50.handshake.one.echo.close": {
+      "sourceHash": "dfa5b1a7006f469663c7a4a35b3c0afaab2044060d3d17eeaeecdf1001e30d71",
+      "translationHash": "3d2fa864469d173f8e87a2c30f29790a48ba7ca4f2efce65a4d282d0a6f3ab8f",
+      "status": "reviewed"
+    },
+    "ui.h1.100.request.batch": {
+      "sourceHash": "5890d40ed5e4bd0daf0bf56aadcca4a4d579eee398602ccb658b8e6d08dd25b1",
+      "translationHash": "5e19527ca8611a19ae5d9e8cfa8da67d8c5d732f972f48a247c877b6835531b5",
+      "status": "reviewed"
+    },
+    "ui.p50.wall.time.until.all.100.concurrent.new": {
+      "sourceHash": "2f19193048dc55f8353443454e917ef093ab09cde3b4d61f37536d1c1e6bb5b5",
+      "translationHash": "14106b67dd620347792771a75fc1724913da01122dad9c326fd6364a74d983fd",
+      "status": "reviewed"
+    },
+    "ui.pass": {
+      "sourceHash": "2f9acb02faa121bb2a3621951f57b4c690655337edee2e5ac350be2b3be88ea8",
+      "translationHash": "1e9f2561b7cf43c495c3417ea97bdebc53321d66be975b811d3bc0022c72197d",
+      "status": "reviewed"
+    },
+    "ui.fail": {
+      "sourceHash": "425305e25df9df108e011164f7ca97522276cf1bc67b8aec3a7139cd60fb9a81",
+      "translationHash": "28384d7afd2e4fa66084f6803b9d3cb3b1c1ebb0a4ecc4cc97706745405e5df4",
+      "status": "reviewed"
+    },
+    "ui.skip": {
+      "sourceHash": "6ad446059a8bb8d8722e1420110f2784368a2ad5a56384d516c602530e5af256",
+      "translationHash": "fc50a99caae0cddc10e0d3f953c48b08c35f1139fcefcc83f01a81bf92124aa1",
+      "status": "reviewed"
+    },
+    "ui.open": {
+      "sourceHash": "6e10953f3e4ca159285c03a116d60c5086727c958dc25b31c39848ffea1dcdfe",
+      "translationHash": "e55f2ab3e631c5f91051d31ba6de9356616b219267e24dd4b78fc2e35267ba86",
+      "status": "reviewed"
+    },
+    "ui.demo": {
+      "sourceHash": "4ff006ca6b88e752f08cb7881714505ceb3d2079eea432acfda8e158e0d1d82e",
+      "translationHash": "0d53f08678d8101b0c7e5053b30224fc671c55051770ba18207435ead7ad37bd",
+      "status": "reviewed"
+    },
+    "locale.label": {
+      "sourceHash": "a4fe65264ef7dbb38d104b1e81eb3350f3142f3d16f32bdec39b1d9b42c1b8d1",
+      "translationHash": "9f6fee1aba17a56586bf16a77b07b1a76d8c4e867430c6ee6abfa3128b55fa98",
+      "status": "reviewed"
+    },
+    "locale.original": {
+      "sourceHash": "f91b469bbbbda9bdea40f8dcfcc13aadd816cdefa870fdf454a982de8fd5e929",
+      "translationHash": "58e5726a0acf5f51719269f181c7c7e666b4b07ff8d6cd3ea79381347b958d2d",
+      "status": "reviewed"
+    },
+    "locale.untranslated": {
+      "sourceHash": "02be0d46ee1f7e409f65d76d1034229b0e264a917d753d06c56ee0728535165d",
+      "translationHash": "63da2c5b43a5c7a46d93c88ad4f61767e3381cace2f2e78959c39833c7a7da71",
+      "status": "reviewed"
+    },
+    "site.description": {
+      "sourceHash": "087d3b8ababeacae4d0f1028155d25d8445a3ab87235de96136902e9e52d8dfe",
+      "translationHash": "d7f320c41b0ae37c17896e3b1d16c79c41d367bbe0ee391023c1e69edaf7ba90",
+      "status": "reviewed"
+    },
+    "fumadocs.Ask AI(AI chat button)": {
+      "sourceHash": "ea9e45ac7083cf49eaca10fc7c9f1ca1f1aaca9067d4b7e974aaf270a7c95414",
+      "translationHash": "69d8ed1c70a6a0ff81d0f96e950f7969d647c3ab0a0da78a0a7975887a8711ed",
+      "status": "reviewed"
+    },
+    "fumadocs.Back to Home(404 page)": {
+      "sourceHash": "eec78426776352f1ec59953c188e053590e17399c3948d810c1b020a8f224da4",
+      "translationHash": "d66f4359dae37110800e78bee282c2c6eed06365b26eddb0b0c3f7598081c8ca",
+      "status": "reviewed"
+    },
+    "fumadocs.Choose a language(language switcher)": {
+      "sourceHash": "f8416d793a642faa027935eb7b5a975533baa3705a806c57cde08be442c95d46",
+      "translationHash": "b90a8ac9c488ce4659237c49ba9e6d271ac16d16939fb1a2d8cbc26f8d7d3b4e",
+      "status": "reviewed"
+    },
+    "fumadocs.Choose a language(language switcher)(aria-label)": {
+      "sourceHash": "f8416d793a642faa027935eb7b5a975533baa3705a806c57cde08be442c95d46",
+      "translationHash": "b90a8ac9c488ce4659237c49ba9e6d271ac16d16939fb1a2d8cbc26f8d7d3b4e",
+      "status": "reviewed"
+    },
+    "fumadocs.Close Banner(banner)(aria-label)": {
+      "sourceHash": "171f7f76bd02de06b42476e067c06e6a78f220be89366bc6474171802a91d638",
+      "translationHash": "1fcab7a395d2131bea9be16d00227bba7d0009d2efc82f72a8035006d7488ab0",
+      "status": "reviewed"
+    },
+    "fumadocs.Close Search(search dialog)(aria-label)": {
+      "sourceHash": "713e7816521d60911bd5720a384d3230d3d1b319e517ed084ccda4d55ad7a592",
+      "translationHash": "ab008ef18dac8f830cfd4c58c9003e17c4cd4dc4689b44fbf5b81df1d65deb7c",
+      "status": "reviewed"
+    },
+    "fumadocs.Close Sidebar(aria-label)": {
+      "sourceHash": "8896c14d09e7669a3807286f212e00c666488cbe66941869a63b0131e9fb293a",
+      "translationHash": "623a7d6abde41e17376e66b7ecc85d76e41a0109025ceb5d987a61ac17c216fa",
+      "status": "reviewed"
+    },
+    "fumadocs.Close Sidebar(sidebar)(aria-label)": {
+      "sourceHash": "8896c14d09e7669a3807286f212e00c666488cbe66941869a63b0131e9fb293a",
+      "translationHash": "623a7d6abde41e17376e66b7ecc85d76e41a0109025ceb5d987a61ac17c216fa",
+      "status": "reviewed"
+    },
+    "fumadocs.Collapse Sidebar(sidebar)(aria-label)": {
+      "sourceHash": "9da0bf42ad074f0967d11de494fc8f7f3afb628a3b40e133a2dd63d10a77a8d6",
+      "translationHash": "ce1d67c2703c6d4393fe3702e70b740185df4b40377d3881d29967e6124c73af",
+      "status": "reviewed"
+    },
+    "fumadocs.Copied Text(code block)(aria-label)": {
+      "sourceHash": "75a5d50a9fe912cc331ef2bd0c4e7dd1ed7415ff4e9a6b89e27f27497a2f79bd",
+      "translationHash": "714207e324062c610ffd1eb167ec25b7e9dcb5843fc0096324c360e81901733e",
+      "status": "reviewed"
+    },
+    "fumadocs.Copy Anchor Link(heading anchor)(aria-label)": {
+      "sourceHash": "6999a51263ff3a5b4c67af6c8c9824f998d9e78712dade1d3bdae78ebc70e7a9",
+      "translationHash": "ee6a2095141add8b579fa306087d562da4cf50b91eb0e55a06c4d5eab7f65f0e",
+      "status": "reviewed"
+    },
+    "fumadocs.Copy Link(accordion)(aria-label)": {
+      "sourceHash": "724e78a3254c899d16ef6324a7abc9a8f5240ffce8bff74976df397c68ce9d78",
+      "translationHash": "8e86f9b1d54f2c5125b0deb2617517c0b0601399dca6917c7527fc1b72ebda7f",
+      "status": "reviewed"
+    },
+    "fumadocs.Copy Markdown(page actions)": {
+      "sourceHash": "47ffe39e75566b3835200592d6862b047b19b40483b056b11ee4086bb675c8ff",
+      "translationHash": "f9c71ee4c4359bef66eccfdb399283036759f74c9b745e74a4e96e1d93bfa677",
+      "status": "reviewed"
+    },
+    "fumadocs.Copy Text(code block)(aria-label)": {
+      "sourceHash": "8195c1caa5035a4402c0196c8eb512c99d722f30eba76cadf99fcfcb01688ab4",
+      "translationHash": "befad318258f8c93fa7640a1fea20fd5c23afa0d81016d459bcf358be4fec5b4",
+      "status": "reviewed"
+    },
+    "fumadocs.Dark(theme switcher)(aria-label)": {
+      "sourceHash": "60acc53f13a5d1bf115878c4a785e9a43e8286c4139a8402a6ac7d23966f9153",
+      "translationHash": "a6b75d0680322a61f4d46185dfb28c875fea97ad8868217b4cbfee3de639f2c1",
+      "status": "reviewed"
+    },
+    "fumadocs.Default(type table)": {
+      "sourceHash": "21b111cbfe6e8fca2d181c43f53ad548b22e38aca955b9824706a504b0a07a2d",
+      "translationHash": "306da767a461a51e85c0ee884498ae78dd543b73c7390b1eae819b67600000f0",
+      "status": "reviewed"
+    },
+    "fumadocs.Edit on GitHub(edit page)": {
+      "sourceHash": "8dbf35488c3f264413696c17b7f55650ddefe9d9fc5864ecc85bf7a90075b309",
+      "translationHash": "359d338ba3364d12d57924cf59361406d99533bab75ea44d70a41699307b0290",
+      "status": "reviewed"
+    },
+    "fumadocs.Hide Sidebar(sidebar)": {
+      "sourceHash": "9709a3b2e51f0ef313f5ad19d1b926e3ae80e95f73e8b7c8c60363810505d6d8",
+      "translationHash": "76af3dbc0795546513eed90bf8ac430396ee32ba29958611560ccf8d4e5675cb",
+      "status": "reviewed"
+    },
+    "fumadocs.Last updated on(page footer)": {
+      "sourceHash": "103e2a9f3f94ffe026e35d59dfdf47a05659b033382560b4bafaea6f9223effb",
+      "translationHash": "a52ee5b247e92f3cdd0a8795a17933120a3e3f83ec9aa7c59ab541c9b39aa198",
+      "status": "reviewed"
+    },
+    "fumadocs.Layout Tab(layout tab trigger)": {
+      "sourceHash": "c0d9415c664fc5f0bc1457d55083971386f74e2e72a85474bfb9885668d73f4d",
+      "translationHash": "c5879e5be7d63f0c24e559096840e35a1d14f3af236fa4df5739e6c05b94271f",
+      "status": "reviewed"
+    },
+    "fumadocs.Light(theme switcher)(aria-label)": {
+      "sourceHash": "dbcd5e7bb7a0f538810de44c3efbd813037ee3fa358747bb71fa58e157af45f7",
+      "translationHash": "aa0819dfc4d8d78280b8c7605b008bfc9df42b585f9106feaa3c8d5bdfda711e",
+      "status": "reviewed"
+    },
+    "fumadocs.Next Page(pagination)": {
+      "sourceHash": "6ead5dfdc11ef7da26e4c09f348d42a8d6306b7faa54ce0a7dc6c567dab1db6f",
+      "translationHash": "8a8542f6964852dc4f7b840333d683776195ca83a2bf184f3b39b621e1b5d842",
+      "status": "reviewed"
+    },
+    "fumadocs.No Headings(table of contents)": {
+      "sourceHash": "877e7e5d5975af695d62c2695eb97d1969d9f7d71d594f5ab48cd70a175a4bd5",
+      "translationHash": "f3b4326ab686d701db5ca2a97e3a9e350130197c943977c3582d1378f8962be4",
+      "status": "reviewed"
+    },
+    "fumadocs.No results found(search dialog)": {
+      "sourceHash": "7d7e360586090927c7aeee67c8a46d8354694e7aa4b722ff5b421347f798057a",
+      "translationHash": "73de5ef9c0c022fac3f75c7ed2a762d7e23a1e80e003120ddc892a7942c25984",
+      "status": "reviewed"
+    },
+    "fumadocs.On this page(table of contents)": {
+      "sourceHash": "b5658fc8edda24f9c94eabac9e536e0a18e3055a8ca255f9d1b8f256ea02a6cc",
+      "translationHash": "a610e0c62b3e1e39e09d7f9d5d9e352a0770d302b31f614c5d11daf6da5e315f",
+      "status": "reviewed"
+    },
+    "fumadocs.Open Search(search trigger)(aria-label)": {
+      "sourceHash": "9c3451e933c5ac535459f88405d7c3973b8103d5df3d75a9615e91b8e0c7ba45",
+      "translationHash": "5e9e915d6fbaa0a2535f2cccd1b63b2160f9d66bf20a15baf7199bf2f83e6e70",
+      "status": "reviewed"
+    },
+    "fumadocs.Open Sidebar(sidebar)(aria-label)": {
+      "sourceHash": "ef84dd64b90fc4856e6076cda0e48af86c3bb6816a434571d08988e205591a98",
+      "translationHash": "dfba9849d56f3a164170bd4b7cef58cb68547c73b9d1abb8837be1b7bb0f3bf1",
+      "status": "reviewed"
+    },
+    "fumadocs.Open in ChatGPT(page actions)": {
+      "sourceHash": "c27a47a5c24fdd0f68175066a80839a0e771f02fd45bde86887228841cef5bf3",
+      "translationHash": "dc1883935d5025cb49af06d83094d4bb75696c1fd70a91a6489b4a9e3d7d89ab",
+      "status": "reviewed"
+    },
+    "fumadocs.Open in Claude(page actions)": {
+      "sourceHash": "9512e37d4a15473303780d07ea21f61afeedb87fcd0241d4dbae2a2a475fe59c",
+      "translationHash": "07f8803c22929fe133f626b313b40003a457b2467be0c7db61d54021b65efb2a",
+      "status": "reviewed"
+    },
+    "fumadocs.Open in Cursor(page actions)": {
+      "sourceHash": "af29fb46ae908eb1a213727c131527d2cfc2a7ec79d968a910f7c88fbc88590c",
+      "translationHash": "71ae5ad52fbeced060ceb8be6365c940b42ce39fa3444dcfd2bb4230d982729d",
+      "status": "reviewed"
+    },
+    "fumadocs.Open in GitHub(page actions)": {
+      "sourceHash": "4fb78818bd18432cb2e7875d7fe5a4985e66dac9cdd4a5b69d0085a31c8974c9",
+      "translationHash": "eb13ef075893699353c866fd1c42cc64497af54578d557d1014ef7b8032ba00b",
+      "status": "reviewed"
+    },
+    "fumadocs.Open in Scira AI(page actions)": {
+      "sourceHash": "d488d0e2510b998b3b25f518c9fbda2388d3cd5466d80bed09f2b28cc010b16a",
+      "translationHash": "d2cd0da2958d08b1aafcf9ceff90cbbaefc90c4c97a649f8d36587d7c3a33f50",
+      "status": "reviewed"
+    },
+    "fumadocs.Open(page actions)": {
+      "sourceHash": "ed077f3d8125d60dca1979c7133601bd187d47c73ed9975028f677e49e709942",
+      "translationHash": "c771248e511fbf9328abdf31f3f2472d14940144c3ef819c3ec3bd8c2631738e",
+      "status": "reviewed"
+    },
+    "fumadocs.Page Not Found(404 page)": {
+      "sourceHash": "cb2f00d1e554baf96001ddb5e22ee63a8053fd3f8b6cad8acd74504af0dadb52",
+      "translationHash": "e75737c1ab90e168e9e4364e5873c26edc50b742e25e634efedd439bd5e0f0b0",
+      "status": "reviewed"
+    },
+    "fumadocs.Parameters(type table)": {
+      "sourceHash": "e68b36b17cbd990802f57741cb75cf3a73fa66a61999b0cd70e3cf7d26cfb25f",
+      "translationHash": "9634fb0832be624fc5beafc8a2ba68e9e66bfc5162c46aed461befee62b84783",
+      "status": "reviewed"
+    },
+    "fumadocs.Previous Page(pagination)": {
+      "sourceHash": "a163aaa22cf7ce6c4c2a634f98bef10d0fe0a0602ada2aa50d60b262dc70b2d9",
+      "translationHash": "c9b9ae7a61444ab7e3b9c2b7e9357bcfe6c7956074de87a9f0dd6fcabcc618c5",
+      "status": "reviewed"
+    },
+    "fumadocs.Prop(type table)": {
+      "sourceHash": "57d968860fabe1008d2c72342adec04b70f4bae48b7bcf6ebca915624100c353",
+      "translationHash": "86de52d178203799951d818b1d3af85f13288de66bf2b0373cc21f53b1e42ff4",
+      "status": "reviewed"
+    },
+    "fumadocs.Read {url}, I want to ask questions about it.(page actions)": {
+      "sourceHash": "619e3673b5ff957f91e9722429e9aebace51f7be53e100efc3f0edddbcb1cdfd",
+      "translationHash": "a952bf988f48f13e8cb9d1546bdf0a9c05c15be3f745dfc3085f58da0388c352",
+      "status": "reviewed"
+    },
+    "fumadocs.Returns(type table)": {
+      "sourceHash": "16dcaa923f16b449fb2089fd7f135465339cc1e6638c8e5fcf7f143d60f4a0d3",
+      "translationHash": "dfd7a59f3d9389d9d93a020f2558a73a32c20609aaeaf466f24d90415dad1e02",
+      "status": "reviewed"
+    },
+    "fumadocs.Search(search dialog)": {
+      "sourceHash": "49c266baaaa70981ea188fa714d5c40cf13830d786a861c9943ae0d26a7f3fe9",
+      "translationHash": "44ce7ae909bbb28bbbe3cbbba8d617b71217869d62741b4c104dc123a6ef603d",
+      "status": "reviewed"
+    },
+    "fumadocs.Search(search trigger)": {
+      "sourceHash": "49c266baaaa70981ea188fa714d5c40cf13830d786a861c9943ae0d26a7f3fe9",
+      "translationHash": "44ce7ae909bbb28bbbe3cbbba8d617b71217869d62741b4c104dc123a6ef603d",
+      "status": "reviewed"
+    },
+    "fumadocs.Show Sidebar(sidebar)": {
+      "sourceHash": "04efae3fc7825d3a016a59f5d8c96460b02f15523dbfaf973fe411717be722f8",
+      "translationHash": "d97efcf76cb0979dbac18d47d68ea7a1ac931df3d68c9aa07b617af80df7ef0d",
+      "status": "reviewed"
+    },
+    "fumadocs.System(theme switcher)(aria-label)": {
+      "sourceHash": "6725e7bbcd28f3a8a586fa34bf191fd72dde8b61756932cd3237c17a6f196f1a",
+      "translationHash": "217cfe7db1e3d10a734f5a0342df7977e5c1eb3c8906b28716732f72330cf181",
+      "status": "reviewed"
+    },
+    "fumadocs.Table of Contents(inline table of contents)": {
+      "sourceHash": "a9360e0212a4d173581c91da68494d022ee55871188be00acf863d2ed0cf7a6a",
+      "translationHash": "52daa71ebc31058156b21dc21c01ed18eb4e9a723749259cacd1558afe32dfea",
+      "status": "reviewed"
+    },
+    "fumadocs.The page you are looking for might have been removed, had its name changed, or is temporarily unavailable.(404 page)": {
+      "sourceHash": "bb6a203b3184da97cc89d010d8cf1092756744a230584c6bcc60b138dcf8ecc5",
+      "translationHash": "0e9958ee182022107fe6f246be85b14b951f6d5f83571a80f3777c559c378a20",
+      "status": "reviewed"
+    },
+    "fumadocs.Toggle Menu(mobile menu)(aria-label)": {
+      "sourceHash": "f2fca5f984057b8d0a173d66466213cc2e910871e9583fbde8fdb8ca342245f1",
+      "translationHash": "69ee5f51f38b9cd9a29679ade207f2d5eb422e23984148f614c6a37d55a28676",
+      "status": "reviewed"
+    },
+    "fumadocs.Toggle Theme(theme switcher)(aria-label)": {
+      "sourceHash": "de148bf172104c6736a88eafadbebc7f7c6a8e7bed558fbe29697e7acb6ff46f",
+      "translationHash": "7a1604323e8bf3f2cd4cc2d2d67fcde41cc27dc36c40017cf9a7dcf1de3216a6",
+      "status": "reviewed"
+    },
+    "fumadocs.Type(type table)": {
+      "sourceHash": "baaddf70fb5d432b8bd948ef91d6f910124a6d138edae4d5f000c4610ddc8eae",
+      "translationHash": "ba40014ff496f64e755492a5c6243cc0222a5d3e4b795ecfea7c9bed809adaab",
+      "status": "reviewed"
+    },
+    "fumadocs.View as Markdown(page actions)": {
+      "sourceHash": "17d36a505f972e68d0a81c212ff4d54427b2df3859346d0aa65f60bb61c75d38",
+      "translationHash": "38eb967b670521dcef486f4b602aa71cf59b39f1048cf0267b6a007c9f0fa1dd",
+      "status": "reviewed"
+    },
+    "fumadocs.displayName": {
+      "sourceHash": "ba118bf7fc9c1aedc1edb28a0aa86e0b43b681f222af6616e13c43be87815b06",
+      "translationHash": "9937e365aaf3a0854053a3179584ad9cd82e1164ea8535b50c1e6ae7102b373c",
+      "status": "reviewed"
+    },
+    "site.title": {
+      "sourceHash": "986fddf29eb12a52484a3c517273318e5661fbfdd7abedef8eb93aa7228833f5",
+      "translationHash": "ff9d738e8085ec9629b11db1324df29de31975c9caf6d41619edd807707c096c",
+      "status": "reviewed"
+    },
+    "blog.description": {
+      "sourceHash": "33a7f7001e09b66ee50a667febce15544fdbcf5f1c0b1875352c662c3df03fcc",
+      "translationHash": "b3b005ec3e957bea345a31e9486eb917d4c2992ca8235b555ceb4ee22da25070",
+      "status": "reviewed"
+    }
+  },
+  "content": {
+    "docs/concepts/meta.json": {
+      "sourceHash": "b131854badc593af84fe13ad5ecb4ecb35479174a15a4d819c3a5f637447cccf",
+      "translationHash": "6238640c0171c218ce20d1b103cf5e034fbcfd4354fc9602fa310a2c0605a59f",
+      "status": "reviewed"
+    },
+    "docs/guides/meta.json": {
+      "sourceHash": "0eb4bd29639f2902ea8c4a6932020a819c06eb9d539c24fd67a14f1312d311af",
+      "translationHash": "45c8d98e796613eab302d19bb8c999bdde2d300ee59ef9ce359b4b2164f877bb",
+      "status": "reviewed"
+    },
+    "docs/meta.json": {
+      "sourceHash": "2b9ccbeed1d2b5fe83f4f751c476c7981ad5b9d933f41805842867c8d4c9520e",
+      "translationHash": "ce086d4c003540350a527190d78c5efca20f11765bf15cf4b15dd02bbd0eb6c6",
+      "status": "reviewed"
+    },
+    "docs/operations/meta.json": {
+      "sourceHash": "3a00ec1f5ccc3055d6b67a1a3ab1bb24ef8991885ac97f2d1671f73427ce1a2d",
+      "translationHash": "cab4e4276a5246a8bcc0cbcaee8cbdfcbbe2418150fa1946779d650be6acdbf1",
+      "status": "reviewed"
+    },
+    "reference/cli/meta.json": {
+      "sourceHash": "0051be3f0f28a386626e0cfdb3a5405fffc85d557d42d906d687f7c7fecba977",
+      "translationHash": "67ed47738a0d28d029169ddb1f9c9a2c344dc99dde60cbe0aa132b14cb90a4b8",
+      "status": "reviewed"
+    },
+    "reference/javascript/meta.json": {
+      "sourceHash": "a179ec0b7536d094fd767d48c9c226406e5f24e357466c926d3aae9af7e65fdf",
+      "translationHash": "a179ec0b7536d094fd767d48c9c226406e5f24e357466c926d3aae9af7e65fdf",
+      "status": "reviewed"
+    },
+    "reference/manifest/meta.json": {
+      "sourceHash": "678fe075c75696ae5e55147b2fedb67f5f226b3c23754df35cb842a795861403",
+      "translationHash": "6ec32b69e2db557bfa014e24a4a9ad63e69f8f275859a69fce223bc6e94d368f",
+      "status": "reviewed"
+    },
+    "reference/meta.json": {
+      "sourceHash": "febad09e350025840d6751615951b2a8e432c8c721013a1d4bc14d5c908e7ca7",
+      "translationHash": "5cfdcf722550547f80039253bbdd8bacd5baa76d3f76851dc18c91434dd611f7",
+      "status": "reviewed"
+    },
+    "reference/runtime/meta.json": {
+      "sourceHash": "1d2d2c743d2e9ee6faab05838c62cee0ffbe1f929d76a1aa451db5329638b36b",
+      "translationHash": "69e99e6629e46009bcd33ebdd732b1c94f8b08c299cfab129b80a4db46b9bbba",
+      "status": "reviewed"
+    },
+    "docs/getting-started.mdx": {
+      "sourceHash": "0226ed150bfdd714d2dcc62879a6f755cfc96d89c0ceec8b61553df95fa0e012",
+      "translationHash": "eaee1f0ada0066c3ba2d360d75a0f4d5e09fd31ecf59a7f99fcc27c4e3b2f808",
+      "status": "reviewed"
+    },
+    "docs/index.mdx": {
+      "sourceHash": "81e5e66ca319958283104df4609a0c2cb692bcdb4fbc34cccb045ca39dd50482",
+      "translationHash": "2e499349f1f44a822d0f20ac56fc9051596c34aae7ba00e3c5c1d070413ee758",
+      "status": "reviewed"
+    },
+    "docs/install.mdx": {
+      "sourceHash": "68273194ace99e7af7933126e3c373d739ab4d856d08558cfeef633939a2e64d",
+      "translationHash": "24152d190dc55eec83fc6f959cd20616905cd0dd87f3c8c8a295d446eef1d167",
+      "status": "reviewed"
+    },
+    "reference/javascript/abortcontroller.mdx": {
+      "sourceHash": "862eec68e10e2387cf1bc3eb6731a1322b20a5b0d209acebbe6d0326e8a4de05",
+      "translationHash": "00043a6aa196621a863918d4bab7c2138ca269235d5dbf12356ef7fbf735ced2",
+      "status": "reviewed"
+    },
+    "reference/javascript/crypto.mdx": {
+      "sourceHash": "8b786a1e3fd23da8fe54171ac1829794e1f3f3a365cf9c288cece10a995c459f",
+      "translationHash": "2af8c80951b7f3d3a22d8feb0c9998be8a59768a4304e3a1bad71e60c892837b",
+      "status": "reviewed"
+    },
+    "reference/javascript/event.mdx": {
+      "sourceHash": "5e13ef4d98d71c564ba7fe008c66dc72b5394a31be8b32318461a76a0cff27d7",
+      "translationHash": "fe7de27ab3665471e9e35a69a46f7c278de99caed90dd5678a6754e659ca263d",
+      "status": "reviewed"
+    },
+    "reference/javascript/fetch.mdx": {
+      "sourceHash": "b344d495c86d2099b2eda4ac8a13c3c972139369eef4fd672057724b470060b9",
+      "translationHash": "928e200aca18e24264aa561afe62a946283b9d91295b8a2ae237ee89f7bab11f",
+      "status": "reviewed"
+    },
+    "reference/javascript/headers.mdx": {
+      "sourceHash": "42f6c11191518ceb86be90d1a1f85d95a7dd9a42d52110f53932941fe9f624a4",
+      "translationHash": "6b80d7840ce3bde9b5a8841c3f8c8f09366e30f30a9c1e025fd7aba579d6cb80",
+      "status": "reviewed"
+    },
+    "reference/javascript/index.mdx": {
+      "sourceHash": "a7ba0a075b701bc1d8e93cebf1a761c5a715a5d478bcc7710c7d64af1bb48f89",
+      "translationHash": "ffe8c800ad04747db3a467d7a5dd797266c9a77ec76ddf59482f184aeeaa1557",
+      "status": "reviewed"
+    },
+    "reference/javascript/request.mdx": {
+      "sourceHash": "995c228d413ae2ac1bbf92ac95004f535a1b6dfa1c2bb8ac578a0c13549899ef",
+      "translationHash": "ce4f359a67ee2d611f9e7362eacabffe98ffd96812b76daa098a1510db3f982e",
+      "status": "reviewed"
+    },
+    "reference/javascript/textencoder.mdx": {
+      "sourceHash": "52c8ba77b4919fe4545a676b63e167bc0b4b477ced4f8129bcc51756309d650d",
+      "translationHash": "1608224618c641be8af79456be3068ff1b82dc871649ebb28a3d875dd9663271",
+      "status": "reviewed"
+    },
+    "reference/javascript/timers.mdx": {
+      "sourceHash": "abf1465fb7850d7347596087f3301d9be1a803cb829d0d3f1a400dbf182761fb",
+      "translationHash": "e870377589a72333d9af18679a2d09a10b9238a7ff9329309169e4e72b8f4627",
+      "status": "reviewed"
+    },
+    "reference/javascript/url.mdx": {
+      "sourceHash": "e7f09130d693bd2743626dbb570023dadcf1ceb99f28f35ffd76b9441d3ffa23",
+      "translationHash": "6c0d7a1785954db13cace77acea2b9b99e9f1203bf14c44e6c0f3c25bf5c6c47",
+      "status": "reviewed"
+    },
+    "reference/javascript/websocket.mdx": {
+      "sourceHash": "9055e593227b9449c300c78ca1c784eb792777fcaa73385d82e689aca5acf6ec",
+      "translationHash": "1a36d9b955f6a5182d7295aaf01b18a5336383b19f4dcab2b1680a29ec428848",
+      "status": "reviewed"
+    },
+    "docs/capabilities/index.mdx": {
+      "sourceHash": "25848e68373e57b145be92b61545e84f1b4249de6e4b1ec20872b1e4e4c749ed",
+      "translationHash": "443a828396339e376b903f5c0008c4f983fcd364e1d9a8447c58dd32d58a1e22",
+      "status": "reviewed"
+    },
+    "docs/guides/index.mdx": {
+      "sourceHash": "1d8b9323711af7578db4574238d675509319e7894a8784beb9c90b66973471a9",
+      "translationHash": "05721b03642f8482ee589942988c580487cbbde6085dfcab540413b469541571",
+      "status": "reviewed"
+    },
+    "docs/performance/index.mdx": {
+      "sourceHash": "a00aceea2007998201738b81ad3292489bf3761b35f10ff95503b92a308d0233",
+      "translationHash": "b622adb33418aabb23909ff75b6f2b040c769ff88c38ff190945818f79962326",
+      "status": "reviewed"
+    },
+    "reference/cli/index.mdx": {
+      "sourceHash": "4aa3fab1c41a0694c91e4c01bc3ac9de2691026f286771a41e16d6eec90a368e",
+      "translationHash": "d550cbe29d988f8dada09d8c1b5faec83b6cf2f3f75b2ec47b785ae93a12bbb6",
+      "status": "reviewed"
+    },
+    "reference/cli/installation.mdx": {
+      "sourceHash": "d59cb6740c462e65a3603bb3339faef2de2b9f42d56f783a1bd1bfda4a5c7ba6",
+      "translationHash": "126716cdee67cf67885e89fe548ab857559c89d18ada41234e864396fd27db02",
+      "status": "reviewed"
+    },
+    "reference/runtime/index.mdx": {
+      "sourceHash": "a5ca3434cb26d3114d50610048270a1b68b4bfc5b9ccf52aa7ae64aabbab3a4b",
+      "translationHash": "3019344e29a158b66f49e5f51a745814e94dd5653cb7396d4991d033b82e2128",
+      "status": "reviewed"
+    },
+    "docs/compatibility/index.mdx": {
+      "sourceHash": "81c1a479cf9d1722f3dea0008e35f4d09f84beca63a11cc16e8b43486f04d10e",
+      "translationHash": "a5d803add4e13519bb8f1e598d2fa726d8ae1cf27c85e68a43afd6162a2688f3",
+      "status": "reviewed"
+    },
+    "reference/cli/evidence.mdx": {
+      "sourceHash": "6756f75b57da793b8125766e73494c101dbe0bee450adf26e28893f8e3696fb8",
+      "translationHash": "b60f387d02d1169ed0bd0a4544bf4e870bbf505d52d4a2ccf8bcc35869d9ea55",
+      "status": "reviewed"
+    },
+    "reference/cli/tasks.mdx": {
+      "sourceHash": "ff5255c0ca17f8bade09a9e7d783ee4e2596e27f1912677ba14b809633d6ec74",
+      "translationHash": "9ce93d245469f5575566963175bb60417598215846eac543f578a9da021db92c",
+      "status": "reviewed"
+    },
+    "docs/concepts/durable-execution.mdx": {
+      "sourceHash": "2e68a5f95eeebce606127e40dec9725e5e49b74f2a82e3d1b04690cb26d12b8b",
+      "translationHash": "e7b15ae198604e28fa0b1ab59ca6447ffda3d2de1d7d8089b27d4361d2b5d525",
+      "status": "reviewed"
+    },
+    "docs/concepts/execution-profiles.mdx": {
+      "sourceHash": "dfb099fb4c0ddd6b8a317793c89b801d8d899c713f3e2713c7ba81f74043cee8",
+      "translationHash": "d67b2dd929183ec9952ee4471638aaddb2f34d8112453893295523243969f9b7",
+      "status": "reviewed"
+    },
+    "docs/concepts/how-tysel-works.mdx": {
+      "sourceHash": "141a911439ac92949aded7d70f29377ca0288f722a55e54eebc44ba981c05afc",
+      "translationHash": "bfd5d75f607ada12379cf84c18eba7ed6548cf7f23d3d144cc8d83106405f1eb",
+      "status": "reviewed"
+    },
+    "docs/operations/component-tasks.mdx": {
+      "sourceHash": "48ecba7539212f3907b4347a8274de14d65ae40d295ff95eae557801079d8824",
+      "translationHash": "c1f988407b949f946abf60eaceaf56f12d1c4adc2f4da83a6473558a07a024c6",
+      "status": "reviewed"
+    },
+    "docs/operations/deployment.mdx": {
+      "sourceHash": "205b5dd1d35372a9a3a983bd789aa0e610fd76c7e815b93cf59775755e8b6af7",
+      "translationHash": "eaf9c071587adf18959b1f4941bc29df98bedc681036d64ba8459ff83de55319",
+      "status": "reviewed"
+    },
+    "docs/security/index.mdx": {
+      "sourceHash": "c3902c708ab537797d358892e96fcc43f818f0847b369aff77b07793604e9168",
+      "translationHash": "0cbeffc14cf35a145e2e10aff4ef556107bb7fa4b418d14a1f93feb8c9310e87",
+      "status": "reviewed"
+    },
+    "reference/component/abi.mdx": {
+      "sourceHash": "d8df19ab62786e117eb541a54226a95aba24b78a2f6f197e7a1d5254c1355902",
+      "translationHash": "5cab532b30b7242159589c4b4d66b708281f7b75a33ee77e4b1570ef0b8a94fa",
+      "status": "reviewed"
+    },
+    "reference/component/index.mdx": {
+      "sourceHash": "08abceedd5eadb67bfe7962cbe265200e4bb229d6a6853c2c4efd725af92cf31",
+      "translationHash": "c0bf69faaff3de69ea3fe90bc92db4be89a7f4a8161c021951639c41bc0e5f5e",
+      "status": "reviewed"
+    },
+    "reference/component/capabilities.mdx": {
+      "sourceHash": "9c63147d94e11a6205f724c042bafb4af4b2c80e9b4d0d1da638200da47820dd",
+      "translationHash": "da4e7eb7272a15fa4a1df8b7a31e492f6407cdb1ab6b0f2a2984ae4cf06ccf89",
+      "status": "reviewed"
+    },
+    "reference/component/go-sdk.mdx": {
+      "sourceHash": "e57eda2207f63b3f19966cb5c265b2114ac927101de9d04e93dc4f579fbd42e0",
+      "translationHash": "90067d80fbc35d2535427d81fff203d061db60edd08ae18ad4920f7b9d89262e",
+      "status": "reviewed"
+    },
+    "reference/component/runtime.mdx": {
+      "sourceHash": "2f032dbdbb521886a3aad260016b942ac73f6c5708aaebdead4037e60d763f14",
+      "translationHash": "f47c98a5620f7553a5450b6960921bca646bde79e0669838b5f2c1b5a1a83c11",
+      "status": "reviewed"
+    },
+    "reference/component/rust-sdk.mdx": {
+      "sourceHash": "af7df701c4d0ec207e023c11d8d67f84f48b55a053aa35718d273d0d6dcfd7cd",
+      "translationHash": "a6386b032b302697b156ff1daad1272dfffcbc25db4e3c5a87b84c4f5dfd2143",
+      "status": "reviewed"
+    },
+    "reference/manifest/durable-observability.mdx": {
+      "sourceHash": "8117f2c1f41ee9966ddae45e97e340360179d77855c29260060dd161060b36a4",
+      "translationHash": "4603d51e9202861a8ece85c83641d5ecae3eb7eb6f59b172444b37f09a4d71ab",
+      "status": "reviewed"
+    },
+    "reference/manifest/limits.mdx": {
+      "sourceHash": "3bfa8de2deef27e1572ae1ab01d136b406891a77d55e88ae111619ea1f839559",
+      "translationHash": "d50eb2af1b750a5c887779e720eecadb8a1800f40eade2d4b4c7aa3df38a83eb",
+      "status": "reviewed"
+    },
+    "reference/manifest/tasks.mdx": {
+      "sourceHash": "af2f770f126ae835e4c1f8f6fb6c255b46519e6898207ea0775589e838c1121e",
+      "translationHash": "04c1024b82858301622cff641d988f22aa1d15985ce0fcc0b2d8daef745568db",
+      "status": "reviewed"
+    },
+    "reference/manifest/app-server.mdx": {
+      "sourceHash": "01a73fef4959d03a0c1a1beff10900b89d1b594dd6fe551baf313c714f30418c",
+      "translationHash": "f066e245b86aa828020286e7892324a91381b539817de2a6c2c573edb31a8ce5",
+      "status": "reviewed"
+    },
+    "reference/manifest/permissions.mdx": {
+      "sourceHash": "16a834f474667d8c67d9efb0da078cfd44b55229d6fea0ecbf99b60bfc8e0718",
+      "translationHash": "0ae1c3f04a7a4fe157f0e8be40e0eddb63b14cd8ab51151c72bf91b3277ee60f",
+      "status": "reviewed"
+    },
+    "reference/cli/delivery.mdx": {
+      "sourceHash": "500bb21ba6dfed50578f2d54e5233d446a6afbfef2eca8bea4e019286cca195d",
+      "translationHash": "ccbbfed3f7d5cdc3b2a01356805d9240a6624ee366dbf8311500913474730cbb",
+      "status": "reviewed"
+    },
+    "docs/guides/redis.mdx": {
+      "sourceHash": "73f82be1c73aaaaff9b298f626c36c46629cd5561757b9999adb725a185bc692",
+      "translationHash": "8fdcf5a8e598e106c18e889ae52b36923b711f610a95e0e75ba83db886f8b0e0",
+      "status": "reviewed"
+    },
+    "reference/cli/development.mdx": {
+      "sourceHash": "ccf571f55dd2b40ada24f282cde88ba63a9f779343cd5c2f49133235b726c8b3",
+      "translationHash": "9ba27257478fd167412867a4c7feb0ea199f74ee56d5094b0d9aceece75d5150",
+      "status": "reviewed"
+    },
+    "reference/environment.mdx": {
+      "sourceHash": "1af65b78116439af012302f640e484d7a6a782b1156b8d2f7c675aabd959a622",
+      "translationHash": "63e00ad319b9a9486e998e53ffa19a8850b2dd69c8a4a2812a39d314f790731a",
+      "status": "reviewed"
+    },
+    "reference/index.mdx": {
+      "sourceHash": "9f3771fc361d60f279e08e19575b151249605d523a817162ce229bdf53d15bdd",
+      "translationHash": "4e244d6c88a1a81f3a4e41cf0090b0106a34eec2fdc9046f1a278778b451ace2",
+      "status": "reviewed"
+    },
+    "reference/limits-and-defaults.mdx": {
+      "sourceHash": "392aa2c7ff52202c7cdd2a658608c1aceacea093b36192c28118bbf12e9ebf7f",
+      "translationHash": "ce294f87a1aa7d02706216475d24b1d494194352212548ea0e91421ba68d40fd",
+      "status": "reviewed"
+    },
+    "reference/runtime/durable.mdx": {
+      "sourceHash": "4835cf1fb7d275ff25c03c3c306fea62235a9d1e7f7505f27f8d3a02073ef8ec",
+      "translationHash": "395f6d2c417078f720458775359a80eabfa7512e1b36d2e7fbab5465a4618a8e",
+      "status": "reviewed"
+    },
+    "reference/runtime/testing.mdx": {
+      "sourceHash": "1fbe75bdc7a2f983dd8ef0a4bca60ebfc783273c6528cdd71130f8d96d455901",
+      "translationHash": "883dade6b463ebd6acee0dcc8902b072d5f3277b48eea5c2141fa7ac3e9f780c",
+      "status": "reviewed"
+    },
+    "docs/performance/redis.mdx": {
+      "sourceHash": "641af3d48a464643f7c6f271fa95dcb310d34c0545333a43856132637750931b",
+      "translationHash": "43b4c6f4340e9d3c278ff2bb9b1a1f8c137d38b8f6450b184a36b7cb92659c8f",
+      "status": "reviewed"
+    },
+    "reference/runtime/types.mdx": {
+      "sourceHash": "1cf8061857b9806f84ecc68c2ebcca590bdc150d1965f48bbbdb5fe1c61dd4cf",
+      "translationHash": "e9d0be559d9f905bd10eb0a8c7d6cce8a53424fe296f71cc35c134d9e7823ce7",
+      "status": "reviewed"
+    },
+    "reference/errors-and-output.mdx": {
+      "sourceHash": "b4c0f1849252797359fc17b91bb62a9d0c0a1c6621d882f03a2e28949861f150",
+      "translationHash": "6703555343b4b012af239d5c6753555cdb99a72ecbbdc59d3532ae98869bf217",
+      "status": "reviewed"
+    },
+    "reference/runtime/application.mdx": {
+      "sourceHash": "00c3afa36bec61bf80805a9ffb14d2b085f703ae4c1295884ee84c6b79996a9e",
+      "translationHash": "3954af320a3a454b1c33bb66c961d6943872dfb0642014fa7bf38237cb3a27eb",
+      "status": "reviewed"
+    },
+    "reference/runtime/capabilities.mdx": {
+      "sourceHash": "91f7fcccda197ee88328bc04924d549982483890743ae0369aa977db7d98a124",
+      "translationHash": "544fe729792b5f7983475cb61b1a1e2ebc3328282b8aae7f83a1866bbc3addff",
+      "status": "reviewed"
+    },
+    "docs/guides/wasm-component-go.mdx": {
+      "sourceHash": "5a86d1a69d42f0e52bb1a5285735372ca331d4b7afa8be330206608ec27521ec",
+      "translationHash": "b7870be7658d5acf5e3b73a9a437e29d3007c96e2cffdb4fe23a283e0b01b684",
+      "status": "reviewed"
+    },
+    "docs/guides/wasm-component-rust.mdx": {
+      "sourceHash": "bdf1470ad9de6928f8180a9808e3fc36216449060dc0cfba85f316cf94dfe8d0",
+      "translationHash": "a731ebb7bc37162dcfcc2f7f8ff77920d488dcc1e8e04ef5603a12c2948ec2f9",
+      "status": "reviewed"
+    },
+    "docs/guides/concurrency-backpressure.mdx": {
+      "sourceHash": "de69dabd5700e284947ed5dd91935f1e02c9062247244a302ed2e05ca6b8e782",
+      "translationHash": "490a0aeffc261282742e9671a289608f249e8761c41aa0fe6dd5b077f38f726a",
+      "status": "reviewed"
+    },
+    "docs/guides/cron-queue.mdx": {
+      "sourceHash": "5a11ef0c1d10143f299031aa96dd7dcec8af582be7e5588daa27e3b529adab74",
+      "translationHash": "1e120533497d6e1935f791fce31ed2918927ab83128d3c1f82a5f64b9ec58833",
+      "status": "reviewed"
+    },
+    "docs/guides/examples.mdx": {
+      "sourceHash": "42327cd1d99f7e302670406d6c60156d5941e4c9a9b8f643692c26fc03cd80a1",
+      "translationHash": "8c23f0cc8c577598e6ea70c2cbf34c6e9d1a442b3bb9a75b398db6eb68362c3d",
+      "status": "reviewed"
+    },
+    "docs/guides/llm-gateway.mdx": {
+      "sourceHash": "af49d85b07422ccc01c8ecc42c4db658e9cf72117c713d7dfc14d4a4decb8f1c",
+      "translationHash": "bba4315677782503a632dcfcf3a397198b90f40668443362e158922a35529ccf",
+      "status": "reviewed"
+    },
+    "docs/guides/sqlite.mdx": {
+      "sourceHash": "478cca2dc1001f230934bd62e8c294c83a78ab55caf52cbbdd7dab5ef0632f55",
+      "translationHash": "348cf0653a061b6e9a6a8a7ad833f60327c75d5de453e02aebf4c56931eb0d7a",
+      "status": "reviewed"
+    },
+    "docs/guides/filesystem.mdx": {
+      "sourceHash": "81bae04c3b88835c78e8e4079bdbfe9f75d37b14803222d13d5663ca72e7ccb3",
+      "translationHash": "e10543afd4ff3e83043362fb37c8493fb5fdb22dbb26cedf4e7a1b77bc65af04",
+      "status": "reviewed"
+    },
+    "docs/guides/postgresql.mdx": {
+      "sourceHash": "fb05bd8adcb7b45e4bf9ad2bf5bff84e939b7e399be315c9351ef2f4cb333c53",
+      "translationHash": "4b4298d32e39076644b7565087ad59efebbf18d5593d7bac679d7affd48c8325",
+      "status": "reviewed"
+    },
+    "docs/guides/service-networking.mdx": {
+      "sourceHash": "5a0de23abde0ad45cf46e8554e9bd13adfad758741934de9b0f5b6a8aef653a2",
+      "translationHash": "27371cd2f01db74a1f933ee578953673b8936417bee868daebcfe2a22e3bd0c7",
+      "status": "reviewed"
+    },
+    "docs/operations/continuous-delivery.mdx": {
+      "sourceHash": "24638b3ee37bdafd0001fec5ecb8934d03dc282ef47e560fec6bb2957d60560d",
+      "translationHash": "f270e88ea52025d1ed2a6a9042d46626688179d874c352b9bfd9c61128e8d955",
+      "status": "reviewed"
+    },
+    "docs/guides/debugging.mdx": {
+      "sourceHash": "b4a60e9452d5907c0905e6e2fa9e1f657793e55016af0d4b12b734b4c99edf81",
+      "translationHash": "9e1e4acdffc837aa234177bac63ceb940dddc0da0c32be750a3a553f6365acf8",
+      "status": "reviewed"
+    },
+    "docs/guides/observability.mdx": {
+      "sourceHash": "660a17eaca7a226fb4f54d28d31b8a94d8369d90bdf974680cf01940ef0ed3f9",
+      "translationHash": "54e0462264673cb9a3c3ae0ccfb60ad135fb51a2c8188fe87d6141c0c3871ff4",
+      "status": "reviewed"
+    },
+    "reference/cli/project.mdx": {
+      "sourceHash": "c9eecfd943d692c18fccfdd27303a677b7bfb1242da764620bf4de0b57ba75f1",
+      "translationHash": "07b0c467ac2892ef6c67601318b1597568329889ff4f93102871e1ba9a515304",
+      "status": "reviewed"
+    },
+    "blog/why-tysel-is-not-another-nodejs-runtime.mdx": {
+      "sourceHash": "c8db949570e52a463a2ca479e79aa3dc99f387b8e374a5bca66cfbfa6c11da6a",
+      "translationHash": "b2be08bc491581ecc90fdca4269fa1fd7ab057802c64e91443779e839f684ae1",
+      "status": "reviewed"
+    },
+    "blog/tysel-v0-1-1.mdx": {
+      "sourceHash": "af2cbfa293e7d3103ac3f0cd86593df173918093afaddca5e034f60a4a4f1ef1",
+      "translationHash": "4812323a0cd4dd84ae4f1c30bb6d437dac4e80cd854bffb167bde2ff089f559f",
+      "status": "reviewed"
+    },
+    "blog/capability-by-default.mdx": {
+      "sourceHash": "5dcaa2145921904e11ae136ff186c412758b7c8d5c483b3f6aa9f87037d50d77",
+      "translationHash": "ffeb415abe583dddb31f9bdd676196765d4fe50fc779e7edd2664a882b41ca78",
+      "status": "reviewed"
+    },
+    "docs/guides/reproducible-release.mdx": {
+      "sourceHash": "57311fbbcecc03e4f69e3f19887d67e45c351d46f6ccbac29d0bdfbd2b61c698",
+      "translationHash": "347b36303bb78f76e6c62f4f51d8f2a71a17158acec7412654f4c4d6928100ef",
+      "status": "reviewed"
+    },
+    "docs/guides/container-image.mdx": {
+      "sourceHash": "00edd4e5891e2461b06746b49a9a48b0a13fc8b0c487598c57a753a16c6d0677",
+      "translationHash": "20811423df2a7e1e020b09f31f6b9106daf400adef341060bf3a95a6b2f39a5e",
+      "status": "reviewed"
+    },
+    "docs/operations/production.mdx": {
+      "sourceHash": "641b9cbc094cd04e82334f8b7a707e6234eee599fc9e8e2ba9e5a7325628a733",
+      "translationHash": "31ecfd97d5004432ce8874cded686af7215c4c97a6d77a12b928eb505e4b912e",
+      "status": "reviewed"
+    },
+    "blog/durable-execution-recovery-semantics.mdx": {
+      "sourceHash": "51edb3c89592023faf481d7cd0a41bdeb60bdc498fab4d5106d768d0c3993e9d",
+      "translationHash": "f5a27973ebaf85dd796c26ab2f7d06bd460df3f58c7ee4353eb282dcc04bbb79",
+      "status": "reviewed"
+    },
+    "blog/from-typescript-to-one-executable.mdx": {
+      "sourceHash": "71d5457c7234102b1520e448efb51af224d20f8da6fb609844b9f04007d4af0e",
+      "translationHash": "55a3306c8f26510709250ed405809182f4fa3bb80f84a2fd701a8f991e88065a",
+      "status": "reviewed"
+    },
+    "docs/concepts/projects-and-configuration.mdx": {
+      "sourceHash": "ec050b6483e6bc5bf91a276a59f208c43c006edddf7680f2d5d89e2318fc6012",
+      "translationHash": "028df783385fea0143155579f0a6b713254ec50ee95cc8cce6fe53658c2f5fbc",
+      "status": "reviewed"
+    },
+    "reference/manifest/index.mdx": {
+      "sourceHash": "23c9cd73c6ccb0abfdb06e1b36345a651b90136cee97297977e22e31fb3891b2",
+      "translationHash": "558082d4f301e0457db8a7decd25373da1741b6c22549ea7f874378891c17c42",
+      "status": "reviewed"
+    }
+  }
+}
diff --git a/website/locales/zh-CN/messages.json b/website/locales/zh-CN/messages.json
new file mode 100644
index 0000000..ed22216
--- /dev/null
+++ b/website/locales/zh-CN/messages.json
@@ -0,0 +1,390 @@
+{
+  "nav.home": "首页",
+  "nav.docs": "文档",
+  "nav.blog": "博客",
+  "nav.reference": "API 参考",
+  "nav.examples": "示例",
+  "nav.benchmarks": "性能测试",
+  "ui.product": "产品",
+  "ui.source": "源码",
+  "common.getStarted": "开始使用",
+  "ui.a.native.typescript.runtime.for.services.and.agents": "面向服务与智能体的原生 TypeScript 运行时。",
+  "home.hero.title": "编写 TypeScript。",
+  "home.hero.ship": "交付一个",
+  "home.hero.binary": "可执行文件",
+  "ui.a.native.runtime.for.services.and.ai.agents": "面向服务与 AI 智能体的原生运行时：单个可执行文件、显式能力授权，以及重启后可恢复的持久任务。",
+  "ui.read.the.docs": "阅读文档",
+  "ui.web.api.first": "以 Web API 为先",
+  "ui.request.response.fetch.streams.and.web.crypto.not": "提供 Request、Response、fetch、流和 Web Crypto，不依赖 Node.js 兼容层。",
+  "ui.no.node.in.production": "生产环境无需 Node",
+  "ui.the.packaged.executable.embeds.the.runtime.targets.do": "运行时内嵌于可执行文件，目标环境无需安装 V8 或 node_modules。",
+  "ui.deny.by.default": "默认拒绝访问",
+  "ui.network.secrets.files.and.databases.stay.closed.until": "网络、机密信息、文件和数据库只有在清单明确授权后才能访问。",
+  "ui.durable.resume": "持久任务恢复",
+  "ui.steps.effects.sleep.and.signals.persist.restarts.replay": "步骤、副作用、休眠和信号均可持久化。重启后复用已完成的结果，避免重复执行。",
+  "ui.ship.one.executable": "交付单个可执行文件",
+  "ui.typescript.becomes.an.application.package.then.a.native": "将 TypeScript 打包为应用，再生成原生可执行文件。校验和、SBOM、兼容性报告与验证结果随版本交付。",
+  "ui.bound.every.capability": "为每项能力限定权限",
+  "ui.the.manifest.requests.authority.the.execution.profile.and": "清单声明所需权限，执行配置和部署策略只能收紧权限。Linux 隔离工作进程还提供 Landlock、seccomp 和 cgroup 限制。",
+  "ui.resume.durable.work": "恢复持久任务",
+  "ui.llm.call.persisted.effect.approval.restart.resume.save": "LLM 调用 → 持久化副作用 → 审批 → 重启 → 恢复 → 保存一次。持久执行是运行时原语，并不代表 exactly-once 保证。",
+  "ui.three.product.contracts": "三项产品约定",
+  "ui.bun.and.deno.optimize.a.general.javascript.toolchain": "Bun 和 Deno 优化通用 JavaScript 工具链，Tysel 则聚焦于更明确的生产交付约定。",
+  "ui.workloads": "工作负载",
+  "ui.services.agents.and.wasm.each.with.a.named": "服务、智能体与 Wasm，各有明确授权。",
+  "ui.a.narrow.host.surface.not.a.kitchen.sink": "精简宿主接口，明确能力边界。网络、机密信息、存储和 LLM 访问均需清单显式授权。",
+  "ui.five.minutes.with.tysel": "五分钟上手 Tysel",
+  "ui.one.loop.from.source.to.an.executable": "从源码到可执行文件，一套流程完成。",
+  "ui.ship.with.proof": "携验证结果交付",
+  "ui.every.release.carries.evidence.not.just.a.binary": "每次发布都附带验证结果。",
+  "ui.compatibility.reports.sboms.checksums.and.ci.admission.gates": "兼容性报告、SBOM、校验和与 CI 准入检查随产物交付。在跨运行时验证满足发布条件之前，首页不会展示性能宣传数据。",
+  "ui.from.the.blog": "来自博客",
+  "ui.why.tysel.ships.a.narrower.production.contract": "为什么 Tysel 聚焦于更明确的生产交付约定。",
+  "ui.all.posts": "全部文章 →",
+  "ui.release": "发布 ·",
+  "ui.read.the.announcement": "阅读公告 →",
+  "ui.from.typescript.source.to.one.production.artifact": "将 TypeScript 源码交付为单个生产产物。",
+  "ui.build.your.first.service": "构建第一个服务",
+  "ui.run.the.durable.agent.example": "运行持久智能体示例",
+  "ui.compatibility.evidence": "兼容性与验证结果",
+  "ui.security.model": "安全模型",
+  "ui.production.operations": "生产运维",
+  "ui.ci.admission": "CI 准入",
+  "ui.a.fetch.handler.is.the.whole.application": "一个 Fetch 处理函数就是完整应用。",
+  "ui.package.the.app.and.native.runtime.together": "将应用与原生运行时一起打包。",
+  "ui.no.node.js.v8.or.node.modules.on": "目标环境无需 Node.js、V8 或 node_modules。",
+  "ui.paused": "已暂停",
+  "ui.replay": "循环播放",
+  "ui.verify.the.toolchain": "检查工具链",
+  "ui.confirm.tysel.tysel.service.and.tysel.worker.are": "确认 PATH 中同时包含 tysel、tysel-service 和 tysel-worker。",
+  "ui.create.a.project": "创建项目",
+  "ui.writes.src.index.ts.tests.and.tysel.toml": "生成 src/index.ts、测试和 tysel.toml，不覆盖已有文件。",
+  "ui.validate.configuration": "验证配置",
+  "ui.the.manifest.is.the.contract.entry.profile.permissions": "清单定义应用约定：入口、执行配置、权限和限制。",
+  "ui.check.and.test": "检查与测试",
+  "ui.type.capability.import.and.isolate.tests.before.you": "打包前完成类型、能力、导入和隔离测试。",
+  "ui.run.then.ship.one.file": "运行并交付单个文件",
+  "ui.reload.in.development.then.emit.one.executable.plus": "开发时自动重载，发布时生成可执行文件与验证结果。",
+  "ui.node.js.is.optional.for.editor.declarations.the": "Node.js 仅用于可选的编辑器类型声明，打包后的应用无需依赖它。",
+  "ui.paused.67": "已暂停。",
+  "ui.hover.to.pause": "悬停即可暂停。",
+  "ui.then.run": "然后运行",
+  "ui.no.rust.node.js.or.npm.on.the": "。机器上无需安装 Rust、Node.js 或 npm。",
+  "ui.http.service": "HTTP 服务",
+  "ui.a.fetch.handler.is.enough.for.a.first": "一个 Fetch 处理函数即可构建自有服务。只有调用宿主能力时才需要授权。",
+  "ui.service.no.host.capability.required": "service · 无需宿主能力授权",
+  "ui.durable.agent": "持久智能体",
+  "ui.llm.call.human.approval.then.resume.after.restart": "LLM 调用、人工审批、重启后恢复；已完成的副作用复用已有结果。",
+  "ui.service.durable.store.llm.declared.secret": "service · 持久存储 + LLM + 已声明机密信息",
+  "ui.llm.call": "LLM 调用",
+  "ui.generation.goes.through.the.host.model.aliases.and": "由宿主代理生成请求，模型别名和凭据与应用源码分离。",
+  "ui.service.provider.config.declared.secret": "service · 提供方配置 + 已声明机密信息",
+  "ui.mcp.tool": "MCP 工具",
+  "ui.validated.json.tools.over.bounded.stdio.isolated.workers": "通过受限标准输入输出提供经过验证的 JSON 工具，隔离工作进程只能获得代理机密信息句柄。",
+  "ui.isolated.brokered.secret.handle.only": "isolated · 仅允许代理机密信息句柄",
+  "ui.sqlite.worker": "SQLite 工作进程",
+  "ui.local.state.through.a.runtime.owned.client.the": "通过运行时管理的客户端访问本地状态，路径受授权约束，不能任意访问工作目录。",
+  "ui.service.runtime.relative.sqlite.grant": "service · 相对运行时路径的 SQLite 授权",
+  "ui.postgres.service": "Postgres 服务",
+  "ui.query.a.named.database.the.connection.url.stays": "查询具名数据库。连接地址保留在宿主中，应用仅使用授权名称。",
+  "ui.service.named.postgres.grant.e.g.main.read": "service · 具名 Postgres 授权（如 main:read-write）",
+  "ui.inbound.upgrades.need.an.explicit.server.flag.outbound": "入站升级需显式启用服务器配置，出站连接遵循 fetch 白名单。",
+  "ui.filesystem": "文件系统",
+  "ui.utf.8.read.and.write.only.beneath.manifest": "仅可在清单指定根目录下读写 UTF-8 文件，不提供任意文件系统访问。",
+  "ui.service.matching.fs.read.fs.write.roots": "service · 匹配 fs_read / fs_write 根目录",
+  "ui.wasm.component": "Wasm 组件",
+  "ui.a.language.neutral.one.shot.json.task.through": "通过组件模型执行与语言无关的单次 JSON 任务。默认拒绝访问，目前为实验功能。",
+  "ui.component.experimental.isolated.task.trust": "component · 实验功能 · 隔离任务信任模型",
+  "ui.services": "服务",
+  "ui.web.request.response.entrypoint": "Web Request / Response 入口",
+  "ui.inbound.upgrade.or.allowlisted.client": "入站升级或白名单内的客户端连接",
+  "ui.scheduled.and.queued.task.handlers": "定时与队列任务处理函数",
+  "ui.agents": "智能体",
+  "ui.effects.sleep.signals.resume": "副作用、休眠、信号与恢复",
+  "ui.host.brokered.model.generation": "宿主代理的模型生成",
+  "ui.mcp.tasks": "MCP 任务",
+  "ui.bounded.stdio.tools.with.validation": "经过验证的受限标准输入输出工具",
+  "ui.host.grants": "宿主授权",
+  "ui.opaque.handles.never.plaintext.env": "不透明句柄，不暴露明文环境变量",
+  "ui.named.grant.bound.sql.clients": "具名且受授权约束的 SQL 客户端",
+  "ui.read.write.under.pinned.roots": "在指定根目录下读写",
+  "ui.web.api.first.application.surface": "以 Web API 为先的应用接口",
+  "ui.outbound.http.on.an.allowlist": "白名单内的出站 HTTP 请求",
+  "ui.web.crypto.subset.no.node.crypto": "Web Crypto 子集，不包含 Node crypto",
+  "ui.wasm.components": "Wasm 组件",
+  "ui.one.shot.json.task.world": "单次 JSON 任务接口",
+  "ui.guest.types.and.dispatcher": "客户程序类型与分发器",
+  "ui.generated.bindings": "生成的绑定",
+  "ui.contracts": "接口约定",
+  "ui.manifest.grants.and.reductions": "清单授权与权限收紧",
+  "ui.effective.authority.and.limits": "实际生效的权限与限制",
+  "ui.handlers.in.a.fresh.isolate": "在全新隔离实例中运行处理函数",
+  "ui.docs": "文档 →",
+  "ui.grant": "授权 ·",
+  "ui.reference.recipe": "参考用法",
+  "ui.lookup.by.contract": "按接口约定查阅",
+  "ui.each.link.is.an.exact.interface.page.accepted": "每个链接对应具体接口说明，涵盖可接受值、默认值及执行配置仍可拒绝的操作。",
+  "ui.api.reference": "API 参考 →",
+  "ui.shell.child.processes.ffi.and.dynamic.libraries.are": "Shell、子进程、FFI 和动态库不属于应用约定的范围。参阅",
+  "ui.capability.matrix": "能力矩阵",
+  "ui.execution.profiles": "执行配置",
+  "ui.and": "，以及",
+  "ui.example.gallery": "示例库",
+  "ui.open.example": "打开示例 →",
+  "ui.ci.admission.linux.x64": "CI 准入 · Linux x64",
+  "ui.clear": "通过",
+  "ui.sample.layout": "示例布局",
+  "ui.waiting.on.ci": "等待 CI 数据",
+  "ui.not.a.ci.claim": "非 CI 实测结果",
+  "ui.illustrative.snapshot": "示意快照",
+  "ui.ci.run": "CI 运行",
+  "ui.fetched": "获取时间",
+  "ui.gates.stay.public.measured.cells.fill.from": "准入标准公开，实测数据来自",
+  "ui.admit.on.p50.linux.pss.regression.budget.not": "按 p50 准入 · Linux PSS · 回归预算，不代表容量",
+  "ui.runtime.microbenchmarks": "运行时微基准测试",
+  "ui.same.run.not.release.gates": "同次运行 · 不作为发布门槛",
+  "ui.observational.only.they.never.fail.a.release.and": "仅用于观测，不会阻止发布，也不代表生产吞吐量。数值单位为毫秒。",
+  "ui.metric": "指标",
+  "ui.on.this.page": "本页目录",
+  "ui.lock.the.environment": "固定环境",
+  "ui.pin.runtime.versions.and.hashes.reject.dirty.trees": "固定运行时版本和哈希，排除未提交改动、有负载的宿主及异常 CPU 配置。",
+  "ui.rotate.every.runtime": "轮换运行顺序",
+  "ui.run.node.js.bun.deno.and.tysel.in": "以四种顺序运行 Node.js、Bun、Deno 和 Tysel，避免某个运行时始终受益于固定位置。",
+  "ui.prove.both.architectures": "验证两种架构",
+  "ui.complete.three.record.cycles.on.dedicated.linux.x86": "在专用 Linux x86_64 和 arm64 执行器上完成三轮记录，不将不同架构合并排名。",
+  "ui.replicate.externally": "从外部复现",
+  "ui.repeat.the.workload.from.a.separate.load.host": "使用记录中的同一服务器二进制，从独立压测主机复现负载，再将对比结果发布到此页。",
+  "ui.release.guards": "发布保护",
+  "ui.shown": "已展示",
+  "ui.runtime.suites": "运行时测试集",
+  "ui.observe": "观测",
+  "ui.cross.runtime": "跨运行时",
+  "ui.withheld": "暂未发布",
+  "ui.seven.gates.ci.measured": "七项准入检查，CI 实测。",
+  "ui.seven.gates.sample.layout": "七项准入检查，示例布局。",
+  "ui.seven.gates.waiting.on.data": "七项准入检查，等待数据。",
+  "ui.illustrative.layout.only.not.a.published.ci.claim": "仅为示意布局，并非已发布的 CI 实测结果。",
+  "ui.fixed.runner.regression.gates.not.a.production.performance": "固定执行器上的回归检查，不代表生产性能 SLA。",
+  "ui.ladder": "验证层级",
+  "ui.reproduce.locally": "本地复现",
+  "ui.release.mode.clean.tree.time.gates.admit.on": "使用发布模式和干净工作区。耗时检查按 p50 准入，测试集仍可报告 p95/p99。启动测试使用热页缓存，预热 2 次后采样 11 次。内存以 Linux PSS 为准。",
+  "ui.release.evidence": "发布验证材料",
+  "ui.performance.documentation": "性能文档",
+  "ui.benchmark.source": "基准测试源码 ↗",
+  "ui.raw.evidence.json": "原始验证 JSON",
+  "ui.evidence.reference": "验证结果参考",
+  "ui.cross.runtime.publication.contract": "跨运行时结果发布约定",
+  "ui.separate.bar.for.public.comparisons.not.these.ci": "公开对比需满足独立标准，不等同于这些 CI 检查。",
+  "ui.expand": "展开 →",
+  "ui.collapse": "收起",
+  "ui.no.cross.runtime.winner.is.published.yet.the": "尚未发布跨运行时排名。统一的 Node.js、Bun、Deno 和 Tysel 测试框架已公开，两种架构均完成上述步骤后才会公布结果。",
+  "ui.comparison.protocol": "对比测试协议 ↗",
+  "ui.looking.for.the.product.story.start.on": "想了解产品？请访问",
+  "ui.post": "文章",
+  "ui.min.read": "分钟阅读 ·",
+  "ui.next": "下一步",
+  "ui.get.started": "开始使用 →",
+  "ui.install.the.toolchain.and.ship.a.hello.service": "安装工具链并交付 hello-service 可执行文件。",
+  "ui.read.the.docs.186": "阅读文档 →",
+  "ui.concepts.capabilities.durable.work.and.operations": "了解概念、能力、持久任务与运维。",
+  "ui.browse.the.runtime.examples.and.release.evidence": "浏览运行时、示例与发布验证材料。",
+  "ui.all.posts.189": "← 全部文章",
+  "ui.tysel.blog": "Tysel 博客",
+  "ui.notes.on.shipping.typescript.as.a.binary": "关于将 TypeScript 交付为可执行文件的实践记录。",
+  "ui.rss.feed": "RSS 订阅 →",
+  "ui.featured": "精选 ·",
+  "ui.min.read.194": "分钟阅读",
+  "ui.read.the.post": "阅读文章 →",
+  "ui.earlier": "往期文章",
+  "ui.fetch.style.service.on.the.web.api.runtime": "基于 Web API 运行时的 Fetch 风格服务。",
+  "ui.queue.worker": "队列工作进程",
+  "ui.service.with.one.named.queue.handler": "包含一个具名队列处理函数的服务。",
+  "ui.isolated.mcp.stdio.tool.with.validated.input": "支持输入验证的隔离 MCP 标准输入输出工具。",
+  "ui.minimal.service": "最小服务",
+  "ui.smallest.fetch.handler.for.custom.application.structure": "用于自定义应用结构的最小 Fetch 处理函数。",
+  "ui.guide": "指南",
+  "ui.contract": "接口约定",
+  "ui.create.a.starter.or.open.an.exact.example": "创建入门项目，或打开具体示例。",
+  "ui.use.a.built.in.template.when.starting.a": "新项目可从内置模板开始。需要完整了解 WebSocket、Postgres、持久执行或 Wasm 等能力时，请使用与版本匹配的仓库示例。",
+  "ui.start.from.a.built.in.template": "从内置模板开始",
+  "ui.these.commands.create.the.project.before.validating.and": "这些命令会先创建项目，再验证并运行。选择最接近需求的应用模板，然后添加显式能力授权。",
+  "ui.init.reference": "初始化命令参考",
+  "ui.download.version.matched.examples": "下载与版本匹配的示例",
+  "ui.replace": "将",
+  "ui.with.another.directory.listed.below.this.downloads.application": "替换为下方列出的其他目录。直接下载应用源码，无需 fork、克隆仓库或在本地构建 Tysel。",
+  "ui.start.with.the.durable.path": "从持久执行开始",
+  "ui.requires.a.real.openai.compatible.endpoint.see.the": "需要真实的 OpenAI 兼容端点；请参阅 README 中的",
+  "ui.development.source": "开发源码",
+  "ui.durable.execution": "持久执行",
+  "ui.durable.api": "持久执行 API",
+  "ui.one.installed.toolchain": "一套已安装的工具链",
+  "ui.install.tysel.once.then.use.the.same": "安装一次 Tysel，即可在所有示例项目中使用同一个",
+  "ui.command.in.every.example.project.the.managed.installation": "命令。托管安装已包含匹配的服务运行时和隔离工作进程，无需构建仓库或覆盖工作进程路径。",
+  "ui.installation.guide": "安装指南",
+  "ui.effective.profile.default": "实际生效的默认执行配置。",
+  "ui.supported.no.dedicated.tree.yet": "已支持，暂未提供独立示例目录",
+  "ui.these.apis.ship.today.they.are.reference.recipes": "这些 API 已可使用。以下为参考用法，并非端到端验收示例。",
+  "ui.recipe.contract.only": "参考用法 · 仅接口约定",
+  "ui.shell.child.processes.ffi.and.dynamic.libraries.stay": "Shell、子进程、FFI 和动态库不属于应用约定的范围。参阅",
+  "ui.and.227": "与",
+  "ui.docs.gallery": "文档示例库",
+  "ui.runnable": "可运行",
+  "ui.experimental": "实验功能",
+  "ui.recipe": "参考用法",
+  "ui.after.opening.the.example.directory": "打开示例目录后运行",
+  "common.copy": "复制",
+  "common.copied": "已复制",
+  "nav.openMenu": "打开菜单",
+  "nav.closeMenu": "关闭菜单",
+  "theme.light": "切换为浅色主题",
+  "theme.dark": "切换为深色主题",
+  "ui.tysel.workload.examples": "Tysel 工作负载示例",
+  "ui.start.an.llm.draft.suspend.for.human.approval": "生成 LLM 草稿，挂起等待人工审批，重启进程后恢复，并保存一次结果。",
+  "ui.llm.secret.sqlite.durable.execution": "LLM · 机密信息 · SQLite · 持久执行",
+  "ui.trusted.first.party.http.apps.labels.name.the": "可信的自有 HTTP 应用，标签标明各示例实际使用的能力。",
+  "ui.the.service.profile.currently.defaults.to.durable.store": "service 执行配置当前默认使用 durable.store = \"sqlite\" 和 ./data/tysel.db，即使示例未调用 SQLite 也是如此。运行 tysel inspect 可查看完整生效配置。",
+  "ui.hello.service": "Hello 服务",
+  "ui.minimal.fetch.handler.and.one.executable.build": "最小 Fetch 处理函数与单文件构建。",
+  "ui.web.api.first.npm.router.compatibility.is.scanned": "以 Web API 为先的 npm 路由库，通过扫描确认兼容性。",
+  "ui.websocket.service": "WebSocket 服务",
+  "ui.http.1.1.upgrade.and.bounded.text.echo": "HTTP/1.1 升级与有界文本回显。",
+  "ui.http.inbound.websocket": "HTTP · 入站 WebSocket",
+  "ui.persistent.counter.through.a.runtime.owned.grant.bound": "通过运行时管理且受授权约束的客户端实现持久计数器。",
+  "ui.named.database.grant.the.url.stays.in.the": "使用具名数据库授权，连接地址保留在宿主环境中。",
+  "ui.redis.service": "Redis 服务",
+  "ui.bounded.cache.operations.through.a.named.host.injected": "通过宿主注入的具名 Redis 授权执行有界缓存操作。",
+  "ui.filesystem.transform": "文件转换",
+  "ui.read.and.write.utf.8.files.beneath.separate": "在分别指定的根目录下读写 UTF-8 文件。",
+  "ui.filesystem.read.filesystem.write": "文件读取 · 文件写入",
+  "ui.cron.and.queue": "定时与队列",
+  "ui.scheduled.and.produced.json.work.on.the.bounded": "通过受限任务通道执行定时和主动投递的 JSON 任务。",
+  "ui.task.worker": "任务工作进程",
+  "ui.utc.cron.registration.and.one.named.queue.consumer": "UTC Cron 注册与一个具名队列消费者。",
+  "ui.agents.and.tools": "智能体与工具",
+  "ui.work.that.must.survive.restarts.or.run.as": "重启后仍需恢复的任务，或作为隔离 MCP 工具运行的任务。",
+  "ui.llm.service": "LLM 服务",
+  "ui.host.configured.provider.alias.with.credential.isolation.and": "使用宿主配置的提供方别名，隔离凭据并记录用量元数据。",
+  "ui.llm.provider.secret": "LLM · 提供方机密信息",
+  "ui.validated.json.tool.over.bounded.stdio.returns.an": "经验证的受限标准输入输出 JSON 工具，仅返回不透明机密信息句柄。",
+  "ui.mcp.brokered.secret": "MCP · 代理机密信息",
+  "ui.isolation.and.wasm": "隔离与 Wasm",
+  "ui.separate.worker.process.or.a.language.neutral.one": "独立工作进程，或与语言无关的单次组件任务。",
+  "ui.isolated.plugin": "隔离插件",
+  "ui.fetch.handler.under.the.isolated.profile.manifest.grants": "在 isolated 执行配置下运行 Fetch 处理函数，清单中的宿主能力授权仍被拒绝。",
+  "ui.host.capabilities.denied": "拒绝宿主能力",
+  "ui.rust.component": "Rust 组件",
+  "ui.one.shot.json.task.via.tysel.component.task": "通过 tysel:component/task@0.4.0 执行单次 JSON 任务。",
+  "ui.json.task.no.ambient.wasi": "JSON 任务 · 无隐式 WASI 权限",
+  "ui.after.building.the.rust.starter": "构建 Rust 入门项目后运行",
+  "ui.starter.guide": "入门指南",
+  "ui.go.component": "Go 组件",
+  "ui.same.component.world.with.committed.go.bindings": "使用相同组件接口，包含已提交的 Go 绑定。",
+  "ui.after.building.the.go.starter": "构建 Go 入门项目后运行",
+  "ui.handler.tests": "处理函数测试",
+  "ui.invoke.fetch.handlers.in.a.fresh.isolate": "在全新隔离实例中调用 Fetch 处理函数。",
+  "ui.fresh.startup": "进程启动",
+  "ui.p50.spawn.listen.2.warm.ups.11.samples": "创建进程至监听的 p50 · 预热 2 次、采样 11 次 · 热页缓存",
+  "ui.idle.pss": "空闲 PSS",
+  "ui.single.pss.sample.400ms.after.listen": "监听后约 400ms 采集一次 PSS",
+  "ui.executable.size": "可执行文件大小",
+  "ui.uncompressed.on.disk.hello.service.binary": "磁盘上未压缩的 hello-service 可执行文件",
+  "ui.isolate.create": "创建隔离实例",
+  "ui.p50.in.process.create.not.pool.reuse": "进程内创建耗时 p50 · 非池复用",
+  "ui.reuse.growth": "复用内存增长",
+  "ui.single.before.after.pss.delta.1.000.reuses": "复用 1,000 次前后的单次 PSS 差值",
+  "ui.queue.delta": "队列内存增量",
+  "ui.in.memory.scheduler.pss.delta.10k.tasks": "内存调度器 PSS 增量 · 1 万个任务",
+  "ui.p50.on.in.memory.sqlite.not.disk.or": "内存 SQLite 的 p50 · 非磁盘或 Postgres",
+  "ui.isolates": "隔离实例",
+  "ui.single.host.lifecycle.microbenchmarks.process.spawn.request.dispatch": "单机生命周期微基准：进程创建、请求分发与崩溃替换。",
+  "ui.worker.process.spawn": "创建工作进程",
+  "ui.p50.supervisor.spawn.worker.ready": "监控进程创建至工作进程就绪的 p50",
+  "ui.warm.pool.request": "预热池请求",
+  "ui.p50.full.request.through.a.pre.warmed.isolated": "通过预热隔离池完成完整请求的 p50",
+  "ui.crash.replace": "崩溃替换",
+  "ui.p50.replacement.after.isolate.crash": "隔离实例崩溃后替换耗时 p50",
+  "ui.tasks": "任务",
+  "ui.in.memory.scheduler.microbenchmarks.not.database.or.distributed": "内存调度器微基准，不代表数据库或分布式吞吐量。",
+  "ui.enqueue.10k": "入队 1 万个任务",
+  "ui.p50.time.to.enqueue.10.000.in.memory": "1 万个内存任务入队耗时 p50",
+  "ui.claim.commit": "领取与提交",
+  "ui.p50.claim.commit.for.1.000.in.memory": "1,000 个内存任务领取与提交耗时 p50",
+  "ui.crash.requeue": "崩溃后重新入队",
+  "ui.p50.requeue.after.worker.crash": "工作进程崩溃后重新入队耗时 p50",
+  "ui.durable": "持久执行",
+  "ui.in.memory.sqlite.except.the.explicitly.file.backed": "使用内存 SQLite，明确标注的文件存储重启恢复场景除外。",
+  "ui.sqlite.append.32.events": "SQLite 追加 · 32 个事件",
+  "ui.p50.append.on.in.memory.sqlite": "内存 SQLite 追加耗时 p50",
+  "ui.replay.1.000.effects": "回放 · 1,000 个副作用",
+  "ui.p50.replay.on.in.memory.sqlite": "内存 SQLite 回放耗时 p50",
+  "ui.file.backed.restart": "文件存储重启",
+  "ui.p50.reopen.replay.of.16.events.on.temporary": "临时 SQLite 重新打开并回放 16 个事件的 p50",
+  "ui.loopback.microbenchmarks.with.explicit.connection.and.batch.boundaries": "连接和批次边界明确的回环微基准，不代表外部吞吐量。",
+  "ui.json.1.kib.new.h1": "JSON 1 KiB · 新建 H1 连接",
+  "ui.p50.tcp.connect.request.full.response": "TCP 连接、请求与完整响应耗时 p50",
+  "ui.websocket.connect.echo": "WebSocket 连接与回显",
+  "ui.p50.handshake.one.echo.close": "握手、一次回显与关闭耗时 p50",
+  "ui.h1.100.request.batch": "H1 · 100 个请求批次",
+  "ui.p50.wall.time.until.all.100.concurrent.new": "100 个并发新连接请求全部完成的实际耗时 p50",
+  "ui.pass": "通过",
+  "ui.fail": "失败",
+  "ui.skip": "跳过",
+  "ui.open": "待测",
+  "ui.demo": "示例",
+  "locale.label": "语言",
+  "locale.original": "阅读英文原文",
+  "locale.untranslated": "此页面暂未提供所选语言版本。",
+  "site.description": "面向服务与智能体的原生 TypeScript 运行时。单个可执行文件、显式能力授权，以及重启后可恢复的持久任务。",
+  "fumadocs.Ask AI(AI chat button)": "询问 AI",
+  "fumadocs.Back to Home(404 page)": "返回首页",
+  "fumadocs.Choose a language(language switcher)": "选择语言",
+  "fumadocs.Choose a language(language switcher)(aria-label)": "选择语言",
+  "fumadocs.Close Banner(banner)(aria-label)": "关闭横幅",
+  "fumadocs.Close Search(search dialog)(aria-label)": "关闭搜索",
+  "fumadocs.Close Sidebar(aria-label)": "关闭侧边栏",
+  "fumadocs.Close Sidebar(sidebar)(aria-label)": "关闭侧边栏",
+  "fumadocs.Collapse Sidebar(sidebar)(aria-label)": "收起侧边栏",
+  "fumadocs.Copied Text(code block)(aria-label)": "文本已复制",
+  "fumadocs.Copy Anchor Link(heading anchor)(aria-label)": "复制锚点链接",
+  "fumadocs.Copy Link(accordion)(aria-label)": "复制链接",
+  "fumadocs.Copy Markdown(page actions)": "复制 Markdown",
+  "fumadocs.Copy Text(code block)(aria-label)": "复制文本",
+  "fumadocs.Dark(theme switcher)(aria-label)": "深色",
+  "fumadocs.Default(type table)": "默认值",
+  "fumadocs.Edit on GitHub(edit page)": "在 GitHub 上编辑",
+  "fumadocs.Hide Sidebar(sidebar)": "隐藏侧边栏",
+  "fumadocs.Last updated on(page footer)": "最后更新于",
+  "fumadocs.Layout Tab(layout tab trigger)": "布局标签页",
+  "fumadocs.Light(theme switcher)(aria-label)": "浅色",
+  "fumadocs.Next Page(pagination)": "下一页",
+  "fumadocs.No Headings(table of contents)": "暂无标题",
+  "fumadocs.No results found(search dialog)": "未找到结果",
+  "fumadocs.On this page(table of contents)": "本页目录",
+  "fumadocs.Open Search(search trigger)(aria-label)": "打开搜索",
+  "fumadocs.Open Sidebar(sidebar)(aria-label)": "打开侧边栏",
+  "fumadocs.Open in ChatGPT(page actions)": "在 ChatGPT 中打开",
+  "fumadocs.Open in Claude(page actions)": "在 Claude 中打开",
+  "fumadocs.Open in Cursor(page actions)": "在 Cursor 中打开",
+  "fumadocs.Open in GitHub(page actions)": "在 GitHub 中打开",
+  "fumadocs.Open in Scira AI(page actions)": "在 Scira AI 中打开",
+  "fumadocs.Open(page actions)": "打开",
+  "fumadocs.Page Not Found(404 page)": "页面不存在",
+  "fumadocs.Parameters(type table)": "参数",
+  "fumadocs.Previous Page(pagination)": "上一页",
+  "fumadocs.Prop(type table)": "属性",
+  "fumadocs.Read {url}, I want to ask questions about it.(page actions)": "请阅读 {url}，我想询问相关问题。",
+  "fumadocs.Returns(type table)": "返回值",
+  "fumadocs.Search(search dialog)": "搜索",
+  "fumadocs.Search(search trigger)": "搜索",
+  "fumadocs.Show Sidebar(sidebar)": "显示侧边栏",
+  "fumadocs.System(theme switcher)(aria-label)": "跟随系统",
+  "fumadocs.Table of Contents(inline table of contents)": "目录",
+  "fumadocs.The page you are looking for might have been removed, had its name changed, or is temporarily unavailable.(404 page)": "你访问的页面可能已被删除、重命名或暂时不可用。",
+  "fumadocs.Toggle Menu(mobile menu)(aria-label)": "切换菜单",
+  "fumadocs.Toggle Theme(theme switcher)(aria-label)": "切换主题",
+  "fumadocs.Type(type table)": "类型",
+  "fumadocs.View as Markdown(page actions)": "查看 Markdown",
+  "fumadocs.displayName": "简体中文",
+  "site.title": "Tysel — 编写 TypeScript，交付可执行文件。",
+  "blog.description": "Tysel 团队的发布说明、运行时设计笔记与生产实践指南。"
+}
diff --git a/website/package.json b/website/package.json
index 52e1493..0c0f5c9 100644
--- a/website/package.json
+++ b/website/package.json
@@ -8,12 +8,17 @@
     "import:docs": "node scripts/import-docs.mjs",
     "check:docs-contracts": "node scripts/check-docs-contracts.mjs",
     "test:benchmarks": "node --experimental-strip-types --test test/build-admission-board.test.mjs",
-    "predev": "node scripts/sync-brand.mjs && node scripts/import-docs.mjs",
-    "prebuild": "node scripts/sync-brand.mjs && node scripts/import-docs.mjs",
+    "prepare:site": "node scripts/sync-brand.mjs && node scripts/import-docs.mjs && node scripts/i18n.mjs prepare",
+    "predev": "pnpm run prepare:site",
+    "prebuild": "pnpm run prepare:site",
     "dev": "next dev --port 4000",
     "build": "next build --webpack",
     "start": "next start --port 4000",
-    "types:check": "next typegen && tsc --noEmit"
+    "types:check": "next typegen && tsc --noEmit",
+    "i18n:export": "node scripts/i18n.mjs export",
+    "i18n:import": "node scripts/i18n.mjs import",
+    "i18n:check": "node scripts/i18n.mjs check",
+    "test:i18n": "node --test test/i18n*.test.mjs"
   },
   "dependencies": {
     "cnfast": "^0.1.0",
diff --git a/website/scripts/check-localized-html.py b/website/scripts/check-localized-html.py
new file mode 100644
index 0000000..9d61ffd
--- /dev/null
+++ b/website/scripts/check-localized-html.py
@@ -0,0 +1,85 @@
+"""Validate the built locale pages, including stable section links (run after build)."""
+import json
+from html.parser import HTMLParser
+from pathlib import Path
+from urllib.parse import unquote, urlsplit
+
+ROOT = Path(__file__).resolve().parents[1]
+OUT = ROOT / 'out'
+
+class Page(HTMLParser):
+    def __init__(self, text):
+        super().__init__()
+        self.ids = set()
+        self.links = []
+        self.images = []
+        self.metadata = {}
+        self.stack = []
+        self.bad_root = False
+        self.feed(text)
+        self.doctype = text.lower().startswith('<!doctype html>')
+
+    def handle_starttag(self, tag, attrs):
+        values = dict(attrs)
+        if tag == 'html' and self.stack:
+            self.bad_root = True
+        if 'id' in values:
+            self.ids.add(values['id'])
+        if tag == 'img':
+            self.images.append(values.get('src'))
+        if tag == 'meta':
+            self.metadata[values.get('property', values.get('name'))] = values.get('content')
+        if tag == 'a':
+            self.links.append(values.get('href', ''))
+        if tag not in {'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'}:
+            self.stack.append(tag)
+
+    def handle_endtag(self, tag):
+        if tag in self.stack:
+            self.stack = self.stack[:len(self.stack) - 1 - self.stack[::-1].index(tag)]
+
+cache = {}
+def read(file):
+    if file not in cache:
+        cache[file] = Page(file.read_text())
+    return cache[file]
+
+errors = []
+checked = 0
+locales = json.loads((ROOT / 'locales/config.json').read_text())
+for locale, config in locales['locales'].items():
+    if not config['published'] or locale == locales['sourceLocale']:
+        continue
+    files = list((OUT / locale).rglob('*.html'))
+    assert files, f'No static pages for {locale}'
+    for file in files:
+        page = read(file)
+        if not page.doctype or page.bad_root:
+            errors.append(f'{file.relative_to(OUT)}: invalid HTML document root')
+        for href in page.links:
+            if not (href.startswith(f'/{locale}/') or href.startswith('#')):
+                continue
+            url = urlsplit(href)
+            if not url.fragment:
+                continue
+            target = OUT / url.path.lstrip('/') / 'index.html' if url.path else file
+            checked += 1
+            if not target.exists() or unquote(url.fragment) not in read(target).ids:
+                errors.append(f'{file.relative_to(OUT)}: missing anchor {href}')
+    # Blog cards must use each translated article's title, rather than source metadata.
+    listing = (OUT / locale / 'blog/index.html').read_text()
+    for article in (ROOT / f'locales/{locale}/content/blog').glob('*.mdx'):
+        title = next(line[7:].strip().strip('"') for line in article.read_text().splitlines() if line.startswith('title: '))
+        if title not in listing:
+            errors.append(f'{locale}/blog: translated title absent: {title}')
+        rendered = read(OUT / locale / 'blog' / article.stem / 'index.html')
+        cover = next(line[7:].strip().strip('"') for line in article.read_text().splitlines() if line.startswith('cover: '))
+        if cover not in rendered.images or rendered.metadata.get('og:type') != 'article':
+            errors.append(f'{locale}/blog/{article.stem}: article cover or metadata absent')
+        if not rendered.metadata.get('article:published_time') or not rendered.metadata.get('author'):
+            errors.append(f'{locale}/blog/{article.stem}: author or publication metadata absent')
+english = read(OUT / 'index.html')
+if not english.doctype or english.bad_root:
+    errors.append('English home: invalid HTML document root')
+assert not errors, '\n'.join(errors)
+print(f'Localized HTML passed: {checked} section links, document roots and translated blog titles')
diff --git a/website/scripts/check-seo.py b/website/scripts/check-seo.py
new file mode 100644
index 0000000..6c6f89f
--- /dev/null
+++ b/website/scripts/check-seo.py
@@ -0,0 +1,49 @@
+"""Audit sitemap pages and multilingual SEO in the static export."""
+import json
+from pathlib import Path
+from html.parser import HTMLParser
+from urllib.parse import urlsplit
+from xml.etree import ElementTree as ET
+ROOT=Path(__file__).resolve().parents[1]/'out'
+class Page(HTMLParser):
+ def __init__(self,text):
+  super().__init__();self.meta={};self.links=[];self.ld=[];self.capture=False;self.buf='';self.title='';self.intitle=False;self.h1=0;self.lang='';self.feed(text)
+ def handle_starttag(self,t,a):
+  d=dict(a)
+  if t=='html':self.lang=d.get('lang','')
+  if t=='meta':self.meta[d.get('name',d.get('property'))]=d.get('content')
+  if t=='link':self.links.append(d)
+  if t=='title':self.intitle=True
+  if t=='h1':self.h1+=1
+  if t=='script' and d.get('type')=='application/ld+json':self.capture=True;self.buf=''
+ def handle_data(self,s):
+  if self.capture:self.buf+=s
+  if self.intitle:self.title+=s
+ def handle_endtag(self,t):
+  if t=='title':self.intitle=False
+  if t=='script' and self.capture:self.ld.append(json.loads(self.buf));self.capture=False
+urls=[e.text for e in ET.parse(ROOT/'sitemap.xml').iter('{http://www.sitemaps.org/schemas/sitemap/0.9}loc')]
+assert len(urls)==len(set(urls)),'Duplicate sitemap URLs'
+pages={};errors=[]
+for url in urls:
+ path=urlsplit(url).path;f=ROOT/path.lstrip('/')/'index.html'
+ if not f.exists():errors.append(f'{url}: missing output');continue
+ p=Page(f.read_text());pages[url]=p
+ if not p.title or not p.meta.get('description'):errors.append(f'{url}: missing title/description')
+ if p.h1!=1:errors.append(f'{url}: H1 count {p.h1}')
+ if 'noindex' in p.meta.get('robots',''):errors.append(f'{url}: noindex in sitemap')
+ if [x.get('href') for x in p.links if x.get('rel')=='canonical']!=[url]:errors.append(f'{url}: canonical mismatch')
+ if '/docs/' in path or '/reference/' in path or '/blog/' in path or path in ['/','/zh-CN/']:
+  if not p.ld:errors.append(f'{url}: missing structured data')
+  for data in p.ld:
+   for entity in data.get('@graph',[data]):
+    if 'inLanguage' in entity and entity['inLanguage']!=p.lang:errors.append(f'{url}: JSON-LD language mismatch')
+for url,p in pages.items():
+ alts={x['hreflang']:x['href'] for x in p.links if x.get('hreflang')}
+ if alts.get(p.lang)!=url:errors.append(f'{url}: missing self hreflang')
+ for lang,target in alts.items():
+  if target not in pages:errors.append(f'{url}: alternate absent from sitemap: {target}');continue
+  reciprocal={x.get('hreflang'):x.get('href') for x in pages[target].links}
+  if reciprocal.get(p.lang)!=url:errors.append(f'{url}: non-reciprocal hreflang')
+assert not errors,'\n'.join(errors)
+print(f'SEO passed: {len(pages)} sitemap pages, titles/descriptions, H1, canonicals, reciprocal hreflang and JSON-LD')
diff --git a/website/scripts/i18n.mjs b/website/scripts/i18n.mjs
new file mode 100644
index 0000000..abe0d51
--- /dev/null
+++ b/website/scripts/i18n.mjs
@@ -0,0 +1,189 @@
+import { navigationIdentity, localizeNavigation } from "./navigation.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { fileURLToPath } from "node:url";
+
+export const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+export const hash = (text) => crypto.createHash("sha256").update(text).digest("hex");
+const read = (file) => JSON.parse(fs.readFileSync(file, "utf8"));
+export function loadConfig(base = root) {
+  const config = read(path.join(base, "locales/config.json"));
+  if (!config.locales?.[config.sourceLocale]?.published) throw new Error("Source locale must be published");
+  for (const locale of Object.keys(config.locales)) {
+    if (!/^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/.test(locale)) throw new Error(`Invalid locale code: ${locale}`);
+  }
+  return config;
+}
+export function sourceUnits(base = root) {
+  const config = loadConfig(base);
+  const units = Object.entries(read(path.join(base, `locales/${config.sourceLocale}/messages.json`)))
+    .map(([id, source]) => ({ kind: "message", id, source, sourceHash: hash(source) }));
+  const walk = (dir) => fs.existsSync(dir) ? fs.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+    const file = path.join(dir, entry.name);
+    return entry.isDirectory() ? walk(file) : /\.(mdx|json)$/.test(file) ? [file] : [];
+  }) : [];
+  for (const collection of ["docs", "reference", "blog"]) {
+    for (const file of walk(path.join(base, "content", collection))) {
+      const source = fs.readFileSync(file, "utf8");
+      const id = `${collection}/${path.relative(path.join(base, "content", collection), file).split(path.sep).join("/")}`;
+      units.push({ kind: "content", id, source, sourceHash: hash(source) });
+    }
+  }
+  return units;
+}
+export function localeState(locale, base = root) {
+  const dir = path.join(base, "locales", locale);
+  const messages = read(path.join(dir, "messages.json")), manifest = read(path.join(dir, "manifest.json"));
+  if (manifest.version !== 1 || !manifest.messages || !manifest.content) throw new Error(`Invalid manifest: ${locale}`);
+  return { messages, manifest };
+}
+export function exportJob(locale, base = root) {
+  const config = loadConfig(base);
+  if (!Object.hasOwn(config.locales, locale) || locale === config.sourceLocale) throw new Error("Expected a configured target locale");
+  const state = localeState(locale, base);
+  const glossaryFile = path.join(base, "locales", locale, "glossary.json");
+  const glossary = fs.existsSync(glossaryFile) ? read(glossaryFile) : {};
+  return { version: 1, sourceLocale: config.sourceLocale, targetLocale: locale, glossary,
+    instructions: "Translate prose only. Preserve placeholders, code fences, URLs, frontmatter structure, API names, and metadata page identifiers. Return each unit with a translation field. This command never calls a model.",
+    units: sourceUnits(base).filter((unit) => state.manifest[unit.kind === "message" ? "messages" : "content"][unit.id]?.sourceHash !== unit.sourceHash)
+  };
+}
+const placeholders = (text) => [...text.matchAll(/\{([A-Za-z][\w.]*)\}/g)].map((m) => m[1]).sort();
+const fences = (text) => [...text.matchAll(/^(`{3,}|~{3,})[^\n]*\n[\s\S]*?^\1\s*$/gm)].map((m) => m[0]);
+const links = (text) => [...text.matchAll(/\]\(([^)]+)\)/g)].map((m) => m[1]).sort();
+export function validateTranslation(unit, translation) {
+  if (typeof translation !== "string" || !translation.trim()) throw new Error(`Empty translation: ${unit.id}`);
+  if (unit.kind === "message") {
+    if (JSON.stringify(placeholders(unit.source)) !== JSON.stringify(placeholders(translation))) throw new Error(`Placeholder mismatch: ${unit.id}`);
+  } else if (unit.id.endsWith(".mdx")) {
+    if (JSON.stringify(fences(unit.source)) !== JSON.stringify(fences(translation))) throw new Error(`Code blocks changed: ${unit.id}`);
+    if (JSON.stringify(links(unit.source)) !== JSON.stringify(links(translation))) throw new Error(`Link targets changed: ${unit.id}`);
+    const metadata = (text) => {
+      const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+      if (!match) throw new Error(`Missing frontmatter: ${unit.id}`);
+      return match[1].split(/\r?\n(?=[A-Za-z_][\w-]*:)/).filter((block) => !/^(title|description|coverAlt):/.test(block)).join("\n");
+    };
+    if (metadata(unit.source) !== metadata(translation)) throw new Error(`Immutable frontmatter changed: ${unit.id}`);
+  } else {
+    const source = JSON.parse(unit.source), target = JSON.parse(translation);
+    // Page ordering/IDs and navigation behavior are never translation targets.
+    for (const key of new Set([...Object.keys(source), ...Object.keys(target)])) {
+      if (!['title', 'description'].includes(key) && JSON.stringify(key === 'pages' ? source[key]?.map(navigationIdentity) : source[key]) !== JSON.stringify(key === 'pages' ? target[key]?.map(navigationIdentity) : target[key])) throw new Error(`Navigation metadata changed: ${unit.id}:${key}`);
+    }
+  }
+}
+export function importJob(job, { base = root, reviewed = false } = {}) {
+  const config = loadConfig(base);
+  if (job.version !== 1 || job.sourceLocale !== config.sourceLocale || !Object.hasOwn(config.locales, job.targetLocale) || job.targetLocale === config.sourceLocale || !Array.isArray(job.units)) throw new Error("Invalid translation job");
+  const current = new Map(sourceUnits(base).map((unit) => [`${unit.kind}:${unit.id}`, unit]));
+  const seen = new Set(), accepted = [];
+  for (const unit of job.units) {
+    const key = `${unit.kind}:${unit.id}`, source = current.get(key);
+    if (seen.has(key)) throw new Error(`Duplicate unit: ${key}`);
+    seen.add(key);
+    if (!source || source.sourceHash !== unit.sourceHash) throw new Error(`Unknown or stale source: ${key}`);
+    validateTranslation(source, unit.translation);
+    accepted.push({ ...source, translation: unit.translation });
+  }
+  // Validate the whole batch before writing anything. IDs must match known source units.
+  const state = localeState(job.targetLocale, base), dir = path.join(base, "locales", job.targetLocale);
+  for (const unit of accepted) {
+    const entry = { sourceHash: unit.sourceHash, translationHash: hash(unit.translation), status: reviewed ? "reviewed" : "draft" };
+    if (unit.kind === "message") { state.messages[unit.id] = unit.translation; state.manifest.messages[unit.id] = entry; }
+    else {
+      const file = path.join(dir, "content", unit.id);
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      fs.writeFileSync(file, unit.translation);
+      state.manifest.content[unit.id] = entry;
+    }
+  }
+  fs.writeFileSync(path.join(dir, "messages.json"), JSON.stringify(state.messages, null, 2) + "\n");
+  fs.writeFileSync(path.join(dir, "manifest.json"), JSON.stringify(state.manifest, null, 2) + "\n");
+  return accepted.length;
+}
+export function check(base = root) {
+  const config = loadConfig(base), units = sourceUnits(base), issues = [];
+  for (const [locale, settings] of Object.entries(config.locales)) {
+    if (locale === config.sourceLocale) continue;
+    const state = localeState(locale, base);
+    for (const unit of units) {
+      const entry = state.manifest[unit.kind === "message" ? "messages" : "content"][unit.id];
+      const required = settings.published && unit.kind === "message";
+      if (!entry && !required) continue;
+      if (!entry || entry.status !== "reviewed" || entry.sourceHash !== unit.sourceHash) {
+        if (settings.published) issues.push(`${locale}:${unit.kind}:${unit.id} is missing, draft, or stale`);
+        continue;
+      }
+      try {
+        const translation = unit.kind === "message" ? state.messages[unit.id] : fs.readFileSync(path.join(base, "locales", locale, "content", unit.id), "utf8");
+        validateTranslation(unit, translation);
+        if (entry.translationHash !== hash(translation)) throw new Error(`Translation changed since review: ${unit.id}`);
+      } catch (error) { issues.push(`${locale}: ${error.message}`); }
+    }
+    const knownMessages = new Set(units.filter((unit) => unit.kind === "message").map((unit) => unit.id));
+    for (const id of Object.keys(state.messages)) if (!knownMessages.has(id)) issues.push(`${locale}:messages:${id} is unknown`);
+    for (const kind of ["messages", "content"]) {
+      const known = new Set(units.filter((u) => u.kind === (kind === "messages" ? "message" : "content")).map((u) => u.id));
+      for (const id of Object.keys(state.manifest[kind])) if (!known.has(id)) issues.push(`${locale}:${kind}:${id} is orphaned`);
+    }
+  }
+  return issues;
+}
+export function prepare(base = root) {
+  const issues = check(base);
+  if (issues.length) throw new Error(issues.join("\n"));
+  const target = path.join(base, "content/translations");
+  fs.rmSync(target, { recursive: true, force: true });
+  for (const collection of ["docs", "reference", "blog"]) fs.mkdirSync(path.join(target, collection), { recursive: true });
+  const config = loadConfig(base), units = sourceUnits(base);
+  // Next static export rejects empty generateStaticParams. Emit route adapters
+  // only when a target language is published; there are no placeholder URLs.
+  const routeRoot = path.join(base, "app/(localized)");
+  fs.rmSync(routeRoot, { recursive: true, force: true });
+  if (Object.entries(config.locales).some(([locale, settings]) => locale !== config.sourceLocale && settings.published)) {
+    const routes = {
+      "[lang]/template.tsx": 'export { default } from "@/app/(site)/template";\n',
+      "[lang]/layout.tsx": 'export { default, metadata } from "@/lib/i18n/routes/layout";\n',
+      "[lang]/[[...path]]/page.tsx": 'export { default, generateMetadata, generateStaticParams } from "@/lib/i18n/routes/page";\nexport const dynamic = "force-static";\nexport const dynamicParams = false;\n',
+      "[lang]/search.json/route.ts": 'export { GET, generateStaticParams } from "@/lib/i18n/routes/search";\nexport const dynamic = "force-static";\nexport const dynamicParams = false;\n',
+    };
+    for (const [name, source] of Object.entries(routes)) {
+      const file = path.join(routeRoot, name);
+      fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, source);
+    }
+  }
+  for (const [locale, settings] of Object.entries(config.locales)) {
+    if (locale === config.sourceLocale || !settings.published) continue;
+    const state = localeState(locale, base);
+    for (const unit of units.filter((unit) => unit.kind === "content")) {
+      if (!state.manifest.content[unit.id]) continue;
+      const [collection, ...rest] = unit.id.split("/");
+      const to = path.join(target, collection, locale, ...rest);
+      fs.mkdirSync(path.dirname(to), { recursive: true });
+      const from = path.join(base, "locales", locale, "content", unit.id);
+      if (unit.id.endsWith(".json")) {
+        const paths = new Set(Object.keys(state.manifest.content).filter(id => id.endsWith(".mdx")).map(id => "/" + id.replace(/\.mdx$/, "").replace(/\/index$/, "")));
+        fs.writeFileSync(to, JSON.stringify(localizeNavigation(read(from), locale, paths), null, 2) + "\n");
+      } else fs.copyFileSync(from, to);
+    }
+  }
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const [command, ...args] = process.argv.slice(2);
+  const option = (name) => args[args.indexOf(name) + 1];
+  try {
+    if (command === "export") {
+      const output = option("--output");
+      if (!args.includes("--locale") || !args.includes("--output") || !output) throw new Error("Usage: i18n.mjs export --locale zh-CN --output /tmp/job.json");
+      fs.writeFileSync(output, JSON.stringify(exportJob(option("--locale")), null, 2) + "\n");
+      console.log(`Translation job written to ${output}`);
+    } else if (command === "import") {
+      if (!args.includes("--input")) throw new Error("Usage: i18n.mjs import --input /tmp/result.json [--reviewed]");
+      console.log(`Imported ${importJob(read(option("--input")), { reviewed: args.includes("--reviewed") })} units`);
+    } else if (command === "check") {
+      const issues = check(); if (issues.length) throw new Error(issues.join("\n")); console.log("Localization contracts passed");
+    } else if (command === "prepare") { prepare(); console.log("Prepared published translations"); }
+    else throw new Error("Expected export, import, check, or prepare");
+  } catch (error) { console.error(error.message); process.exitCode = 1; }
+}
diff --git a/website/scripts/import-docs.mjs b/website/scripts/import-docs.mjs
index 95e1829..3354e2c 100644
--- a/website/scripts/import-docs.mjs
+++ b/website/scripts/import-docs.mjs
@@ -222,7 +222,8 @@ function escapeMdx(content) {
   const chunks = content.split(/(```[\s\S]*?```)/g);
   return chunks
     .map((chunk, index) => {
-      if (index % 2 === 1) return chunk;
+      // The current highlighter has no gitignore grammar.
+      if (index % 2 === 1) return chunk.replace(/^```gitignore(?=\r?\n)/, "```text");
       return chunk
         .split("\n")
         .map((line) => {
diff --git a/website/scripts/navigation.mjs b/website/scripts/navigation.mjs
new file mode 100644
index 0000000..e3d5203
--- /dev/null
+++ b/website/scripts/navigation.mjs
@@ -0,0 +1,14 @@
+// Preserve route tokens and link targets, while allowing visible labels to change.
+export function navigationIdentity(entry) {
+  if (typeof entry !== 'string') return entry;
+  if (/^---.+---$/.test(entry)) return '---separator---';
+  const link = entry.match(/^\[([^\]]+)\]\(([^)]+)\)$/);
+  return link ? `[](${link[2]})` : entry;
+}
+export function localizeNavigation(metadata, locale, paths) {
+  return { ...metadata, ...(metadata.pages && { pages: metadata.pages.map(entry => {
+    const link = typeof entry === 'string' && entry.match(/^\[([^\]]+)\]\(([^)]+)\)$/);
+    if (!link || !paths.has(link[2].split(/[?#]/)[0].replace(/\/$/, '') || '/')) return entry;
+    return `[${link[1]}](/${locale}${link[2]})`;
+  }) }) };
+}
diff --git a/website/test/i18n-presentation.test.mjs b/website/test/i18n-presentation.test.mjs
new file mode 100644
index 0000000..70fcc2f
--- /dev/null
+++ b/website/test/i18n-presentation.test.mjs
@@ -0,0 +1,23 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { navigationIdentity, localizeNavigation } from '../scripts/navigation.mjs';
+import { validateTranslation } from '../scripts/i18n.mjs';
+import { estimateReadingMinutes } from '../lib/reading-time.mjs';
+test('navigation labels translate without changing destinations or ordering', () => {
+ const source=JSON.stringify({pages:['index','---Start---','[Capabilities](/docs/capabilities)']});
+ const unit={kind:'content',id:'docs/meta.json',source};
+ assert.doesNotThrow(()=>validateTranslation(unit,JSON.stringify({pages:['index','---开始---','[能力](/docs/capabilities)']})));
+ assert.throws(()=>validateTranslation(unit,JSON.stringify({pages:['index','---开始---','[能力](/wrong)']})));
+ assert.throws(()=>validateTranslation(unit,JSON.stringify({pages:['other','---开始---','[能力](/docs/capabilities)']})));
+ assert.equal(navigationIdentity('---开始---'),'---separator---');
+});
+test('navigation prefixes only available translated destinations', () => {
+ const pages=['[能力](/docs/capabilities)','[Missing](/docs/missing)','[External](https://example.com)'];
+ assert.deepEqual(localizeNavigation({pages},'zh-CN',new Set(['/docs/capabilities'])).pages,['[能力](/zh-CN/docs/capabilities)',pages[1],pages[2]]);
+});
+test('reading time counts unspaced Chinese and mixed prose, excluding fenced code', () => {
+ assert.equal(estimateReadingMinutes('文'.repeat(2000)),5);
+ assert.equal(estimateReadingMinutes('word '.repeat(1100)),5);
+ assert.equal(estimateReadingMinutes('文'.repeat(800)+' word '.repeat(440)),4);
+ assert.equal(estimateReadingMinutes('```ts\n'+'文'.repeat(2000)+'\n```'),1);
+});
diff --git a/website/test/i18n-routing.test.mjs b/website/test/i18n-routing.test.mjs
new file mode 100644
index 0000000..39ed6c2
--- /dev/null
+++ b/website/test/i18n-routing.test.mjs
@@ -0,0 +1,35 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import ts from "typescript";
+
+// Compile the actual TS helpers without Next.js or a browser runtime.
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), "tysel-routing-"));
+const config = JSON.parse(fs.readFileSync(new URL("../locales/config.json", import.meta.url), "utf8"));
+for (const name of ["config", "routing"]) {
+  let source = fs.readFileSync(new URL(`../lib/i18n/${name}.ts`, import.meta.url), "utf8");
+  source = source.replace('import config from "../../locales/config.json";', `const config = ${JSON.stringify(config)};`)
+    .replace('from "./config"', 'from "./config.mjs"');
+  fs.writeFileSync(path.join(dir, `${name}.mjs`), ts.transpileModule(source, { compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext } }).outputText);
+}
+const { localePath, splitLocale, availableLocalePath } = await import(pathToFileURL(path.join(dir, "routing.mjs")).href);
+process.on("exit", () => fs.rmSync(dir, { recursive: true, force: true }));
+test("English URL migration preserves the old canonical paths", () => {
+  assert.equal(localePath("/docs/install/", "en"), "/docs/install");
+  assert.equal(localePath("/zh-CN/docs/install/?from=nav#step", "en"), "/docs/install?from=nav#step");
+});
+test("locale prefixing is idempotent and preserves query and fragment", () => {
+  assert.equal(localePath("/", "zh-CN"), "/zh-CN");
+  assert.equal(localePath("/zh-CN/docs/install/?q=a#b", "zh-CN"), "/zh-CN/docs/install?q=a#b");
+  assert.deepEqual(splitLocale("/zh-CN/docs"), { locale: "zh-CN", pathname: "/docs" });
+});
+test("untranslated pages and assets link to original URLs, not invented locale routes", () => {
+  assert.equal(availableLocalePath("/docs/install#step", "zh-CN", ["/", "/docs"]), "/docs/install#step");
+  assert.equal(availableLocalePath("/docs", "zh-CN", ["/docs"]), "/zh-CN/docs");
+  for (const path of ["/rss.xml", "/install.sh", "/benchmark-evidence/latest.json", "https://example.com/docs", "//example.com/docs", "#step", "mailto:a@example.com"]) {
+    assert.equal(availableLocalePath(path, "zh-CN", ["/docs"]), path);
+  }
+});
diff --git a/website/test/i18n.test.mjs b/website/test/i18n.test.mjs
new file mode 100644
index 0000000..3d513ea
--- /dev/null
+++ b/website/test/i18n.test.mjs
@@ -0,0 +1,90 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { hash, sourceUnits, exportJob, importJob, check, prepare } from "../scripts/i18n.mjs";
+
+function fixture(t) {
+  const base = fs.mkdtempSync(path.join(os.tmpdir(), "tysel-i18n-"));
+  t.after(() => fs.rmSync(base, { recursive: true, force: true }));
+  for (const dir of ["locales/en", "locales/zh-CN", "content/docs"]) fs.mkdirSync(path.join(base, dir), { recursive: true });
+  const write = (file, value) => fs.writeFileSync(path.join(base, file), typeof value === "string" ? value : JSON.stringify(value));
+  write("locales/config.json", { sourceLocale: "en", locales: { en: { published: true }, "zh-CN": { published: false } } });
+  write("locales/en/messages.json", { "nav.home": "Home", "greeting": "Hello {name}" });
+  write("locales/zh-CN/messages.json", {});
+  write("locales/zh-CN/manifest.json", { version: 1, messages: {}, content: {} });
+  write("content/docs/index.mdx", '---\ntitle: Documentation\n---\nRead [install](/docs/install).\n\n```sh\ntysel doctor\n```\n');
+  return { base, write, publish() { write("locales/config.json", { sourceLocale: "en", locales: { en: { published: true }, "zh-CN": { published: true } } }); } };
+}
+function result(base) {
+  const job = exportJob("zh-CN", base);
+  // Synthetic fixture output, never repository translations or a model call.
+  return { ...job, units: job.units.map((unit) => ({ ...unit, translation: unit.source })) };
+}
+test("draft locale can be configured with zero translations", (t) => {
+  const { base } = fixture(t);
+  assert.deepEqual(check(base), []);
+  prepare(base);
+  assert.deepEqual(fs.readdirSync(path.join(base, "content/translations/docs")), []);
+  assert.equal(exportJob("zh-CN", base).units.length, 3);
+});
+test("publication requires reviewed, current UI messages", (t) => {
+  const f = fixture(t); f.publish();
+  assert.equal(check(f.base).length, 2);
+  importJob(result(f.base), { base: f.base });
+  assert.match(check(f.base).join("\n"), /draft/);
+});
+test("reviewed partial content prepares separately and English stays intact", (t) => {
+  const f = fixture(t), before = fs.readFileSync(path.join(f.base, "content/docs/index.mdx"), "utf8");
+  importJob(result(f.base), { base: f.base, reviewed: true }); f.publish();
+  assert.deepEqual(check(f.base), []); prepare(f.base);
+  assert.equal(fs.readFileSync(path.join(f.base, "content/translations/docs/zh-CN/index.mdx"), "utf8"), before);
+  assert.equal(fs.readFileSync(path.join(f.base, "content/docs/index.mdx"), "utf8"), before);
+  assert.equal(exportJob("zh-CN", f.base).units.length, 0);
+});
+test("incremental export detects source edits and blocks stale publication", (t) => {
+  const f = fixture(t); importJob(result(f.base), { base: f.base, reviewed: true }); f.publish();
+  f.write("locales/en/messages.json", { "nav.home": "Homepage", greeting: "Hello {name}" });
+  assert.equal(exportJob("zh-CN", f.base).units.length, 1);
+  assert.match(check(f.base).join("\n"), /nav.home.*stale/);
+});
+test("stale, duplicate, and unknown/path traversal units are rejected before writes", (t) => {
+  const { base } = fixture(t), job = result(base);
+  for (const units of [[{ ...job.units[0], sourceHash: "old" }], [job.units[0], job.units[0]], [{ ...job.units[0], kind: "content", id: "../../outside.mdx" }]]) {
+    assert.throws(() => importJob({ ...job, units }, { base }));
+    assert.deepEqual(JSON.parse(fs.readFileSync(path.join(base, "locales/zh-CN/messages.json"))), {});
+  }
+});
+test("placeholders, code blocks, and link destinations cannot silently change", (t) => {
+  const { base } = fixture(t), job = result(base);
+  for (const [find, replace] of [["{name}", "{user}"], ["tysel doctor", "other command"], ["/docs/install", "/other"]]) {
+    const units = job.units.map((unit) => ({ ...unit, translation: unit.translation.replace(find, replace) }));
+    assert.throws(() => importJob({ ...job, units }, { base }));
+  }
+});
+test("publishing a locale does not require all documents to be translated", (t) => {
+  const f = fixture(t), job = result(f.base);
+  importJob({ ...job, units: job.units.filter((unit) => unit.kind === "message") }, { base: f.base, reviewed: true });
+  f.publish(); assert.deepEqual(check(f.base), []); prepare(f.base);
+  assert.deepEqual(fs.readdirSync(path.join(f.base, "content/translations/docs")), []);
+});
+test("removed locale content cannot survive the preparation step", (t) => {
+  const f = fixture(t); importJob(result(f.base), { base: f.base, reviewed: true }); f.publish(); prepare(f.base);
+  f.write("locales/config.json", { sourceLocale: "en", locales: { en: { published: true }, "zh-CN": { published: false } } });
+  prepare(f.base); assert.deepEqual(fs.readdirSync(path.join(f.base, "content/translations/docs")), []);
+});
+test("source fingerprint hashes exact UTF-8 content", (t) => {
+  const { base } = fixture(t);
+  for (const unit of sourceUnits(base)) assert.equal(unit.sourceHash, hash(unit.source));
+});
+test("editing a reviewed translation requires another review", (t) => {
+  const f = fixture(t); importJob(result(f.base), { base: f.base, reviewed: true }); f.publish();
+  f.write("locales/zh-CN/messages.json", { "nav.home": "Modified", greeting: "Hello {name}" });
+  assert.match(check(f.base).join("\n"), /changed since review/);
+});
+test("locale route adapters exist only for published target locales", (t) => {
+  const f = fixture(t); prepare(f.base); assert.equal(fs.existsSync(path.join(f.base, "app/(localized)")), false);
+  importJob(result(f.base), { base: f.base, reviewed: true }); f.publish(); prepare(f.base);
+  assert.equal(fs.existsSync(path.join(f.base, "app/(localized)/[lang]/[[...path]]/page.tsx")), true);
+});

From cb64df09a513129e83700c82ddf0e8059c97550a Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Sun, 6 Sep 2026 08:04:47 +0800
Subject: [PATCH 08/31] fix(runtime): preserve HTTP body bytes within isolate
 memory limits

Use byte-preserving request and response bodies, account HTTP chunks in the QuickJS heap, and normalize response chunk views with independent snapshots.

Avoid intermediate UTF-8 string copies and add memory-limit, binary roundtrip, chunk lifecycle, and throughput coverage.
---
 crates/tysel-engine-qjs/src/host.rs           |  31 +-
 crates/tysel-engine-qjs/src/queue.rs          |  30 +-
 crates/tysel-engine-qjs/src/tests.rs          | 292 ++++++++++++++++++
 .../javascript-runtime-compatibility.md       |  37 ++-
 runtime-js/capability-client/runtime.js       |   8 +-
 runtime-js/capability-client/source/fetch.js  |   8 +-
 runtime-js/web-api/compatibility.json         |   4 +-
 runtime-js/web-api/index.ts                   |   6 +-
 runtime-js/web-api/runtime.js                 | 187 +++++------
 runtime-js/web-api/source/encoding.js         |   2 +-
 runtime-js/web-api/source/http.js             | 185 +++++------
 11 files changed, 581 insertions(+), 209 deletions(-)

diff --git a/crates/tysel-engine-qjs/src/host.rs b/crates/tysel-engine-qjs/src/host.rs
index 5275066..830a881 100644
--- a/crates/tysel-engine-qjs/src/host.rs
+++ b/crates/tysel-engine-qjs/src/host.rs
@@ -90,7 +90,11 @@ fn install_inner(
         "_httpStart",
         Function::new(
             ctx.clone(),
-            move |ctx, url: String, method: String, headers_json: String, body: String| {
+            move |ctx, url: String, method: String, headers_json: String, body: TypedArray<u8>| {
+                let body = bytes::Bytes::copy_from_slice(
+                    body.as_bytes()
+                        .ok_or_else(|| Exception::throw_type(&ctx, "request body is detached"))?,
+                );
                 submit_cancellable(ctx, &io_http_start, |id| IoRequest::HttpGet {
                     id,
                     url,
@@ -130,14 +134,16 @@ fn install_inner(
     tysel.set(
         "_utf8Decode",
         Function::new(ctx.clone(), |ctx, bytes: TypedArray<u8>, fatal: bool| {
-            let Some(raw) = bytes.as_bytes() else {
-                return Ok(String::new());
-            };
+            let raw = bytes.as_bytes().unwrap_or_default();
+            // QuickJS copies the UTF-8 input into its own string storage. Borrow
+            // valid input here instead of allocating an intermediate Rust String.
             if fatal {
-                String::from_utf8(raw.to_vec())
-                    .map_err(|_| Exception::throw_type(&ctx, "UTF-8 decode failed"))
+                let text = std::str::from_utf8(raw)
+                    .map_err(|_| Exception::throw_type(&ctx, "UTF-8 decode failed"))?;
+                rquickjs::String::from_str(ctx, text)
             } else {
-                Ok(String::from_utf8_lossy(raw).into_owned())
+                let text = String::from_utf8_lossy(raw);
+                rquickjs::String::from_str(ctx, &text)
             }
         })?,
     )?;
@@ -464,7 +470,16 @@ pub fn settle(ctx: &Ctx<'_>, id: OpId, result: Result<Value, String>) -> rquickj
     match result {
         Ok(value) => {
             let resolve: Function = entry.get("resolve")?;
-            resolve.call::<(rquickjs::Value<'_>,), ()>((value_to_js(ctx, value)?,))?;
+            // HTTP bytes must use the QuickJS allocator so retained chunks count
+            // against the isolate heap limit. External Vec-backed buffers bypass
+            // that limit. Nested capability values keep their array representation.
+            let value = match value {
+                Value::Bytes(bytes) => {
+                    TypedArray::<u8>::new_copy(ctx.clone(), &bytes)?.into_js(ctx)?
+                }
+                value => value_to_js(ctx, value)?,
+            };
+            resolve.call::<(rquickjs::Value<'_>,), ()>((value,))?;
         }
         Err(error) => {
             if let Ok(reject) = entry.get::<_, Function>("reject") {
diff --git a/crates/tysel-engine-qjs/src/queue.rs b/crates/tysel-engine-qjs/src/queue.rs
index 166ce6e..9596dbe 100644
--- a/crates/tysel-engine-qjs/src/queue.rs
+++ b/crates/tysel-engine-qjs/src/queue.rs
@@ -52,7 +52,7 @@ pub enum IoRequest {
     Echo { id: OpId, value: String },
     SecretRef { id: OpId, name: String },
     ReadBody { id: OpId },
-    HttpGet { id: OpId, url: String, method: String, headers_json: String, body: String },
+    HttpGet { id: OpId, url: String, method: String, headers_json: String, body: Bytes },
     HttpRead { id: OpId, body_id: u64 },
     WsRead { id: OpId },
     WsSend { id: OpId, data: String },
@@ -851,9 +851,14 @@ async fn execute(
         IoRequest::SecretRef { id, name } => {
             IoCompletion { id, result: crate::secrets::refer(&name) }
         }
-        IoRequest::ReadBody { id } => {
-            IoCompletion { id, result: read_chunk(&slots.inbound, &cancel, deadline).await }
-        }
+        IoRequest::ReadBody { id } => IoCompletion {
+            id,
+            result: slots
+                .inbound
+                .read(&cancel, deadline)
+                .await
+                .map(|chunk| chunk.map_or(Value::Null, Value::Bytes)),
+        },
         IoRequest::HttpRead { id, body_id } => IoCompletion {
             id,
             result: read_http_chunk_interruptible(&slots.outbound, body_id, &cancel, deadline)
@@ -865,7 +870,7 @@ async fn execute(
                 &method,
                 &url,
                 &headers_json,
-                &body,
+                body,
                 cancel,
                 deadline,
                 slots.outbound,
@@ -1122,11 +1127,10 @@ async fn read_http_chunk_interruptible(
     cancel: &AtomicBool,
     deadline: Instant,
 ) -> Result<Value, String> {
-    streams.read(body_id, cancel, deadline).await.map(|chunk| {
-        chunk.map_or(Value::Null, |bytes| {
-            Value::String(String::from_utf8_lossy(&bytes).into_owned())
-        })
-    })
+    streams
+        .read(body_id, cancel, deadline)
+        .await
+        .map(|chunk| chunk.map_or(Value::Null, Value::Bytes))
 }
 
 const MAX_REDIRECTS: u8 = 20;
@@ -1141,7 +1145,7 @@ async fn outbound_fetch(
     method: &str,
     url: &str,
     headers_json: &str,
-    body: &str,
+    body: Bytes,
     cancel: Arc<AtomicBool>,
     deadline: Instant,
     outbound: StreamRegistry,
@@ -1218,14 +1222,14 @@ fn normalize_method(method: &str) -> Result<String, String> {
     }
 }
 
-fn request_body(method: &str, body: &str) -> Result<Bytes, String> {
+fn request_body(method: &str, body: Bytes) -> Result<Bytes, String> {
     if method == "GET" || method == "HEAD" {
         return Ok(Bytes::new());
     }
     if body.len() > MAX_OUTBOUND_BODY {
         return Err(format!("request body exceeds {MAX_OUTBOUND_BODY} bytes"));
     }
-    Ok(Bytes::from(body.to_owned()))
+    Ok(body)
 }
 
 async fn fetch_hop(
diff --git a/crates/tysel-engine-qjs/src/tests.rs b/crates/tysel-engine-qjs/src/tests.rs
index a594237..a773a03 100644
--- a/crates/tysel-engine-qjs/src/tests.rs
+++ b/crates/tysel-engine-qjs/src/tests.rs
@@ -2823,3 +2823,295 @@ impl hyper::body::Body for CountedBody {
         Poll::Ready(Some(Ok(Frame::data(Bytes::from(vec![b'x'; COUNTED_CHUNK_LEN])))))
     }
 }
+
+#[test]
+fn byte_bodies_preserve_views_clones_and_consumption() {
+    let value = eval(r#"(async () => {
+      for (const Ctor of [Request, Response]) {
+        const raw = new Uint8Array([99, 0, 255, 128, 65, 99]);
+        const view = new DataView(raw.buffer, 1, 4);
+        const body = Ctor === Request ? new Request('http://local/', {body: view}) : new Response(view);
+        raw.fill(42);
+        const clone = body.clone();
+        const bytes = new Uint8Array(await body.arrayBuffer());
+        if (String(bytes) !== '0,255,128,65' || !body.bodyUsed) return false;
+        bytes.fill(7);
+        if (String(new Uint8Array(await clone.arrayBuffer())) !== '0,255,128,65') return false;
+        try { await body.text(); return false; } catch (e) { if (!(e instanceof TypeError)) return false; }
+      }
+      try { await new Response('').json(); return false; } catch (e) { if (!(e instanceof SyntaxError)) return false; }
+      const bom = new Uint8Array([239,187,191,65]);
+      return await new Response(bom).text() === 'A'
+        && new TextDecoder('utf-8', {ignoreBOM: true}).decode(bom) === '\ufeffA';
+    })()"#, config()).expect("byte body contract");
+    assert_eq!(value, Value::Bool(true));
+}
+
+#[tokio::test]
+async fn inbound_body_preserves_binary_and_split_utf8() {
+    for (source, payload, expected) in [
+        (
+            "export default { async fetch(r) { return new Response(await r.arrayBuffer()); } };",
+            vec![0, 255, 128, 65],
+            vec![0, 255, 128, 65],
+        ),
+        (ECHO_BODY, "中😀".as_bytes().to_vec(), "中😀".as_bytes().to_vec()),
+    ] {
+        let pool = IsolatePool::spawn(1, source, config()).expect("pool");
+        let (tx, rx) = tokio::sync::mpsc::channel(STREAM_WINDOW);
+        for byte in payload {
+            tx.send(Ok(vec![byte])).await.unwrap();
+        }
+        drop(tx);
+        let (_, mut body) = pool
+            .dispatch_incoming(IncomingHttp {
+                method: "POST".into(),
+                url: "http://tysel.local/".into(),
+                headers: vec![],
+                body: rx,
+                ws_in: None,
+                ws_out: None,
+                request_id: 0,
+            })
+            .await
+            .expect("dispatch");
+        let mut actual = Vec::new();
+        while let Some(chunk) = body.recv().await {
+            actual.extend(chunk);
+        }
+        assert_eq!(actual, expected);
+    }
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn fetch_binary_roundtrip_preserves_all_bytes_and_upload_snapshot() {
+    let addr = spawn_origin(|request: HyperRequest<hyper::body::Incoming>| async move {
+        let bytes = request.into_body().collect().await.unwrap().to_bytes();
+        Ok::<_, Infallible>(Response::new(http_body_util::Full::new(bytes)))
+    });
+    let source = format!(
+        r#"(async () => {{
+      for (const size of [0, 256, 262144]) {{
+        for (const asRequest of [false, true]) {{
+          const backing = new Uint8Array(size + 2);
+          const bytes = new Uint8Array(backing.buffer, 1, size);
+          for (let i = 0; i < size; i++) bytes[i] = i & 255;
+          const request = asRequest ? new Request('http://{addr}/', {{method: 'POST', body: bytes}}) : null;
+          const pending = request ? fetch(request) : fetch('http://{addr}/', {{method: 'POST', body: bytes}});
+          bytes.fill(42);
+          const response = await pending;
+          const actual = new Uint8Array(await response.arrayBuffer());
+          if (actual.length !== size || !response.bodyUsed || (request && !request.bodyUsed)) return false;
+          for (let i = 0; i < size; i++) if (actual[i] !== (i & 255)) return false;
+        }}
+      }}
+      return true;
+    }})()"#
+    );
+    let value = tokio::task::spawn_blocking(move || {
+        eval(&source, IsolateConfig { cpu_ms_per_turn: 500, ..config() })
+    })
+    .await
+    .unwrap()
+    .expect("binary roundtrip");
+    assert_eq!(value, Value::Bool(true));
+}
+
+/// Opt-in local I/O measurement; timing is reported, never used as a flaky CI gate.
+#[tokio::test(flavor = "multi_thread")]
+#[ignore = "local HTTP body throughput measurement"]
+async fn http_body_throughput() {
+    let size = 1024 * 1024;
+    let addr = serve_bytes(Bytes::from(vec![b'x'; size]));
+    for method in ["text", "arrayBuffer"] {
+        let source = format!(
+            r#"(async () => {{
+          let total = 0;
+          for (let i = 0; i < 21; i++) {{
+            const response = await fetch('http://{addr}/');
+            const body = await response.{method}();
+            const size = body.byteLength === undefined ? body.length : body.byteLength;
+            if (size !== {size}) throw new Error('incorrect body size');
+            if (i === 0) globalThis.started = Date.now();
+            else total += size;
+          }}
+          return JSON.stringify({{bytes: total, milliseconds: Date.now() - started}});
+        }})()"#
+        );
+        let value = tokio::task::spawn_blocking(move || {
+            eval(
+                &source,
+                IsolateConfig {
+                    request_timeout_ms: 30_000,
+                    cpu_ms_per_turn: 5_000,
+                    memory_limit_bytes: 16 * 1024 * 1024,
+                },
+            )
+        })
+        .await
+        .unwrap()
+        .expect("throughput");
+        eprintln!("HTTP 1 MiB {method}, 20 warm iterations, 16 MiB configured heap: {value:?}");
+    }
+}
+
+#[test]
+fn text_decoder_preserves_borrowed_and_lossy_input_semantics() {
+    let value = eval(
+        r#"(() => {
+      for (const fatal of [false, true]) {
+        const decoder = new TextDecoder('utf-8', {fatal});
+        const bytes = new TextEncoder().encode('x中😀\u0000y');
+        const view = new DataView(bytes.buffer, 1, bytes.byteLength - 2);
+        const result = decoder.decode(view);
+        bytes.fill(0);
+        if (result !== '中😀\u0000' || decoder.decode() !== '') return false;
+      }
+      for (const input of [[255], [226,130], [237,160,128]]) {
+        const bytes = new Uint8Array(input);
+        if (!new TextDecoder().decode(bytes).includes('\ufffd')) return false;
+        try { new TextDecoder('utf-8', {fatal:true}).decode(bytes); return false; }
+        catch (error) { if (!(error instanceof TypeError)) return false; }
+      }
+      const bytes = new Uint8Array([239,187,191,65]);
+      return new TextDecoder().decode(bytes) === 'A'
+        && new TextDecoder('utf-8', {ignoreBOM:true}).decode(bytes) === '\ufeffA';
+    })()"#,
+        config(),
+    )
+    .expect("UTF-8 decode ownership and error semantics");
+    assert_eq!(value, Value::Bool(true));
+}
+
+#[tokio::test]
+async fn inbound_byte_bodies_obey_heap_limit_for_single_and_accumulated_chunks() {
+    const SOURCE: &str = "export default { async fetch(r) { return new Response(String((await r.arrayBuffer()).byteLength)); } };";
+    for (chunks, chunk_size) in [(1, 8 * 1024 * 1024), (32, 128 * 1024)] {
+        let pool = IsolatePool::spawn(
+            1,
+            SOURCE,
+            IsolateConfig { memory_limit_bytes: 2 * 1024 * 1024, ..config() },
+        )
+        .unwrap();
+        let (tx, rx) = tokio::sync::mpsc::channel(STREAM_WINDOW);
+        let producer = tokio::spawn(async move {
+            for _ in 0..chunks {
+                if tx.send(Ok(vec![65; chunk_size])).await.is_err() {
+                    break;
+                }
+            }
+        });
+        let result = pool
+            .dispatch_response(IncomingHttp {
+                method: "POST".into(),
+                url: "http://local/".into(),
+                headers: vec![],
+                body: rx,
+                ws_in: None,
+                ws_out: None,
+                request_id: 0,
+            })
+            .await;
+        assert!(
+            matches!(
+                result,
+                Err(EngineError::Interrupted(InterruptReason::MemoryLimit)
+                    | EngineError::Isolate(_))
+            ),
+            "oversized body must fail allocation, not succeed or time out"
+        );
+        tokio::time::timeout(Duration::from_secs(2), producer).await.unwrap().unwrap();
+        // Allocation failure must release pending reads and leave the pool usable.
+        let (_, body) = pool
+            .dispatch_response(IncomingHttp::from(HttpRequest {
+                method: "POST".into(),
+                url: "http://local/".into(),
+                headers: vec![],
+                body: vec![65; 3],
+                request_id: 1,
+            }))
+            .await
+            .expect("reuse after memory limit");
+        let OutgoingHttpBody::Buffered(bytes) = body else {
+            panic!("expected buffered response");
+        };
+        assert_eq!(bytes, b"3");
+    }
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn outbound_byte_body_obeys_heap_limit() {
+    let addr = serve_bytes(Bytes::from(vec![65; 8 * 1024 * 1024]));
+    // Retain native chunks without a final aggregate allocation: this verifies
+    // that each chunk itself is charged, rather than failing only at concat.
+    let source = format!(
+        r#"(async () => {{
+      const response = await fetch('http://{addr}/');
+      const chunks = [];
+      for (;;) {{
+        const chunk = await tysel._httpRead(response._bodyId).promise;
+        if (chunk === null) break;
+        chunks.push(chunk);
+      }}
+      return chunks.reduce((total, chunk) => total + chunk.byteLength, 0);
+    }})()"#
+    );
+    let result = tokio::task::spawn_blocking(move || {
+        eval(&source, IsolateConfig { memory_limit_bytes: 2 * 1024 * 1024, ..config() })
+    })
+    .await
+    .unwrap();
+    assert!(
+        matches!(
+            result,
+            Err(EngineError::Interrupted(InterruptReason::MemoryLimit) | EngineError::Isolate(_))
+        ),
+        "outbound bytes must be charged before aggregate allocation"
+    );
+}
+
+#[tokio::test]
+async fn response_view_chunks_preserve_bytes_offsets_and_snapshots() {
+    let pool = IsolatePool::spawn(1, r#"export default { fetch() {
+      const backing = new Uint8Array([99, 0, 255, 65, 66, 99]);
+      const words = new Uint16Array(2);
+      new Uint8Array(words.buffer).set([67, 0, 68, 0]);
+      const chunks = ['start', new DataView(backing.buffer, 1, 4), words, new Uint8Array([69]).buffer];
+      const response = new Response(chunks);
+      backing.fill(42); words.fill(0); chunks.length = 0;
+      return response;
+    } };"#, config()).unwrap();
+    let (_, body) = pool
+        .dispatch_response(IncomingHttp::from(HttpRequest {
+            method: "GET".into(),
+            url: "http://local/".into(),
+            headers: vec![],
+            body: vec![],
+            request_id: 0,
+        }))
+        .await
+        .unwrap();
+    let OutgoingHttpBody::Stream(mut rx) = body else {
+        panic!("chunk output must stay streaming");
+    };
+    let mut chunks = Vec::new();
+    while let Some(chunk) = rx.recv().await {
+        chunks.push(chunk);
+    }
+    assert_eq!(chunks, vec![b"start".to_vec(), vec![0, 255, 65, 66], vec![67, 0, 68, 0], vec![69]]);
+}
+
+#[test]
+fn response_chunk_consumption_and_clone_match_emitted_bytes() {
+    let result = eval(r#"(async () => {
+      const response = new Response([new Uint8Array([228]), new DataView(new Uint8Array([184,173]).buffer), '😀']);
+      const clone = response.clone();
+      response.body[0][0] = 65;
+      if (await clone.text() !== '中😀') return false;
+      if (String(new Uint8Array(await response.arrayBuffer())) !== '65,184,173,240,159,152,128') return false;
+      try { await response.text(); return false; } catch (e) { if (!(e instanceof TypeError)) return false; }
+      const json = new Response(['{"a":', new TextEncoder().encode('1}')]);
+      return (await json.json()).a === 1 && (await new Response([]).arrayBuffer()).byteLength === 0;
+    })()"#, config()).unwrap();
+    assert_eq!(result, Value::Bool(true));
+}
diff --git a/docs/architecture/javascript-runtime-compatibility.md b/docs/architecture/javascript-runtime-compatibility.md
index 3ff09c1..16b8079 100644
--- a/docs/architecture/javascript-runtime-compatibility.md
+++ b/docs/architecture/javascript-runtime-compatibility.md
@@ -15,13 +15,13 @@ in the [JavaScript reference](../reference/javascript/index.md).
 | --- | --- | --- | --- |
 | URL / URLSearchParams | Partial | Authority URLs, relative resolution, dot segments, live query mutation, iterable parameters | Full WHATWG parsing, IDNA, credentials, file/blob URLs |
 | Headers | Partial | Common initializers and mutations, stable iteration | Header guards, Set-Cookie splitting, full token validation |
-| Request / Response | Partial | Single-use text/JSON/arrayBuffer, bodyUsed, streamed host bodies, buffered request/response clone | Public ReadableStream, form/blob helpers, stream teeing/clone, browser policy fields |
+| Request / Response | Partial | Byte-preserving string/ArrayBuffer/ArrayBufferView bodies, single-use text/JSON/arrayBuffer, bodyUsed, streamed host bodies, buffered clone | Public ReadableStream, form/blob helpers, stream teeing/clone, browser policy fields |
 | TextEncoder / TextDecoder | Partial | UTF-8 conversion | Legacy encodings and streaming decode options |
 | Timers | Supported | Timeout/interval creation, clearing, isolate-reset cleanup | Browser scheduling guarantees |
 | Event / EventTarget | Partial | Function/object listeners, deduplication, removal, once/signal options, cancellation | DOM trees, capture/bubble phases, browser exception reporting |
 | AbortController / AbortSignal | Partial | EventTarget inheritance, reasons, static abort/timeout, fetch and body cancellation | `AbortSignal.any` |
 | Crypto | Partial | Random values, SHA-2 digest, raw HMAC import/sign/verify | UUID, key export, encryption, asymmetric algorithms |
-| fetch | Partial | Policy-controlled HTTP, headers/body, redirects, streamed responses, abort | Streaming uploads, multipart helpers, browser cache/credential/mode fields |
+| fetch | Partial | Policy-controlled HTTP, binary-safe buffered uploads and response reads, redirects, abort | Streaming uploads, multipart helpers, browser cache/credential/mode fields |
 | WebSocket | Partial | Accepted/outbound text sockets, core events, listener lifecycle, reuse cleanup | Subprotocols, extensions, Blob messages, buffered amount |
 
 ## Contract evidence
@@ -40,3 +40,36 @@ Adding a supported feature requires updating the authored implementation, its
 public type when applicable, a QuickJS behavior test, and this matrix. Features
 outside the matrix remain unsupported even if incidental behavior appears to
 work.
+
+## HTTP byte body implementation
+
+HTTP chunks are copied into QuickJS-allocated Uint8Array storage so every retained
+chunk counts against the isolate heap limit, including the single-chunk fast path.
+Body reads
+preserve arbitrary bytes and typed-array/DataView offsets. `text()` decodes UTF-8
+only after collection, so code points split across transport chunks remain intact;
+`arrayBuffer()` never decodes text. Buffered binary constructors and clones snapshot
+the selected bytes. Tysel response chunk arrays snapshot the list and every binary
+element; DataView and other typed views are normalized to Uint8Array while preserving
+byte offsets and chunk boundaries. Body helpers concatenate the same bytes, and
+clones have independent snapshots. Empty-body `json()` rejects with a SyntaxError.
+
+For performance, a single received chunk is reused; multiple chunks use one
+exact-size allocation and one linear copy pass. Buffered strings retain their
+text fast path. UTF-8 decoding borrows valid input while constructing the QuickJS
+string, avoiding an intermediate owned Rust string in both strict and replacement
+modes; invalid input still allocates the required replacement text. Uploads take
+one native snapshot before asynchronous I/O, and redirects share that native buffer.
+The existing bounded channels, cancellation,
+body limits, and isolate cleanup remain in effect. Full-body helpers still require
+O(body size) memory; public Streams and streaming uploads remain unsupported.
+
+Run the optional local throughput measurement with:
+
+```sh
+cargo test -p tysel-engine-qjs http_body_throughput -- --ignored --nocapture
+```
+
+It checks 1 MiB ASCII bodies with both text and arrayBuffer consumption, one
+warm-up and 20 measured fetches, under a configured 16 MiB JS heap. Timings include
+local HTTP I/O and are diagnostic, not a CI threshold or an RSS measurement.
diff --git a/runtime-js/capability-client/runtime.js b/runtime-js/capability-client/runtime.js
index 62d16ed..a8fed9f 100644
--- a/runtime-js/capability-client/runtime.js
+++ b/runtime-js/capability-client/runtime.js
@@ -51,10 +51,10 @@
     const headers = new Headers(init.headers || (input && input.headers));
     const pairs = [];
     headers.forEach((value, key) => pairs.push([key, value]));
-    let body = "";
-    if (init.body != null) body = String(init.body);
-    else if (input instanceof Request && (input._stream || input.body != null)) body = await input.text();
-    else if (input && typeof input !== "string" && input.body != null) body = String(input.body);
+    let body;
+    if (init.body != null) body = globalThis.__tysel_bodyBytes(init.body);
+    else if (input instanceof Request) body = await globalThis.__tysel_consumeBytes(input);
+    else body = globalThis.__tysel_bodyBytes(input && typeof input !== "string" ? input.body : null);
     const operation = tysel._httpStart(String(url), method, JSON.stringify(pairs), body);
     const started = await awaitOperation(operation, signal);
     let headerPairs = [];
diff --git a/runtime-js/capability-client/source/fetch.js b/runtime-js/capability-client/source/fetch.js
index c3a67e1..4fbad1e 100644
--- a/runtime-js/capability-client/source/fetch.js
+++ b/runtime-js/capability-client/source/fetch.js
@@ -49,10 +49,10 @@
     const headers = new Headers(init.headers || (input && input.headers));
     const pairs = [];
     headers.forEach((value, key) => pairs.push([key, value]));
-    let body = "";
-    if (init.body != null) body = String(init.body);
-    else if (input instanceof Request && (input._stream || input.body != null)) body = await input.text();
-    else if (input && typeof input !== "string" && input.body != null) body = String(input.body);
+    let body;
+    if (init.body != null) body = globalThis.__tysel_bodyBytes(init.body);
+    else if (input instanceof Request) body = await globalThis.__tysel_consumeBytes(input);
+    else body = globalThis.__tysel_bodyBytes(input && typeof input !== "string" ? input.body : null);
     const operation = tysel._httpStart(String(url), method, JSON.stringify(pairs), body);
     const started = await awaitOperation(operation, signal);
     let headerPairs = [];
diff --git a/runtime-js/web-api/compatibility.json b/runtime-js/web-api/compatibility.json
index a893825..b3db1ec 100644
--- a/runtime-js/web-api/compatibility.json
+++ b/runtime-js/web-api/compatibility.json
@@ -23,7 +23,7 @@
     {
       "name": "Request and Response",
       "status": "partial",
-      "supported": ["string, Uint8Array, and ArrayBuffer response bodies", "single-use json/text/arrayBuffer consumption", "bodyUsed", "buffered request and response clone", "streamed host request and response bodies"],
+      "supported": ["string, ArrayBuffer, and ArrayBufferView request/response bodies with byte-preserving consumption", "single-use json/text/arrayBuffer consumption", "bodyUsed", "buffered request and response clone", "streamed host request and response bodies", "UTF-8 decoding after byte collection, including split code points and BOM handling", "Tysel response chunk arrays with snapshotted string/ArrayBuffer/ArrayBufferView elements"],
       "unsupported": ["public ReadableStream bodies", "formData/blob helpers", "stream teeing and streamed response clone", "browser cache/credentials/mode semantics"]
     },
     {
@@ -59,7 +59,7 @@
     {
       "name": "fetch",
       "status": "partial",
-      "supported": ["HTTP methods allowed by host policy", "headers and buffered request bodies", "redirect policy", "streamed response consumption", "AbortSignal cancellation"],
+      "supported": ["HTTP methods allowed by host policy", "headers and byte-preserving buffered request bodies", "redirect policy", "streamed response consumption", "AbortSignal cancellation"],
       "unsupported": ["streaming request bodies", "multipart/form data", "browser cache/credentials/mode semantics"]
     },
     {
diff --git a/runtime-js/web-api/index.ts b/runtime-js/web-api/index.ts
index 036a9bb..0f2d04a 100644
--- a/runtime-js/web-api/index.ts
+++ b/runtime-js/web-api/index.ts
@@ -105,10 +105,12 @@ export type TyselHeadersInit =
   | Iterable<readonly [string, string]>
   | Record<string, string>;
 
+export type TyselBodyInit = string | ArrayBuffer | ArrayBufferView;
+
 export interface TyselRequestInit {
   method?: string;
   headers?: TyselHeadersInit;
-  body?: unknown;
+  body?: TyselBodyInit | null;
   signal?: TyselAbortSignal | null;
 }
 
@@ -226,7 +228,7 @@ export interface TyselWebApiGlobals {
   Headers: new (init?: TyselHeadersInit) => TyselHeaders;
   Request: new (input: string | TyselRequest, init?: TyselRequestInit) => TyselRequest;
   Response: {
-    new (body?: unknown, init?: TyselResponseInit): TyselResponse;
+    new (body?: TyselBodyInit | readonly TyselBodyInit[] | null, init?: TyselResponseInit): TyselResponse;
     json(data: unknown, init?: TyselResponseInit): TyselResponse;
   };
   AbortController: new () => TyselAbortController;
diff --git a/runtime-js/web-api/runtime.js b/runtime-js/web-api/runtime.js
index bb7ff89..8a4c882 100644
--- a/runtime-js/web-api/runtime.js
+++ b/runtime-js/web-api/runtime.js
@@ -489,6 +489,96 @@
     }
   }
 
+  function bodyBytes(body) {
+    if (body == null) return new Uint8Array(0);
+    if (Array.isArray(body)) {
+      const chunks = body.map(bodyBytes);
+      return joinBytes(chunks, chunks.reduce((size, chunk) => size + chunk.byteLength, 0));
+    }
+    if (body instanceof ArrayBuffer) return new Uint8Array(body);
+    if (ArrayBuffer.isView(body)) {
+      return new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+    }
+    return new TextEncoder().encode(String(body));
+  }
+
+  function copyBody(body) {
+    return body instanceof ArrayBuffer || ArrayBuffer.isView(body)
+      ? bodyBytes(body).slice()
+      : body;
+  }
+
+  function copyResponseBody(body) {
+    if (!Array.isArray(body)) return copyBody(body);
+    // Snapshot both the chunk list and each view's selected bytes. Native
+    // emission can then handle every public ArrayBufferView as Uint8Array.
+    return Array.from(body, (chunk) => {
+      if (typeof chunk !== "string" && !(chunk instanceof ArrayBuffer) && !ArrayBuffer.isView(chunk)) {
+        throw new TypeError("response chunk must be a string or BufferSource");
+      }
+      return copyBody(chunk);
+    });
+  }
+
+  function joinBytes(chunks, length) {
+    if (chunks.length === 1) return chunks[0];
+    const bytes = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return bytes;
+  }
+
+  async function consumeBytes(owner) {
+    if (owner._bodyUsed) throw new TypeError("body has already been consumed");
+    owner._bodyUsed = true;
+    if (!owner._stream) return bodyBytes(owner.body);
+    const chunks = [];
+    let length = 0;
+    try {
+      for (;;) {
+        const chunk = owner instanceof Request
+          ? await tysel._readBody()
+          : await globalThis.__tysel_awaitOperation(
+              tysel._httpRead(owner._bodyId), owner._signal,
+            );
+        if (chunk == null) break;
+        if (chunk.byteLength === 0) continue;
+        chunks.push(chunk);
+        length += chunk.byteLength;
+      }
+      return joinBytes(chunks, length);
+    } finally {
+      owner._stream = false;
+      if (owner._abortCleanup) owner._abortCleanup();
+    }
+  }
+
+  async function consumeText(owner) {
+    // Buffered strings need no encode/decode round trip.
+    if (!owner._stream && typeof owner.body === "string") {
+      if (owner._bodyUsed) throw new TypeError("body has already been consumed");
+      owner._bodyUsed = true;
+      return owner.body.charCodeAt(0) === 0xfeff ? owner.body.slice(1) : owner.body;
+    }
+    return new TextDecoder().decode(await consumeBytes(owner));
+  }
+
+  async function consumeArrayBuffer(owner) {
+    const ownsBytes = owner._stream || (Array.isArray(owner.body) && owner.body.length !== 1);
+    const bytes = await consumeBytes(owner);
+    // Stream chunks and freshly joined arrays belong to this consumption;
+    // a single buffered chunk must not expose its mutable backing storage.
+    return ownsBytes && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
+      ? bytes.buffer
+      : bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+  }
+
+  globalThis.__tysel_bodyBytes = bodyBytes;
+  globalThis.__tysel_consumeBytes = consumeBytes;
+
   class Request {
     constructor(input, init) {
       init = init || {};
@@ -496,9 +586,8 @@
         this.url = input;
         this.method = String(init.method || "GET").toUpperCase();
         this.headers = new Headers(init.headers);
-        this.body = init.body == null ? null : init.body;
+        this.body = init.body == null ? null : copyBody(init.body);
         this._stream = init.bodyStream === true;
-        this._text = null;
         this.signal = init.signal || null;
       } else {
         if (input.bodyUsed && init.body == null) {
@@ -507,9 +596,8 @@
         this.url = input.url;
         this.method = String(init.method || input.method || "GET").toUpperCase();
         this.headers = new Headers(init.headers || input.headers);
-        this.body = init.body == null ? input.body : init.body;
+        this.body = copyBody(init.body == null ? input.body : init.body);
         this._stream = init.bodyStream === true || (init.body == null && input._stream === true);
-        this._text = input._text || null;
         this.signal = init.signal || input.signal || null;
       }
       this._bodyUsed = false;
@@ -517,31 +605,9 @@
     get bodyUsed() {
       return this._bodyUsed;
     }
-    async text() {
-      if (this._bodyUsed) throw new TypeError("body has already been consumed");
-      this._bodyUsed = true;
-      if (this._text != null) return this._text;
-      if (this._stream) {
-        const chunks = [];
-        for (;;) {
-          const chunk = await tysel._readBody();
-          if (chunk == null) break;
-          chunks.push(chunk);
-        }
-        this._text = chunks.join("");
-        this._stream = false;
-        return this._text;
-      }
-      this._text = this.body == null ? "" : String(this.body);
-      return this._text;
-    }
-    async json() {
-      const text = await this.text();
-      return text ? JSON.parse(text) : null;
-    }
-    async arrayBuffer() {
-      return new TextEncoder().encode(await this.text()).buffer;
-    }
+    async text() { return consumeText(this); }
+    async json() { return JSON.parse(await this.text()); }
+    async arrayBuffer() { return consumeArrayBuffer(this); }
     clone() {
       if (this._stream || this._bodyUsed) {
         throw new TypeError("cannot clone a streaming or consumed request");
@@ -558,15 +624,7 @@
   class Response {
     constructor(body, init) {
       init = init || {};
-      if (body instanceof ArrayBuffer) {
-        this.body = body.slice(0);
-      } else if (body instanceof Uint8Array) {
-        this.body = new Uint8Array(
-          body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength),
-        );
-      } else {
-        this.body = body == null ? null : body;
-      }
+      this.body = body == null ? null : copyResponseBody(body);
       this.status = init.status || 200;
       this.headers = new Headers(init.headers);
       this._stream = false;
@@ -589,54 +647,9 @@
     get bodyUsed() {
       return this._bodyUsed;
     }
-    async text() {
-      if (this._bodyUsed) throw new TypeError("body has already been consumed");
-      this._bodyUsed = true;
-      if (this._stream) {
-        const chunks = [];
-        try {
-          for (;;) {
-            const operation = tysel._httpRead(this._bodyId);
-            const chunk = await globalThis.__tysel_awaitOperation(
-              operation,
-              this._signal,
-            );
-            if (chunk == null) break;
-            chunks.push(chunk);
-          }
-          this.body = chunks.join("");
-          return this.body;
-        } finally {
-          this._stream = false;
-          if (this._abortCleanup) this._abortCleanup();
-        }
-      }
-      if (this.body == null) return "";
-      if (this.body instanceof ArrayBuffer || ArrayBuffer.isView(this.body)) {
-        return new TextDecoder().decode(this.body);
-      }
-      return String(this.body);
-    }
-    async json() {
-      const text = await this.text();
-      return text ? JSON.parse(text) : null;
-    }
-    async arrayBuffer() {
-      if (!this._stream && !this._bodyUsed) {
-        if (this.body instanceof ArrayBuffer) {
-          this._bodyUsed = true;
-          return this.body.slice(0);
-        }
-        if (ArrayBuffer.isView(this.body)) {
-          this._bodyUsed = true;
-          return this.body.buffer.slice(
-            this.body.byteOffset,
-            this.body.byteOffset + this.body.byteLength,
-          );
-        }
-      }
-      return new TextEncoder().encode(await this.text()).buffer;
-    }
+    async text() { return consumeText(this); }
+    async json() { return JSON.parse(await this.text()); }
+    async arrayBuffer() { return consumeArrayBuffer(this); }
     clone() {
       if (this._stream || this._bodyUsed) {
         throw new TypeError("cannot clone a streaming or consumed response");
@@ -684,7 +697,7 @@
         throw new TypeError("expected BufferSource");
       }
       let text = tysel._utf8Decode(view, this.fatal);
-      if (this.ignoreBOM && text.charCodeAt(0) === 0xfeff) text = text.slice(1);
+      if (!this.ignoreBOM && text.charCodeAt(0) === 0xfeff) text = text.slice(1);
       return text;
     }
   }
diff --git a/runtime-js/web-api/source/encoding.js b/runtime-js/web-api/source/encoding.js
index 0ccbc7d..89cb4ae 100644
--- a/runtime-js/web-api/source/encoding.js
+++ b/runtime-js/web-api/source/encoding.js
@@ -31,7 +31,7 @@
         throw new TypeError("expected BufferSource");
       }
       let text = tysel._utf8Decode(view, this.fatal);
-      if (this.ignoreBOM && text.charCodeAt(0) === 0xfeff) text = text.slice(1);
+      if (!this.ignoreBOM && text.charCodeAt(0) === 0xfeff) text = text.slice(1);
       return text;
     }
   }
diff --git a/runtime-js/web-api/source/http.js b/runtime-js/web-api/source/http.js
index 4ea205a..56b6dc5 100644
--- a/runtime-js/web-api/source/http.js
+++ b/runtime-js/web-api/source/http.js
@@ -52,6 +52,96 @@
     }
   }
 
+  function bodyBytes(body) {
+    if (body == null) return new Uint8Array(0);
+    if (Array.isArray(body)) {
+      const chunks = body.map(bodyBytes);
+      return joinBytes(chunks, chunks.reduce((size, chunk) => size + chunk.byteLength, 0));
+    }
+    if (body instanceof ArrayBuffer) return new Uint8Array(body);
+    if (ArrayBuffer.isView(body)) {
+      return new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+    }
+    return new TextEncoder().encode(String(body));
+  }
+
+  function copyBody(body) {
+    return body instanceof ArrayBuffer || ArrayBuffer.isView(body)
+      ? bodyBytes(body).slice()
+      : body;
+  }
+
+  function copyResponseBody(body) {
+    if (!Array.isArray(body)) return copyBody(body);
+    // Snapshot both the chunk list and each view's selected bytes. Native
+    // emission can then handle every public ArrayBufferView as Uint8Array.
+    return Array.from(body, (chunk) => {
+      if (typeof chunk !== "string" && !(chunk instanceof ArrayBuffer) && !ArrayBuffer.isView(chunk)) {
+        throw new TypeError("response chunk must be a string or BufferSource");
+      }
+      return copyBody(chunk);
+    });
+  }
+
+  function joinBytes(chunks, length) {
+    if (chunks.length === 1) return chunks[0];
+    const bytes = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return bytes;
+  }
+
+  async function consumeBytes(owner) {
+    if (owner._bodyUsed) throw new TypeError("body has already been consumed");
+    owner._bodyUsed = true;
+    if (!owner._stream) return bodyBytes(owner.body);
+    const chunks = [];
+    let length = 0;
+    try {
+      for (;;) {
+        const chunk = owner instanceof Request
+          ? await tysel._readBody()
+          : await globalThis.__tysel_awaitOperation(
+              tysel._httpRead(owner._bodyId), owner._signal,
+            );
+        if (chunk == null) break;
+        if (chunk.byteLength === 0) continue;
+        chunks.push(chunk);
+        length += chunk.byteLength;
+      }
+      return joinBytes(chunks, length);
+    } finally {
+      owner._stream = false;
+      if (owner._abortCleanup) owner._abortCleanup();
+    }
+  }
+
+  async function consumeText(owner) {
+    // Buffered strings need no encode/decode round trip.
+    if (!owner._stream && typeof owner.body === "string") {
+      if (owner._bodyUsed) throw new TypeError("body has already been consumed");
+      owner._bodyUsed = true;
+      return owner.body.charCodeAt(0) === 0xfeff ? owner.body.slice(1) : owner.body;
+    }
+    return new TextDecoder().decode(await consumeBytes(owner));
+  }
+
+  async function consumeArrayBuffer(owner) {
+    const ownsBytes = owner._stream || (Array.isArray(owner.body) && owner.body.length !== 1);
+    const bytes = await consumeBytes(owner);
+    // Stream chunks and freshly joined arrays belong to this consumption;
+    // a single buffered chunk must not expose its mutable backing storage.
+    return ownsBytes && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
+      ? bytes.buffer
+      : bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+  }
+
+  globalThis.__tysel_bodyBytes = bodyBytes;
+  globalThis.__tysel_consumeBytes = consumeBytes;
+
   class Request {
     constructor(input, init) {
       init = init || {};
@@ -59,9 +149,8 @@
         this.url = input;
         this.method = String(init.method || "GET").toUpperCase();
         this.headers = new Headers(init.headers);
-        this.body = init.body == null ? null : init.body;
+        this.body = init.body == null ? null : copyBody(init.body);
         this._stream = init.bodyStream === true;
-        this._text = null;
         this.signal = init.signal || null;
       } else {
         if (input.bodyUsed && init.body == null) {
@@ -70,9 +159,8 @@
         this.url = input.url;
         this.method = String(init.method || input.method || "GET").toUpperCase();
         this.headers = new Headers(init.headers || input.headers);
-        this.body = init.body == null ? input.body : init.body;
+        this.body = copyBody(init.body == null ? input.body : init.body);
         this._stream = init.bodyStream === true || (init.body == null && input._stream === true);
-        this._text = input._text || null;
         this.signal = init.signal || input.signal || null;
       }
       this._bodyUsed = false;
@@ -80,31 +168,9 @@
     get bodyUsed() {
       return this._bodyUsed;
     }
-    async text() {
-      if (this._bodyUsed) throw new TypeError("body has already been consumed");
-      this._bodyUsed = true;
-      if (this._text != null) return this._text;
-      if (this._stream) {
-        const chunks = [];
-        for (;;) {
-          const chunk = await tysel._readBody();
-          if (chunk == null) break;
-          chunks.push(chunk);
-        }
-        this._text = chunks.join("");
-        this._stream = false;
-        return this._text;
-      }
-      this._text = this.body == null ? "" : String(this.body);
-      return this._text;
-    }
-    async json() {
-      const text = await this.text();
-      return text ? JSON.parse(text) : null;
-    }
-    async arrayBuffer() {
-      return new TextEncoder().encode(await this.text()).buffer;
-    }
+    async text() { return consumeText(this); }
+    async json() { return JSON.parse(await this.text()); }
+    async arrayBuffer() { return consumeArrayBuffer(this); }
     clone() {
       if (this._stream || this._bodyUsed) {
         throw new TypeError("cannot clone a streaming or consumed request");
@@ -121,15 +187,7 @@
   class Response {
     constructor(body, init) {
       init = init || {};
-      if (body instanceof ArrayBuffer) {
-        this.body = body.slice(0);
-      } else if (body instanceof Uint8Array) {
-        this.body = new Uint8Array(
-          body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength),
-        );
-      } else {
-        this.body = body == null ? null : body;
-      }
+      this.body = body == null ? null : copyResponseBody(body);
       this.status = init.status || 200;
       this.headers = new Headers(init.headers);
       this._stream = false;
@@ -152,54 +210,9 @@
     get bodyUsed() {
       return this._bodyUsed;
     }
-    async text() {
-      if (this._bodyUsed) throw new TypeError("body has already been consumed");
-      this._bodyUsed = true;
-      if (this._stream) {
-        const chunks = [];
-        try {
-          for (;;) {
-            const operation = tysel._httpRead(this._bodyId);
-            const chunk = await globalThis.__tysel_awaitOperation(
-              operation,
-              this._signal,
-            );
-            if (chunk == null) break;
-            chunks.push(chunk);
-          }
-          this.body = chunks.join("");
-          return this.body;
-        } finally {
-          this._stream = false;
-          if (this._abortCleanup) this._abortCleanup();
-        }
-      }
-      if (this.body == null) return "";
-      if (this.body instanceof ArrayBuffer || ArrayBuffer.isView(this.body)) {
-        return new TextDecoder().decode(this.body);
-      }
-      return String(this.body);
-    }
-    async json() {
-      const text = await this.text();
-      return text ? JSON.parse(text) : null;
-    }
-    async arrayBuffer() {
-      if (!this._stream && !this._bodyUsed) {
-        if (this.body instanceof ArrayBuffer) {
-          this._bodyUsed = true;
-          return this.body.slice(0);
-        }
-        if (ArrayBuffer.isView(this.body)) {
-          this._bodyUsed = true;
-          return this.body.buffer.slice(
-            this.body.byteOffset,
-            this.body.byteOffset + this.body.byteLength,
-          );
-        }
-      }
-      return new TextEncoder().encode(await this.text()).buffer;
-    }
+    async text() { return consumeText(this); }
+    async json() { return JSON.parse(await this.text()); }
+    async arrayBuffer() { return consumeArrayBuffer(this); }
     clone() {
       if (this._stream || this._bodyUsed) {
         throw new TypeError("cannot clone a streaming or consumed response");

From 42635fd676fed2aabed39c8c98e6ad4284a6e700 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Mon, 7 Sep 2026 17:24:34 +0800
Subject: [PATCH 09/31] feat(runtime): add lazy Streams and P1 JavaScript APIs

Add checked streaming response completion, bounded writes and disconnect cleanup. Preserve body consumption state, live Headers iteration, incremental decoding and abort dependency cleanup, with regression tests and an opt-in profile harness.
---
 .../tysel-engine-qjs/examples/p1_profile.rs   | 134 +++
 crates/tysel-engine-qjs/src/fetch.rs          | 101 ++-
 crates/tysel-engine-qjs/src/host.rs           |  34 +-
 crates/tysel-engine-qjs/src/isolate.rs        |   2 +-
 crates/tysel-engine-qjs/src/p1_tests.rs       | 649 ++++++++++++++
 crates/tysel-engine-qjs/src/pool.rs           |  42 +-
 crates/tysel-engine-qjs/src/queue.rs          |  31 +-
 crates/tysel-engine-qjs/src/tests.rs          |   5 +-
 crates/tysel-runtime/src/http.rs              |  57 +-
 runtime-js/scripts/build-runtime.mjs          |  44 +-
 runtime-js/source/README.md                   |   3 +
 runtime-js/test/encoding.test.mjs             |  40 +
 runtime-js/test/headers.test.mjs              |  43 +
 runtime-js/test/runtime.test.mjs              |  11 +
 runtime-js/web-api/compatibility.json         | 153 +++-
 runtime-js/web-api/index.ts                   |  29 +-
 runtime-js/web-api/runtime.js                 | 518 +++++++++--
 runtime-js/web-api/source/abort.js            |  65 +-
 runtime-js/web-api/source/crypto.js           |   7 +
 runtime-js/web-api/source/encoding.js         |  65 +-
 runtime-js/web-api/source/http.js             | 284 ++++--
 runtime-js/web-api/source/utilities.js        |  37 +
 runtime-js/web-api/type-contract.ts           |  15 +
 .../vendor/web-streams-polyfill/LICENSE       |  22 +
 .../vendor/web-streams-polyfill/README.md     |  17 +
 .../vendor/web-streams-polyfill/polyfill.js   |   8 +
 .../vendor/web-streams-polyfill/types.d.ts    | 821 ++++++++++++++++++
 27 files changed, 3000 insertions(+), 237 deletions(-)
 create mode 100644 crates/tysel-engine-qjs/examples/p1_profile.rs
 create mode 100644 crates/tysel-engine-qjs/src/p1_tests.rs
 create mode 100644 runtime-js/test/encoding.test.mjs
 create mode 100644 runtime-js/test/headers.test.mjs
 create mode 100644 runtime-js/web-api/source/utilities.js
 create mode 100644 runtime-js/web-api/type-contract.ts
 create mode 100644 runtime-js/web-api/vendor/web-streams-polyfill/LICENSE
 create mode 100644 runtime-js/web-api/vendor/web-streams-polyfill/README.md
 create mode 100644 runtime-js/web-api/vendor/web-streams-polyfill/polyfill.js
 create mode 100644 runtime-js/web-api/vendor/web-streams-polyfill/types.d.ts

diff --git a/crates/tysel-engine-qjs/examples/p1_profile.rs b/crates/tysel-engine-qjs/examples/p1_profile.rs
new file mode 100644
index 0000000..320e9f1
--- /dev/null
+++ b/crates/tysel-engine-qjs/examples/p1_profile.rs
@@ -0,0 +1,134 @@
+//! Opt-in local P0/P1 measurement; no timing assertions. See the assessment report.
+use std::time::Instant;
+use tysel_engine::{HttpRequest, IsolateConfig};
+use tysel_engine_qjs::{IsolatePool, eval};
+
+fn config() -> IsolateConfig {
+    IsolateConfig {
+        memory_limit_bytes: 16 * 1024 * 1024,
+        request_timeout_ms: 30_000,
+        cpu_ms_per_turn: 5000,
+    }
+}
+fn percentile(values: &mut [f64], p: usize) -> f64 {
+    values.sort_by(f64::total_cmp);
+    values[(values.len() - 1) * p / 100]
+}
+fn main() {
+    let mode = std::env::args().nth(1).unwrap_or_else(|| "cold".into());
+    if mode == "cold" {
+        let mut times = Vec::new();
+        for i in 0..52 {
+            let start = Instant::now();
+            assert!(eval("true", config()).is_ok());
+            if i >= 2 {
+                times.push(start.elapsed().as_secs_f64() * 1000.0);
+            }
+        }
+        println!(
+            "{}",
+            serde_json::json!({"mode":mode,"n":times.len(),"median_ms":percentile(&mut times,50),"p95_ms":percentile(&mut times,95)})
+        );
+        return;
+    }
+    if mode == "bootstrap" || mode == "bootstrap-streams" {
+        let rt = rquickjs::Runtime::new().unwrap();
+        let ctx = rquickjs::Context::full(&rt).unwrap();
+        ctx.with(|ctx| ctx.eval::<(), _>("globalThis.tysel={};")).unwrap();
+        rt.run_gc();
+        let before = rt.memory_usage();
+        let start = Instant::now();
+        ctx.with(|ctx| ctx.eval::<(), _>(include_str!("../../../runtime-js/web-api/runtime.js")))
+            .unwrap();
+        if mode == "bootstrap-streams" {
+            ctx.with(|ctx| {
+                let host: rquickjs::Object = ctx.globals().get("tysel")?;
+                host.set("_loadStreams", rquickjs::Function::new(ctx.clone(), load_streams)?)
+            })
+            .unwrap();
+            ctx.with(|ctx| ctx.eval::<(), _>("void ReadableStream;")).unwrap();
+        }
+        let elapsed = start.elapsed().as_secs_f64() * 1000.0;
+        rt.run_gc();
+        let after = rt.memory_usage();
+        println!(
+            "{}",
+            serde_json::json!({"mode":mode,"milliseconds":elapsed,"js_used_bytes":after.memory_used_size-before.memory_used_size,"malloc_bytes":after.malloc_size-before.malloc_size})
+        );
+        return;
+    }
+    if mode == "stream-memory" {
+        let mib: usize = std::env::args().nth(2).unwrap_or_else(|| "64".into()).parse().unwrap();
+        let size = mib * 1024 * 1024;
+        let source = format!(
+            "export default {{fetch(){{let n=0;return new Response(new ReadableStream({{pull(c){{if(n==={size})c.close();else{{c.enqueue(new Uint8Array(16384));n+=16384;}}}}}},{{highWaterMark:0}}));}}}};"
+        );
+        let pool = IsolatePool::spawn(1, &source, config()).unwrap();
+        let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
+        let start = Instant::now();
+        let received = rt.block_on(async {
+            let (_, mut chunks) = pool
+                .dispatch(HttpRequest {
+                    method: "GET".into(),
+                    url: "http://local/".into(),
+                    headers: vec![],
+                    body: vec![],
+                    request_id: 1,
+                })
+                .await
+                .unwrap();
+            let mut received = 0;
+            while let Some(chunk) = chunks.recv().await {
+                received += chunk.len();
+            }
+            received
+        });
+        assert_eq!(received, size);
+        println!(
+            "{}",
+            serde_json::json!({"mode":mode,"mib":mib,"bytes":received,"milliseconds":start.elapsed().as_secs_f64()*1000.0,"configured_js_heap_bytes":config().memory_limit_bytes})
+        );
+        return;
+    }
+    let (source, count, expected) = match mode.as_str() {
+        "small" => ("export default {fetch(){return Response.json({ok:true,value:42});}};".to_owned(), 5000, 22),
+        "buffered" => ("export default {fetch(){return new Response(new Uint8Array(1048576));}};".to_owned(), 100, 1048576),
+        "chunks" => ("export default {fetch(){return new Response(Array.from({length:64},()=>new Uint8Array(16384)));}};".to_owned(),100,1048576),
+        "stream16k" | "stream1k" | "stream64k" => {
+            let chunk = match mode.as_str(){"stream1k"=>1024,"stream64k"=>65536,_=>16384};
+            (format!("export default {{fetch(){{let n=0;return new Response(new ReadableStream({{pull(c){{if(n===1048576)c.close();else{{c.enqueue(new Uint8Array({chunk}));n+={chunk};}}}}}},{{highWaterMark:0}}));}}}};"),100,1048576)
+        },
+        _ => panic!("unknown measurement"),
+    };
+    let pool = IsolatePool::spawn(1, &source, config()).unwrap();
+    let mut times = Vec::new();
+    for i in 0..count + 10 {
+        let start = Instant::now();
+        let (_, body) = pool
+            .dispatch_sync(HttpRequest {
+                method: "GET".into(),
+                url: "http://local/".into(),
+                headers: vec![],
+                body: vec![],
+                request_id: i,
+            })
+            .unwrap();
+        assert_eq!(body.len(), expected);
+        if i >= 10 {
+            times.push(start.elapsed().as_secs_f64() * 1000.0);
+        }
+    }
+    let total: f64 = times.iter().sum();
+    println!(
+        "{}",
+        serde_json::json!({"mode":mode,"n":count,"median_ms":percentile(&mut times,50),"p95_ms":percentile(&mut times,95),"total_ms":total,"requests_per_second":count as f64*1000.0/total,"mib_per_second":count as f64*expected as f64/1048576.0*1000.0/total})
+    );
+}
+
+fn load_streams(ctx: rquickjs::Ctx<'_>) -> rquickjs::Result<rquickjs::Object<'_>> {
+    ctx.eval(concat!(
+        "(function(globalThis) {\n",
+        include_str!("../../../runtime-js/web-api/vendor/web-streams-polyfill/polyfill.js"),
+        "\nreturn globalThis; })(Object.create(globalThis))"
+    ))
+}
diff --git a/crates/tysel-engine-qjs/src/fetch.rs b/crates/tysel-engine-qjs/src/fetch.rs
index 79101ad..8087049 100644
--- a/crates/tysel-engine-qjs/src/fetch.rs
+++ b/crates/tysel-engine-qjs/src/fetch.rs
@@ -1,10 +1,11 @@
 use rquickjs::{ArrayBuffer, Ctx, Function, Module, Object, TypedArray};
-use tokio::sync::mpsc;
+use std::sync::{Arc, Mutex};
+use tokio::sync::{mpsc, oneshot};
 use tysel_engine::{EngineError, HttpHead, HttpRequest};
 
 use crate::isolate::{js_err, js_err_ctx};
 use crate::pool::{OutgoingHttpBody, PreparedHttpResponse, ResponseSender};
-use crate::queue::STREAM_WINDOW;
+use crate::queue::{IoHandle, IoRequest, STREAM_WINDOW};
 
 const BOOTSTRAP: &str = include_str!("../../../runtime-js/web-api/runtime.js");
 const REQUEST_FACTORY: &str = "__tysel_request_factory";
@@ -48,7 +49,34 @@ pub fn take_response_into_globals(ctx: Ctx<'_>) -> Result<(), EngineError> {
     Ok(())
 }
 
-pub fn emit_response(ctx: Ctx<'_>, response_tx: ResponseSender) -> Result<(), EngineError> {
+pub(crate) struct ResponseCompletion {
+    completion: Option<oneshot::Sender<Result<(), EngineError>>>,
+    sink: Arc<Mutex<Option<mpsc::Sender<Vec<u8>>>>>,
+    watcher_stop: Option<oneshot::Sender<()>>,
+}
+
+impl ResponseCompletion {
+    pub fn finish(mut self, result: Result<(), EngineError>) {
+        self.watcher_stop.take();
+        self.sink.lock().expect("response sink").take();
+        if let Some(completion) = self.completion.take() {
+            let _ = completion.send(result);
+        }
+    }
+}
+
+impl Drop for ResponseCompletion {
+    fn drop(&mut self) {
+        self.watcher_stop.take();
+        self.sink.lock().expect("response sink").take();
+    }
+}
+
+pub fn emit_response(
+    ctx: Ctx<'_>,
+    response_tx: ResponseSender,
+    io: &IoHandle,
+) -> Result<Option<ResponseCompletion>, EngineError> {
     let response: Object = ctx.globals().get("__tysel_response").map_err(js_err)?;
     let status: i32 = response.get("status").unwrap_or(200);
     let headers = read_headers(&response)?;
@@ -57,7 +85,50 @@ pub fn emit_response(ctx: Ctx<'_>, response_tx: ResponseSender) -> Result<(), En
         headers,
         websocket: ctx.globals().get::<_, bool>("__tysel_ws_accepted").unwrap_or(false),
     };
-    let body: rquickjs::Value = response.get("body").map_err(js_err)?;
+    let get_body: Function = ctx.globals().get("__tysel_responseBody").map_err(js_err)?;
+    let body: rquickjs::Value =
+        get_body.call((response.clone(),)).map_err(|e| js_err_ctx(&ctx, e))?;
+    if body
+        .as_object()
+        .is_some_and(|o| o.contains_key("_readableStreamController").unwrap_or(false))
+    {
+        let (tx, rx) = mpsc::channel(STREAM_WINDOW);
+        let (watcher_stop, stop) = oneshot::channel();
+        let closed = crate::host::submit_cancellable(ctx.clone(), io, |id| {
+            IoRequest::ResponseClosed { id, tx: tx.clone(), stop }
+        })
+        .map_err(js_err)?;
+        let sink = Arc::new(Mutex::new(Some(tx)));
+        let write_sink = sink.clone();
+        let io = io.clone();
+        let write = Function::new(ctx.clone(), move |ctx, bytes: TypedArray<u8>| {
+            let tx =
+                write_sink.lock().expect("response sink").as_ref().cloned().ok_or_else(|| {
+                    rquickjs::Exception::throw_type(&ctx, "response stream has finished")
+                })?;
+            let bytes = bytes.as_bytes().ok_or(rquickjs::Error::Unknown)?.to_vec();
+            crate::host::submit(ctx, &io, |id| IoRequest::ResponseWrite {
+                id,
+                tx: tx.clone(),
+                bytes,
+            })
+        })
+        .map_err(js_err)?;
+        let pump: Function = ctx.globals().get("__tysel_pumpResponse").map_err(js_err)?;
+        let promise: rquickjs::Promise =
+            pump.call((body, write, closed)).map_err(|e| js_err_ctx(&ctx, e))?;
+        ctx.globals().set("__tysel_result", promise).map_err(js_err)?;
+        let (completion_tx, completion) = tokio::sync::oneshot::channel();
+        let _ = response_tx.send(Ok(PreparedHttpResponse {
+            head,
+            body: OutgoingHttpBody::CheckedStream { chunks: rx, completion },
+        }));
+        return Ok(Some(ResponseCompletion {
+            completion: Some(completion_tx),
+            sink,
+            watcher_stop: Some(watcher_stop),
+        }));
+    }
     if let Some(bytes) = buffered_body(&body)? {
         let _ = response_tx
             .send(Ok(PreparedHttpResponse { head, body: OutgoingHttpBody::Buffered(bytes) }));
@@ -67,7 +138,7 @@ pub fn emit_response(ctx: Ctx<'_>, response_tx: ResponseSender) -> Result<(), En
             .send(Ok(PreparedHttpResponse { head, body: OutgoingHttpBody::Stream(body_rx) }));
         send_body(body, &body_tx)?;
     }
-    Ok(())
+    Ok(None)
 }
 
 pub fn arm_websocket(ctx: Ctx<'_>) -> Result<bool, EngineError> {
@@ -80,11 +151,19 @@ pub fn arm_websocket(ctx: Ctx<'_>) -> Result<bool, EngineError> {
 
 fn read_headers(response: &Object<'_>) -> Result<Vec<(String, String)>, EngineError> {
     let headers_obj: Object = response.get("headers").map_err(js_err)?;
+    // Adapter to our Headers storage: avoid a JS generator, sorting, pair
+    // arrays and nested Vec allocations on every response. Public iteration
+    // remains sorted; wire order is immaterial except for individual cookies.
     let map: Object = headers_obj.get("_map").map_err(js_err)?;
     let mut headers = Vec::new();
     for entry in map.props::<String, String>() {
         let (key, value) = entry.map_err(js_err)?;
-        headers.push((key, value));
+        if key == "set-cookie" {
+            let cookies: Vec<String> = headers_obj.get("_cookies").map_err(js_err)?;
+            headers.extend(cookies.into_iter().map(|value| (key.clone(), value)));
+        } else {
+            headers.push((key, value));
+        }
     }
     Ok(headers)
 }
@@ -159,10 +238,10 @@ fn to_js_request<'js>(ctx: &Ctx<'js>, request: &HttpRequest) -> Result<Object<'j
     let init = Object::new(ctx.clone()).map_err(js_err)?;
     init.set("method", request.method.as_str()).map_err(js_err)?;
     init.set("bodyStream", true).map_err(js_err)?;
-    let headers = Object::new(ctx.clone()).map_err(js_err)?;
-    for (key, value) in &request.headers {
-        headers.set(key.as_str(), value.as_str()).map_err(js_err)?;
-    }
-    init.set("headers", headers).map_err(js_err)?;
+    init.set(
+        "headers",
+        request.headers.iter().map(|(k, v)| vec![k.as_str(), v.as_str()]).collect::<Vec<_>>(),
+    )
+    .map_err(js_err)?;
     factory.call((request.url.as_str(), init)).map_err(js_err)
 }
diff --git a/crates/tysel-engine-qjs/src/host.rs b/crates/tysel-engine-qjs/src/host.rs
index 830a881..030db87 100644
--- a/crates/tysel-engine-qjs/src/host.rs
+++ b/crates/tysel-engine-qjs/src/host.rs
@@ -39,6 +39,8 @@ fn install_inner(
     let io_echo = io.clone();
     let io_secret = io.clone();
     let io_body = io.clone();
+    let io_body_op = io.clone();
+    let io_cancel_request_body = io.clone();
     let io_http_start = io.clone();
     let io_http_read = io.clone();
     let io_http_cancel_body = io.clone();
@@ -62,6 +64,12 @@ fn install_inner(
     let io_fs_read = io.clone();
     let io_fs_write = io.clone();
     let io_llm = io.clone();
+    // Keep the fixed vendor source in native storage until an API is used.
+    tysel.set("_loadStreams", Function::new(ctx.clone(), load_streams)?)?;
+    tysel.set(
+        "_queueMicrotask",
+        Function::new(ctx.clone(), |callback: Function| callback.defer(()))?,
+    )?;
     tysel.set(
         "sleep",
         Function::new(ctx.clone(), move |ctx, millis: f64| {
@@ -86,6 +94,18 @@ fn install_inner(
             submit(ctx, &io_body, |id| IoRequest::ReadBody { id })
         })?,
     )?;
+    tysel.set(
+        "_readBodyOp",
+        Function::new(ctx.clone(), move |ctx| {
+            submit_cancellable(ctx, &io_body_op, |id| IoRequest::ReadBody { id })
+        })?,
+    )?;
+    tysel.set(
+        "_cancelRequestBody",
+        Function::new(ctx.clone(), move || {
+            io_cancel_request_body.inbound.clear();
+        })?,
+    )?;
     tysel.set(
         "_httpStart",
         Function::new(
@@ -426,7 +446,7 @@ fn durable_millis(ctx: &Ctx<'_>, value: f64, label: &str) -> rquickjs::Result<u6
     Ok(value as u64)
 }
 
-fn submit<'js>(
+pub(crate) fn submit<'js>(
     ctx: Ctx<'js>,
     io: &IoHandle,
     request: impl FnOnce(OpId) -> IoRequest,
@@ -434,7 +454,7 @@ fn submit<'js>(
     submit_operation(ctx, io, request).map(|(promise, _)| promise)
 }
 
-fn submit_cancellable<'js>(
+pub(crate) fn submit_cancellable<'js>(
     ctx: Ctx<'js>,
     io: &IoHandle,
     request: impl FnOnce(OpId) -> IoRequest,
@@ -621,3 +641,13 @@ fn value_to_js<'js>(ctx: &Ctx<'js>, value: Value) -> rquickjs::Result<rquickjs::
         }
     }
 }
+
+// The facade inherits platform globals (notably DOMException) while vendor
+// constructors are installed as its own properties, never on the real global.
+fn load_streams(ctx: Ctx<'_>) -> rquickjs::Result<Object<'_>> {
+    ctx.eval(concat!(
+        "(function(globalThis) {\n",
+        include_str!("../../../runtime-js/web-api/vendor/web-streams-polyfill/polyfill.js"),
+        "\nreturn globalThis; })(Object.create(globalThis))"
+    ))
+}
diff --git a/crates/tysel-engine-qjs/src/isolate.rs b/crates/tysel-engine-qjs/src/isolate.rs
index cf61fe2..2521389 100644
--- a/crates/tysel-engine-qjs/src/isolate.rs
+++ b/crates/tysel-engine-qjs/src/isolate.rs
@@ -425,7 +425,7 @@ fn take_settled(
     }
 }
 
-fn drain_jobs(
+pub(crate) fn drain_jobs(
     runtime: &Runtime,
     cancel: &IsolateCancel,
     request_deadline: Instant,
diff --git a/crates/tysel-engine-qjs/src/p1_tests.rs b/crates/tysel-engine-qjs/src/p1_tests.rs
new file mode 100644
index 0000000..96ba101
--- /dev/null
+++ b/crates/tysel-engine-qjs/src/p1_tests.rs
@@ -0,0 +1,649 @@
+use super::*;
+
+#[test]
+fn p1_utilities_and_abort_composition() {
+    let value = eval(r#"(async () => {
+      const order = [];
+      queueMicrotask(() => order.push('microtask'));
+      Promise.resolve().then(() => order.push('promise'));
+      order.push('sync'); await Promise.resolve();
+      if (order.join() !== 'sync,microtask,promise') return false;
+      const uuid = crypto.randomUUID();
+      if (!/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(uuid) || uuid === crypto.randomUUID()) return false;
+      let binary = ''; for (let i=0;i<256;i++) binary += String.fromCharCode(i);
+      if (atob(btoa(binary)) !== binary || atob(' Y Q==\n') !== 'a' || atob('YQ') !== 'a') return false;
+      for (const f of [() => btoa('中'), () => atob('a'), () => atob('a===')]) {
+        try { f(); return false; } catch(e) { if (e.name !== 'InvalidCharacterError') return false; }
+      }
+      const a = new AbortController(), b = new AbortController();
+      const combined = AbortSignal.any([a.signal, b.signal, a.signal]);
+      let calls = 0; combined.addEventListener('abort', () => calls++);
+      const reason = {}; b.abort(reason); a.abort('later');
+      if (combined.reason !== reason || calls !== 1) return false;
+      if (AbortSignal.any([]).aborted || AbortSignal.any([a.signal,b.signal]).reason !== 'later') return false;
+      try { AbortSignal.any([a.signal, {}]); return false; } catch(e) { if (!(e instanceof TypeError)) return false; }
+      for (const invalid of [{}, 42, null]) {
+        try { AbortSignal.any(invalid); return false; } catch(e) { if (!(e instanceof TypeError)) return false; }
+      }
+      return true;
+    })()"#, config()).unwrap();
+    assert_eq!(value, Value::Bool(true));
+}
+
+#[test]
+fn p1_decoder_handles_every_split_bom_and_flush() {
+    let value = eval(r#"(() => {
+      const bytes = new TextEncoder().encode('\ufeff中😀\ufeffend');
+      for (let split=0;split<=bytes.length;split++) {
+        const decoder = new TextDecoder();
+        const actual = decoder.decode(bytes.subarray(0,split),{stream:true}) + decoder.decode(bytes.subarray(split),{stream:true}) + decoder.decode();
+        if (actual !== '中😀\ufeffend') return false;
+      }
+      const decoder = new TextDecoder(); let result = '';
+      for (const byte of bytes) result += decoder.decode(new Uint8Array([byte]),{stream:true});
+      if (result + decoder.decode() !== '中😀\ufeffend') return false;
+      if (decoder.decode(new Uint8Array([226,130]),{stream:true}) !== '' || decoder.decode() !== '\ufffd') return false;
+      const fatal = new TextDecoder('utf-8',{fatal:true});
+      fatal.decode(new Uint8Array([240]),{stream:true});
+      try { fatal.decode(); return false; } catch(e) { if (!(e instanceof TypeError)) return false; }
+      if (fatal.decode(new Uint8Array([65])) !== 'A') return false;
+      for (const input of [[224,128],[237,160],[244,144]]) {
+        try { fatal.decode(new Uint8Array(input),{stream:true}); return false; } catch(e) { if (!(e instanceof TypeError)) return false; }
+      }
+      return true;
+    })()"#, config()).unwrap();
+    assert_eq!(value, Value::Bool(true));
+}
+
+#[test]
+fn p1_stream_pipe_transform_backpressure_and_cancel() {
+    let value = eval(r#"(async () => {
+      let next=0, inFlight=0, maxInFlight=0;
+      const source = new ReadableStream({pull(c) { if (next===5) c.close(); else c.enqueue(next++); }});
+      const output=[];
+      const sink=new WritableStream({async write(v) { inFlight++; maxInFlight=Math.max(maxInFlight,inFlight); await tysel.sleep(1); output.push(v); inFlight--; }});
+      await source.pipeThrough(new TransformStream({transform(v,c){c.enqueue(v*2);}})).pipeTo(sink);
+      if(output.join()!=='0,2,4,6,8'||maxInFlight!==1||source.locked||sink.locked) return false;
+      let reason;
+      const canceled=new ReadableStream({cancel(r){reason=r;}},{highWaterMark:0});
+      const reader=canceled.getReader(); const pending=reader.read();
+      await reader.cancel('stop'); if(!(await pending).done||reason!=='stop') return false;
+      reader.releaseLock();
+      const bytes = new TextEncoder().encode('中😀'); let index=0;
+      const decoded = new ReadableStream({pull(c){if(index===bytes.length)c.close();else c.enqueue(bytes.slice(index,++index));}}).pipeThrough(new TextDecoderStream());
+      let text=''; for await(const chunk of decoded) text+=chunk;
+      return text==='中😀';
+    })()"#, config()).unwrap();
+    assert_eq!(value, Value::Bool(true));
+}
+
+#[test]
+fn p1_body_stream_locks_and_disturbance() {
+    let value=eval(r#"(async()=>{
+      const response = new Response(new Uint8Array([65,66]));
+      const reader=response.body.getReader();
+      if(response.bodyUsed) return false;
+      try { await response.text(); return false; } catch(e){ if(!(e instanceof TypeError))return false; }
+      const chunk=await reader.read();
+      if(!response.bodyUsed||String(chunk.value)!=='65,66') return false;
+      reader.releaseLock();
+      try { response.clone(); return false; } catch(e){if(!(e instanceof TypeError))return false;}
+      const request = new Request('http://local/',{body:'hello'});
+      let text=''; for await(const bytes of request.body) text+=new TextDecoder().decode(bytes);
+      if(text!=='hello'||!request.bodyUsed) return false;
+      const retained=new Uint8Array([65]);
+      const supplied=new Response(new ReadableStream({start(c){c.enqueue(retained);c.close();}}));
+      const result=new Uint8Array(await supplied.arrayBuffer());result[0]=66;
+      return retained[0]===65;
+    })()"#,config()).unwrap();
+    assert_eq!(value, Value::Bool(true));
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn p1_set_cookie_roundtrips_without_comma_splitting() {
+    let cookie = "a=1; Expires=Wed, 21 Oct 2030 07:28:00 GMT";
+    let addr = spawn_origin(move |_| async move {
+        Ok::<_, Infallible>(
+            Response::builder()
+                .header("set-cookie", cookie)
+                .header("set-cookie", "b=2; HttpOnly")
+                .body(http_body_util::Full::new(Bytes::from_static(b"ok")))
+                .unwrap(),
+        )
+    });
+    let source = format!(
+        r#"export default {{async fetch(request){{
+      const response=await fetch('http://{addr}/');
+      const headers=new Headers(response.headers);
+      const cookies=headers.getSetCookie(); cookies.push('bad');
+      if(headers.getSetCookie().length!==2) throw new Error('not a snapshot');
+      return new Response(response.body,{{headers}});
+    }}}};"#
+    );
+    let pool = IsolatePool::spawn(1, &source, config()).unwrap();
+    let (head, body) = pool
+        .dispatch_response(IncomingHttp::from(HttpRequest {
+            method: "GET".into(),
+            url: "http://local/".into(),
+            headers: vec![],
+            body: vec![],
+            request_id: 0,
+        }))
+        .await
+        .unwrap();
+    assert_eq!(
+        head.headers
+            .iter()
+            .filter(|(k, _)| k == "set-cookie")
+            .map(|(_, v)| v.as_str())
+            .collect::<Vec<_>>(),
+        [cookie, "b=2; HttpOnly"]
+    );
+    let OutgoingHttpBody::CheckedStream { mut chunks, completion } = body else {
+        panic!("expected stream")
+    };
+    let mut bytes = vec![];
+    while let Some(chunk) = chunks.recv().await {
+        bytes.extend(chunk);
+    }
+    completion.await.unwrap().unwrap();
+    assert_eq!(bytes, b"ok");
+}
+
+#[tokio::test]
+async fn p1_response_stream_backpressure_disconnect_and_reuse() {
+    const SOURCE: &str = r#"let pulls=0,canceled=false; export default {fetch(r){
+      if(r.url.endsWith('/status'))return Response.json({pulls,canceled});
+      return new Response(new ReadableStream({pull(c){pulls++;c.enqueue(new Uint8Array(1024));},cancel(){canceled=true;}},{highWaterMark:0}));
+    }};"#;
+    let pool = IsolatePool::spawn(1, SOURCE, config()).unwrap();
+    let request = |path: &str, id| {
+        IncomingHttp::from(HttpRequest {
+            method: "GET".into(),
+            url: format!("http://local/{path}"),
+            headers: vec![],
+            body: vec![],
+            request_id: id,
+        })
+    };
+    let (_, body) = pool.dispatch_response(request("stream", 0)).await.unwrap();
+    let OutgoingHttpBody::CheckedStream { chunks, completion } = body else { panic!("stream") };
+    tokio::time::sleep(Duration::from_millis(40)).await;
+    drop(chunks);
+    assert!(completion.await.unwrap().is_err());
+    let (_, body) = pool.dispatch_response(request("status", 1)).await.unwrap();
+    let OutgoingHttpBody::Buffered(bytes) = body else { panic!("buffer") };
+    let status: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
+    assert_eq!(status["canceled"], true);
+    assert!(status["pulls"].as_u64().unwrap() <= STREAM_WINDOW as u64 + 1);
+}
+
+#[tokio::test]
+async fn p1_response_stream_reports_failure_after_headers() {
+    let pool=IsolatePool::spawn(1,r#"export default {fetch(){let i=0;return new Response(new ReadableStream({pull(c){if(i++===0)c.enqueue(new Uint8Array([65]));else throw new Error('broken stream');}},{highWaterMark:0}));}};"#,config()).unwrap();
+    let (_, body) = pool
+        .dispatch_response(IncomingHttp::from(HttpRequest {
+            method: "GET".into(),
+            url: "http://local/".into(),
+            headers: vec![],
+            body: vec![],
+            request_id: 0,
+        }))
+        .await
+        .unwrap();
+    let OutgoingHttpBody::CheckedStream { mut chunks, completion } = body else { panic!("stream") };
+    assert_eq!(chunks.recv().await.unwrap(), [65]);
+    assert!(chunks.recv().await.is_none());
+    assert!(completion.await.unwrap().unwrap_err().to_string().contains("broken stream"));
+}
+
+#[test]
+fn p1_headers_validate_iterables_and_prototype_names() {
+    let value=eval(r#"(()=>{
+      const h=new Headers((function*(){yield ['x','a'];yield ['set-cookie','a=1'];yield ['set-cookie','b=2'];})());
+      if(new Headers().get('constructor')!==null||h.get('x')!=='a'||new Headers(h).getSetCookie().length!==2)return false;
+      h.set('set-cookie','c=3');if(h.getSetCookie().join()!=='c=3')return false;
+      h.delete('set-cookie');if(h.getSetCookie().length)return false;
+      try{h.set('bad name','x');return false;}catch(e){if(!(e instanceof TypeError))return false;}
+      try{h.set('x','a\r\nb');return false;}catch(e){if(!(e instanceof TypeError))return false;}
+      return true;
+    })()"#,config()).unwrap();
+    assert_eq!(value, Value::Bool(true));
+}
+
+#[tokio::test]
+async fn p1_request_stream_cancel_releases_pending_native_read() {
+    let pool = IsolatePool::spawn(
+        1,
+        r#"export default {async fetch(request){
+      const reader=request.body.getReader();const pending=reader.read();
+      await reader.cancel('stop');
+      return Response.json({done:(await pending).done,used:request.bodyUsed});
+    }};"#,
+        config(),
+    )
+    .unwrap();
+    let (tx, rx) = tokio::sync::mpsc::channel(STREAM_WINDOW);
+    let (_, body) = pool
+        .dispatch_response(IncomingHttp {
+            method: "POST".into(),
+            url: "http://local/".into(),
+            headers: vec![],
+            body: rx,
+            ws_in: None,
+            ws_out: None,
+            request_id: 0,
+        })
+        .await
+        .unwrap();
+    let OutgoingHttpBody::Buffered(bytes) = body else { panic!("buffer") };
+    assert_eq!(String::from_utf8(bytes).unwrap(), r#"{"done":true,"used":true}"#);
+    tokio::time::timeout(Duration::from_secs(1), tx.closed())
+        .await
+        .expect("native inbound reader released");
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn p1_fetch_body_reader_cancel_does_not_poison_other_fetch() {
+    let addr = serve_slow_body();
+    let second = serve_bytes(Bytes::from_static(b"ok"));
+    let source = format!(
+        r#"(async()=>{{
+      const response=await fetch('http://{addr}/');
+      const reader=response.body.getReader();const pending=reader.read();
+      await reader.cancel();if(!(await pending).done||!response.bodyUsed)return false;
+      return await (await fetch('http://{second}/')).text()==='ok';
+    }})()"#
+    );
+    assert_eq!(
+        tokio::task::spawn_blocking(move || eval(&source, config())).await.unwrap().unwrap(),
+        Value::Bool(true)
+    );
+}
+
+#[tokio::test]
+async fn p1_stale_request_body_cannot_read_next_request() {
+    let pool = IsolatePool::spawn(
+        1,
+        r#"let stale;export default{async fetch(r){
+      if(!stale){stale=r.body;return new Response('stored');}
+      try{await stale.getReader().read();return new Response('bad');}catch{}
+      return new Response(await r.text());
+    }};"#,
+        config(),
+    )
+    .unwrap();
+    for (id, expected) in [(0, b"stored".as_slice()), (1, b"new".as_slice())] {
+        let (_, body) = pool
+            .dispatch_response(IncomingHttp::from(HttpRequest {
+                method: "POST".into(),
+                url: "http://local/".into(),
+                headers: vec![],
+                body: b"new".to_vec(),
+                request_id: id,
+            }))
+            .await
+            .unwrap();
+        let OutgoingHttpBody::Buffered(bytes) = body else { panic!("buffer") };
+        assert_eq!(bytes, expected);
+    }
+}
+
+#[test]
+fn p1_pipe_abort_and_tee_lifecycle() {
+    let value=eval(r#"(async()=>{
+      const controller=new AbortController();let sourceReason,sinkReason;
+      const source=new ReadableStream({cancel(reason){sourceReason=reason;}},{highWaterMark:0});
+      const sink=new WritableStream({abort(reason){sinkReason=reason;}});
+      const pipe=source.pipeTo(sink,{signal:controller.signal});controller.abort('stop');
+      try{await pipe;return false;}catch(e){if(e!=='stop')return false;}
+      if(sourceReason!=='stop'||sinkReason!=='stop'||source.locked||sink.locked)return false;
+      const [a,b]=new ReadableStream({start(c){c.enqueue(7);c.close();}}).tee();
+      const collect=async stream=>{let result=[];for await(const x of stream)result.push(x);return result.join();};
+      return (await Promise.all([collect(a),collect(b)])).join()==='7,7';
+    })()"#,config()).unwrap();
+    assert_eq!(value, Value::Bool(true));
+}
+
+#[test]
+fn p1_microtask_exceptions_are_reported() {
+    let error=eval("(async()=>{queueMicrotask(()=>{throw new Error('microtask failure')});await tysel.sleep(1);})()",config()).unwrap_err();
+    assert!(error.to_string().contains("microtask failure"));
+}
+
+#[test]
+fn p1_any_cannot_be_blocked_by_public_event_listeners() {
+    let value=eval(r#"(()=>{const a=new AbortController();a.signal.addEventListener('abort',e=>e.stopImmediatePropagation());const combined=AbortSignal.any([a.signal]);a.abort('reason');return combined.aborted&&combined.reason==='reason';})()"#,config()).unwrap();
+    assert_eq!(value, Value::Bool(true));
+}
+
+#[tokio::test]
+async fn p1_lazily_opened_stale_body_cannot_read_next_request() {
+    let pool = IsolatePool::spawn(
+        1,
+        r#"let stale;export default{async fetch(r){
+      if(!stale){stale=r;return new Response('stored');}
+      try{await new Request(stale).body.getReader().read();return new Response('bad copy');}catch{}
+      try{await stale.body.getReader().read();return new Response('bad');}catch{}
+      return new Response(await r.text());
+    }};"#,
+        config(),
+    )
+    .unwrap();
+    for (id, expected) in [(0, b"stored".as_slice()), (1, b"new".as_slice())] {
+        let (_, body) = pool
+            .dispatch_response(IncomingHttp::from(HttpRequest {
+                method: "POST".into(),
+                url: "http://local/".into(),
+                headers: vec![],
+                body: b"new".to_vec(),
+                request_id: id,
+            }))
+            .await
+            .unwrap();
+        let OutgoingHttpBody::Buffered(bytes) = body else { panic!("buffer") };
+        assert_eq!(bytes, expected);
+    }
+}
+
+#[test]
+fn p1_stream_queues_obey_isolate_heap_limit() {
+    let error=eval(r#"(()=>{const stream=new ReadableStream({start(c){for(let i=0;i<64;i++)c.enqueue(new Uint8Array(128*1024));}});return stream.locked;})()"#,IsolateConfig{memory_limit_bytes:2*1024*1024,..config()}).unwrap_err();
+    assert!(matches!(
+        error,
+        EngineError::Interrupted(InterruptReason::MemoryLimit) | EngineError::Isolate(_)
+    ));
+}
+
+#[tokio::test]
+async fn p1_retained_stream_releases_output_sender_on_timeout() {
+    let pool=IsolatePool::spawn(1,r#"let retained;export default{fetch(){retained=new ReadableStream({pull(){return new Promise(()=>{});}});return new Response(retained);}};"#,IsolateConfig{request_timeout_ms:100,..config()}).unwrap();
+    let (_, body) = pool
+        .dispatch_response(IncomingHttp::from(HttpRequest {
+            method: "GET".into(),
+            url: "http://local/".into(),
+            headers: vec![],
+            body: vec![],
+            request_id: 0,
+        }))
+        .await
+        .unwrap();
+    let OutgoingHttpBody::CheckedStream { mut chunks, completion } = body else { panic!("stream") };
+    assert!(
+        tokio::time::timeout(Duration::from_secs(1), chunks.recv())
+            .await
+            .expect("sender released")
+            .is_none()
+    );
+    assert!(matches!(
+        completion.await.unwrap(),
+        Err(EngineError::Interrupted(InterruptReason::Timeout))
+    ));
+}
+
+#[tokio::test]
+async fn p1_idle_stream_disconnect_cancels_without_waiting_for_source_cleanup() {
+    let pool = IsolatePool::spawn(
+        1,
+        r#"let canceled=false;
+      export default{fetch(r){
+        if(r.url.endsWith('/status'))return Response.json({canceled});
+        return new Response(new ReadableStream({
+          pull(){return new Promise(()=>{});},
+          cancel(){canceled=true;return new Promise(()=>{});}
+        },{highWaterMark:0}));
+      }};"#,
+        IsolateConfig { request_timeout_ms: 5000, ..config() },
+    )
+    .unwrap();
+    let request = |path: &str, id| {
+        IncomingHttp::from(HttpRequest {
+            method: "GET".into(),
+            url: format!("http://local/{path}"),
+            headers: vec![],
+            body: vec![],
+            request_id: id,
+        })
+    };
+    let (_, body) = pool.dispatch_response(request("stream", 1)).await.unwrap();
+    let OutgoingHttpBody::CheckedStream { chunks, completion } = body else { panic!("stream") };
+    drop(chunks);
+    let result = tokio::time::timeout(Duration::from_secs(1), completion)
+        .await
+        .expect("disconnect must not wait for the request deadline")
+        .unwrap();
+    assert!(result.is_err());
+    let (_, body) =
+        tokio::time::timeout(Duration::from_secs(1), pool.dispatch_response(request("status", 2)))
+            .await
+            .expect("worker must be reusable")
+            .unwrap();
+    let OutgoingHttpBody::Buffered(bytes) = body else { panic!("buffer") };
+    assert_eq!(serde_json::from_slice::<serde_json::Value>(&bytes).unwrap()["canceled"], true);
+}
+
+#[test]
+fn p1_any_marks_all_dependents_before_reentrant_callbacks() {
+    let result = eval(
+        r#"(()=>{
+      const a=new AbortController(), b=new AbortController();
+      const first=AbortSignal.any([a.signal]);
+      const second=AbortSignal.any([a.signal,b.signal]);
+      const nested=AbortSignal.any([second,b.signal]);
+      let marked=false;
+      first.addEventListener('abort',()=>{marked=second.aborted&&nested.aborted;b.abort('b');});
+      a.abort('a');
+      return marked&&second.reason==='a'&&nested.reason==='a';
+    })()"#,
+        config(),
+    )
+    .unwrap();
+    assert_eq!(result, Value::Bool(true));
+}
+
+#[tokio::test]
+async fn p1_any_unused_dependents_are_collectible_across_requests() {
+    let pool = IsolatePool::spawn(
+        1,
+        r#"const root=new AbortController();
+      const observed=AbortSignal.any([AbortSignal.any([root.signal])]);
+      export default{fetch(r){
+        if(r.url.endsWith('/abort')){root.abort('done');return new Response(observed.reason);}
+        for(let i=0;i<64;i++)AbortSignal.any([root.signal]);
+        return new Response('ok');
+      }};"#,
+        IsolateConfig { memory_limit_bytes: 4 * 1024 * 1024, cpu_ms_per_turn: 500, ..config() },
+    )
+    .unwrap();
+    for id in 0..401 {
+        let last = id == 400;
+        let (_, body) = pool
+            .dispatch_response(IncomingHttp::from(HttpRequest {
+                method: "GET".into(),
+                url: if last { "http://local/abort" } else { "http://local/" }.into(),
+                headers: vec![],
+                body: vec![],
+                request_id: id,
+            }))
+            .await
+            .expect("discarded dependents must not exhaust the heap");
+        let OutgoingHttpBody::Buffered(bytes) = body else { panic!("buffer") };
+        assert_eq!(bytes, if last { b"done".as_slice() } else { b"ok".as_slice() });
+    }
+}
+
+#[tokio::test]
+async fn p1_sync_handler_drains_microtasks_within_its_request() {
+    let pool = IsolatePool::spawn(
+        1,
+        r#"let completed=false;
+      export default {fetch(r){
+        if(r.url.endsWith('/status'))return new Response(String(completed));
+        queueMicrotask(()=>{completed=true;});
+        return new Response('queued');
+      }};"#,
+        config(),
+    )
+    .unwrap();
+    for (id, path, expected) in [(1, "queue", "queued"), (2, "status", "true")] {
+        let (_, body) = pool
+            .dispatch_response(IncomingHttp::from(HttpRequest {
+                method: "GET".into(),
+                url: format!("http://local/{path}"),
+                headers: vec![],
+                body: vec![],
+                request_id: id,
+            }))
+            .await
+            .unwrap();
+        let OutgoingHttpBody::Buffered(bytes) = body else { panic!("buffer") };
+        assert_eq!(bytes, expected.as_bytes());
+    }
+}
+
+#[test]
+fn p1_buffered_bodies_do_not_initialize_streams() {
+    let result = eval(r#"(async()=>{
+      const lazy=()=>typeof Object.getOwnPropertyDescriptor(globalThis,'ReadableStream').get==='function';
+      if(!lazy())return false;
+      const response=Response.json({ok:true});
+      if(await response.text()!=='{"ok":true}'||!lazy())return false;
+      await new Request('http://local/',{body:new Uint8Array([65])}).arrayBuffer();
+      if(!lazy())return false;
+      const stream=new Response('A').body;
+      const constructor=ReadableStream;
+      if(lazy()||constructor!==ReadableStream||!(stream instanceof constructor))return false;
+      const reader=stream.getReader();
+      return (await reader.read()).value[0]===65;
+    })()"#,config()).unwrap();
+    assert_eq!(result, Value::Bool(true));
+}
+
+#[test]
+fn p1_stream_globals_preserve_identity_and_writable_assignment() {
+    let result = eval(
+        r#"(()=>{
+      // Assigning before another constructor is read must not be overwritten
+      // later when the remaining globals are used.
+      const custom=function(){};
+      WritableStream=custom;
+      const original=ReadableStream;
+      return WritableStream===custom && ReadableStream===original &&
+        Object.getOwnPropertyDescriptor(globalThis,'ReadableStream').writable===true &&
+        typeof TransformStream==='function';
+    })()"#,
+        config(),
+    )
+    .unwrap();
+    assert_eq!(result, Value::Bool(true));
+}
+
+#[test]
+fn p1_lazy_streams_preserve_defined_and_deleted_globals() {
+    let result = eval(r#"(async()=>{
+      const custom=function CustomReadable() {};
+      Object.defineProperty(globalThis,'ReadableStream',{value:custom,writable:true,configurable:true});
+      Object.defineProperty(globalThis,'WritableStream',{value:42,configurable:false});
+      delete globalThis.ByteLengthQueuingStrategy;
+      const transform=new TransformStream();
+      if(ReadableStream!==custom || WritableStream!==42 || 'ByteLengthQueuingStrategy' in globalThis)return false;
+      // Body branding uses the private constructor, even when the public name
+      // was replaced before the first load.
+      const response=new Response(transform.readable);
+      const writer=transform.writable.getWriter();
+      const reading=response.text();
+      await writer.write(new Uint8Array([65])); await writer.close();
+      return await reading==='A' && typeof CountQueuingStrategy==='function';
+    })()"#,config()).unwrap();
+    assert_eq!(result, Value::Bool(true));
+}
+
+#[test]
+fn p1_lazy_streams_allow_nonconfigurable_accessor() {
+    let result = eval(
+        r#"(()=>{
+      Object.defineProperty(globalThis,'ReadableStream',{configurable:false});
+      const constructor=ReadableStream;
+      const stream=new constructor();
+      return ReadableStream===constructor && stream instanceof constructor &&
+        typeof TransformStream==='function' && new Response(stream).body===stream;
+    })()"#,
+        config(),
+    )
+    .unwrap();
+    assert_eq!(result, Value::Bool(true));
+}
+
+#[test]
+fn p1_body_read_errors_do_not_wait_for_cancel() {
+    let result = eval(r#"(async()=>{
+      for(const method of ['text','json','arrayBuffer']) {
+        for(const cancellation of ['pending','reject','throw']) {
+          let canceled=false;
+          const stream=new ReadableStream({
+            start(c){c.enqueue('invalid HTTP chunk');},
+            cancel(){
+              canceled=true;
+              if(cancellation==='throw')throw new Error('cleanup failure');
+              return cancellation==='pending' ? new Promise(()=>{}) : Promise.reject(new Error('cleanup failure'));
+            },
+          });
+          const response=new Response(stream);
+          const result=await Promise.race([
+            response[method]().then(()=> 'success',e=>e instanceof TypeError ? 'TypeError' : e.message),
+            tysel.sleep(30).then(()=> 'timeout'),
+          ]);
+          if(result!=='TypeError'||!canceled||stream.locked||!response.bodyUsed)return false;
+        }
+      }
+      return true;
+    })()"#,config()).unwrap();
+    assert_eq!(result, Value::Bool(true));
+}
+
+#[test]
+fn p1_consumed_buffered_body_preserves_lazy_stream_state() {
+    let result=eval(r#"(async()=>{
+      const first=new Response('A');await first.text();
+      if(typeof Object.getOwnPropertyDescriptor(globalThis,'ReadableStream').get!=='function')return false;
+      for(const kind of ['response','request']) for(const method of ['text','json','arrayBuffer']) {
+        for(const early of [false,true])for(const binary of [false,true]) {
+          const data=binary?new TextEncoder().encode('{"ok":true}'):'{"ok":true}';
+          const owner=kind==='response'?new Response(data):new Request('http://local/',{method:'POST',body:data});
+          const initial=early?owner.body:null;
+          await owner[method]();
+          const body=owner.body;
+          if(!owner.bodyUsed||body!==owner.body||body.locked||(early&&body!==initial))return false;
+          try{new Response(body);return false;}catch(e){if(!(e instanceof TypeError))return false;}
+          try{owner.clone();return false;}catch(e){if(!(e instanceof TypeError))return false;}
+          const reader=body.getReader();
+          if(!(await reader.read()).done)return false;
+          reader.releaseLock();
+          try{await owner.text();return false;}catch(e){if(!(e instanceof TypeError))return false;}
+        }
+      }
+      const chunks=new Response([new Uint8Array([65]),'B']);await chunks.arrayBuffer();
+      try{new Response(chunks.body);return false;}catch(e){if(!(e instanceof TypeError))return false;}
+      return true;
+    })()"#,config()).unwrap();
+    assert_eq!(result, Value::Bool(true));
+}
+
+#[test]
+fn p1_headers_live_iteration_tracks_mutation() {
+    let result=eval(r#"(()=>{
+      const h=new Headers({a:'1',b:'2',c:'3'}),seen=[];
+      h.forEach((value,key)=>{seen.push([key,value]);if(key==='a'){h.delete('b');h.set('c','updated');h.append('d','4');}});
+      if(JSON.stringify(seen)!=='[["a","1"],["c","updated"],["d","4"]]')return false;
+      const entries=h.entries();entries.next();h.delete('c');
+      const copied=new Headers(entries);if(copied.has('c')||copied.get('d')!=='4')return false;
+      const cookies=new Headers([['a','1'],['set-cookie','first=1'],['set-cookie','second=2'],['z','last']]);
+      const iterator=cookies.entries();iterator.next();iterator.next();cookies.delete('set-cookie');
+      // Cursor indexes the current flattened list; it is already past z.
+      if(!iterator.next().done)return false;
+      cookies.append('zz','after end');
+      const resumed=iterator.next();
+      return !resumed.done && resumed.value[0]==='zz' && iterator.next().done;
+    })()"#,config()).unwrap();
+    assert_eq!(result, Value::Bool(true));
+}
diff --git a/crates/tysel-engine-qjs/src/pool.rs b/crates/tysel-engine-qjs/src/pool.rs
index 6150508..b976b30 100644
--- a/crates/tysel-engine-qjs/src/pool.rs
+++ b/crates/tysel-engine-qjs/src/pool.rs
@@ -71,6 +71,10 @@ pub(crate) type ResponseSender = oneshot::Sender<Result<PreparedHttpResponse, En
 pub enum OutgoingHttpBody {
     Buffered(Vec<u8>),
     Stream(mpsc::Receiver<Vec<u8>>),
+    CheckedStream {
+        chunks: mpsc::Receiver<Vec<u8>>,
+        completion: oneshot::Receiver<Result<(), EngineError>>,
+    },
 }
 
 struct Budgets {
@@ -145,6 +149,8 @@ impl IsolatePool {
         let body = match body {
             OutgoingHttpBody::Buffered(bytes) => sealed_response_body(bytes),
             OutgoingHttpBody::Stream(body) => body,
+            // Legacy chunk-only API cannot surface errors after the head.
+            OutgoingHttpBody::CheckedStream { chunks, .. } => chunks,
         };
         Ok((head, body))
     }
@@ -206,11 +212,23 @@ impl IsolatePool {
     /// workers use this from a blocking IPC thread.
     pub fn dispatch_sync(&self, request: HttpRequest) -> Result<(HttpHead, Vec<u8>), EngineError> {
         crate::queue::io_handle().block_on(async {
-            let (head, mut chunks) = self.dispatch(request).await?;
+            let (head, response) = self.dispatch_response(IncomingHttp::from(request)).await?;
             let mut body = Vec::new();
+            let (mut chunks, completion) = match response {
+                OutgoingHttpBody::Buffered(bytes) => return Ok((head, bytes)),
+                OutgoingHttpBody::Stream(chunks) => (chunks, None),
+                OutgoingHttpBody::CheckedStream { chunks, completion } => {
+                    (chunks, Some(completion))
+                }
+            };
             while let Some(chunk) = chunks.recv().await {
                 body.extend(chunk);
             }
+            if let Some(completion) = completion {
+                completion
+                    .await
+                    .map_err(|_| EngineError::Isolate("response stream interrupted".into()))??;
+            }
             Ok((head, body))
         })
     }
@@ -438,6 +456,12 @@ fn handle_job(
             return Err(err);
         }
     };
+    // Synchronous handlers also create microtasks (including weak-reference
+    // finalizers). Drain them within this request's budgets before returning.
+    if !pending && let Err(err) = isolate::drain_jobs(runtime, cancel, request_deadline, cpu) {
+        let _ = response_tx.send(Err(err.clone()));
+        return Err(err);
+    }
     if pending {
         if let Err(err) = isolate::wait_until_settled(
             runtime,
@@ -456,7 +480,21 @@ fn handle_job(
             return Err(err);
         }
     }
-    context.with(|ctx| fetch::emit_response(ctx, response_tx))?;
+    if let Some(completion) =
+        context.with(|ctx| fetch::emit_response(ctx, response_tx, &reactor.io))?
+    {
+        let result = isolate::wait_until_settled(
+            runtime,
+            context,
+            reactor,
+            cancel,
+            request_deadline,
+            cpu,
+            None,
+        );
+        completion.finish(result.clone());
+        result?;
+    }
     if context.with(fetch::arm_websocket)? {
         isolate::wait_until_settled(
             runtime,
diff --git a/crates/tysel-engine-qjs/src/queue.rs b/crates/tysel-engine-qjs/src/queue.rs
index 9596dbe..5ab3d1d 100644
--- a/crates/tysel-engine-qjs/src/queue.rs
+++ b/crates/tysel-engine-qjs/src/queue.rs
@@ -54,6 +54,8 @@ pub enum IoRequest {
     ReadBody { id: OpId },
     HttpGet { id: OpId, url: String, method: String, headers_json: String, body: Bytes },
     HttpRead { id: OpId, body_id: u64 },
+    ResponseClosed { id: OpId, tx: mpsc::Sender<Vec<u8>>, stop: tokio::sync::oneshot::Receiver<()> },
+    ResponseWrite { id: OpId, tx: mpsc::Sender<Vec<u8>>, bytes: Vec<u8> },
     WsRead { id: OpId },
     WsSend { id: OpId, data: String },
     WsClose { id: OpId },
@@ -84,6 +86,8 @@ impl IoRequest {
             | Self::ReadBody { id }
             | Self::HttpGet { id, .. }
             | Self::HttpRead { id, .. }
+            | Self::ResponseClosed { id, .. }
+            | Self::ResponseWrite { id, .. }
             | Self::WsRead { id }
             | Self::WsSend { id, .. }
             | Self::WsClose { id }
@@ -111,7 +115,9 @@ impl IoRequest {
             Self::Sleep { .. } => Cap::Sleep,
             Self::Echo { .. } => Cap::Echo,
             Self::SecretRef { .. } => Cap::SecretRef,
-            Self::ReadBody { .. } => Cap::ReadBody,
+            Self::ReadBody { .. } | Self::ResponseWrite { .. } | Self::ResponseClosed { .. } => {
+                Cap::ReadBody
+            }
             Self::HttpGet { .. } | Self::HttpRead { .. } => Cap::Fetch,
             Self::WsRead { .. }
             | Self::WsSend { .. }
@@ -158,6 +164,8 @@ impl IoRequest {
             | Self::Echo { .. }
             | Self::ReadBody { .. }
             | Self::HttpRead { .. }
+            | Self::ResponseClosed { .. }
+            | Self::ResponseWrite { .. }
             | Self::WsRead { .. } => None,
             Self::WsClientRead { .. } => None,
         }
@@ -835,7 +843,9 @@ async fn execute(
 ) -> IoCompletion {
     let audit = request.audit_target();
     let started = Instant::now();
-    if let Err(error) = crate::trust::require(request.capability()) {
+    if !matches!(request, IoRequest::ResponseWrite { .. } | IoRequest::ResponseClosed { .. })
+        && let Err(error) = crate::trust::require(request.capability())
+    {
         audit_log(audit, "denied", started, request_id);
         return IoCompletion { id: request.id(), result: Err(error) };
     }
@@ -851,6 +861,23 @@ async fn execute(
         IoRequest::SecretRef { id, name } => {
             IoCompletion { id, result: crate::secrets::refer(&name) }
         }
+        IoRequest::ResponseClosed { id, tx, stop } => IoCompletion {
+            id,
+            result: tokio::select! {
+                biased;
+                () = cancelled(&cancel, deadline) => Err(interrupt_err(&cancel, deadline)),
+                _ = stop => Err("response stream finished".into()),
+                () = tx.closed() => Ok(Value::Null),
+            },
+        },
+        IoRequest::ResponseWrite { id, tx, bytes } => IoCompletion {
+            id,
+            result: tokio::select! {
+                biased;
+                () = cancelled(&cancel, deadline) => Err(interrupt_err(&cancel, deadline)),
+                result = tx.send(bytes) => result.map(|()| Value::Null).map_err(|_| "response consumer closed".into()),
+            },
+        },
         IoRequest::ReadBody { id } => IoCompletion {
             id,
             result: slots
diff --git a/crates/tysel-engine-qjs/src/tests.rs b/crates/tysel-engine-qjs/src/tests.rs
index a773a03..e408932 100644
--- a/crates/tysel-engine-qjs/src/tests.rs
+++ b/crates/tysel-engine-qjs/src/tests.rs
@@ -3106,7 +3106,7 @@ fn response_chunk_consumption_and_clone_match_emitted_bytes() {
     let result = eval(r#"(async () => {
       const response = new Response([new Uint8Array([228]), new DataView(new Uint8Array([184,173]).buffer), '😀']);
       const clone = response.clone();
-      response.body[0][0] = 65;
+      response._body[0][0] = 65; // Internal snapshot check; public body is now a stream.
       if (await clone.text() !== '中😀') return false;
       if (String(new Uint8Array(await response.arrayBuffer())) !== '65,184,173,240,159,152,128') return false;
       try { await response.text(); return false; } catch (e) { if (!(e instanceof TypeError)) return false; }
@@ -3115,3 +3115,6 @@ fn response_chunk_consumption_and_clone_match_emitted_bytes() {
     })()"#, config()).unwrap();
     assert_eq!(result, Value::Bool(true));
 }
+
+#[path = "p1_tests.rs"]
+mod p1;
diff --git a/crates/tysel-runtime/src/http.rs b/crates/tysel-runtime/src/http.rs
index f872638..a387097 100644
--- a/crates/tysel-runtime/src/http.rs
+++ b/crates/tysel-runtime/src/http.rs
@@ -15,8 +15,9 @@ use hyper::service::service_fn;
 use hyper::{Request, Response, StatusCode};
 use hyper_util::rt::{TokioExecutor, TokioIo};
 use hyper_util::server::conn::auto;
+use std::future::Future;
 use tokio::net::TcpListener;
-use tokio::sync::mpsc;
+use tokio::sync::{mpsc, oneshot};
 use tokio_tungstenite::WebSocketStream;
 use tokio_tungstenite::tungstenite::Message;
 use tokio_tungstenite::tungstenite::handshake::derive_accept_key;
@@ -848,6 +849,11 @@ async fn dispatch_inner(
             HttpBody::once(bytes)
         }
         OutgoingHttpBody::Stream(chunks) => HttpBody::stream(chunks, limits.max_response_bytes),
+        OutgoingHttpBody::CheckedStream { chunks, completion } => {
+            let mut body = HttpBody::stream(chunks, limits.max_response_bytes);
+            body.completion = Some(completion);
+            body
+        }
     };
     builder.body(body).map_err(|err| HttpError::Hyper(err.to_string()))
 }
@@ -946,21 +952,22 @@ enum HttpBodyKind {
 }
 
 pub struct HttpBody {
+    completion: Option<oneshot::Receiver<Result<(), EngineError>>>,
     kind: HttpBodyKind,
     permit: Option<AdmissionPermit>,
 }
 
 impl HttpBody {
     fn once(bytes: Vec<u8>) -> Self {
-        Self { kind: HttpBodyKind::Once(Some(Bytes::from(bytes))), permit: None }
+        Self { completion: None, kind: HttpBodyKind::Once(Some(Bytes::from(bytes))), permit: None }
     }
 
     fn empty() -> Self {
-        Self { kind: HttpBodyKind::Once(None), permit: None }
+        Self { completion: None, kind: HttpBodyKind::Once(None), permit: None }
     }
 
     fn stream(rx: mpsc::Receiver<Vec<u8>>, limit: usize) -> Self {
-        Self { kind: HttpBodyKind::Stream { rx, remaining: limit }, permit: None }
+        Self { completion: None, kind: HttpBodyKind::Stream { rx, remaining: limit }, permit: None }
     }
 
     fn hold_permit(&mut self, permit: AdmissionPermit) {
@@ -996,6 +1003,25 @@ impl Body for HttpBody {
                     Poll::Ready(Some(Err(io::Error::other("response body limit exceeded"))))
                 }
                 Poll::Ready(None) => {
+                    if let Some(completion) = &mut this.completion {
+                        let result = match Pin::new(completion).poll(cx) {
+                            Poll::Pending => return Poll::Pending,
+                            Poll::Ready(result) => result,
+                        };
+                        this.completion = None;
+                        this.permit.take();
+                        match result {
+                            Ok(Ok(())) => {}
+                            Ok(Err(error)) => {
+                                return Poll::Ready(Some(Err(io::Error::other(error.to_string()))));
+                            }
+                            Err(_) => {
+                                return Poll::Ready(Some(Err(io::Error::other(
+                                    "response stream interrupted",
+                                ))));
+                            }
+                        }
+                    }
                     this.permit.take();
                     Poll::Ready(None)
                 }
@@ -1064,3 +1090,26 @@ mod body_tests {
         assert_eq!(admission.available(), 1);
     }
 }
+
+#[cfg(test)]
+mod stream_completion_tests {
+    use super::*;
+    use http_body_util::BodyExt;
+
+    #[tokio::test]
+    async fn stream_error_is_not_reported_as_clean_eof() {
+        let (tx, rx) = mpsc::channel(1);
+        let (done, completion) = oneshot::channel();
+        let mut body = HttpBody::stream(rx, 1024);
+        body.completion = Some(completion);
+        tx.send(vec![65]).await.unwrap();
+        drop(tx);
+        done.send(Err(EngineError::Isolate("broken stream".into()))).unwrap();
+        assert_eq!(
+            body.frame().await.unwrap().unwrap().into_data().unwrap(),
+            Bytes::from_static(b"A")
+        );
+        assert!(body.frame().await.unwrap().unwrap_err().to_string().contains("broken stream"));
+        assert!(body.frame().await.is_none());
+    }
+}
diff --git a/runtime-js/scripts/build-runtime.mjs b/runtime-js/scripts/build-runtime.mjs
index 86f1996..1ed04bd 100644
--- a/runtime-js/scripts/build-runtime.mjs
+++ b/runtime-js/scripts/build-runtime.mjs
@@ -16,6 +16,8 @@ const targets = [
     sources: [
       "web-api/source/event.js",
       "web-api/source/url.js",
+      "web-api/source/utilities.js",
+      "web-api/vendor/web-streams-polyfill/polyfill.js",
       "web-api/source/http.js",
       "web-api/source/encoding.js",
       "web-api/source/timers.js",
@@ -42,7 +44,47 @@ const targets = [
 ];
 
 function readSource(path) {
-  return readFileSync(resolve(root, path), "utf8").replaceAll("\r\n", "\n").trimEnd();
+  const source = readFileSync(resolve(root, path), "utf8").replaceAll("\r\n", "\n").trimEnd();
+  if (path === "web-api/vendor/web-streams-polyfill/polyfill.js") {
+    const license = readFileSync(resolve(root, "web-api/vendor/web-streams-polyfill/LICENSE"), "utf8").trimEnd();
+    const globals = [
+      "ReadableStream", "ReadableStreamDefaultController", "ReadableByteStreamController",
+      "ReadableStreamBYOBRequest", "ReadableStreamDefaultReader", "ReadableStreamBYOBReader",
+      "WritableStream", "WritableStreamDefaultController", "WritableStreamDefaultWriter",
+      "ByteLengthQueuingStrategy", "CountQueuingStrategy", "TransformStream", "TransformStreamDefaultController",
+    ];
+    return `/*\n${license}\n*/\n(() => {
+  let constructors;
+  let slots = [];
+  function load() {
+    if (constructors) return;
+    // Evaluate against a private global facade: vendor installation must never
+    // overwrite an application's replacements or fail on sealed globals.
+    constructors = tysel._loadStreams();
+    for (const [name, get, set] of slots) {
+      const descriptor = Object.getOwnPropertyDescriptor(globalThis, name);
+      if (descriptor && descriptor.configurable && descriptor.get === get && descriptor.set === set) {
+        Object.defineProperty(globalThis, name, {
+          value: constructors[name], writable: true, configurable: true,
+        });
+      }
+    }
+    slots = null;
+  }
+  // Buffered bodies must not trigger loading merely to test instanceof.
+  globalThis.__tysel_isReadableStream = value => constructors !== undefined && value instanceof constructors.ReadableStream;
+  for (const name of ${JSON.stringify(globals)}) {
+    const get = () => { load(); return constructors[name]; };
+    const set = value => {
+      load();
+      Object.defineProperty(globalThis, name, {value, writable: true, configurable: true});
+    };
+    slots.push([name, get, set]);
+    Object.defineProperty(globalThis, name, {configurable: true, get, set});
+  }
+})();`;
+  }
+  return source;
 }
 
 function build(target) {
diff --git a/runtime-js/source/README.md b/runtime-js/source/README.md
index c82b05a..1fd55cb 100644
--- a/runtime-js/source/README.md
+++ b/runtime-js/source/README.md
@@ -7,3 +7,6 @@ repository check uses `--check` and fails when a generated artifact is stale.
 Web API and capability-client sources are independently scoped scripts. Durable
 sources are ordered `.part.js` fragments because they deliberately share one
 replay-state closure; they are syntax-checked after deterministic assembly.
+
+The Streams vendor snapshot is a pinned, separately licensed build input under
+`web-api/vendor/`; see its README for provenance and update instructions.
diff --git a/runtime-js/test/encoding.test.mjs b/runtime-js/test/encoding.test.mjs
new file mode 100644
index 0000000..2db8993
--- /dev/null
+++ b/runtime-js/test/encoding.test.mjs
@@ -0,0 +1,40 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import vm from 'node:vm';
+import test from 'node:test';
+
+const NativeDecoder = globalThis.TextDecoder;
+test('incremental UTF-8 agrees with native decoding across malformed and split input', () => {
+  const context = vm.createContext({tysel: {
+    _utf8Decode(bytes, fatal) { return new NativeDecoder('utf-8', {fatal, ignoreBOM: true}).decode(bytes); },
+  }});
+  vm.runInContext(readFileSync(new URL('../web-api/source/encoding.js', import.meta.url), 'utf8'), context);
+  const custom = vm.runInContext(`(input, widths, fatal) => {
+    const decoder = new TextDecoder('utf-8', {fatal});
+    const output = []; let offset = 0;
+    try {
+      for (const width of widths) {
+        output.push(decoder.decode(new Uint8Array(input.slice(offset, offset + width)), {stream:true}));
+        offset += width;
+      }
+      output.push(decoder.decode());
+      return JSON.stringify(output);
+    } catch (error) { return JSON.stringify({output, error:error.name}); }
+  }`, context);
+  const cases = [[239,187,191,228,184,173,240,159,152,128], [224,128], [237,160,128], [244,144,128,128], [226,130]];
+  let seed = 47829;
+  for (let i=0;i<300;i++) {
+    const bytes=[];
+    for(let j=0;j<12;j++) { seed=(Math.imul(seed,1664525)+1013904223)>>>0; bytes.push(seed>>>24); }
+    cases.push(bytes);
+  }
+  for (const input of cases) for (const fatal of [false,true]) for (const chunkSize of [1,2,3,5]) {
+    const widths=[];for(let i=0;i<input.length;i+=chunkSize) widths.push(Math.min(chunkSize,input.length-i));
+    const decoder=new NativeDecoder('utf-8',{fatal});const output=[];let offset=0, expected;
+    try {
+      for(const width of widths) {output.push(decoder.decode(new Uint8Array(input.slice(offset,offset+width)),{stream:true}));offset+=width;}
+      output.push(decoder.decode());expected=JSON.stringify(output);
+    } catch(error) {expected=JSON.stringify({output,error:error.name});}
+    assert.equal(custom(input,widths,fatal),expected,JSON.stringify({input,widths,fatal}));
+  }
+});
diff --git a/runtime-js/test/headers.test.mjs b/runtime-js/test/headers.test.mjs
new file mode 100644
index 0000000..b9b7fa3
--- /dev/null
+++ b/runtime-js/test/headers.test.mjs
@@ -0,0 +1,43 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import vm from 'node:vm';
+import test from 'node:test';
+const context=vm.createContext({});
+vm.runInContext(fs.readFileSync(new URL('../web-api/source/http.js',import.meta.url),'utf8'),context);
+const CustomHeaders=vm.runInContext('Headers',context);
+
+test('Headers live iteration follows mutation for entries, keys and values',()=>{
+  const cases=[
+    [['next'],['next'],['next'],['next'],['next'],['append','z','after end'],['next'],['next']],
+    [['next'],['delete','b'],['next'],['next']],
+    [['next'],['delete','a'],['next'],['next']],
+    [['next'],['set','b','updated'],['next'],['next']],
+    [['next'],['append','b','extra'],['next'],['next']],
+    [['next'],['set','0','before'],['next'],['next'],['next'],['next']],
+    [['next'],['append','z','after'],['next'],['next'],['next'],['next']],
+    [['next'],['next'],['set','set-cookie','replacement'],['next'],['next'],['next']],
+    [['next'],['next'],['delete','set-cookie'],['next'],['next']],
+    [['next'],['next'],['append','set-cookie','third=3'],['next'],['next'],['next'],['next']],
+  ];
+  for(const method of ['entries','keys','values'])for(const actions of cases) {
+    const run=Constructor=>{
+      const headers=new Constructor([['a','1'],['b','2'],['set-cookie','first=1'],['set-cookie','second=2']]);
+      const iterator=headers[method](),output=[];
+      for(const [operation,...args] of actions) {
+        if(operation==='next')output.push(iterator.next());else headers[operation](...args);
+      }
+      return JSON.stringify(output);
+    };
+    assert.equal(run(CustomHeaders),run(Headers),JSON.stringify({method,actions}));
+  }
+});
+
+test('Headers forEach and reconstruction do not resurrect deleted headers',()=>{
+  const h=new CustomHeaders({a:'1',b:'2',c:'3'}),seen=[];
+  h.forEach((value,key)=>{seen.push([key,value]);if(key==='a'){h.delete('b');h.set('c','updated');h.append('d','4');}});
+  assert.equal(JSON.stringify(seen),JSON.stringify([['a','1'],['c','updated'],['d','4']]));
+  const iterator=h.entries();iterator.next();h.delete('c');
+  const copy=new CustomHeaders(iterator);
+  assert.equal(copy.has('c'),false);assert.equal(copy.get('d'),'4');
+  const first=h.entries().next().value;first[1]='modified';assert.equal(h.get('a'),'1');
+});
diff --git a/runtime-js/test/runtime.test.mjs b/runtime-js/test/runtime.test.mjs
index 3e74354..ff2b470 100644
--- a/runtime-js/test/runtime.test.mjs
+++ b/runtime-js/test/runtime.test.mjs
@@ -163,3 +163,14 @@ test("@tysel/types is a standalone public contract for the runtime surface", ()
   assert.match(capabilities, /export interface TyselRuntime/);
   assert.match(webApi, /export interface TyselWebApiGlobals/);
 });
+
+test("vendored Streams snapshot matches its recorded checksum", async () => {
+  const { createHash } = await import('node:crypto');
+  const root = new URL('../web-api/vendor/web-streams-polyfill/', import.meta.url);
+  const bytes = readFileSync(new URL('polyfill.js', root));
+  const readme = readFileSync(new URL('README.md', root), 'utf8');
+  assert.ok(readme.includes(createHash('sha256').update(bytes).digest('hex')));
+  assert.match(readFileSync(new URL('LICENSE', root), 'utf8'), /Permission is hereby granted/);
+  assert.match(bytes.toString(), /web-streams-polyfill v4\.3\.0/);
+  assert.ok(readFileSync(new URL('../web-api/runtime.js', import.meta.url), 'utf8').includes(readFileSync(new URL('LICENSE', root), 'utf8').trimEnd()));
+});
diff --git a/runtime-js/web-api/compatibility.json b/runtime-js/web-api/compatibility.json
index b3db1ec..f470d26 100644
--- a/runtime-js/web-api/compatibility.json
+++ b/runtime-js/web-api/compatibility.json
@@ -12,61 +12,178 @@
         "live search and searchParams mutation",
         "iterable and record URLSearchParams initialization"
       ],
-      "unsupported": ["full WHATWG parsing", "IDNA", "username/password properties", "file and blob URLs"]
+      "unsupported": [
+        "full WHATWG parsing",
+        "IDNA",
+        "username/password properties",
+        "file and blob URLs"
+      ]
     },
     {
       "name": "Headers",
       "status": "partial",
-      "supported": ["record, Headers, and pair initialization", "get/set/append/delete/has", "stable iteration"],
-      "unsupported": ["browser header guards", "Set-Cookie splitting", "full HTTP token validation"]
+      "supported": [
+        "record, Headers, and pair initialization",
+        "get/set/append/delete/has",
+        "live sorted iteration across header mutations",
+        "iterable pair initialization",
+        "HTTP token and CR/LF validation",
+        "independent Set-Cookie values and getSetCookie snapshots"
+      ],
+      "unsupported": [
+        "browser header guards"
+      ]
     },
     {
       "name": "Request and Response",
       "status": "partial",
-      "supported": ["string, ArrayBuffer, and ArrayBufferView request/response bodies with byte-preserving consumption", "single-use json/text/arrayBuffer consumption", "bodyUsed", "buffered request and response clone", "streamed host request and response bodies", "UTF-8 decoding after byte collection, including split code points and BOM handling", "Tysel response chunk arrays with snapshotted string/ArrayBuffer/ArrayBufferView elements"],
-      "unsupported": ["public ReadableStream bodies", "formData/blob helpers", "stream teeing and streamed response clone", "browser cache/credentials/mode semantics"]
+      "supported": [
+        "string, ArrayBuffer, and ArrayBufferView request/response bodies with byte-preserving consumption",
+        "single-use json/text/arrayBuffer consumption",
+        "bodyUsed",
+        "buffered request and response clone",
+        "streamed host request and response bodies",
+        "UTF-8 decoding after byte collection, including split code points and BOM handling",
+        "Tysel response chunk arrays with snapshotted string/ArrayBuffer/ArrayBufferView elements",
+        "lazy ReadableStream body access with locking and disturbance",
+        "Response with a ReadableStream of Uint8Array chunks, native backpressure and cancellation"
+      ],
+      "unsupported": [
+        "formData/blob helpers",
+        "streamed request and response clone",
+        "browser cache/credentials/mode semantics"
+      ]
     },
     {
       "name": "TextEncoder and TextDecoder",
       "status": "partial",
-      "supported": ["UTF-8 encode and decode"],
-      "unsupported": ["legacy encodings", "streaming decode options"]
+      "supported": [
+        "UTF-8 encode and decode",
+        "stateful UTF-8 decode with stream option and final flush",
+        "TextDecoderStream over TransformStream"
+      ],
+      "unsupported": [
+        "legacy encodings",
+        "TextEncoder.encodeInto"
+      ]
     },
     {
       "name": "Timers",
       "status": "supported",
-      "supported": ["setTimeout", "clearTimeout", "setInterval", "clearInterval", "isolate reset cleanup"],
+      "supported": [
+        "setTimeout",
+        "clearTimeout",
+        "setInterval",
+        "clearInterval",
+        "isolate reset cleanup"
+      ],
       "unsupported": []
     },
     {
       "name": "Event and EventTarget",
       "status": "partial",
-      "supported": ["function and object listeners", "listener deduplication and removal", "once and AbortSignal options", "preventDefault and immediate propagation stop"],
-      "unsupported": ["DOM event trees", "capture and bubble phases", "browser exception reporting"]
+      "supported": [
+        "function and object listeners",
+        "listener deduplication and removal",
+        "once and AbortSignal options",
+        "preventDefault and immediate propagation stop"
+      ],
+      "unsupported": [
+        "DOM event trees",
+        "capture and bubble phases",
+        "browser exception reporting"
+      ]
     },
     {
       "name": "AbortController and AbortSignal",
       "status": "partial",
-      "supported": ["abort reason", "throwIfAborted", "AbortSignal.abort", "AbortSignal.timeout", "fetch and response-body cancellation"],
-      "unsupported": ["AbortSignal.any"]
+      "supported": [
+        "abort reason",
+        "throwIfAborted",
+        "AbortSignal.abort",
+        "AbortSignal.timeout",
+        "fetch and response-body cancellation",
+        "AbortSignal.any with first reason and dependency cleanup"
+      ],
+      "unsupported": [
+        "browser task scheduling guarantees"
+      ]
     },
     {
       "name": "Crypto",
       "status": "partial",
-      "supported": ["getRandomValues", "SHA-256/384/512 digest", "raw HMAC import/sign/verify"],
-      "unsupported": ["randomUUID", "key export", "encryption", "asymmetric algorithms"]
+      "supported": [
+        "getRandomValues",
+        "SHA-256/384/512 digest",
+        "raw HMAC import/sign/verify",
+        "randomUUID (cryptographic UUID v4)"
+      ],
+      "unsupported": [
+        "key export",
+        "encryption",
+        "asymmetric algorithms"
+      ]
     },
     {
       "name": "fetch",
       "status": "partial",
-      "supported": ["HTTP methods allowed by host policy", "headers and byte-preserving buffered request bodies", "redirect policy", "streamed response consumption", "AbortSignal cancellation"],
-      "unsupported": ["streaming request bodies", "multipart/form data", "browser cache/credentials/mode semantics"]
+      "supported": [
+        "HTTP methods allowed by host policy",
+        "headers and byte-preserving buffered request bodies",
+        "redirect policy",
+        "streamed response consumption",
+        "AbortSignal cancellation",
+        "response.body reader, async iteration and cancellation",
+        "multiple Set-Cookie headers preserved"
+      ],
+      "unsupported": [
+        "streaming request bodies",
+        "multipart/form data",
+        "browser cache/credentials/mode semantics"
+      ]
     },
     {
       "name": "WebSocket",
       "status": "partial",
-      "supported": ["outbound and accepted sockets", "text messages", "open/message/error/close listeners", "once and listener removal", "native cleanup on isolate reuse"],
-      "unsupported": ["subprotocol negotiation", "extensions", "Blob messages", "bufferedAmount"]
+      "supported": [
+        "outbound and accepted sockets",
+        "text messages",
+        "open/message/error/close listeners",
+        "once and listener removal",
+        "native cleanup on isolate reuse"
+      ],
+      "unsupported": [
+        "subprotocol negotiation",
+        "extensions",
+        "Blob messages",
+        "bufferedAmount"
+      ]
+    },
+    {
+      "name": "Streams",
+      "status": "partial",
+      "supported": [
+        "ReadableStream default readers and async iteration",
+        "WritableStream writer locks, ready and serial writes",
+        "TransformStream, pipeThrough, pipeTo with backpressure and AbortSignal",
+        "tee, cancellation and error propagation",
+        "ByteLengthQueuingStrategy and CountQueuingStrategy"
+      ],
+      "unsupported": [
+        "HTTP streaming uploads",
+        "HTTP body BYOB readers",
+        "transfer of host-owned external buffers",
+        "streamed Body.clone"
+      ]
+    },
+    {
+      "name": "Microtasks and base64",
+      "status": "supported",
+      "supported": [
+        "queueMicrotask with callback validation, native job ordering and request-generation cleanup",
+        "atob and btoa with Latin-1 binary strings and InvalidCharacterError"
+      ],
+      "unsupported": []
     }
   ]
 }
diff --git a/runtime-js/web-api/index.ts b/runtime-js/web-api/index.ts
index 0f2d04a..142220d 100644
--- a/runtime-js/web-api/index.ts
+++ b/runtime-js/web-api/index.ts
@@ -1,3 +1,6 @@
+import type * as Streams from "./vendor/web-streams-polyfill/types.js";
+export type { ReadableStream, WritableStream, TransformStream, ReadableStreamDefaultReader, WritableStreamDefaultWriter, QueuingStrategy } from "./vendor/web-streams-polyfill/types.js";
+
 /** Versioned, server-side Web API subset installed into each isolate. */
 export const webApiVersion = "0.2.0";
 
@@ -89,6 +92,7 @@ export interface TyselHeaders extends Iterable<[string, string]> {
   append(name: string, value: string): void;
   delete(name: string): void;
   get(name: string): string | null;
+  getSetCookie(): string[];
   has(name: string): boolean;
   set(name: string, value: string): void;
   entries(): IterableIterator<[string, string]>;
@@ -127,7 +131,7 @@ export interface TyselBody {
 }
 
 export interface TyselRequest extends TyselBody {
-  readonly body: unknown | null;
+  readonly body: Streams.ReadableStream<Uint8Array> | null;
   readonly url: string;
   readonly method: string;
   readonly headers: TyselHeaders;
@@ -136,7 +140,7 @@ export interface TyselRequest extends TyselBody {
 }
 
 export interface TyselResponse extends TyselBody {
-  readonly body: unknown | null;
+  readonly body: Streams.ReadableStream<Uint8Array> | null;
   readonly status: number;
   readonly ok: boolean;
   readonly headers: TyselHeaders;
@@ -193,6 +197,7 @@ export type TyselIntegerTypedArray =
   | BigUint64Array;
 
 export interface TyselCrypto {
+  randomUUID(): string;
   getRandomValues<T extends TyselIntegerTypedArray>(typedArray: T): T;
   readonly subtle: TyselSubtleCrypto;
 }
@@ -206,7 +211,7 @@ export interface TyselTextDecoder {
   readonly encoding: "utf-8";
   readonly fatal: boolean;
   readonly ignoreBOM: boolean;
-  decode(input?: BufferSource): string;
+  decode(input?: BufferSource, options?: { stream?: boolean }): string;
 }
 
 export type TyselFetch = (
@@ -228,19 +233,35 @@ export interface TyselWebApiGlobals {
   Headers: new (init?: TyselHeadersInit) => TyselHeaders;
   Request: new (input: string | TyselRequest, init?: TyselRequestInit) => TyselRequest;
   Response: {
-    new (body?: TyselBodyInit | readonly TyselBodyInit[] | null, init?: TyselResponseInit): TyselResponse;
+    new (body?: TyselBodyInit | readonly TyselBodyInit[] | Streams.ReadableStream<Uint8Array> | null, init?: TyselResponseInit): TyselResponse;
     json(data: unknown, init?: TyselResponseInit): TyselResponse;
   };
   AbortController: new () => TyselAbortController;
   AbortSignal: {
     abort(reason?: unknown): TyselAbortSignal;
     timeout(milliseconds: number): TyselAbortSignal;
+    any(signals: Iterable<TyselAbortSignal>): TyselAbortSignal;
   };
   TextEncoder: new () => TyselTextEncoder;
   TextDecoder: new (
     label?: "utf-8" | "utf8",
     options?: { fatal?: boolean; ignoreBOM?: boolean },
   ) => TyselTextDecoder;
+  ReadableStream: typeof Streams.ReadableStream;
+  WritableStream: typeof Streams.WritableStream;
+  TransformStream: typeof Streams.TransformStream;
+  ByteLengthQueuingStrategy: typeof Streams.ByteLengthQueuingStrategy;
+  CountQueuingStrategy: typeof Streams.CountQueuingStrategy;
+  TextDecoderStream: new (label?: "utf-8" | "utf8", options?: {fatal?: boolean; ignoreBOM?: boolean}) => {
+    readonly encoding: "utf-8";
+    readonly fatal: boolean;
+    readonly ignoreBOM: boolean;
+    readonly readable: Streams.ReadableStream<string>;
+    readonly writable: Streams.WritableStream<any>; // Runtime validates BufferSource; permits piping every byte-view stream.
+  };
+  queueMicrotask(callback: () => void): void;
+  atob(input: string): string;
+  btoa(input: string): string;
   crypto: TyselCrypto;
   fetch: TyselFetch;
   setTimeout(
diff --git a/runtime-js/web-api/runtime.js b/runtime-js/web-api/runtime.js
index 8a4c882..be330ba 100644
--- a/runtime-js/web-api/runtime.js
+++ b/runtime-js/web-api/runtime.js
@@ -434,62 +434,183 @@
   globalThis.URLSearchParams = URLSearchParams;
 })();
 
+// source: web-api/source/utilities.js
+(() => {
+  globalThis.queueMicrotask = function(callback) {
+    if (typeof callback !== "function") throw new TypeError("callback must be a function");
+    const generation = globalThis.__tysel_request_generation;
+    tysel._queueMicrotask(() => {
+      if (generation === globalThis.__tysel_request_generation) callback();
+    });
+  };
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  globalThis.btoa = function(input) {
+    const text = String(input);
+    const output = [];
+    for (let i = 0; i < text.length; i += 3) {
+      const a = text.charCodeAt(i), b = text.charCodeAt(i + 1), c = text.charCodeAt(i + 2);
+      if (a > 255 || b > 255 || c > 255) throw new DOMException("Invalid character", "InvalidCharacterError");
+      output.push(alphabet[a >> 2], alphabet[((a & 3) << 4) | ((b || 0) >> 4)],
+        i + 1 < text.length ? alphabet[((b & 15) << 2) | ((c || 0) >> 6)] : "=",
+        i + 2 < text.length ? alphabet[c & 63] : "=");
+    }
+    return output.join("");
+  };
+  globalThis.atob = function(input) {
+    let text = String(input).replace(/[\t\n\f\r ]/g, "");
+    if (text.length % 4 === 0) text = text.replace(/==?$/, "");
+    if (text.length % 4 === 1 || /[^A-Za-z0-9+/]/.test(text)) {
+      throw new DOMException("Invalid base64", "InvalidCharacterError");
+    }
+    let bits = 0, count = 0;
+    const output = [];
+    for (const char of text) {
+      bits = (bits << 6) | alphabet.indexOf(char);
+      count += 6;
+      if (count >= 8) { count -= 8; output.push(String.fromCharCode((bits >> count) & 255)); }
+    }
+    return output.join("");
+  };
+})();
+
+// source: web-api/vendor/web-streams-polyfill/polyfill.js
+/*
+The MIT License (MIT)
+
+Copyright (c) 2026 Mattias Buelens
+Copyright (c) 2016 Diwank Singh Tomer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+(() => {
+  let constructors;
+  let slots = [];
+  function load() {
+    if (constructors) return;
+    // Evaluate against a private global facade: vendor installation must never
+    // overwrite an application's replacements or fail on sealed globals.
+    constructors = tysel._loadStreams();
+    for (const [name, get, set] of slots) {
+      const descriptor = Object.getOwnPropertyDescriptor(globalThis, name);
+      if (descriptor && descriptor.configurable && descriptor.get === get && descriptor.set === set) {
+        Object.defineProperty(globalThis, name, {
+          value: constructors[name], writable: true, configurable: true,
+        });
+      }
+    }
+    slots = null;
+  }
+  // Buffered bodies must not trigger loading merely to test instanceof.
+  globalThis.__tysel_isReadableStream = value => constructors !== undefined && value instanceof constructors.ReadableStream;
+  for (const name of ["ReadableStream","ReadableStreamDefaultController","ReadableByteStreamController","ReadableStreamBYOBRequest","ReadableStreamDefaultReader","ReadableStreamBYOBReader","WritableStream","WritableStreamDefaultController","WritableStreamDefaultWriter","ByteLengthQueuingStrategy","CountQueuingStrategy","TransformStream","TransformStreamDefaultController"]) {
+    const get = () => { load(); return constructors[name]; };
+    const set = value => {
+      load();
+      Object.defineProperty(globalThis, name, {value, writable: true, configurable: true});
+    };
+    slots.push([name, get, set]);
+    Object.defineProperty(globalThis, name, {configurable: true, get, set});
+  }
+})();
+
 // source: web-api/source/http.js
 (() => {
+  function headerName(name) {
+    const key = String(name).toLowerCase();
+    if (!/^[!#$%&'*+.^_`|~0-9a-z-]+$/.test(key)) throw new TypeError("invalid header name");
+    return key;
+  }
+  function headerValue(value) {
+    const text = String(value).replace(/^[ \t]+|[ \t]+$/g, "");
+    if (/[\r\n\0]/.test(text)) throw new TypeError("invalid header value");
+    return text;
+  }
+  function headerIterator(headers, kind) {
+    let version = -1, entries, index = 0;
+    return {
+      [Symbol.iterator]() { return this; },
+      next() {
+        // Web IDL indexes the current sorted list, including separate cookies.
+        // Rebuild only after mutation. Reaching the end does not freeze the list.
+        if (version !== headers._version) {
+          entries = [];
+          for (const key of Object.keys(headers._map).sort()) {
+            if (key === "set-cookie") {
+              for (const cookie of headers._cookies) entries.push([key, cookie]);
+            } else entries.push([key, headers._map[key]]);
+          }
+          version = headers._version;
+        }
+        if (index >= entries.length) return {value: undefined, done: true};
+        const pair = entries[index++];
+        return {value: kind === "keys" ? pair[0] : kind === "values" ? pair[1] : pair, done: false};
+      },
+    };
+  }
+
   class Headers {
     constructor(init) {
-      this._map = {};
-      if (!init) return;
-      // Arrays have forEach, so the sequence form must be checked first.
-      if (Array.isArray(init)) {
-        for (const pair of init) this.append(pair[0], pair[1]);
-      } else if (typeof init.forEach === "function") {
-        init.forEach((value, key) => this.append(key, value));
+      this._map = Object.create(null);
+      this._cookies = [];
+      this._version = 0;
+      if (init == null) return;
+      if (typeof init[Symbol.iterator] === "function") {
+        for (const item of init) {
+          const pair = Array.from(item);
+          if (pair.length !== 2) throw new TypeError("header pair must have two items");
+          this.append(pair[0], pair[1]);
+        }
       } else {
         for (const key of Object.keys(init)) this.append(key, init[key]);
       }
     }
-    get(name) {
-      const value = this._map[String(name).toLowerCase()];
-      return value === undefined ? null : value;
-    }
+    get(name) { return this._map[headerName(name)] ?? null; }
+    getSetCookie() { return this._cookies.slice(); }
     set(name, value) {
-      this._map[String(name).toLowerCase()] = String(value);
+      const key = headerName(name), text = headerValue(value);
+      this._map[key] = text;
+      this._version++;
+      if (key === "set-cookie") this._cookies = [text];
     }
     append(name, value) {
-      const key = String(name).toLowerCase();
+      const key = headerName(name), text = headerValue(value);
       const prev = this._map[key];
-      this._map[key] = prev == null ? String(value) : prev + ", " + String(value);
-    }
-    has(name) {
-      return Object.prototype.hasOwnProperty.call(this._map, String(name).toLowerCase());
+      this._map[key] = prev == null ? text : prev + ", " + text;
+      this._version++;
+      if (key === "set-cookie") this._cookies.push(text);
     }
+    has(name) { return Object.hasOwn(this._map, headerName(name)); }
     delete(name) {
-      delete this._map[String(name).toLowerCase()];
-    }
-    _names() {
-      return Object.keys(this._map).sort();
-    }
-    forEach(callback, thisArg) {
-      for (const key of this._names()) {
-        callback.call(thisArg, this._map[key], key, this);
-      }
-    }
-    entries() {
-      return this._names().map((key) => [key, this._map[key]])[Symbol.iterator]();
-    }
-    keys() {
-      return this._names()[Symbol.iterator]();
-    }
-    values() {
-      return this._names().map((key) => this._map[key])[Symbol.iterator]();
-    }
-    [Symbol.iterator]() {
-      return this.entries();
-    }
+      const key = headerName(name);
+      delete this._map[key];
+      this._version++;
+      if (key === "set-cookie") this._cookies = [];
+    }
+    entries() { return headerIterator(this, "entries"); }
+    keys() { return headerIterator(this, "keys"); }
+    values() { return headerIterator(this, "values"); }
+    forEach(callback, thisArg) { for (const [key, value] of this) callback.call(thisArg, value, key, this); }
+    [Symbol.iterator]() { return this.entries(); }
   }
 
   function bodyBytes(body) {
+    if (globalThis.__tysel_isReadableStream(body)) throw new TypeError("streaming uploads are not supported");
     if (body == null) return new Uint8Array(0);
     if (Array.isArray(body)) {
       const chunks = body.map(bodyBytes);
@@ -531,49 +652,96 @@
     return bytes;
   }
 
+  function used(owner) {
+    // Adapter to the pinned web-streams-polyfill's disturbed flag. Covered by
+    // reader/pipe/async-iteration lifecycle tests when updating the vendor.
+    return owner._bodyUsed || Boolean(owner._bodyStream && owner._bodyStream._disturbed);
+  }
+  function getBody(owner) {
+    if (owner._bodyStream) return owner._bodyStream;
+    if (!owner._stream && owner._body == null) return null;
+    if (owner._bodyUsed) {
+      // The buffered fast path consumed the body without initializing Streams.
+      // Materialize the same closed, disturbed, unlocked state as consumeBytes.
+      // A public read marks disturbance synchronously without vendor field writes.
+      const stream = new ReadableStream({ start(controller) { controller.close(); } });
+      const reader = stream.getReader();
+      reader.read();
+      reader.releaseLock();
+      owner._bodyStream = stream;
+      return stream;
+    }
+    const host = owner._stream;
+    const generation = owner._generation;
+    let operation = null;
+    let index = 0;
+    const chunks = Array.isArray(owner._body) ? owner._body : [owner._body];
+    owner._bodyStream = new ReadableStream({
+      async pull(controller) {
+        if (used(owner) && owner._bodyUsed) throw new TypeError("body has already been consumed");
+        if (host) {
+          if (generation !== globalThis.__tysel_request_generation) throw new TypeError("body belongs to a completed request");
+          operation = owner instanceof Request ? tysel._readBodyOp() : tysel._httpRead(owner._bodyId);
+          try {
+            const chunk = await globalThis.__tysel_awaitOperation(operation, owner._signal || owner.signal);
+            if (chunk == null) {
+              controller.close();
+              if (owner._abortCleanup) owner._abortCleanup();
+            } else controller.enqueue(chunk);
+          } finally { operation = null; }
+        } else {
+          if (index < chunks.length) controller.enqueue(bodyBytes(chunks[index++]));
+          if (index === chunks.length) controller.close();
+        }
+      },
+      cancel() {
+        if (host && generation === globalThis.__tysel_request_generation) {
+          if (operation) tysel._cancelOp(operation.id);
+          if (owner instanceof Request) tysel._cancelRequestBody();
+          else tysel._httpCancelBody(owner._bodyId);
+        }
+        if (owner._abortCleanup) owner._abortCleanup();
+      },
+    }, { highWaterMark: 0 });
+    return owner._bodyStream;
+  }
   async function consumeBytes(owner) {
-    if (owner._bodyUsed) throw new TypeError("body has already been consumed");
-    owner._bodyUsed = true;
-    if (!owner._stream) return bodyBytes(owner.body);
+    if (used(owner)) throw new TypeError("body has already been consumed");
+    if (!owner._stream && !owner._bodyStream) {
+      owner._bodyUsed = true;
+      return bodyBytes(owner._body);
+    }
+    const reader = getBody(owner).getReader();
     const chunks = [];
     let length = 0;
     try {
       for (;;) {
-        const chunk = owner instanceof Request
-          ? await tysel._readBody()
-          : await globalThis.__tysel_awaitOperation(
-              tysel._httpRead(owner._bodyId), owner._signal,
-            );
-        if (chunk == null) break;
-        if (chunk.byteLength === 0) continue;
-        chunks.push(chunk);
-        length += chunk.byteLength;
+        const {value: chunk, done} = await reader.read();
+        if (done) break;
+        if (!(chunk instanceof Uint8Array)) throw new TypeError("HTTP stream chunks must be Uint8Array");
+        if (chunk.byteLength) { chunks.push(chunk); length += chunk.byteLength; }
       }
       return joinBytes(chunks, length);
-    } finally {
-      owner._stream = false;
-      if (owner._abortCleanup) owner._abortCleanup();
-    }
+    } catch (error) {
+      // Cleanup must not delay the original failure if user cancellation hangs.
+      try { reader.cancel(error).catch(() => {}); } catch (_) {}
+      throw error;
+    } finally { owner._bodyUsed = true; reader.releaseLock(); }
   }
-
   async function consumeText(owner) {
-    // Buffered strings need no encode/decode round trip.
-    if (!owner._stream && typeof owner.body === "string") {
-      if (owner._bodyUsed) throw new TypeError("body has already been consumed");
+    if (!owner._stream && !owner._bodyStream && typeof owner._body === "string") {
+      if (used(owner)) throw new TypeError("body has already been consumed");
       owner._bodyUsed = true;
-      return owner.body.charCodeAt(0) === 0xfeff ? owner.body.slice(1) : owner.body;
+      return owner._body.charCodeAt(0) === 0xfeff ? owner._body.slice(1) : owner._body;
     }
     return new TextDecoder().decode(await consumeBytes(owner));
   }
-
   async function consumeArrayBuffer(owner) {
-    const ownsBytes = owner._stream || (Array.isArray(owner.body) && owner.body.length !== 1);
+    const ownsBytes = owner._stream || owner._bodyStream || (Array.isArray(owner._body) && owner._body.length !== 1);
     const bytes = await consumeBytes(owner);
-    // Stream chunks and freshly joined arrays belong to this consumption;
-    // a single buffered chunk must not expose its mutable backing storage.
-    return ownsBytes && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
-      ? bytes.buffer
-      : bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    // A user-supplied stream can retain its chunks: return independent bytes.
+    return ownsBytes && !owner._customStream && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
+      ? bytes.buffer : bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
   }
 
   globalThis.__tysel_bodyBytes = bodyBytes;
@@ -582,40 +750,46 @@
   class Request {
     constructor(input, init) {
       init = init || {};
+      if (globalThis.__tysel_isReadableStream(init.body)) throw new TypeError("streaming uploads are not supported");
       if (typeof input === "string") {
         this.url = input;
         this.method = String(init.method || "GET").toUpperCase();
         this.headers = new Headers(init.headers);
-        this.body = init.body == null ? null : copyBody(init.body);
+        this._body = init.body == null ? null : copyBody(init.body);
         this._stream = init.bodyStream === true;
         this.signal = init.signal || null;
       } else {
-        if (input.bodyUsed && init.body == null) {
+        if ((input.bodyUsed || (input._bodyStream && input._bodyStream.locked)) && init.body == null) {
           throw new TypeError("cannot construct from a consumed Request");
         }
         this.url = input.url;
         this.method = String(init.method || input.method || "GET").toUpperCase();
         this.headers = new Headers(init.headers || input.headers);
-        this.body = copyBody(init.body == null ? input.body : init.body);
+        this._body = copyBody(init.body == null ? input._body : init.body);
         this._stream = init.bodyStream === true || (init.body == null && input._stream === true);
         this.signal = init.signal || input.signal || null;
       }
+      this._generation = typeof input !== "string" && init.body == null && input._stream
+        ? input._generation : globalThis.__tysel_request_generation;
       this._bodyUsed = false;
+      this._bodyStream = null;
+      this._customStream = false;
     }
     get bodyUsed() {
-      return this._bodyUsed;
+      return used(this);
     }
+    get body() { return getBody(this); }
     async text() { return consumeText(this); }
     async json() { return JSON.parse(await this.text()); }
     async arrayBuffer() { return consumeArrayBuffer(this); }
     clone() {
-      if (this._stream || this._bodyUsed) {
+      if (this._stream || this._customStream || used(this) || (this._bodyStream && this._bodyStream.locked)) {
         throw new TypeError("cannot clone a streaming or consumed request");
       }
       return new Request(this.url, {
         method: this.method,
         headers: this.headers,
-        body: this.body,
+        body: this._body,
         signal: this.signal,
       });
     }
@@ -624,40 +798,83 @@
   class Response {
     constructor(body, init) {
       init = init || {};
-      this.body = body == null ? null : copyResponseBody(body);
+      const stream = globalThis.__tysel_isReadableStream(body);
+      if (stream && (body.locked || body._disturbed)) throw new TypeError("body stream is locked or consumed");
+      this._body = stream ? null : body == null ? null : copyResponseBody(body);
       this.status = init.status || 200;
       this.headers = new Headers(init.headers);
       this._stream = false;
       this._signal = null;
+      this._generation = globalThis.__tysel_request_generation;
       this._bodyUsed = false;
+      this._bodyStream = null;
+      this._customStream = stream;
+      if (this._customStream) this._bodyStream = body;
     }
     get ok() {
       return this.status >= 200 && this.status < 300;
     }
     static json(data, init) {
       init = init || {};
-      const headers = new Headers(init.headers);
-      if (!headers.get("content-type")) {
-        headers.set("content-type", "application/json");
-      }
       const body = JSON.stringify(data);
       if (body === undefined) throw new TypeError("data is not JSON serializable");
-      return new Response(body, { status: init.status || 200, headers });
+      // The constructor snapshots headers once. Building another Headers here
+      // would iterate, sort and revalidate the same list a second time.
+      const response = new Response(body, init);
+      if (!response.headers.get("content-type")) {
+        response.headers.set("content-type", "application/json");
+      }
+      return response;
     }
     get bodyUsed() {
-      return this._bodyUsed;
+      return used(this);
     }
+    get body() { return getBody(this); }
     async text() { return consumeText(this); }
     async json() { return JSON.parse(await this.text()); }
     async arrayBuffer() { return consumeArrayBuffer(this); }
     clone() {
-      if (this._stream || this._bodyUsed) {
+      if (this._stream || this._customStream || used(this) || (this._bodyStream && this._bodyStream.locked)) {
         throw new TypeError("cannot clone a streaming or consumed response");
       }
-      return new Response(this.body, { status: this.status, headers: this.headers });
+      return new Response(this._body, { status: this.status, headers: this.headers });
     }
   }
 
+  globalThis.__tysel_responseBody = response => {
+    if (used(response)) throw new TypeError("response body has already been consumed");
+    if (response._bodyStream && response._bodyStream.locked) throw new TypeError("response body is locked");
+    return response._stream || response._bodyStream ? response.body : response._body;
+  };
+  globalThis.__tysel_headerPairs = headers => Array.from(headers);
+  globalThis.__tysel_pumpResponse = async function(body, write, closed) {
+    const reader = body.getReader();
+    let stopped = false;
+    const pump = async () => {
+      for (;;) {
+        const {value, done} = await reader.read();
+        if (done || stopped) break;
+        if (!(value instanceof Uint8Array)) throw new TypeError("HTTP stream chunks must be Uint8Array");
+        await write(value);
+      }
+    };
+    try {
+      // One race per response, not per chunk: pending reactions stay bounded.
+      await Promise.race([pump(), closed.promise.then(() => {
+        throw new TypeError("response consumer closed");
+      })]);
+    } catch (error) {
+      stopped = true;
+      // Invoke cleanup, but an application's pending cancel promise must not
+      // keep the worker assigned after the consumer has disconnected.
+      try { reader.cancel(error).catch(() => {}); } catch (_) {}
+      throw error;
+    } finally {
+      stopped = true;
+      tysel._cancelOp(closed.id);
+      reader.releaseLock();
+    }
+  };
   globalThis.Headers = Headers;
   globalThis.Request = Request;
   globalThis.Response = Response;
@@ -686,22 +903,67 @@
       this.encoding = "utf-8";
       this.fatal = Boolean(options && options.fatal);
       this.ignoreBOM = Boolean(options && options.ignoreBOM);
+      this._pending = new Uint8Array(0);
+      this._bomSeen = false;
     }
-    decode(input) {
-      if (input == null) return "";
+    decode(input, options) {
       let view;
-      if (input instanceof ArrayBuffer) view = new Uint8Array(input);
-      else if (ArrayBuffer.isView(input)) {
-        view = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
-      } else {
-        throw new TypeError("expected BufferSource");
+      if (input == null) view = new Uint8Array(0);
+      else if (input instanceof ArrayBuffer) view = new Uint8Array(input);
+      else if (ArrayBuffer.isView(input)) view = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+      else throw new TypeError("expected BufferSource");
+      const stream = Boolean(options && options.stream);
+      if (this._pending.length) {
+        const joined = new Uint8Array(this._pending.length + view.byteLength);
+        joined.set(this._pending); joined.set(view, this._pending.length); view = joined;
+      }
+      this._pending = new Uint8Array(0);
+      if (stream && view.length) {
+        let start = view.length - 1;
+        while (start > 0 && view[start] >= 128 && view[start] <= 191 && view.length - start < 4) start--;
+        const lead = view[start];
+        const required = lead >= 194 && lead <= 223 ? 2 : lead >= 224 && lead <= 239 ? 3 : lead >= 240 && lead <= 244 ? 4 : 0;
+        const available = view.length - start;
+        const second = view[start + 1];
+        const validSecond = available < 2 || (second >= 128 && second <= 191
+          && !(lead === 224 && second < 160) && !(lead === 237 && second > 159)
+          && !(lead === 240 && second < 144) && !(lead === 244 && second > 143));
+        if (required > available && validSecond) {
+          this._pending = view.slice(start);
+          view = view.subarray(0, start);
+        }
+      }
+      try {
+        let text = tysel._utf8Decode(view, this.fatal);
+        if (text.length && !this._bomSeen) {
+          this._bomSeen = true;
+          if (!this.ignoreBOM && text.charCodeAt(0) === 0xfeff) text = text.slice(1);
+        }
+        if (!stream) { this._pending = new Uint8Array(0); this._bomSeen = false; }
+        return text;
+      } catch (error) {
+        this._pending = new Uint8Array(0); this._bomSeen = false;
+        throw error;
       }
-      let text = tysel._utf8Decode(view, this.fatal);
-      if (!this.ignoreBOM && text.charCodeAt(0) === 0xfeff) text = text.slice(1);
-      return text;
     }
   }
 
+  class TextDecoderStream {
+    constructor(label, options) {
+      const decoder = new TextDecoder(label, options);
+      const transform = new TransformStream({
+        transform(chunk, controller) {
+          const text = decoder.decode(chunk, {stream: true});
+          if (text) controller.enqueue(text);
+        },
+        flush(controller) { const text = decoder.decode(); if (text) controller.enqueue(text); },
+      });
+      for (const key of ["encoding", "fatal", "ignoreBOM"]) Object.defineProperty(this, key, {value: decoder[key], enumerable: true});
+      Object.defineProperties(this, {readable: {value: transform.readable}, writable: {value: transform.writable}});
+    }
+  }
+  globalThis.TextDecoderStream = TextDecoderStream;
+
   globalThis.TextEncoder = TextEncoder;
   globalThis.TextDecoder = TextDecoder;
 })();
@@ -768,6 +1030,14 @@
   const signalToken = Object.freeze({});
   const states = new WeakMap();
 
+  // Held values contain only weak source references, never the dependent.
+  const collected = new FinalizationRegistry(links => {
+    for (const [source, dependent] of links) {
+      const signal = source.deref();
+      if (signal) states.get(signal).followers.delete(dependent);
+    }
+  });
+
   function defaultReason() {
     return new DOMException("This operation was aborted", "AbortError");
   }
@@ -776,7 +1046,7 @@
     constructor(token) {
       super();
       if (token !== signalToken) throw new TypeError("Illegal constructor");
-      states.set(this, { aborted: false, reason: undefined });
+      states.set(this, { aborted: false, reason: undefined, followers: new Set() });
       this.onabort = null;
     }
     static abort(reason) {
@@ -784,6 +1054,30 @@
       controller.abort(reason);
       return controller.signal;
     }
+    static any(signals) {
+      if (signals == null || typeof signals[Symbol.iterator] !== "function") {
+        throw new TypeError("expected an iterable of AbortSignal");
+      }
+      const list = Array.from(signals);
+      for (const signal of list) if (!states.has(signal)) throw new TypeError("expected AbortSignal");
+      const controller = new AbortController();
+      const aborted = list.find(signal => signal.aborted);
+      if (aborted) { controller.abort(aborted.reason); return controller.signal; }
+      const dependent = new WeakRef(controller.signal);
+      const links = [];
+      for (const signal of new Set(list)) {
+        states.get(signal).followers.add(dependent);
+        links.push([new WeakRef(signal), dependent]);
+      }
+      const state = states.get(controller.signal);
+      state.links = links;
+      // A live dependent keeps its propagation path alive, including temporary
+      // intermediate composites. The reverse edges remain weak.
+      state.sources = list;
+      // This QuickJS version retains unregister tokens: never use the target.
+      if (links.length) collected.register(controller.signal, links, links);
+      return controller.signal;
+    }
     static timeout(milliseconds) {
       const delay = Number(milliseconds);
       if (!Number.isFinite(delay) || delay < 0 || delay > 0xffffffff) {
@@ -812,10 +1106,35 @@
     _abort(reason) {
       const state = states.get(this);
       if (state.aborted) return;
+      const pending = [this];
+      const value = reason === undefined ? defaultReason() : reason;
+      // Mark the complete dependency graph before running any user callback.
       state.aborted = true;
-      state.reason = reason === undefined ? defaultReason() : reason;
-      const event = globalThis.__tysel_event("abort");
-      this.dispatchEvent(event);
+      state.reason = value;
+      for (let i = 0; i < pending.length; i++) {
+        const current = states.get(pending[i]);
+        for (const reference of current.followers) {
+          const signal = reference.deref();
+          if (!signal) continue;
+          const next = states.get(signal);
+          if (next.aborted) continue;
+          next.aborted = true;
+          next.reason = value;
+          pending.push(signal);
+        }
+        current.followers.clear();
+      }
+      for (const signal of pending) {
+        const current = states.get(signal);
+        for (const [source, dependent] of current.links || []) {
+          const parent = source.deref();
+          if (parent) states.get(parent).followers.delete(dependent);
+        }
+        if (current.links) collected.unregister(current.links);
+        current.links = undefined;
+        current.sources = undefined;
+      }
+      for (const signal of pending) signal.dispatchEvent(globalThis.__tysel_event("abort"));
     }
   }
 
@@ -862,6 +1181,13 @@
     "[object BigUint64Array]",
   ]);
   globalThis.crypto = {
+    randomUUID() {
+      const bytes = tysel._randomBytes(16);
+      bytes[6] = (bytes[6] & 15) | 64;
+      bytes[8] = (bytes[8] & 63) | 128;
+      const hex = Array.from(bytes, b => b.toString(16).padStart(2, "0")).join("");
+      return `${hex.slice(0,8)}-${hex.slice(8,12)}-${hex.slice(12,16)}-${hex.slice(16,20)}-${hex.slice(20)}`;
+    },
     getRandomValues(typedArray) {
       if (!integerTypedArrays.has(Object.prototype.toString.call(typedArray))) {
         throw new DOMException("expected an integer TypedArray", "TypeMismatchError");
diff --git a/runtime-js/web-api/source/abort.js b/runtime-js/web-api/source/abort.js
index 40b7988..2e57eb7 100644
--- a/runtime-js/web-api/source/abort.js
+++ b/runtime-js/web-api/source/abort.js
@@ -2,6 +2,14 @@
   const signalToken = Object.freeze({});
   const states = new WeakMap();
 
+  // Held values contain only weak source references, never the dependent.
+  const collected = new FinalizationRegistry(links => {
+    for (const [source, dependent] of links) {
+      const signal = source.deref();
+      if (signal) states.get(signal).followers.delete(dependent);
+    }
+  });
+
   function defaultReason() {
     return new DOMException("This operation was aborted", "AbortError");
   }
@@ -10,7 +18,7 @@
     constructor(token) {
       super();
       if (token !== signalToken) throw new TypeError("Illegal constructor");
-      states.set(this, { aborted: false, reason: undefined });
+      states.set(this, { aborted: false, reason: undefined, followers: new Set() });
       this.onabort = null;
     }
     static abort(reason) {
@@ -18,6 +26,30 @@
       controller.abort(reason);
       return controller.signal;
     }
+    static any(signals) {
+      if (signals == null || typeof signals[Symbol.iterator] !== "function") {
+        throw new TypeError("expected an iterable of AbortSignal");
+      }
+      const list = Array.from(signals);
+      for (const signal of list) if (!states.has(signal)) throw new TypeError("expected AbortSignal");
+      const controller = new AbortController();
+      const aborted = list.find(signal => signal.aborted);
+      if (aborted) { controller.abort(aborted.reason); return controller.signal; }
+      const dependent = new WeakRef(controller.signal);
+      const links = [];
+      for (const signal of new Set(list)) {
+        states.get(signal).followers.add(dependent);
+        links.push([new WeakRef(signal), dependent]);
+      }
+      const state = states.get(controller.signal);
+      state.links = links;
+      // A live dependent keeps its propagation path alive, including temporary
+      // intermediate composites. The reverse edges remain weak.
+      state.sources = list;
+      // This QuickJS version retains unregister tokens: never use the target.
+      if (links.length) collected.register(controller.signal, links, links);
+      return controller.signal;
+    }
     static timeout(milliseconds) {
       const delay = Number(milliseconds);
       if (!Number.isFinite(delay) || delay < 0 || delay > 0xffffffff) {
@@ -46,10 +78,35 @@
     _abort(reason) {
       const state = states.get(this);
       if (state.aborted) return;
+      const pending = [this];
+      const value = reason === undefined ? defaultReason() : reason;
+      // Mark the complete dependency graph before running any user callback.
       state.aborted = true;
-      state.reason = reason === undefined ? defaultReason() : reason;
-      const event = globalThis.__tysel_event("abort");
-      this.dispatchEvent(event);
+      state.reason = value;
+      for (let i = 0; i < pending.length; i++) {
+        const current = states.get(pending[i]);
+        for (const reference of current.followers) {
+          const signal = reference.deref();
+          if (!signal) continue;
+          const next = states.get(signal);
+          if (next.aborted) continue;
+          next.aborted = true;
+          next.reason = value;
+          pending.push(signal);
+        }
+        current.followers.clear();
+      }
+      for (const signal of pending) {
+        const current = states.get(signal);
+        for (const [source, dependent] of current.links || []) {
+          const parent = source.deref();
+          if (parent) states.get(parent).followers.delete(dependent);
+        }
+        if (current.links) collected.unregister(current.links);
+        current.links = undefined;
+        current.sources = undefined;
+      }
+      for (const signal of pending) signal.dispatchEvent(globalThis.__tysel_event("abort"));
     }
   }
 
diff --git a/runtime-js/web-api/source/crypto.js b/runtime-js/web-api/source/crypto.js
index 54a1200..8ab0202 100644
--- a/runtime-js/web-api/source/crypto.js
+++ b/runtime-js/web-api/source/crypto.js
@@ -24,6 +24,13 @@
     "[object BigUint64Array]",
   ]);
   globalThis.crypto = {
+    randomUUID() {
+      const bytes = tysel._randomBytes(16);
+      bytes[6] = (bytes[6] & 15) | 64;
+      bytes[8] = (bytes[8] & 63) | 128;
+      const hex = Array.from(bytes, b => b.toString(16).padStart(2, "0")).join("");
+      return `${hex.slice(0,8)}-${hex.slice(8,12)}-${hex.slice(12,16)}-${hex.slice(16,20)}-${hex.slice(20)}`;
+    },
     getRandomValues(typedArray) {
       if (!integerTypedArrays.has(Object.prototype.toString.call(typedArray))) {
         throw new DOMException("expected an integer TypedArray", "TypeMismatchError");
diff --git a/runtime-js/web-api/source/encoding.js b/runtime-js/web-api/source/encoding.js
index 89cb4ae..075dd27 100644
--- a/runtime-js/web-api/source/encoding.js
+++ b/runtime-js/web-api/source/encoding.js
@@ -20,21 +20,66 @@
       this.encoding = "utf-8";
       this.fatal = Boolean(options && options.fatal);
       this.ignoreBOM = Boolean(options && options.ignoreBOM);
+      this._pending = new Uint8Array(0);
+      this._bomSeen = false;
     }
-    decode(input) {
-      if (input == null) return "";
+    decode(input, options) {
       let view;
-      if (input instanceof ArrayBuffer) view = new Uint8Array(input);
-      else if (ArrayBuffer.isView(input)) {
-        view = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
-      } else {
-        throw new TypeError("expected BufferSource");
+      if (input == null) view = new Uint8Array(0);
+      else if (input instanceof ArrayBuffer) view = new Uint8Array(input);
+      else if (ArrayBuffer.isView(input)) view = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+      else throw new TypeError("expected BufferSource");
+      const stream = Boolean(options && options.stream);
+      if (this._pending.length) {
+        const joined = new Uint8Array(this._pending.length + view.byteLength);
+        joined.set(this._pending); joined.set(view, this._pending.length); view = joined;
       }
-      let text = tysel._utf8Decode(view, this.fatal);
-      if (!this.ignoreBOM && text.charCodeAt(0) === 0xfeff) text = text.slice(1);
-      return text;
+      this._pending = new Uint8Array(0);
+      if (stream && view.length) {
+        let start = view.length - 1;
+        while (start > 0 && view[start] >= 128 && view[start] <= 191 && view.length - start < 4) start--;
+        const lead = view[start];
+        const required = lead >= 194 && lead <= 223 ? 2 : lead >= 224 && lead <= 239 ? 3 : lead >= 240 && lead <= 244 ? 4 : 0;
+        const available = view.length - start;
+        const second = view[start + 1];
+        const validSecond = available < 2 || (second >= 128 && second <= 191
+          && !(lead === 224 && second < 160) && !(lead === 237 && second > 159)
+          && !(lead === 240 && second < 144) && !(lead === 244 && second > 143));
+        if (required > available && validSecond) {
+          this._pending = view.slice(start);
+          view = view.subarray(0, start);
+        }
+      }
+      try {
+        let text = tysel._utf8Decode(view, this.fatal);
+        if (text.length && !this._bomSeen) {
+          this._bomSeen = true;
+          if (!this.ignoreBOM && text.charCodeAt(0) === 0xfeff) text = text.slice(1);
+        }
+        if (!stream) { this._pending = new Uint8Array(0); this._bomSeen = false; }
+        return text;
+      } catch (error) {
+        this._pending = new Uint8Array(0); this._bomSeen = false;
+        throw error;
+      }
+    }
+  }
+
+  class TextDecoderStream {
+    constructor(label, options) {
+      const decoder = new TextDecoder(label, options);
+      const transform = new TransformStream({
+        transform(chunk, controller) {
+          const text = decoder.decode(chunk, {stream: true});
+          if (text) controller.enqueue(text);
+        },
+        flush(controller) { const text = decoder.decode(); if (text) controller.enqueue(text); },
+      });
+      for (const key of ["encoding", "fatal", "ignoreBOM"]) Object.defineProperty(this, key, {value: decoder[key], enumerable: true});
+      Object.defineProperties(this, {readable: {value: transform.readable}, writable: {value: transform.writable}});
     }
   }
+  globalThis.TextDecoderStream = TextDecoderStream;
 
   globalThis.TextEncoder = TextEncoder;
   globalThis.TextDecoder = TextDecoder;
diff --git a/runtime-js/web-api/source/http.js b/runtime-js/web-api/source/http.js
index 56b6dc5..160c34d 100644
--- a/runtime-js/web-api/source/http.js
+++ b/runtime-js/web-api/source/http.js
@@ -1,58 +1,84 @@
 (() => {
+  function headerName(name) {
+    const key = String(name).toLowerCase();
+    if (!/^[!#$%&'*+.^_`|~0-9a-z-]+$/.test(key)) throw new TypeError("invalid header name");
+    return key;
+  }
+  function headerValue(value) {
+    const text = String(value).replace(/^[ \t]+|[ \t]+$/g, "");
+    if (/[\r\n\0]/.test(text)) throw new TypeError("invalid header value");
+    return text;
+  }
+  function headerIterator(headers, kind) {
+    let version = -1, entries, index = 0;
+    return {
+      [Symbol.iterator]() { return this; },
+      next() {
+        // Web IDL indexes the current sorted list, including separate cookies.
+        // Rebuild only after mutation. Reaching the end does not freeze the list.
+        if (version !== headers._version) {
+          entries = [];
+          for (const key of Object.keys(headers._map).sort()) {
+            if (key === "set-cookie") {
+              for (const cookie of headers._cookies) entries.push([key, cookie]);
+            } else entries.push([key, headers._map[key]]);
+          }
+          version = headers._version;
+        }
+        if (index >= entries.length) return {value: undefined, done: true};
+        const pair = entries[index++];
+        return {value: kind === "keys" ? pair[0] : kind === "values" ? pair[1] : pair, done: false};
+      },
+    };
+  }
+
   class Headers {
     constructor(init) {
-      this._map = {};
-      if (!init) return;
-      // Arrays have forEach, so the sequence form must be checked first.
-      if (Array.isArray(init)) {
-        for (const pair of init) this.append(pair[0], pair[1]);
-      } else if (typeof init.forEach === "function") {
-        init.forEach((value, key) => this.append(key, value));
+      this._map = Object.create(null);
+      this._cookies = [];
+      this._version = 0;
+      if (init == null) return;
+      if (typeof init[Symbol.iterator] === "function") {
+        for (const item of init) {
+          const pair = Array.from(item);
+          if (pair.length !== 2) throw new TypeError("header pair must have two items");
+          this.append(pair[0], pair[1]);
+        }
       } else {
         for (const key of Object.keys(init)) this.append(key, init[key]);
       }
     }
-    get(name) {
-      const value = this._map[String(name).toLowerCase()];
-      return value === undefined ? null : value;
-    }
+    get(name) { return this._map[headerName(name)] ?? null; }
+    getSetCookie() { return this._cookies.slice(); }
     set(name, value) {
-      this._map[String(name).toLowerCase()] = String(value);
+      const key = headerName(name), text = headerValue(value);
+      this._map[key] = text;
+      this._version++;
+      if (key === "set-cookie") this._cookies = [text];
     }
     append(name, value) {
-      const key = String(name).toLowerCase();
+      const key = headerName(name), text = headerValue(value);
       const prev = this._map[key];
-      this._map[key] = prev == null ? String(value) : prev + ", " + String(value);
-    }
-    has(name) {
-      return Object.prototype.hasOwnProperty.call(this._map, String(name).toLowerCase());
+      this._map[key] = prev == null ? text : prev + ", " + text;
+      this._version++;
+      if (key === "set-cookie") this._cookies.push(text);
     }
+    has(name) { return Object.hasOwn(this._map, headerName(name)); }
     delete(name) {
-      delete this._map[String(name).toLowerCase()];
-    }
-    _names() {
-      return Object.keys(this._map).sort();
-    }
-    forEach(callback, thisArg) {
-      for (const key of this._names()) {
-        callback.call(thisArg, this._map[key], key, this);
-      }
-    }
-    entries() {
-      return this._names().map((key) => [key, this._map[key]])[Symbol.iterator]();
-    }
-    keys() {
-      return this._names()[Symbol.iterator]();
-    }
-    values() {
-      return this._names().map((key) => this._map[key])[Symbol.iterator]();
-    }
-    [Symbol.iterator]() {
-      return this.entries();
+      const key = headerName(name);
+      delete this._map[key];
+      this._version++;
+      if (key === "set-cookie") this._cookies = [];
     }
+    entries() { return headerIterator(this, "entries"); }
+    keys() { return headerIterator(this, "keys"); }
+    values() { return headerIterator(this, "values"); }
+    forEach(callback, thisArg) { for (const [key, value] of this) callback.call(thisArg, value, key, this); }
+    [Symbol.iterator]() { return this.entries(); }
   }
 
   function bodyBytes(body) {
+    if (globalThis.__tysel_isReadableStream(body)) throw new TypeError("streaming uploads are not supported");
     if (body == null) return new Uint8Array(0);
     if (Array.isArray(body)) {
       const chunks = body.map(bodyBytes);
@@ -94,49 +120,96 @@
     return bytes;
   }
 
+  function used(owner) {
+    // Adapter to the pinned web-streams-polyfill's disturbed flag. Covered by
+    // reader/pipe/async-iteration lifecycle tests when updating the vendor.
+    return owner._bodyUsed || Boolean(owner._bodyStream && owner._bodyStream._disturbed);
+  }
+  function getBody(owner) {
+    if (owner._bodyStream) return owner._bodyStream;
+    if (!owner._stream && owner._body == null) return null;
+    if (owner._bodyUsed) {
+      // The buffered fast path consumed the body without initializing Streams.
+      // Materialize the same closed, disturbed, unlocked state as consumeBytes.
+      // A public read marks disturbance synchronously without vendor field writes.
+      const stream = new ReadableStream({ start(controller) { controller.close(); } });
+      const reader = stream.getReader();
+      reader.read();
+      reader.releaseLock();
+      owner._bodyStream = stream;
+      return stream;
+    }
+    const host = owner._stream;
+    const generation = owner._generation;
+    let operation = null;
+    let index = 0;
+    const chunks = Array.isArray(owner._body) ? owner._body : [owner._body];
+    owner._bodyStream = new ReadableStream({
+      async pull(controller) {
+        if (used(owner) && owner._bodyUsed) throw new TypeError("body has already been consumed");
+        if (host) {
+          if (generation !== globalThis.__tysel_request_generation) throw new TypeError("body belongs to a completed request");
+          operation = owner instanceof Request ? tysel._readBodyOp() : tysel._httpRead(owner._bodyId);
+          try {
+            const chunk = await globalThis.__tysel_awaitOperation(operation, owner._signal || owner.signal);
+            if (chunk == null) {
+              controller.close();
+              if (owner._abortCleanup) owner._abortCleanup();
+            } else controller.enqueue(chunk);
+          } finally { operation = null; }
+        } else {
+          if (index < chunks.length) controller.enqueue(bodyBytes(chunks[index++]));
+          if (index === chunks.length) controller.close();
+        }
+      },
+      cancel() {
+        if (host && generation === globalThis.__tysel_request_generation) {
+          if (operation) tysel._cancelOp(operation.id);
+          if (owner instanceof Request) tysel._cancelRequestBody();
+          else tysel._httpCancelBody(owner._bodyId);
+        }
+        if (owner._abortCleanup) owner._abortCleanup();
+      },
+    }, { highWaterMark: 0 });
+    return owner._bodyStream;
+  }
   async function consumeBytes(owner) {
-    if (owner._bodyUsed) throw new TypeError("body has already been consumed");
-    owner._bodyUsed = true;
-    if (!owner._stream) return bodyBytes(owner.body);
+    if (used(owner)) throw new TypeError("body has already been consumed");
+    if (!owner._stream && !owner._bodyStream) {
+      owner._bodyUsed = true;
+      return bodyBytes(owner._body);
+    }
+    const reader = getBody(owner).getReader();
     const chunks = [];
     let length = 0;
     try {
       for (;;) {
-        const chunk = owner instanceof Request
-          ? await tysel._readBody()
-          : await globalThis.__tysel_awaitOperation(
-              tysel._httpRead(owner._bodyId), owner._signal,
-            );
-        if (chunk == null) break;
-        if (chunk.byteLength === 0) continue;
-        chunks.push(chunk);
-        length += chunk.byteLength;
+        const {value: chunk, done} = await reader.read();
+        if (done) break;
+        if (!(chunk instanceof Uint8Array)) throw new TypeError("HTTP stream chunks must be Uint8Array");
+        if (chunk.byteLength) { chunks.push(chunk); length += chunk.byteLength; }
       }
       return joinBytes(chunks, length);
-    } finally {
-      owner._stream = false;
-      if (owner._abortCleanup) owner._abortCleanup();
-    }
+    } catch (error) {
+      // Cleanup must not delay the original failure if user cancellation hangs.
+      try { reader.cancel(error).catch(() => {}); } catch (_) {}
+      throw error;
+    } finally { owner._bodyUsed = true; reader.releaseLock(); }
   }
-
   async function consumeText(owner) {
-    // Buffered strings need no encode/decode round trip.
-    if (!owner._stream && typeof owner.body === "string") {
-      if (owner._bodyUsed) throw new TypeError("body has already been consumed");
+    if (!owner._stream && !owner._bodyStream && typeof owner._body === "string") {
+      if (used(owner)) throw new TypeError("body has already been consumed");
       owner._bodyUsed = true;
-      return owner.body.charCodeAt(0) === 0xfeff ? owner.body.slice(1) : owner.body;
+      return owner._body.charCodeAt(0) === 0xfeff ? owner._body.slice(1) : owner._body;
     }
     return new TextDecoder().decode(await consumeBytes(owner));
   }
-
   async function consumeArrayBuffer(owner) {
-    const ownsBytes = owner._stream || (Array.isArray(owner.body) && owner.body.length !== 1);
+    const ownsBytes = owner._stream || owner._bodyStream || (Array.isArray(owner._body) && owner._body.length !== 1);
     const bytes = await consumeBytes(owner);
-    // Stream chunks and freshly joined arrays belong to this consumption;
-    // a single buffered chunk must not expose its mutable backing storage.
-    return ownsBytes && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
-      ? bytes.buffer
-      : bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    // A user-supplied stream can retain its chunks: return independent bytes.
+    return ownsBytes && !owner._customStream && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
+      ? bytes.buffer : bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
   }
 
   globalThis.__tysel_bodyBytes = bodyBytes;
@@ -145,40 +218,46 @@
   class Request {
     constructor(input, init) {
       init = init || {};
+      if (globalThis.__tysel_isReadableStream(init.body)) throw new TypeError("streaming uploads are not supported");
       if (typeof input === "string") {
         this.url = input;
         this.method = String(init.method || "GET").toUpperCase();
         this.headers = new Headers(init.headers);
-        this.body = init.body == null ? null : copyBody(init.body);
+        this._body = init.body == null ? null : copyBody(init.body);
         this._stream = init.bodyStream === true;
         this.signal = init.signal || null;
       } else {
-        if (input.bodyUsed && init.body == null) {
+        if ((input.bodyUsed || (input._bodyStream && input._bodyStream.locked)) && init.body == null) {
           throw new TypeError("cannot construct from a consumed Request");
         }
         this.url = input.url;
         this.method = String(init.method || input.method || "GET").toUpperCase();
         this.headers = new Headers(init.headers || input.headers);
-        this.body = copyBody(init.body == null ? input.body : init.body);
+        this._body = copyBody(init.body == null ? input._body : init.body);
         this._stream = init.bodyStream === true || (init.body == null && input._stream === true);
         this.signal = init.signal || input.signal || null;
       }
+      this._generation = typeof input !== "string" && init.body == null && input._stream
+        ? input._generation : globalThis.__tysel_request_generation;
       this._bodyUsed = false;
+      this._bodyStream = null;
+      this._customStream = false;
     }
     get bodyUsed() {
-      return this._bodyUsed;
+      return used(this);
     }
+    get body() { return getBody(this); }
     async text() { return consumeText(this); }
     async json() { return JSON.parse(await this.text()); }
     async arrayBuffer() { return consumeArrayBuffer(this); }
     clone() {
-      if (this._stream || this._bodyUsed) {
+      if (this._stream || this._customStream || used(this) || (this._bodyStream && this._bodyStream.locked)) {
         throw new TypeError("cannot clone a streaming or consumed request");
       }
       return new Request(this.url, {
         method: this.method,
         headers: this.headers,
-        body: this.body,
+        body: this._body,
         signal: this.signal,
       });
     }
@@ -187,40 +266,83 @@
   class Response {
     constructor(body, init) {
       init = init || {};
-      this.body = body == null ? null : copyResponseBody(body);
+      const stream = globalThis.__tysel_isReadableStream(body);
+      if (stream && (body.locked || body._disturbed)) throw new TypeError("body stream is locked or consumed");
+      this._body = stream ? null : body == null ? null : copyResponseBody(body);
       this.status = init.status || 200;
       this.headers = new Headers(init.headers);
       this._stream = false;
       this._signal = null;
+      this._generation = globalThis.__tysel_request_generation;
       this._bodyUsed = false;
+      this._bodyStream = null;
+      this._customStream = stream;
+      if (this._customStream) this._bodyStream = body;
     }
     get ok() {
       return this.status >= 200 && this.status < 300;
     }
     static json(data, init) {
       init = init || {};
-      const headers = new Headers(init.headers);
-      if (!headers.get("content-type")) {
-        headers.set("content-type", "application/json");
-      }
       const body = JSON.stringify(data);
       if (body === undefined) throw new TypeError("data is not JSON serializable");
-      return new Response(body, { status: init.status || 200, headers });
+      // The constructor snapshots headers once. Building another Headers here
+      // would iterate, sort and revalidate the same list a second time.
+      const response = new Response(body, init);
+      if (!response.headers.get("content-type")) {
+        response.headers.set("content-type", "application/json");
+      }
+      return response;
     }
     get bodyUsed() {
-      return this._bodyUsed;
+      return used(this);
     }
+    get body() { return getBody(this); }
     async text() { return consumeText(this); }
     async json() { return JSON.parse(await this.text()); }
     async arrayBuffer() { return consumeArrayBuffer(this); }
     clone() {
-      if (this._stream || this._bodyUsed) {
+      if (this._stream || this._customStream || used(this) || (this._bodyStream && this._bodyStream.locked)) {
         throw new TypeError("cannot clone a streaming or consumed response");
       }
-      return new Response(this.body, { status: this.status, headers: this.headers });
+      return new Response(this._body, { status: this.status, headers: this.headers });
     }
   }
 
+  globalThis.__tysel_responseBody = response => {
+    if (used(response)) throw new TypeError("response body has already been consumed");
+    if (response._bodyStream && response._bodyStream.locked) throw new TypeError("response body is locked");
+    return response._stream || response._bodyStream ? response.body : response._body;
+  };
+  globalThis.__tysel_headerPairs = headers => Array.from(headers);
+  globalThis.__tysel_pumpResponse = async function(body, write, closed) {
+    const reader = body.getReader();
+    let stopped = false;
+    const pump = async () => {
+      for (;;) {
+        const {value, done} = await reader.read();
+        if (done || stopped) break;
+        if (!(value instanceof Uint8Array)) throw new TypeError("HTTP stream chunks must be Uint8Array");
+        await write(value);
+      }
+    };
+    try {
+      // One race per response, not per chunk: pending reactions stay bounded.
+      await Promise.race([pump(), closed.promise.then(() => {
+        throw new TypeError("response consumer closed");
+      })]);
+    } catch (error) {
+      stopped = true;
+      // Invoke cleanup, but an application's pending cancel promise must not
+      // keep the worker assigned after the consumer has disconnected.
+      try { reader.cancel(error).catch(() => {}); } catch (_) {}
+      throw error;
+    } finally {
+      stopped = true;
+      tysel._cancelOp(closed.id);
+      reader.releaseLock();
+    }
+  };
   globalThis.Headers = Headers;
   globalThis.Request = Request;
   globalThis.Response = Response;
diff --git a/runtime-js/web-api/source/utilities.js b/runtime-js/web-api/source/utilities.js
new file mode 100644
index 0000000..30286eb
--- /dev/null
+++ b/runtime-js/web-api/source/utilities.js
@@ -0,0 +1,37 @@
+(() => {
+  globalThis.queueMicrotask = function(callback) {
+    if (typeof callback !== "function") throw new TypeError("callback must be a function");
+    const generation = globalThis.__tysel_request_generation;
+    tysel._queueMicrotask(() => {
+      if (generation === globalThis.__tysel_request_generation) callback();
+    });
+  };
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  globalThis.btoa = function(input) {
+    const text = String(input);
+    const output = [];
+    for (let i = 0; i < text.length; i += 3) {
+      const a = text.charCodeAt(i), b = text.charCodeAt(i + 1), c = text.charCodeAt(i + 2);
+      if (a > 255 || b > 255 || c > 255) throw new DOMException("Invalid character", "InvalidCharacterError");
+      output.push(alphabet[a >> 2], alphabet[((a & 3) << 4) | ((b || 0) >> 4)],
+        i + 1 < text.length ? alphabet[((b & 15) << 2) | ((c || 0) >> 6)] : "=",
+        i + 2 < text.length ? alphabet[c & 63] : "=");
+    }
+    return output.join("");
+  };
+  globalThis.atob = function(input) {
+    let text = String(input).replace(/[\t\n\f\r ]/g, "");
+    if (text.length % 4 === 0) text = text.replace(/==?$/, "");
+    if (text.length % 4 === 1 || /[^A-Za-z0-9+/]/.test(text)) {
+      throw new DOMException("Invalid base64", "InvalidCharacterError");
+    }
+    let bits = 0, count = 0;
+    const output = [];
+    for (const char of text) {
+      bits = (bits << 6) | alphabet.indexOf(char);
+      count += 6;
+      if (count >= 8) { count -= 8; output.push(String.fromCharCode((bits >> count) & 255)); }
+    }
+    return output.join("");
+  };
+})();
diff --git a/runtime-js/web-api/type-contract.ts b/runtime-js/web-api/type-contract.ts
new file mode 100644
index 0000000..1d01ff9
--- /dev/null
+++ b/runtime-js/web-api/type-contract.ts
@@ -0,0 +1,15 @@
+import type { TyselWebApiGlobals } from "./index.js";
+// Compile-only integration examples: explicit subset types must compose.
+export function checkStreamTypes(api: TyselWebApiGlobals) {
+  const signal = api.AbortSignal.any([new api.AbortController().signal]);
+  const stream = new api.ReadableStream<Uint8Array>({
+    start(controller) { controller.enqueue(new Uint8Array([65])); controller.close(); },
+  });
+  const decoder = new api.TextDecoderStream();
+  const text = stream.pipeThrough(decoder);
+  const done = text.pipeTo(new api.WritableStream<string>({ write(value) { void value; } }), { signal });
+  const response = new api.Response(new api.ReadableStream<Uint8Array>());
+  const cookie: string[] = response.headers.getSetCookie();
+  const id: string = api.crypto.randomUUID();
+  return { done, cookie, id };
+}
diff --git a/runtime-js/web-api/vendor/web-streams-polyfill/LICENSE b/runtime-js/web-api/vendor/web-streams-polyfill/LICENSE
new file mode 100644
index 0000000..7adbcf5
--- /dev/null
+++ b/runtime-js/web-api/vendor/web-streams-polyfill/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Mattias Buelens
+Copyright (c) 2016 Diwank Singh Tomer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/runtime-js/web-api/vendor/web-streams-polyfill/README.md b/runtime-js/web-api/vendor/web-streams-polyfill/README.md
new file mode 100644
index 0000000..8d597ae
--- /dev/null
+++ b/runtime-js/web-api/vendor/web-streams-polyfill/README.md
@@ -0,0 +1,17 @@
+# Web Streams vendor snapshot
+
+web-streams-polyfill 4.3.0, MIT license (see LICENSE).
+Source: https://github.com/MattiasBuelens/web-streams-polyfill/tree/v4.3.0
+Package: https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-4.3.0.tgz
+polyfill.js SHA-256: `30835bf3c9af5236b16126f83512d5daaf5e6b53d93ae4e61efadce775857a95`
+
+The unmodified published ES2015 polyfill is embedded by the QuickJS adapter in
+native read-only storage. build-runtime.mjs embeds the full MIT license and a
+lazy loader; first access to a Streams constructor asks the native host to
+evaluate the fixed vendor source. Buffered HTTP bodies use a loader-owned brand
+check to avoid triggering initialization.
+Update the pinned snapshot, types, license, checksum and QuickJS tests together.
+
+The type snapshot adapts its AbortSignal alias to TyselAbortSignal so explicit
+runtime types compose without depending on the complete ambient DOM interface.
+The runtime polyfill itself is unmodified.
diff --git a/runtime-js/web-api/vendor/web-streams-polyfill/polyfill.js b/runtime-js/web-api/vendor/web-streams-polyfill/polyfill.js
new file mode 100644
index 0000000..f4bca78
--- /dev/null
+++ b/runtime-js/web-api/vendor/web-streams-polyfill/polyfill.js
@@ -0,0 +1,8 @@
+/**
+ * @license
+ * web-streams-polyfill v4.3.0
+ * Copyright 2026 Mattias Buelens, Diwank Singh Tomer and other contributors.
+ * This code is released under the MIT license.
+ * SPDX-License-Identifier: MIT
+ */
+!function(){"use strict";function e(){}function t(e){return"object"==typeof e&&null!==e||"function"==typeof e}const r=e;function o(e,t){try{Object.defineProperty(e,"name",{value:t,configurable:!0})}catch(e){}}const n=Promise,a=Promise.resolve.bind(n),i=Promise.prototype.then,s=Promise.reject.bind(n),l=a;function u(e){return new n(e)}function c(e){return u(t=>t(e))}function d(e){return s(e)}function f(e,t,r){return i.call(e,t,r)}function b(e,t,o){f(f(e,t,o),void 0,r)}function h(e,t){b(e,t)}function _(e,t){b(e,void 0,t)}function m(e,t,r){return f(e,t,r)}function p(e){f(e,void 0,r)}let y=e=>{if("function"==typeof queueMicrotask)y=queueMicrotask;else{const e=c(void 0);y=t=>f(e,t)}return y(e)};function S(e,t,r){if("function"!=typeof e)throw new TypeError("Argument is not a function");return Function.prototype.apply.call(e,t,r)}function g(e,t,r){try{return c(S(e,t,r))}catch(e){return d(e)}}class v{constructor(){this._cursor=0,this._size=0,this._front={_elements:[],_next:void 0},this._back=this._front,this._cursor=0,this._size=0}get length(){return this._size}push(e){const t=this._back;let r=t;16383===t._elements.length&&(r={_elements:[],_next:void 0}),t._elements.push(e),r!==t&&(this._back=r,t._next=r),++this._size}shift(){const e=this._front;let t=e;const r=this._cursor;let o=r+1;const n=e._elements,a=n[r];return 16384===o&&(t=e._next,o=0),--this._size,this._cursor=o,e!==t&&(this._front=t),n[r]=void 0,a}forEach(e){let t=this._cursor,r=this._front,o=r._elements;for(;!(t===o.length&&void 0===r._next||t===o.length&&(r=r._next,o=r._elements,t=0,0===o.length));)e(o[t]),++t}peek(){const e=this._front,t=this._cursor;return e._elements[t]}}const w=Symbol("[[AbortSteps]]"),R=Symbol("[[ErrorSteps]]"),T=Symbol("[[CancelSteps]]"),P=Symbol("[[PullSteps]]"),C=Symbol("[[CanPullSyncSteps]]"),q=Symbol("[[ReleaseSteps]]");function E(e,t){e._ownerReadableStream=t,t._reader=e,"readable"===t._state?j(e):"closed"===t._state?function(e){j(e),z(e)}(e):k(e,t._storedError)}function W(e,t){return Mr(e._ownerReadableStream,t)}function B(e){const t=e._ownerReadableStream;"readable"===t._state?A(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")):function(e,t){k(e,t)}(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")),t._readableStreamController[q](),t._reader=void 0,e._ownerReadableStream=void 0}function O(e){return new TypeError("Cannot "+e+" a stream using a released reader")}function j(e){e._closedPromise=u((t,r)=>{e._closedPromise_resolve=t,e._closedPromise_reject=r})}function k(e,t){j(e),A(e,t)}function A(e,t){void 0!==e._closedPromise_reject&&(p(e._closedPromise),e._closedPromise_reject(t),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}function z(e){void 0!==e._closedPromise_resolve&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}const D=Number.isFinite||function(e){return"number"==typeof e&&isFinite(e)},F=Math.trunc||function(e){return e<0?Math.ceil(e):Math.floor(e)};function L(e,t){if(void 0!==e&&("object"!=typeof(r=e)&&"function"!=typeof r))throw new TypeError(`${t} is not an object.`);var r}function I(e,t){if("function"!=typeof e)throw new TypeError(`${t} is not a function.`)}function $(e,t){if(!function(e){return"object"==typeof e&&null!==e||"function"==typeof e}(e))throw new TypeError(`${t} is not an object.`)}function M(e,t,r){if(void 0===e)throw new TypeError(`Parameter ${t} is required in '${r}'.`)}function Y(e,t,r){if(void 0===e)throw new TypeError(`${t} is required in '${r}'.`)}function Q(e){return Number(e)}function x(e){return 0===e?0:e}function N(e,t){const r=Number.MAX_SAFE_INTEGER;let o=Number(e);if(o=x(o),!D(o))throw new TypeError(`${t} is not a finite number`);if(o=function(e){return x(F(e))}(o),o<0||o>r)throw new TypeError(`${t} is outside the accepted range of 0 to ${r}, inclusive`);return D(o)&&0!==o?o:0}function H(e,t){if(!Ir(e))throw new TypeError(`${t} is not a ReadableStream.`)}function V(e){return new ReadableStreamDefaultReader(e)}function U(e,t){e._reader._readRequests.push(t)}function G(e,t,r){const o=e._reader._readRequests.shift();r?o._closeSteps():o._chunkSteps(t)}function X(e){return e._reader._readRequests.length}function J(e){const t=e._reader;return void 0!==t&&!!ee(t)}class ReadableStreamDefaultReader{constructor(e){if(M(e,1,"ReadableStreamDefaultReader"),H(e,"First parameter"),$r(e))throw new TypeError("This stream has already been locked for exclusive reading by another reader");E(this,e),this._readRequests=new v}get closed(){return ee(this)?this._closedPromise:d(ne("closed"))}cancel(e=void 0){return ee(this)?void 0===this._ownerReadableStream?d(O("cancel")):W(this,e):d(ne("cancel"))}read(){if(!ee(this))return d(ne("read"));if(void 0===this._ownerReadableStream)return d(O("read from"));const e=re(this)?new Z:new K;return te(this,e),e._promise}releaseLock(){if(!ee(this))throw ne("releaseLock");void 0!==this._ownerReadableStream&&function(e){B(e);const t=new TypeError("Reader was released");oe(e,t)}(this)}}Object.defineProperties(ReadableStreamDefaultReader.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),o(ReadableStreamDefaultReader.prototype.cancel,"cancel"),o(ReadableStreamDefaultReader.prototype.read,"read"),o(ReadableStreamDefaultReader.prototype.releaseLock,"releaseLock"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableStreamDefaultReader.prototype,Symbol.toStringTag,{value:"ReadableStreamDefaultReader",configurable:!0});class K{constructor(){this._promise=u((e,t)=>{this._resolvePromise=e,this._rejectPromise=t})}_chunkSteps(e){this._resolvePromise({value:e,done:!1})}_closeSteps(){this._resolvePromise({value:void 0,done:!0})}_errorSteps(e){this._rejectPromise(e)}}class Z{constructor(){this._promise=void 0}_chunkSteps(e){this._promise=l({value:e,done:!1})}_closeSteps(){this._promise=l({value:void 0,done:!0})}_errorSteps(e){this._promise=d(e)}}function ee(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readRequests")&&e instanceof ReadableStreamDefaultReader)}function te(e,t){const r=e._ownerReadableStream;r._disturbed=!0,"closed"===r._state?t._closeSteps():"errored"===r._state?t._errorSteps(r._storedError):r._readableStreamController[P](t)}function re(e){const t=e._ownerReadableStream;return"closed"===t._state||("errored"===t._state||t._readableStreamController[C]())}function oe(e,t){const r=e._readRequests;e._readRequests=new v,r.forEach(e=>{e._errorSteps(t)})}function ne(e){return new TypeError(`ReadableStreamDefaultReader.prototype.${e} can only be used on a ReadableStreamDefaultReader`)}var ae,ie,se;function le(e){return e.slice()}function ue(e,t,r,o,n){new Uint8Array(e).set(new Uint8Array(r,o,n),t)}let ce=e=>(ce="function"==typeof e.transfer?e=>e.transfer():"function"==typeof structuredClone?e=>structuredClone(e,{transfer:[e]}):e=>e,ce(e)),de=e=>(de="boolean"==typeof e.detached?e=>e.detached:e=>0===e.byteLength,de(e));function fe(e,t,r){if(e.slice)return e.slice(t,r);const o=r-t,n=new ArrayBuffer(o);return ue(n,0,e,t,o),n}function be(e,t){const r=e[t];if(null!=r){if("function"!=typeof r)throw new TypeError(`${String(t)} is not a function`);return r}}function he(e){try{const t=e.done,r=e.value;return f(l(r),e=>({done:t,value:e}))}catch(e){return d(e)}}const _e=null!==(se=null!==(ae=Symbol.asyncIterator)&&void 0!==ae?ae:null===(ie=Symbol.for)||void 0===ie?void 0:ie.call(Symbol,"Symbol.asyncIterator"))&&void 0!==se?se:"@@asyncIterator";function me(e,r="sync",o){if(void 0===o)if("async"===r){if(void 0===(o=be(e,_e))){return function(e){const r={next(){let t;try{t=pe(e)}catch(e){return d(e)}return he(t)},return(r){let o;try{const t=be(e.iterator,"return");if(void 0===t)return c({done:!0,value:r});o=S(t,e.iterator,[r])}catch(e){return d(e)}return t(o)?he(o):d(new TypeError("The iterator.return() method must return an object"))}};return{iterator:r,nextMethod:r.next,done:!1}}(me(e,"sync",be(e,Symbol.iterator)))}}else o=be(e,Symbol.iterator);if(void 0===o)throw new TypeError("The object is not iterable");const n=S(o,e,[]);if(!t(n))throw new TypeError("The iterator method must return an object");return{iterator:n,nextMethod:n.next,done:!1}}function pe(e){const r=S(e.nextMethod,e.iterator,[]);if(!t(r))throw new TypeError("The iterator.next() method must return an object");return r}class ye{constructor(e,t){this._ongoingPromise=void 0,this._isFinished=!1,this._reader=e,this._preventCancel=t}next(){const e=()=>this._nextSteps();return this._ongoingPromise=this._ongoingPromise?m(this._ongoingPromise,e,e):e(),this._ongoingPromise}return(e){const t=()=>this._returnSteps(e);return this._ongoingPromise=this._ongoingPromise?m(this._ongoingPromise,t,t):t(),this._ongoingPromise}_nextSteps(){if(this._isFinished)return Promise.resolve({value:void 0,done:!0});const e=this._reader,t=new Se(this);return te(e,t),t._promise}_returnSteps(e){if(this._isFinished)return Promise.resolve({value:e,done:!0});this._isFinished=!0;const t=this._reader;if(!this._preventCancel){const r=W(t,e);return B(t),m(r,()=>({value:e,done:!0}))}return B(t),c({value:e,done:!0})}}class Se{constructor(e){this._iterator=e,this._promise=u((e,t)=>{this._resolvePromise=e,this._rejectPromise=t})}_chunkSteps(e){this._iterator._ongoingPromise=void 0,y(()=>this._resolvePromise({value:e,done:!1}))}_closeSteps(){const e=this._iterator;e._ongoingPromise=void 0,e._isFinished=!0,B(e._reader),this._resolvePromise({value:void 0,done:!0})}_errorSteps(e){const t=this._iterator;t._ongoingPromise=void 0,t._isFinished=!0,B(t._reader),this._rejectPromise(e)}}const ge={next(){return ve(this)?this._asyncIteratorImpl.next():d(we("next"))},return(e){return ve(this)?this._asyncIteratorImpl.return(e):d(we("return"))},[_e](){return this}};function ve(e){if(!t(e))return!1;if(!Object.prototype.hasOwnProperty.call(e,"_asyncIteratorImpl"))return!1;try{return e._asyncIteratorImpl instanceof ye}catch(e){return!1}}function we(e){return new TypeError(`ReadableStreamAsyncIterator.${e} can only be used on a ReadableSteamAsyncIterator`)}Object.defineProperty(ge,_e,{enumerable:!1});const Re=Number.isNaN||function(e){return e!=e};function Te(e){const t=fe(e.buffer,e.byteOffset,e.byteOffset+e.byteLength);return new Uint8Array(t)}function Pe(e){const t=e._queue.shift();return e._queueTotalSize-=t.size,e._queueTotalSize<0&&(e._queueTotalSize=0),t.value}function Ce(e,t,r){if("number"!=typeof(o=r)||Re(o)||o<0||r===1/0)throw new RangeError("Size must be a finite, non-NaN, non-negative number.");var o;e._queue.push({value:t,size:r}),e._queueTotalSize+=r}function qe(e){e._queue=new v,e._queueTotalSize=0}function Ee(e){return e===DataView}function We(e){return Ee(e)?1:e.BYTES_PER_ELEMENT}class ReadableStreamBYOBRequest{constructor(){throw new TypeError("Illegal constructor")}get view(){if(!Oe(this))throw ot("view");return this._view}respond(e){if(!Oe(this))throw ot("respond");if(M(e,1,"respond"),e=N(e,"First parameter"),void 0===this._associatedReadableByteStreamController)throw new TypeError("This BYOB request has been invalidated");if(de(this._view.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");et(this._associatedReadableByteStreamController,e)}respondWithNewView(e){if(!Oe(this))throw ot("respondWithNewView");if(M(e,1,"respondWithNewView"),!ArrayBuffer.isView(e))throw new TypeError("You can only respond with array buffer views");if(void 0===this._associatedReadableByteStreamController)throw new TypeError("This BYOB request has been invalidated");if(de(e.buffer))throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");tt(this._associatedReadableByteStreamController,e)}}Object.defineProperties(ReadableStreamBYOBRequest.prototype,{respond:{enumerable:!0},respondWithNewView:{enumerable:!0},view:{enumerable:!0}}),o(ReadableStreamBYOBRequest.prototype.respond,"respond"),o(ReadableStreamBYOBRequest.prototype.respondWithNewView,"respondWithNewView"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableStreamBYOBRequest.prototype,Symbol.toStringTag,{value:"ReadableStreamBYOBRequest",configurable:!0});class ReadableByteStreamController{constructor(){throw new TypeError("Illegal constructor")}get byobRequest(){if(!Be(this))throw nt("byobRequest");return Ke(this)}get desiredSize(){if(!Be(this))throw nt("desiredSize");return Ze(this)}close(){if(!Be(this))throw nt("close");if(this._closeRequested)throw new TypeError("The stream has already been closed; do not close it again!");const e=this._controlledReadableByteStream._state;if("readable"!==e)throw new TypeError(`The stream (in ${e} state) is not in the readable state and cannot be closed`);Ue(this)}enqueue(e){if(!Be(this))throw nt("enqueue");if(M(e,1,"enqueue"),!ArrayBuffer.isView(e))throw new TypeError("chunk must be an array buffer view");if(0===e.byteLength)throw new TypeError("chunk must have non-zero byteLength");if(0===e.buffer.byteLength)throw new TypeError("chunk's buffer must have non-zero byteLength");if(this._closeRequested)throw new TypeError("stream is closed or draining");const t=this._controlledReadableByteStream._state;if("readable"!==t)throw new TypeError(`The stream (in ${t} state) is not in the readable state and cannot be enqueued to`);Ge(this,e)}error(e=void 0){if(!Be(this))throw nt("error");Xe(this,e)}[T](e){ke(this),qe(this);const t=this._cancelAlgorithm(e);return Ve(this),t}[P](e){const t=this._controlledReadableByteStream;if(this._queueTotalSize>0)return void Je(this,e);const r=this._autoAllocateChunkSize;if(void 0!==r){let t;try{t=new ArrayBuffer(r)}catch(t){return void e._errorSteps(t)}const o={buffer:t,bufferByteLength:r,byteOffset:0,byteLength:r,bytesFilled:0,minimumFill:1,elementSize:1,viewConstructor:Uint8Array,readerType:"default"};this._pendingPullIntos.push(o)}U(t,e),je(this)}[C](){return this._queueTotalSize>0}[q](){if(this._pendingPullIntos.length>0){const e=this._pendingPullIntos.peek();e.readerType="none",this._pendingPullIntos=new v,this._pendingPullIntos.push(e)}}}function Be(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledReadableByteStream")&&e instanceof ReadableByteStreamController)}function Oe(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_associatedReadableByteStreamController")&&e instanceof ReadableStreamBYOBRequest)}function je(e){const t=function(e){const t=e._controlledReadableByteStream;if("readable"!==t._state)return!1;if(e._closeRequested)return!1;if(!e._started)return!1;if(J(t)&&X(t)>0)return!0;if(ut(t)&&lt(t)>0)return!0;const r=Ze(e);if(r>0)return!0;return!1}(e);if(!t)return;if(e._pulling)return void(e._pullAgain=!0);e._pulling=!0;b(e._pullAlgorithm(),()=>(e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,je(e)),null),t=>(Xe(e,t),null))}function ke(e){Qe(e),e._pendingPullIntos=new v}function Ae(e,t){let r=!1;"closed"===e._state&&(r=!0);const o=De(t);"default"===t.readerType?G(e,o,r):function(e,t,r){const o=e._reader,n=o._readIntoRequests.shift();r?n._closeSteps(t):n._chunkSteps(t)}(e,o,r)}function ze(e,t){for(let r=0;r<t.length;++r)Ae(e,t[r])}function De(e){const t=e.bytesFilled,r=e.elementSize;return new e.viewConstructor(e.buffer,e.byteOffset,t/r)}function Fe(e,t,r,o){e._queue.push({buffer:t,byteOffset:r,byteLength:o}),e._queueTotalSize+=o}function Le(e,t,r,o){let n;try{n=fe(t,r,r+o)}catch(t){throw Xe(e,t),t}Fe(e,n,0,o)}function Ie(e,t){t.bytesFilled>0&&Le(e,t.buffer,t.byteOffset,t.bytesFilled),He(e)}function $e(e,t){const r=Math.min(e._queueTotalSize,t.byteLength-t.bytesFilled),o=t.bytesFilled+r;let n=r,a=!1;const i=o-o%t.elementSize;i>=t.minimumFill&&(n=i-t.bytesFilled,a=!0);const s=e._queue;for(;n>0;){const r=s.peek(),o=Math.min(n,r.byteLength),a=t.byteOffset+t.bytesFilled;ue(t.buffer,a,r.buffer,r.byteOffset,o),r.byteLength===o?s.shift():(r.byteOffset+=o,r.byteLength-=o),e._queueTotalSize-=o,Me(e,o,t),n-=o}return a}function Me(e,t,r){r.bytesFilled+=t}function Ye(e){0===e._queueTotalSize&&e._closeRequested?(Ve(e),Yr(e._controlledReadableByteStream)):je(e)}function Qe(e){null!==e._byobRequest&&(e._byobRequest._associatedReadableByteStreamController=void 0,e._byobRequest._view=null,e._byobRequest=null)}function xe(e){const t=[];for(;e._pendingPullIntos.length>0&&0!==e._queueTotalSize;){const r=e._pendingPullIntos.peek();$e(e,r)&&(He(e),t.push(r))}return t}function Ne(e,t){const r=e._pendingPullIntos.peek();Qe(e);"closed"===e._controlledReadableByteStream._state?function(e,t){"none"===t.readerType&&He(e);const r=e._controlledReadableByteStream;if(ut(r)){const t=[];for(;t.length<lt(r);)t.push(He(e));ze(r,t)}}(e,r):function(e,t,r){if(Me(0,t,r),"none"===r.readerType){Ie(e,r);const t=xe(e);return void ze(e._controlledReadableByteStream,t)}if(r.bytesFilled<r.minimumFill)return;He(e);const o=r.bytesFilled%r.elementSize;if(o>0){const t=r.byteOffset+r.bytesFilled;Le(e,r.buffer,t-o,o)}r.bytesFilled-=o;const n=xe(e);Ae(e._controlledReadableByteStream,r),ze(e._controlledReadableByteStream,n)}(e,t,r),je(e)}function He(e){return e._pendingPullIntos.shift()}function Ve(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0}function Ue(e){const t=e._controlledReadableByteStream;if(!e._closeRequested&&"readable"===t._state)if(e._queueTotalSize>0)e._closeRequested=!0;else{if(e._pendingPullIntos.length>0){const t=e._pendingPullIntos.peek();if(t.bytesFilled%t.elementSize!==0){const t=new TypeError("Insufficient bytes to fill elements in the given buffer");throw Xe(e,t),t}}Ve(e),Yr(t)}}function Ge(e,t){const r=e._controlledReadableByteStream;if(e._closeRequested||"readable"!==r._state)return;const{buffer:o,byteOffset:n,byteLength:a}=t;if(de(o))throw new TypeError("chunk's buffer is detached and so cannot be enqueued");const i=ce(o);if(e._pendingPullIntos.length>0){const t=e._pendingPullIntos.peek();if(de(t.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");Qe(e),t.buffer=ce(t.buffer),"none"===t.readerType&&Ie(e,t)}if(J(r))if(function(e){const t=e._controlledReadableByteStream._reader;for(;t._readRequests.length>0;){if(0===e._queueTotalSize)return;Je(e,t._readRequests.shift())}}(e),0===X(r))Fe(e,i,n,a);else{e._pendingPullIntos.length>0&&He(e);G(r,new Uint8Array(i,n,a),!1)}else if(ut(r)){Fe(e,i,n,a);ze(r,xe(e))}else Fe(e,i,n,a);je(e)}function Xe(e,t){const r=e._controlledReadableByteStream;"readable"===r._state&&(ke(e),qe(e),Ve(e),Qr(r,t))}function Je(e,t){const r=e._queue.shift();e._queueTotalSize-=r.byteLength,Ye(e);const o=new Uint8Array(r.buffer,r.byteOffset,r.byteLength);t._chunkSteps(o)}function Ke(e){if(null===e._byobRequest&&e._pendingPullIntos.length>0){const t=e._pendingPullIntos.peek(),r=new Uint8Array(t.buffer,t.byteOffset+t.bytesFilled,t.byteLength-t.bytesFilled),o=Object.create(ReadableStreamBYOBRequest.prototype);!function(e,t,r){e._associatedReadableByteStreamController=t,e._view=r}(o,e,r),e._byobRequest=o}return e._byobRequest}function Ze(e){const t=e._controlledReadableByteStream._state;return"errored"===t?null:"closed"===t?0:e._strategyHWM-e._queueTotalSize}function et(e,t){const r=e._pendingPullIntos.peek();if("closed"===e._controlledReadableByteStream._state){if(0!==t)throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream")}else{if(0===t)throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");if(r.bytesFilled+t>r.byteLength)throw new RangeError("bytesWritten out of range")}r.buffer=ce(r.buffer),Ne(e,t)}function tt(e,t){const r=e._pendingPullIntos.peek();if("closed"===e._controlledReadableByteStream._state){if(0!==t.byteLength)throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream")}else if(0===t.byteLength)throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");if(r.byteOffset+r.bytesFilled!==t.byteOffset)throw new RangeError("The region specified by view does not match byobRequest");if(r.bufferByteLength!==t.buffer.byteLength)throw new RangeError("The buffer of view has different capacity than byobRequest");if(r.bytesFilled+t.byteLength>r.byteLength)throw new RangeError("The region specified by view is larger than byobRequest");const o=t.byteLength;r.buffer=ce(t.buffer),Ne(e,o)}function rt(e,t,r,o,n,a,i){t._controlledReadableByteStream=e,t._pullAgain=!1,t._pulling=!1,t._byobRequest=null,t._queue=t._queueTotalSize=void 0,qe(t),t._closeRequested=!1,t._started=!1,t._strategyHWM=a,t._pullAlgorithm=o,t._cancelAlgorithm=n,t._autoAllocateChunkSize=i,t._pendingPullIntos=new v,e._readableStreamController=t;b(c(r()),()=>(t._started=!0,je(t),null),e=>(Xe(t,e),null))}function ot(e){return new TypeError(`ReadableStreamBYOBRequest.prototype.${e} can only be used on a ReadableStreamBYOBRequest`)}function nt(e){return new TypeError(`ReadableByteStreamController.prototype.${e} can only be used on a ReadableByteStreamController`)}function at(e,t){if("byob"!==(e=`${e}`))throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamReaderMode`);return e}function it(e){return new ReadableStreamBYOBReader(e)}function st(e,t){e._reader._readIntoRequests.push(t)}function lt(e){return e._reader._readIntoRequests.length}function ut(e){const t=e._reader;return void 0!==t&&!!ft(t)}Object.defineProperties(ReadableByteStreamController.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},byobRequest:{enumerable:!0},desiredSize:{enumerable:!0}}),o(ReadableByteStreamController.prototype.close,"close"),o(ReadableByteStreamController.prototype.enqueue,"enqueue"),o(ReadableByteStreamController.prototype.error,"error"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableByteStreamController.prototype,Symbol.toStringTag,{value:"ReadableByteStreamController",configurable:!0});class ReadableStreamBYOBReader{constructor(e){if(M(e,1,"ReadableStreamBYOBReader"),H(e,"First parameter"),$r(e))throw new TypeError("This stream has already been locked for exclusive reading by another reader");if(!Be(e._readableStreamController))throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");E(this,e),this._readIntoRequests=new v}get closed(){return ft(this)?this._closedPromise:d(_t("closed"))}cancel(e=void 0){return ft(this)?void 0===this._ownerReadableStream?d(O("cancel")):W(this,e):d(_t("cancel"))}read(e,t={}){if(!ft(this))return d(_t("read"));if(!ArrayBuffer.isView(e))return d(new TypeError("view must be an array buffer view"));if(0===e.byteLength)return d(new TypeError("view must have non-zero byteLength"));if(0===e.buffer.byteLength)return d(new TypeError("view's buffer must have non-zero byteLength"));if(de(e.buffer))return d(new TypeError("view's buffer has been detached"));let r;try{r=function(e,t){var r;return L(e,t),{min:N(null!==(r=null==e?void 0:e.min)&&void 0!==r?r:1,`${t} has member 'min' that`)}}(t,"options")}catch(e){return d(e)}const o=r.min;if(0===o)return d(new TypeError("options.min must be greater than 0"));if(function(e){return Ee(e.constructor)}(e)){if(o>e.byteLength)return d(new RangeError("options.min must be less than or equal to view's byteLength"))}else if(o>e.length)return d(new RangeError("options.min must be less than or equal to view's length"));if(void 0===this._ownerReadableStream)return d(O("read from"));const n=function(e,t,r){const o=e._ownerReadableStream;return"errored"===o._state||function(e,t,r){const o=e._controlledReadableByteStream,n=We(t.constructor),{byteLength:a}=t,i=r*n;return!(e._pendingPullIntos.length>0)&&("closed"===o._state||e._queueTotalSize>=i)}(o._readableStreamController,t,r)}(this,e,o)?new dt:new ct;return bt(this,e,o,n),n._promise}releaseLock(){if(!ft(this))throw _t("releaseLock");void 0!==this._ownerReadableStream&&function(e){B(e);const t=new TypeError("Reader was released");ht(e,t)}(this)}}Object.defineProperties(ReadableStreamBYOBReader.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),o(ReadableStreamBYOBReader.prototype.cancel,"cancel"),o(ReadableStreamBYOBReader.prototype.read,"read"),o(ReadableStreamBYOBReader.prototype.releaseLock,"releaseLock"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableStreamBYOBReader.prototype,Symbol.toStringTag,{value:"ReadableStreamBYOBReader",configurable:!0});class ct{constructor(){this._promise=u((e,t)=>{this._resolvePromise=e,this._rejectPromise=t})}_chunkSteps(e){this._resolvePromise({value:e,done:!1})}_closeSteps(e){this._resolvePromise({value:e,done:!0})}_errorSteps(e){this._rejectPromise(e)}}class dt{constructor(){this._promise=void 0}_chunkSteps(e){this._promise=l({value:e,done:!1})}_closeSteps(e){this._promise=l({value:e,done:!0})}_errorSteps(e){this._promise=d(e)}}function ft(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readIntoRequests")&&e instanceof ReadableStreamBYOBReader)}function bt(e,t,r,o){const n=e._ownerReadableStream;n._disturbed=!0,"errored"===n._state?o._errorSteps(n._storedError):function(e,t,r,o){const n=e._controlledReadableByteStream,a=t.constructor,i=We(a),{byteOffset:s,byteLength:l}=t,u=r*i;let c;try{c=ce(t.buffer)}catch(e){return void o._errorSteps(e)}const d={buffer:c,bufferByteLength:c.byteLength,byteOffset:s,byteLength:l,bytesFilled:0,minimumFill:u,elementSize:i,viewConstructor:a,readerType:"byob"};if(e._pendingPullIntos.length>0)return e._pendingPullIntos.push(d),void st(n,o);if("closed"===n._state){const e=new a(d.buffer,d.byteOffset,0);return void o._closeSteps(e)}if(e._queueTotalSize>0){if($e(e,d)){const t=De(d);return Ye(e),void o._chunkSteps(t)}if(e._closeRequested){const t=new TypeError("Insufficient bytes to fill elements in the given buffer");return Xe(e,t),void o._errorSteps(t)}}e._pendingPullIntos.push(d),st(n,o),je(e)}(n._readableStreamController,t,r,o)}function ht(e,t){const r=e._readIntoRequests;e._readIntoRequests=new v,r.forEach(e=>{e._errorSteps(t)})}function _t(e){return new TypeError(`ReadableStreamBYOBReader.prototype.${e} can only be used on a ReadableStreamBYOBReader`)}function mt(e,t){const{highWaterMark:r}=e;if(void 0===r)return t;if(Re(r)||r<0)throw new RangeError("Invalid highWaterMark");return r}function pt(e){const{size:t}=e;return t||(()=>1)}function yt(e,t){L(e,t);const r=null==e?void 0:e.highWaterMark,o=null==e?void 0:e.size;return{highWaterMark:void 0===r?void 0:Q(r),size:void 0===o?void 0:St(o,`${t} has member 'size' that`)}}function St(e,t){return I(e,t),t=>Q(e(t))}function gt(e,t,r){return I(e,r),r=>g(e,t,[r])}function vt(e,t,r){return I(e,r),()=>g(e,t,[])}function wt(e,t,r){return I(e,r),r=>S(e,t,[r])}function Rt(e,t,r){return I(e,r),(r,o)=>g(e,t,[r,o])}function Tt(e,t){if(!qt(e))throw new TypeError(`${t} is not a WritableStream.`)}class WritableStream{constructor(e={},t={}){void 0===e?e=null:$(e,"First parameter");const r=yt(t,"Second parameter"),o=function(e,t){L(e,t);const r=null==e?void 0:e.abort,o=null==e?void 0:e.close,n=null==e?void 0:e.start,a=null==e?void 0:e.type,i=null==e?void 0:e.write;return{abort:void 0===r?void 0:gt(r,e,`${t} has member 'abort' that`),close:void 0===o?void 0:vt(o,e,`${t} has member 'close' that`),start:void 0===n?void 0:wt(n,e,`${t} has member 'start' that`),write:void 0===i?void 0:Rt(i,e,`${t} has member 'write' that`),type:a}}(e,"First parameter");Ct(this);if(void 0!==o.type)throw new RangeError("Invalid type is specified");const n=pt(r);!function(e,t,r,o){const n=Object.create(WritableStreamDefaultController.prototype);let a,i,s,l;a=void 0!==t.start?()=>t.start(n):()=>{};i=void 0!==t.write?e=>t.write(e,n):()=>c(void 0);s=void 0!==t.close?()=>t.close():()=>c(void 0);l=void 0!==t.abort?e=>t.abort(e):()=>c(void 0);Nt(e,n,a,i,s,l,r,o)}(this,o,mt(r,1),n)}get locked(){if(!qt(this))throw Kt("locked");return Et(this)}abort(e=void 0){return qt(this)?Et(this)?d(new TypeError("Cannot abort a stream that already has a writer")):Wt(this,e):d(Kt("abort"))}close(){return qt(this)?Et(this)?d(new TypeError("Cannot close a stream that already has a writer")):At(this)?d(new TypeError("Cannot close an already-closing stream")):Bt(this):d(Kt("close"))}getWriter(){if(!qt(this))throw Kt("getWriter");return Pt(this)}}function Pt(e){return new WritableStreamDefaultWriter(e)}function Ct(e){e._state="writable",e._storedError=void 0,e._writer=void 0,e._writableStreamController=void 0,e._writeRequests=new v,e._inFlightWriteRequest=void 0,e._closeRequest=void 0,e._inFlightCloseRequest=void 0,e._pendingAbortRequest=void 0,e._backpressure=!1}function qt(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_writableStreamController")&&e instanceof WritableStream)}function Et(e){return void 0!==e._writer}function Wt(e,t){var r;if("closed"===e._state||"errored"===e._state)return c(void 0);e._writableStreamController._abortReason=t,null===(r=e._writableStreamController._abortController)||void 0===r||r.abort(t);const o=e._state;if("closed"===o||"errored"===o)return c(void 0);if(void 0!==e._pendingAbortRequest)return e._pendingAbortRequest._promise;let n=!1;"erroring"===o&&(n=!0,t=void 0);const a=u((r,o)=>{e._pendingAbortRequest={_promise:void 0,_resolve:r,_reject:o,_reason:t,_wasAlreadyErroring:n}});return e._pendingAbortRequest._promise=a,n||jt(e,t),a}function Bt(e){const t=e._state;if("closed"===t||"errored"===t)return d(new TypeError(`The stream (in ${t} state) is not in the writable state and cannot be closed`));const r=u((t,r)=>{const o={_resolve:t,_reject:r};e._closeRequest=o}),o=e._writer;var n;return void 0!==o&&e._backpressure&&"writable"===t&&cr(o),Ce(n=e._writableStreamController,Qt,0),Ut(n),r}function Ot(e,t){"writable"!==e._state?kt(e):jt(e,t)}function jt(e,t){const r=e._writableStreamController;e._state="erroring",e._storedError=t;const o=e._writer;void 0!==o&&$t(o,t),!function(e){if(void 0===e._inFlightWriteRequest&&void 0===e._inFlightCloseRequest)return!1;return!0}(e)&&r._started&&kt(e)}function kt(e){e._state="errored",e._writableStreamController[R]();const t=e._storedError;if(e._writeRequests.forEach(e=>{e._reject(t)}),e._writeRequests=new v,void 0===e._pendingAbortRequest)return void zt(e);const r=e._pendingAbortRequest;if(e._pendingAbortRequest=void 0,r._wasAlreadyErroring)return r._reject(t),void zt(e);b(e._writableStreamController[w](r._reason),()=>(r._resolve(),zt(e),null),t=>(r._reject(t),zt(e),null))}function At(e){return void 0!==e._closeRequest||void 0!==e._inFlightCloseRequest}function zt(e){void 0!==e._closeRequest&&(e._closeRequest._reject(e._storedError),e._closeRequest=void 0);const t=e._writer;void 0!==t&&nr(t,e._storedError)}function Dt(e,t){const r=e._writer;void 0!==r&&t!==e._backpressure&&(t?function(e){ir(e)}(r):cr(r)),e._backpressure=t}Object.defineProperties(WritableStream.prototype,{abort:{enumerable:!0},close:{enumerable:!0},getWriter:{enumerable:!0},locked:{enumerable:!0}}),o(WritableStream.prototype.abort,"abort"),o(WritableStream.prototype.close,"close"),o(WritableStream.prototype.getWriter,"getWriter"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(WritableStream.prototype,Symbol.toStringTag,{value:"WritableStream",configurable:!0});class WritableStreamDefaultWriter{constructor(e){if(M(e,1,"WritableStreamDefaultWriter"),Tt(e,"First parameter"),Et(e))throw new TypeError("This stream has already been locked for exclusive writing by another writer");this._ownerWritableStream=e,e._writer=this;const t=e._state;if("writable"===t)!At(e)&&e._backpressure?ir(this):lr(this),rr(this);else if("erroring"===t)sr(this,e._storedError),rr(this);else if("closed"===t)lr(this),rr(r=this),ar(r);else{const t=e._storedError;sr(this,t),or(this,t)}var r}get closed(){return Ft(this)?this._closedPromise:d(er("closed"))}get desiredSize(){if(!Ft(this))throw er("desiredSize");if(void 0===this._ownerWritableStream)throw tr("desiredSize");return function(e){const t=e._ownerWritableStream,r=t._state;if("errored"===r||"erroring"===r)return null;if("closed"===r)return 0;return Vt(t._writableStreamController)}(this)}get ready(){return Ft(this)?this._readyPromise:d(er("ready"))}abort(e=void 0){return Ft(this)?void 0===this._ownerWritableStream?d(tr("abort")):function(e,t){return Wt(e._ownerWritableStream,t)}(this,e):d(er("abort"))}close(){if(!Ft(this))return d(er("close"));const e=this._ownerWritableStream;return void 0===e?d(tr("close")):At(e)?d(new TypeError("Cannot close an already-closing stream")):Lt(this)}releaseLock(){if(!Ft(this))throw er("releaseLock");void 0!==this._ownerWritableStream&&Mt(this)}write(e=void 0){return Ft(this)?void 0===this._ownerWritableStream?d(tr("write to")):Yt(this,e):d(er("write"))}}function Ft(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_ownerWritableStream")&&e instanceof WritableStreamDefaultWriter)}function Lt(e){return Bt(e._ownerWritableStream)}function It(e,t){"pending"===e._closedPromiseState?nr(e,t):function(e,t){or(e,t)}(e,t)}function $t(e,t){"pending"===e._readyPromiseState?ur(e,t):function(e,t){sr(e,t)}(e,t)}function Mt(e){const t=e._ownerWritableStream,r=new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");$t(e,r),It(e,r),t._writer=void 0,e._ownerWritableStream=void 0}function Yt(e,t){const r=e._ownerWritableStream,o=r._writableStreamController,n=function(e,t){if(void 0===e._strategySizeAlgorithm)return 1;try{return e._strategySizeAlgorithm(t)}catch(t){return Gt(e,t),1}}(o,t);if(r!==e._ownerWritableStream)return d(tr("write to"));const a=r._state;if("errored"===a)return d(r._storedError);if(At(r)||"closed"===a)return d(new TypeError("The stream is closing or closed and cannot be written to"));if("erroring"===a)return d(r._storedError);const i=function(e){return u((t,r)=>{const o={_resolve:t,_reject:r};e._writeRequests.push(o)})}(r);return function(e,t,r){try{Ce(e,t,r)}catch(t){return void Gt(e,t)}const o=e._controlledWritableStream;if(!At(o)&&"writable"===o._state){Dt(o,Xt(e))}Ut(e)}(o,t,n),i}Object.defineProperties(WritableStreamDefaultWriter.prototype,{abort:{enumerable:!0},close:{enumerable:!0},releaseLock:{enumerable:!0},write:{enumerable:!0},closed:{enumerable:!0},desiredSize:{enumerable:!0},ready:{enumerable:!0}}),o(WritableStreamDefaultWriter.prototype.abort,"abort"),o(WritableStreamDefaultWriter.prototype.close,"close"),o(WritableStreamDefaultWriter.prototype.releaseLock,"releaseLock"),o(WritableStreamDefaultWriter.prototype.write,"write"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(WritableStreamDefaultWriter.prototype,Symbol.toStringTag,{value:"WritableStreamDefaultWriter",configurable:!0});const Qt={};class WritableStreamDefaultController{constructor(){throw new TypeError("Illegal constructor")}get abortReason(){if(!xt(this))throw Zt("abortReason");return this._abortReason}get signal(){if(!xt(this))throw Zt("signal");if(void 0===this._abortController)throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");return this._abortController.signal}error(e=void 0){if(!xt(this))throw Zt("error");"writable"===this._controlledWritableStream._state&&Jt(this,e)}[w](e){const t=this._abortAlgorithm(e);return Ht(this),t}[R](){qe(this)}}function xt(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledWritableStream")&&e instanceof WritableStreamDefaultController)}function Nt(e,t,r,o,n,a,i,s){t._controlledWritableStream=e,e._writableStreamController=t,t._queue=void 0,t._queueTotalSize=void 0,qe(t),t._abortReason=void 0,t._abortController=function(){if("function"==typeof AbortController)return new AbortController}(),t._started=!1,t._strategySizeAlgorithm=s,t._strategyHWM=i,t._writeAlgorithm=o,t._closeAlgorithm=n,t._abortAlgorithm=a;const l=Xt(t);Dt(e,l);b(c(r()),()=>(t._started=!0,Ut(t),null),r=>(t._started=!0,Ot(e,r),null))}function Ht(e){e._writeAlgorithm=void 0,e._closeAlgorithm=void 0,e._abortAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function Vt(e){return e._strategyHWM-e._queueTotalSize}function Ut(e){const t=e._controlledWritableStream;if(!e._started)return;if(void 0!==t._inFlightWriteRequest)return;if("erroring"===t._state)return void kt(t);if(0===e._queue.length)return;const r=e._queue.peek().value;r===Qt?function(e){const t=e._controlledWritableStream;(function(e){e._inFlightCloseRequest=e._closeRequest,e._closeRequest=void 0})(t),Pe(e);const r=e._closeAlgorithm();Ht(e),b(r,()=>(function(e){e._inFlightCloseRequest._resolve(void 0),e._inFlightCloseRequest=void 0,"erroring"===e._state&&(e._storedError=void 0,void 0!==e._pendingAbortRequest&&(e._pendingAbortRequest._resolve(),e._pendingAbortRequest=void 0)),e._state="closed";const t=e._writer;void 0!==t&&ar(t)}(t),null),e=>(function(e,t){e._inFlightCloseRequest._reject(t),e._inFlightCloseRequest=void 0,void 0!==e._pendingAbortRequest&&(e._pendingAbortRequest._reject(t),e._pendingAbortRequest=void 0),Ot(e,t)}(t,e),null))}(e):function(e,t){const r=e._controlledWritableStream;!function(e){e._inFlightWriteRequest=e._writeRequests.shift()}(r);const o=e._writeAlgorithm(t);b(o,()=>{!function(e){e._inFlightWriteRequest._resolve(void 0),e._inFlightWriteRequest=void 0}(r);const t=r._state;if(Pe(e),!At(r)&&"writable"===t){const t=Xt(e);Dt(r,t)}return Ut(e),null},t=>("writable"===r._state&&Ht(e),function(e,t){e._inFlightWriteRequest._reject(t),e._inFlightWriteRequest=void 0,Ot(e,t)}(r,t),null))}(e,r)}function Gt(e,t){"writable"===e._controlledWritableStream._state&&Jt(e,t)}function Xt(e){return Vt(e)<=0}function Jt(e,t){const r=e._controlledWritableStream;Ht(e),jt(r,t)}function Kt(e){return new TypeError(`WritableStream.prototype.${e} can only be used on a WritableStream`)}function Zt(e){return new TypeError(`WritableStreamDefaultController.prototype.${e} can only be used on a WritableStreamDefaultController`)}function er(e){return new TypeError(`WritableStreamDefaultWriter.prototype.${e} can only be used on a WritableStreamDefaultWriter`)}function tr(e){return new TypeError("Cannot "+e+" a stream using a released writer")}function rr(e){e._closedPromise=u((t,r)=>{e._closedPromise_resolve=t,e._closedPromise_reject=r,e._closedPromiseState="pending"})}function or(e,t){rr(e),nr(e,t)}function nr(e,t){void 0!==e._closedPromise_reject&&(p(e._closedPromise),e._closedPromise_reject(t),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="rejected")}function ar(e){void 0!==e._closedPromise_resolve&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="resolved")}function ir(e){e._readyPromise=u((t,r)=>{e._readyPromise_resolve=t,e._readyPromise_reject=r}),e._readyPromiseState="pending"}function sr(e,t){ir(e),ur(e,t)}function lr(e){ir(e),cr(e)}function ur(e,t){void 0!==e._readyPromise_reject&&(p(e._readyPromise),e._readyPromise_reject(t),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="rejected")}function cr(e){void 0!==e._readyPromise_resolve&&(e._readyPromise_resolve(void 0),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="fulfilled")}Object.defineProperties(WritableStreamDefaultController.prototype,{abortReason:{enumerable:!0},signal:{enumerable:!0},error:{enumerable:!0}}),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(WritableStreamDefaultController.prototype,Symbol.toStringTag,{value:"WritableStreamDefaultController",configurable:!0});const dr="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:"undefined"!=typeof global?global:void 0;const fr=function(){const e=null==dr?void 0:dr.DOMException;return function(e){if("function"!=typeof e&&"object"!=typeof e)return!1;if("DOMException"!==e.name)return!1;try{return new e,!0}catch(e){return!1}}(e)?e:void 0}()||function(){const e=function(e,t){this.message=e||"",this.name=t||"Error",Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)};return o(e,"DOMException"),e.prototype=Object.create(Error.prototype),Object.defineProperty(e.prototype,"constructor",{value:e,writable:!0,configurable:!0}),e}();function br(e,t,r,o,n,a){const i=V(e),s=Pt(t);e._disturbed=!0;const l=new hr(s),_=new mr(l);return u((m,y)=>{let S;if(void 0!==a){if(S=()=>{const r=void 0!==a.reason?a.reason:new fr("Aborted","AbortError"),i=[];o||i.push(()=>"writable"===t._state?Wt(t,r):c(void 0)),n||i.push(()=>"readable"===e._state?Mr(e,r):c(void 0)),T(()=>Promise.all(i.map(e=>e())),!0,r)},a.aborted)return void S();a.addEventListener("abort",S)}function g(){for(;!l._shuttingDown&&!t._backpressure&&"writable"===t._state&&!At(t)&&"readable"===e._state&&re(i);)te(i,_);if(l._shuttingDown)return c(!0);if(t._backpressure)return f(s._readyPromise,g);const r=new _r(l);return te(i,r),r._promise}var v,w,R;if(pr(e,i._closedPromise,e=>(o?P(!0,e):T(()=>Wt(t,e),!0,e),null)),pr(t,s._closedPromise,t=>(n?P(!0,t):T(()=>Mr(e,t),!0,t),null)),v=e,w=i._closedPromise,R=()=>(r?P():T(()=>function(e){const t=e._ownerWritableStream,r=t._state;return At(t)||"closed"===r?c(void 0):"errored"===r?d(t._storedError):Lt(e)}(s)),null),"closed"===v._state?R():h(w,R),At(t)||"closed"===t._state){const t=new TypeError("the destination writable stream closed before all data could be piped to it");n?P(!0,t):T(()=>Mr(e,t),!0,t)}function T(e,r,o){function n(){return b(e(),()=>C(r,o),e=>C(!0,e)),null}l._shuttingDown||(l._shuttingDown=!0,"writable"!==t._state||At(t)?n():h(l._waitForWritesToFinish(),n))}function P(e,r){l._shuttingDown||(l._shuttingDown=!0,"writable"!==t._state||At(t)?C(e,r):h(l._waitForWritesToFinish(),()=>C(e,r)))}function C(e,t){return Mt(s),B(i),void 0!==a&&a.removeEventListener("abort",S),e?y(t):m(void 0),null}p(u((e,t)=>{!function r(o){o?e():f(g(),r,t)}(!1)}))})}class hr{constructor(e){this._writer=e,this._shuttingDown=!1,this._currentWrite=c(void 0)}_waitForWritesToFinish(){const e=this._currentWrite;return f(this._currentWrite,()=>e!==this._currentWrite?this._waitForWritesToFinish():void 0)}}class _r{constructor(e){this._state=e,this._promise=u((e,t)=>{this._resolvePromise=e,this._rejectPromise=t})}_chunkSteps(t){this._state._currentWrite=f(Yt(this._state._writer,t),void 0,e),this._resolvePromise(!1)}_closeSteps(){this._resolvePromise(!0)}_errorSteps(e){this._rejectPromise(e)}}class mr{constructor(e){this._state=e}_chunkSteps(t){this._state._currentWrite=f(Yt(this._state._writer,t),void 0,e)}_closeSteps(){}_errorSteps(e){}}function pr(e,t,r){"errored"===e._state?r(e._storedError):_(t,r)}class ReadableStreamDefaultController{constructor(){throw new TypeError("Illegal constructor")}get desiredSize(){if(!yr(this))throw Er("desiredSize");return Pr(this)}close(){if(!yr(this))throw Er("close");if(!Cr(this))throw new TypeError("The stream is not in a state that permits close");wr(this)}enqueue(e=void 0){if(!yr(this))throw Er("enqueue");if(!Cr(this))throw new TypeError("The stream is not in a state that permits enqueue");return Rr(this,e)}error(e=void 0){if(!yr(this))throw Er("error");Tr(this,e)}[T](e){qe(this);const t=this._cancelAlgorithm(e);return vr(this),t}[P](e){const t=this._controlledReadableStream;if(this._queue.length>0){const r=Pe(this);this._closeRequested&&0===this._queue.length?(vr(this),Yr(t)):Sr(this),e._chunkSteps(r)}else U(t,e),Sr(this)}[C](){return this._queue.length>0}[q](){}}function yr(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledReadableStream")&&e instanceof ReadableStreamDefaultController)}function Sr(e){if(!gr(e))return;if(e._pulling)return void(e._pullAgain=!0);e._pulling=!0;b(e._pullAlgorithm(),()=>(e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,Sr(e)),null),t=>(Tr(e,t),null))}function gr(e){const t=e._controlledReadableStream;if(!Cr(e))return!1;if(!e._started)return!1;if($r(t)&&X(t)>0)return!0;return Pr(e)>0}function vr(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function wr(e){if(!Cr(e))return;const t=e._controlledReadableStream;e._closeRequested=!0,0===e._queue.length&&(vr(e),Yr(t))}function Rr(e,t){if(!Cr(e))return;const r=e._controlledReadableStream;if($r(r)&&X(r)>0)G(r,t,!1);else{let r;try{r=e._strategySizeAlgorithm(t)}catch(t){throw Tr(e,t),t}try{Ce(e,t,r)}catch(t){throw Tr(e,t),t}}Sr(e)}function Tr(e,t){const r=e._controlledReadableStream;"readable"===r._state&&(qe(e),vr(e),Qr(r,t))}function Pr(e){const t=e._controlledReadableStream._state;return"errored"===t?null:"closed"===t?0:e._strategyHWM-e._queueTotalSize}function Cr(e){const t=e._controlledReadableStream._state;return!e._closeRequested&&"readable"===t}function qr(e,t,r,o,n,a,i){t._controlledReadableStream=e,t._queue=void 0,t._queueTotalSize=void 0,qe(t),t._started=!1,t._closeRequested=!1,t._pullAgain=!1,t._pulling=!1,t._strategySizeAlgorithm=i,t._strategyHWM=a,t._pullAlgorithm=o,t._cancelAlgorithm=n,e._readableStreamController=t;b(c(r()),()=>(t._started=!0,Sr(t),null),e=>(Tr(t,e),null))}function Er(e){return new TypeError(`ReadableStreamDefaultController.prototype.${e} can only be used on a ReadableStreamDefaultController`)}function Wr(e,t){return Be(e._readableStreamController)?function(e){let t,r,o,n,a,i=V(e),s=!1,l=!1,d=!1,f=!1,b=!1;const h=u(e=>{a=e});function m(e){_(e._closedPromise,t=>(e!==i||(Xe(o._readableStreamController,t),Xe(n._readableStreamController,t),f&&b||a(void 0)),null))}function p(){ft(i)&&(B(i),i=V(e),m(i));te(i,{_chunkSteps:t=>{y(()=>{l=!1,d=!1;const r=t;let i=t;if(!f&&!b)try{i=Te(t)}catch(t){return Xe(o._readableStreamController,t),Xe(n._readableStreamController,t),void a(Mr(e,t))}f||Ge(o._readableStreamController,r),b||Ge(n._readableStreamController,i),s=!1,l?g():d&&v()})},_closeSteps:()=>{s=!1,f||Ue(o._readableStreamController),b||Ue(n._readableStreamController),o._readableStreamController._pendingPullIntos.length>0&&et(o._readableStreamController,0),n._readableStreamController._pendingPullIntos.length>0&&et(n._readableStreamController,0),f&&b||a(void 0)},_errorSteps:()=>{s=!1}})}function S(t,r){ee(i)&&(B(i),i=it(e),m(i));const u=r?n:o,c=r?o:n;bt(i,t,1,{_chunkSteps:t=>{y(()=>{l=!1,d=!1;const o=r?b:f;if(r?f:b)o||tt(u._readableStreamController,t);else{let r;try{r=Te(t)}catch(t){return Xe(u._readableStreamController,t),Xe(c._readableStreamController,t),void a(Mr(e,t))}o||tt(u._readableStreamController,t),Ge(c._readableStreamController,r)}s=!1,l?g():d&&v()})},_closeSteps:e=>{s=!1;const t=r?b:f,o=r?f:b;t||Ue(u._readableStreamController),o||Ue(c._readableStreamController),void 0!==e&&(t||tt(u._readableStreamController,e),!o&&c._readableStreamController._pendingPullIntos.length>0&&et(c._readableStreamController,0)),t&&o||a(void 0)},_errorSteps:()=>{s=!1}})}function g(){if(s)return l=!0,c(void 0);s=!0;const e=Ke(o._readableStreamController);return null===e?p():S(e._view,!1),c(void 0)}function v(){if(s)return d=!0,c(void 0);s=!0;const e=Ke(n._readableStreamController);return null===e?p():S(e._view,!0),c(void 0)}function w(o){if(f=!0,t=o,b){const o=le([t,r]),n=Mr(e,o);a(n)}return h}function R(o){if(b=!0,r=o,f){const o=le([t,r]),n=Mr(e,o);a(n)}return h}function T(){}return o=Fr(T,g,w),n=Fr(T,v,R),m(i),[o,n]}(e):function(e){const t=V(e);let r,o,n,a,i,s=!1,l=!1,d=!1,f=!1;const b=u(e=>{i=e});function h(){if(s)return l=!0,c(void 0);s=!0;return te(t,{_chunkSteps:e=>{y(()=>{l=!1;const t=e,r=e;d||Rr(n._readableStreamController,t),f||Rr(a._readableStreamController,r),s=!1,l&&h()})},_closeSteps:()=>{s=!1,d||wr(n._readableStreamController),f||wr(a._readableStreamController),d&&f||i(void 0)},_errorSteps:()=>{s=!1}}),c(void 0)}function m(t){if(d=!0,r=t,f){const t=le([r,o]),n=Mr(e,t);i(n)}return b}function p(t){if(f=!0,o=t,d){const t=le([r,o]),n=Mr(e,t);i(n)}return b}function S(){}return n=Dr(S,h,m),a=Dr(S,h,p),_(t._closedPromise,e=>(Tr(n._readableStreamController,e),Tr(a._readableStreamController,e),d&&f||i(void 0),null)),[n,a]}(e)}function Br(r){return t(o=r)&&void 0!==o.getReader?function(r){let o;function n(){let e;try{e=r.read()}catch(e){return d(e)}return m(e,e=>{if(!t(e))throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");if(e.done)wr(o._readableStreamController);else{const t=e.value;Rr(o._readableStreamController,t)}})}function a(e){try{return c(r.cancel(e))}catch(e){return d(e)}}return o=Dr(e,n,a,0),o}(r.getReader()):function(r){let o;const n=me(r,"async");function a(){let e;try{e=pe(n)}catch(e){return d(e)}return m(c(e),e=>{if(!t(e))throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");if(e.done)wr(o._readableStreamController);else{const t=e.value;Rr(o._readableStreamController,t)}})}function i(e){const r=n.iterator;let o;try{o=be(r,"return")}catch(e){return d(e)}if(void 0===o)return c(void 0);return m(g(o,r,[e]),e=>{if(!t(e))throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object")})}return o=Dr(e,a,i,0),o}(r);var o}function Or(e,t,r){return I(e,r),r=>g(e,t,[r])}function jr(e,t,r){return I(e,r),r=>g(e,t,[r])}function kr(e,t,r){return I(e,r),r=>S(e,t,[r])}function Ar(e,t){if("bytes"!==(e=`${e}`))throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamType`);return e}function zr(e,t){L(e,t);const r=null==e?void 0:e.preventAbort,o=null==e?void 0:e.preventCancel,n=null==e?void 0:e.preventClose,a=null==e?void 0:e.signal;return void 0!==a&&function(e,t){if(!function(e){if("object"!=typeof e||null===e)return!1;try{return"boolean"==typeof e.aborted}catch(e){return!1}}(e))throw new TypeError(`${t} is not an AbortSignal.`)}(a,`${t} has member 'signal' that`),{preventAbort:Boolean(r),preventCancel:Boolean(o),preventClose:Boolean(n),signal:a}}Object.defineProperties(ReadableStreamDefaultController.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},desiredSize:{enumerable:!0}}),o(ReadableStreamDefaultController.prototype.close,"close"),o(ReadableStreamDefaultController.prototype.enqueue,"enqueue"),o(ReadableStreamDefaultController.prototype.error,"error"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableStreamDefaultController.prototype,Symbol.toStringTag,{value:"ReadableStreamDefaultController",configurable:!0});class ReadableStream{constructor(e={},t={}){void 0===e?e=null:$(e,"First parameter");const r=yt(t,"Second parameter"),o=function(e,t){L(e,t);const r=e,o=null==r?void 0:r.autoAllocateChunkSize,n=null==r?void 0:r.cancel,a=null==r?void 0:r.pull,i=null==r?void 0:r.start,s=null==r?void 0:r.type;return{autoAllocateChunkSize:void 0===o?void 0:N(o,`${t} has member 'autoAllocateChunkSize' that`),cancel:void 0===n?void 0:Or(n,r,`${t} has member 'cancel' that`),pull:void 0===a?void 0:jr(a,r,`${t} has member 'pull' that`),start:void 0===i?void 0:kr(i,r,`${t} has member 'start' that`),type:void 0===s?void 0:Ar(s,`${t} has member 'type' that`)}}(e,"First parameter");if(Lr(this),"bytes"===o.type){if(void 0!==r.size)throw new RangeError("The strategy for a byte stream cannot have a size function");!function(e,t,r){const o=Object.create(ReadableByteStreamController.prototype);let n,a,i;n=void 0!==t.start?()=>t.start(o):()=>{},a=void 0!==t.pull?()=>t.pull(o):()=>c(void 0),i=void 0!==t.cancel?e=>t.cancel(e):()=>c(void 0);const s=t.autoAllocateChunkSize;if(0===s)throw new TypeError("autoAllocateChunkSize must be greater than 0");rt(e,o,n,a,i,r,s)}(this,o,mt(r,0))}else{const e=pt(r);!function(e,t,r,o){const n=Object.create(ReadableStreamDefaultController.prototype);let a,i,s;a=void 0!==t.start?()=>t.start(n):()=>{},i=void 0!==t.pull?()=>t.pull(n):()=>c(void 0),s=void 0!==t.cancel?e=>t.cancel(e):()=>c(void 0),qr(e,n,a,i,s,r,o)}(this,o,mt(r,1),e)}}get locked(){if(!Ir(this))throw xr("locked");return $r(this)}cancel(e=void 0){return Ir(this)?$r(this)?d(new TypeError("Cannot cancel a stream that already has a reader")):Mr(this,e):d(xr("cancel"))}getReader(e=void 0){if(!Ir(this))throw xr("getReader");return void 0===function(e,t){L(e,t);const r=null==e?void 0:e.mode;return{mode:void 0===r?void 0:at(r,`${t} has member 'mode' that`)}}(e,"First parameter").mode?V(this):it(this)}pipeThrough(e,t={}){if(!Ir(this))throw xr("pipeThrough");M(e,1,"pipeThrough");const r=function(e,t){L(e,t);const r=null==e?void 0:e.readable;Y(r,"readable","ReadableWritablePair"),H(r,`${t} has member 'readable' that`);const o=null==e?void 0:e.writable;return Y(o,"writable","ReadableWritablePair"),Tt(o,`${t} has member 'writable' that`),{readable:r,writable:o}}(e,"First parameter"),o=zr(t,"Second parameter");if($r(this))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");if(Et(r.writable))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");return p(br(this,r.writable,o.preventClose,o.preventAbort,o.preventCancel,o.signal)),r.readable}pipeTo(e,t={}){if(!Ir(this))return d(xr("pipeTo"));if(void 0===e)return d("Parameter 1 is required in 'pipeTo'.");if(!qt(e))return d(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));let r;try{r=zr(t,"Second parameter")}catch(e){return d(e)}return $r(this)?d(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")):Et(e)?d(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")):br(this,e,r.preventClose,r.preventAbort,r.preventCancel,r.signal)}tee(){if(!Ir(this))throw xr("tee");return le(Wr(this))}values(e=void 0){if(!Ir(this))throw xr("values");return function(e,t){const r=V(e),o=new ye(r,t),n=Object.create(ge);return n._asyncIteratorImpl=o,n}(this,function(e,t){L(e,t);const r=null==e?void 0:e.preventCancel;return{preventCancel:Boolean(r)}}(e,"First parameter").preventCancel)}[_e](e){return this.values(e)}static from(e){return Br(e)}}function Dr(e,t,r,o=1,n=()=>1){const a=Object.create(ReadableStream.prototype);Lr(a);return qr(a,Object.create(ReadableStreamDefaultController.prototype),e,t,r,o,n),a}function Fr(e,t,r){const o=Object.create(ReadableStream.prototype);Lr(o);return rt(o,Object.create(ReadableByteStreamController.prototype),e,t,r,0,void 0),o}function Lr(e){e._state="readable",e._reader=void 0,e._storedError=void 0,e._disturbed=!1}function Ir(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readableStreamController")&&e instanceof ReadableStream)}function $r(e){return void 0!==e._reader}function Mr(t,r){if(t._disturbed=!0,"closed"===t._state)return c(void 0);if("errored"===t._state)return d(t._storedError);Yr(t);const o=t._reader;if(void 0!==o&&ft(o)){const e=o._readIntoRequests;o._readIntoRequests=new v,e.forEach(e=>{e._closeSteps(void 0)})}return m(t._readableStreamController[T](r),e)}function Yr(e){e._state="closed";const t=e._reader;if(void 0!==t&&(z(t),ee(t))){const e=t._readRequests;t._readRequests=new v,e.forEach(e=>{e._closeSteps()})}}function Qr(e,t){e._state="errored",e._storedError=t;const r=e._reader;void 0!==r&&(A(r,t),ee(r)?oe(r,t):ht(r,t))}function xr(e){return new TypeError(`ReadableStream.prototype.${e} can only be used on a ReadableStream`)}function Nr(e,t){L(e,t);const r=null==e?void 0:e.highWaterMark;return Y(r,"highWaterMark","QueuingStrategyInit"),{highWaterMark:Q(r)}}Object.defineProperties(ReadableStream,{from:{enumerable:!0}}),Object.defineProperties(ReadableStream.prototype,{cancel:{enumerable:!0},getReader:{enumerable:!0},pipeThrough:{enumerable:!0},pipeTo:{enumerable:!0},tee:{enumerable:!0},values:{enumerable:!0},locked:{enumerable:!0}}),o(ReadableStream.from,"from"),o(ReadableStream.prototype.cancel,"cancel"),o(ReadableStream.prototype.getReader,"getReader"),o(ReadableStream.prototype.pipeThrough,"pipeThrough"),o(ReadableStream.prototype.pipeTo,"pipeTo"),o(ReadableStream.prototype.tee,"tee"),o(ReadableStream.prototype.values,"values"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableStream.prototype,Symbol.toStringTag,{value:"ReadableStream",configurable:!0}),Object.defineProperty(ReadableStream.prototype,_e,{value:ReadableStream.prototype.values,writable:!0,configurable:!0});const Hr=e=>e.byteLength;o(Hr,"size");class ByteLengthQueuingStrategy{constructor(e){M(e,1,"ByteLengthQueuingStrategy"),e=Nr(e,"First parameter"),this._byteLengthQueuingStrategyHighWaterMark=e.highWaterMark}get highWaterMark(){if(!Ur(this))throw Vr("highWaterMark");return this._byteLengthQueuingStrategyHighWaterMark}get size(){if(!Ur(this))throw Vr("size");return Hr}}function Vr(e){return new TypeError(`ByteLengthQueuingStrategy.prototype.${e} can only be used on a ByteLengthQueuingStrategy`)}function Ur(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_byteLengthQueuingStrategyHighWaterMark")&&e instanceof ByteLengthQueuingStrategy)}Object.defineProperties(ByteLengthQueuingStrategy.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ByteLengthQueuingStrategy.prototype,Symbol.toStringTag,{value:"ByteLengthQueuingStrategy",configurable:!0});const Gr=()=>1;o(Gr,"size");class CountQueuingStrategy{constructor(e){M(e,1,"CountQueuingStrategy"),e=Nr(e,"First parameter"),this._countQueuingStrategyHighWaterMark=e.highWaterMark}get highWaterMark(){if(!Jr(this))throw Xr("highWaterMark");return this._countQueuingStrategyHighWaterMark}get size(){if(!Jr(this))throw Xr("size");return Gr}}function Xr(e){return new TypeError(`CountQueuingStrategy.prototype.${e} can only be used on a CountQueuingStrategy`)}function Jr(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_countQueuingStrategyHighWaterMark")&&e instanceof CountQueuingStrategy)}function Kr(e,t,r){return I(e,r),r=>g(e,t,[r])}function Zr(e,t,r){return I(e,r),r=>S(e,t,[r])}function eo(e,t,r){return I(e,r),(r,o)=>g(e,t,[r,o])}function to(e,t,r){return I(e,r),r=>g(e,t,[r])}Object.defineProperties(CountQueuingStrategy.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(CountQueuingStrategy.prototype,Symbol.toStringTag,{value:"CountQueuingStrategy",configurable:!0});class TransformStream{constructor(e={},t={},r={}){void 0===e&&(e=null);const o=yt(t,"Second parameter"),n=yt(r,"Third parameter"),a=function(e,t){L(e,t);const r=null==e?void 0:e.cancel,o=null==e?void 0:e.flush,n=null==e?void 0:e.readableType,a=null==e?void 0:e.start,i=null==e?void 0:e.transform,s=null==e?void 0:e.writableType;return{cancel:void 0===r?void 0:to(r,e,`${t} has member 'cancel' that`),flush:void 0===o?void 0:Kr(o,e,`${t} has member 'flush' that`),readableType:n,start:void 0===a?void 0:Zr(a,e,`${t} has member 'start' that`),transform:void 0===i?void 0:eo(i,e,`${t} has member 'transform' that`),writableType:s}}(e,"First parameter");if(void 0!==a.readableType)throw new RangeError("Invalid readableType specified");if(void 0!==a.writableType)throw new RangeError("Invalid writableType specified");const i=mt(n,0),s=pt(n),l=mt(o,1),f=pt(o);let h;!function(e,t,r,o,n,a){function i(){return t}function s(t){return function(e,t){const r=e._transformStreamController;if(e._backpressure){return m(e._backpressureChangePromise,()=>{const o=e._writable;if("erroring"===o._state)throw o._storedError;return co(r,t)})}return co(r,t)}(e,t)}function l(t){return function(e,t){const r=e._transformStreamController;if(void 0!==r._finishPromise)return r._finishPromise;const o=e._readable;r._finishPromise=u((e,t)=>{r._finishPromise_resolve=e,r._finishPromise_reject=t});const n=r._cancelAlgorithm(t);return lo(r),b(n,()=>("errored"===o._state?ho(r,o._storedError):(Tr(o._readableStreamController,t),bo(r)),null),e=>(Tr(o._readableStreamController,e),ho(r,e),null)),r._finishPromise}(e,t)}function c(){return function(e){const t=e._transformStreamController;if(void 0!==t._finishPromise)return t._finishPromise;const r=e._readable;t._finishPromise=u((e,r)=>{t._finishPromise_resolve=e,t._finishPromise_reject=r});const o=t._flushAlgorithm();return lo(t),b(o,()=>("errored"===r._state?ho(t,r._storedError):(wr(r._readableStreamController),bo(t)),null),e=>(Tr(r._readableStreamController,e),ho(t,e),null)),t._finishPromise}(e)}function d(){return function(e){return io(e,!1),e._backpressureChangePromise}(e)}function f(t){return function(e,t){const r=e._transformStreamController;if(void 0!==r._finishPromise)return r._finishPromise;const o=e._writable;r._finishPromise=u((e,t)=>{r._finishPromise_resolve=e,r._finishPromise_reject=t});const n=r._cancelAlgorithm(t);return lo(r),b(n,()=>("errored"===o._state?ho(r,o._storedError):(Gt(o._writableStreamController,t),ao(e),bo(r)),null),t=>(Gt(o._writableStreamController,t),ao(e),ho(r,t),null)),r._finishPromise}(e,t)}e._writable=function(e,t,r,o,n=1,a=()=>1){const i=Object.create(WritableStream.prototype);return Ct(i),Nt(i,Object.create(WritableStreamDefaultController.prototype),e,t,r,o,n,a),i}(i,s,c,l,r,o),e._readable=Dr(i,d,f,n,a),e._backpressure=void 0,e._backpressureChangePromise=void 0,e._backpressureChangePromise_resolve=void 0,io(e,!0),e._transformStreamController=void 0}(this,u(e=>{h=e}),l,f,i,s),function(e,t){const r=Object.create(TransformStreamDefaultController.prototype);let o,n,a;o=void 0!==t.transform?e=>t.transform(e,r):e=>{try{return uo(r,e),c(void 0)}catch(e){return d(e)}};n=void 0!==t.flush?()=>t.flush(r):()=>c(void 0);a=void 0!==t.cancel?e=>t.cancel(e):()=>c(void 0);!function(e,t,r,o,n){t._controlledTransformStream=e,e._transformStreamController=t,t._transformAlgorithm=r,t._flushAlgorithm=o,t._cancelAlgorithm=n,t._finishPromise=void 0,t._finishPromise_resolve=void 0,t._finishPromise_reject=void 0}(e,r,o,n,a)}(this,a),void 0!==a.start?h(a.start(this._transformStreamController)):h(void 0)}get readable(){if(!ro(this))throw _o("readable");return this._readable}get writable(){if(!ro(this))throw _o("writable");return this._writable}}function ro(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_transformStreamController")&&e instanceof TransformStream)}function oo(e,t){Tr(e._readable._readableStreamController,t),no(e,t)}function no(e,t){lo(e._transformStreamController),Gt(e._writable._writableStreamController,t),ao(e)}function ao(e){e._backpressure&&io(e,!1)}function io(e,t){void 0!==e._backpressureChangePromise&&e._backpressureChangePromise_resolve(),e._backpressureChangePromise=u(t=>{e._backpressureChangePromise_resolve=t}),e._backpressure=t}Object.defineProperties(TransformStream.prototype,{readable:{enumerable:!0},writable:{enumerable:!0}}),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(TransformStream.prototype,Symbol.toStringTag,{value:"TransformStream",configurable:!0});class TransformStreamDefaultController{constructor(){throw new TypeError("Illegal constructor")}get desiredSize(){if(!so(this))throw fo("desiredSize");return Pr(this._controlledTransformStream._readable._readableStreamController)}enqueue(e=void 0){if(!so(this))throw fo("enqueue");uo(this,e)}error(e=void 0){if(!so(this))throw fo("error");var t;t=e,oo(this._controlledTransformStream,t)}terminate(){if(!so(this))throw fo("terminate");!function(e){const t=e._controlledTransformStream;wr(t._readable._readableStreamController);const r=new TypeError("TransformStream terminated");no(t,r)}(this)}}function so(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledTransformStream")&&e instanceof TransformStreamDefaultController)}function lo(e){e._transformAlgorithm=void 0,e._flushAlgorithm=void 0,e._cancelAlgorithm=void 0}function uo(e,t){const r=e._controlledTransformStream,o=r._readable._readableStreamController;if(!Cr(o))throw new TypeError("Readable side is not in a state that permits enqueue");try{Rr(o,t)}catch(e){throw no(r,e),r._readable._storedError}const n=function(e){return!gr(e)}(o);n!==r._backpressure&&io(r,!0)}function co(e,t){return m(e._transformAlgorithm(t),void 0,t=>{throw oo(e._controlledTransformStream,t),t})}function fo(e){return new TypeError(`TransformStreamDefaultController.prototype.${e} can only be used on a TransformStreamDefaultController`)}function bo(e){void 0!==e._finishPromise_resolve&&(e._finishPromise_resolve(),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}function ho(e,t){void 0!==e._finishPromise_reject&&(p(e._finishPromise),e._finishPromise_reject(t),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}function _o(e){return new TypeError(`TransformStream.prototype.${e} can only be used on a TransformStream`)}Object.defineProperties(TransformStreamDefaultController.prototype,{enqueue:{enumerable:!0},error:{enumerable:!0},terminate:{enumerable:!0},desiredSize:{enumerable:!0}}),o(TransformStreamDefaultController.prototype.enqueue,"enqueue"),o(TransformStreamDefaultController.prototype.error,"error"),o(TransformStreamDefaultController.prototype.terminate,"terminate"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(TransformStreamDefaultController.prototype,Symbol.toStringTag,{value:"TransformStreamDefaultController",configurable:!0});const mo={ReadableStream:ReadableStream,ReadableStreamDefaultController:ReadableStreamDefaultController,ReadableByteStreamController:ReadableByteStreamController,ReadableStreamBYOBRequest:ReadableStreamBYOBRequest,ReadableStreamDefaultReader:ReadableStreamDefaultReader,ReadableStreamBYOBReader:ReadableStreamBYOBReader,WritableStream:WritableStream,WritableStreamDefaultController:WritableStreamDefaultController,WritableStreamDefaultWriter:WritableStreamDefaultWriter,ByteLengthQueuingStrategy:ByteLengthQueuingStrategy,CountQueuingStrategy:CountQueuingStrategy,TransformStream:TransformStream,TransformStreamDefaultController:TransformStreamDefaultController};for(const e in mo)Object.prototype.hasOwnProperty.call(mo,e)&&Object.defineProperty(dr,e,{value:mo[e],writable:!0,configurable:!0})}();
diff --git a/runtime-js/web-api/vendor/web-streams-polyfill/types.d.ts b/runtime-js/web-api/vendor/web-streams-polyfill/types.d.ts
new file mode 100644
index 0000000..af24e98
--- /dev/null
+++ b/runtime-js/web-api/vendor/web-streams-polyfill/types.d.ts
@@ -0,0 +1,821 @@
+/**
+ * A signal object that allows you to communicate with a request and abort it if required
+ * via its associated `AbortController` object.
+ *
+ * @remarks
+ *   This is equivalent to the `AbortSignal` interface defined in TypeScript's DOM types or `@types/node`.
+ *
+ * @public
+ */
+// Tysel adaptation: use the explicit runtime subset rather than ambient DOM.
+export declare type AbortSignal = import("../../index.js").TyselAbortSignal;
+
+/**
+ * A queuing strategy that counts the number of bytes in each chunk.
+ *
+ * @public
+ */
+export declare class ByteLengthQueuingStrategy implements QueuingStrategy<ArrayBufferView> {
+    constructor(options: QueuingStrategyInit);
+    /**
+     * Returns the high water mark provided to the constructor.
+     */
+    get highWaterMark(): number;
+    /**
+     * Measures the size of `chunk` by returning the value of its `byteLength` property.
+     */
+    get size(): (chunk: ArrayBufferView) => number;
+}
+
+/**
+ * A queuing strategy that counts the number of chunks.
+ *
+ * @public
+ */
+export declare class CountQueuingStrategy implements QueuingStrategy<any> {
+    constructor(options: QueuingStrategyInit);
+    /**
+     * Returns the high water mark provided to the constructor.
+     */
+    get highWaterMark(): number;
+    /**
+     * Measures the size of `chunk` by always returning 1.
+     * This ensures that the total queue size is a count of the number of chunks in the queue.
+     */
+    get size(): (chunk: any) => 1;
+}
+
+/**
+ * A queuing strategy.
+ *
+ * @public
+ */
+export declare interface QueuingStrategy<T = any> {
+    /**
+     * A non-negative number indicating the high water mark of the stream using this queuing strategy.
+     */
+    highWaterMark?: number;
+    /**
+     * A function that computes and returns the finite non-negative size of the given chunk value.
+     */
+    size?: QueuingStrategySizeCallback<T>;
+}
+
+/**
+ * @public
+ */
+export declare interface QueuingStrategyInit {
+    /**
+     * {@inheritDoc QueuingStrategy.highWaterMark}
+     */
+    highWaterMark: number;
+}
+
+/**
+ * {@inheritDoc QueuingStrategy.size}
+ * @public
+ */
+export declare type QueuingStrategySizeCallback<T = any> = (chunk: T) => number;
+
+/**
+ * Allows control of a {@link ReadableStream | readable byte stream}'s state and internal queue.
+ *
+ * @public
+ */
+export declare class ReadableByteStreamController {
+    private constructor();
+    /**
+     * Returns the current BYOB pull request, or `null` if there isn't one.
+     */
+    get byobRequest(): ReadableStreamBYOBRequest | null;
+    /**
+     * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
+     * over-full. An underlying byte source ought to use this information to determine when and how to apply backpressure.
+     */
+    get desiredSize(): number | null;
+    /**
+     * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from
+     * the stream, but once those are read, the stream will become closed.
+     */
+    close(): void;
+    /**
+     * Enqueues the given chunk chunk in the controlled readable stream.
+     * The chunk has to be an `ArrayBufferView` instance, or else a `TypeError` will be thrown.
+     */
+    enqueue(chunk: ArrayBufferView): void;
+    /**
+     * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
+     */
+    error(e?: any): void;
+}
+
+/**
+ * A readable stream represents a source of data, from which you can read.
+ *
+ * @public
+ */
+export declare class ReadableStream<R = any> implements AsyncIterable<R> {
+    constructor(underlyingSource: UnderlyingByteSource, strategy?: {
+        highWaterMark?: number;
+        size?: undefined;
+    });
+    constructor(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>);
+    /**
+     * Whether or not the readable stream is locked to a {@link ReadableStreamDefaultReader | reader}.
+     */
+    get locked(): boolean;
+    /**
+     * Cancels the stream, signaling a loss of interest in the stream by a consumer.
+     *
+     * The supplied `reason` argument will be given to the underlying source's {@link UnderlyingSource.cancel | cancel()}
+     * method, which might or might not use it.
+     */
+    cancel(reason?: any): Promise<void>;
+    /**
+     * Creates a {@link ReadableStreamBYOBReader} and locks the stream to the new reader.
+     *
+     * This call behaves the same way as the no-argument variant, except that it only works on readable byte streams,
+     * i.e. streams which were constructed specifically with the ability to handle "bring your own buffer" reading.
+     * The returned BYOB reader provides the ability to directly read individual chunks from the stream via its
+     * {@link ReadableStreamBYOBReader.read | read()} method, into developer-supplied buffers, allowing more precise
+     * control over allocation.
+     */
+    getReader(options: {
+        mode: 'byob';
+    }): ReadableStreamBYOBReader;
+    /**
+     * Creates a {@link ReadableStreamDefaultReader} and locks the stream to the new reader.
+     * While the stream is locked, no other reader can be acquired until this one is released.
+     *
+     * This functionality is especially useful for creating abstractions that desire the ability to consume a stream
+     * in its entirety. By getting a reader for the stream, you can ensure nobody else can interleave reads with yours
+     * or cancel the stream, which would interfere with your abstraction.
+     */
+    getReader(): ReadableStreamDefaultReader<R>;
+    /**
+     * Creates a {@link ReadableStreamReader} and locks the stream to the new reader.
+     */
+    getReader(options?: ReadableStreamGetReaderOptions | undefined): ReadableStreamReader<R>;
+    /**
+     * Provides a convenient, chainable way of piping this readable stream through a transform stream
+     * (or any other `{ writable, readable }` pair). It simply {@link ReadableStream.pipeTo | pipes} the stream
+     * into the writable side of the supplied pair, and returns the readable side for further use.
+     *
+     * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
+     */
+    pipeThrough<RS extends ReadableStream>(transform: {
+        readable: RS;
+        writable: WritableStream<R>;
+    }, options?: StreamPipeOptions): RS;
+    /**
+     * Pipes this readable stream to a given writable stream. The way in which the piping process behaves under
+     * various error conditions can be customized with a number of passed options. It returns a promise that fulfills
+     * when the piping process completes successfully, or rejects if any errors were encountered.
+     *
+     * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
+     */
+    pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
+    /**
+     * Tees this readable stream, returning a two-element array containing the two resulting branches as
+     * new {@link ReadableStream} instances.
+     *
+     * Teeing a stream will lock it, preventing any other consumer from acquiring a reader.
+     * To cancel the stream, cancel both of the resulting branches; a composite cancellation reason will then be
+     * propagated to the stream's underlying source.
+     *
+     * Note that the chunks seen in each branch will be the same object. If the chunks are not immutable,
+     * this could allow interference between the two branches.
+     */
+    tee(): [ReadableStream<R>, ReadableStream<R>];
+    /**
+     * Asynchronously iterates over the chunks in the stream's internal queue.
+     *
+     * Asynchronously iterating over the stream will lock it, preventing any other consumer from acquiring a reader.
+     * The lock will be released if the async iterator's {@link ReadableStreamAsyncIterator.return | return()} method
+     * is called, e.g. by breaking out of the loop.
+     *
+     * By default, calling the async iterator's {@link ReadableStreamAsyncIterator.return | return()} method will also
+     * cancel the stream. To prevent this, use the stream's {@link ReadableStream.values | values()} method, passing
+     * `true` for the `preventCancel` option.
+     */
+    values(options?: ReadableStreamIteratorOptions): ReadableStreamAsyncIterator<R>;
+    /**
+     * {@inheritDoc ReadableStream.values}
+     */
+    [Symbol.asyncIterator](options?: ReadableStreamIteratorOptions): ReadableStreamAsyncIterator<R>;
+    /**
+     * Creates a new ReadableStream wrapping the provided iterable or async iterable.
+     *
+     * This can be used to adapt various kinds of objects into a readable stream,
+     * such as an array, an async generator, or a Node.js readable stream.
+     */
+    static from<R>(asyncIterable: Iterable<R> | AsyncIterable<R> | ReadableStreamLike<R>): ReadableStream<R>;
+}
+
+/**
+ * An async iterator returned by {@link ReadableStream.values}.
+ *
+ * @public
+ */
+export declare interface ReadableStreamAsyncIterator<R> extends AsyncIterableIterator<R> {
+    next(): Promise<IteratorResult<R, undefined>>;
+    return(value?: any): Promise<IteratorResult<any>>;
+}
+
+/**
+ * A BYOB reader vended by a {@link ReadableStream}.
+ *
+ * @public
+ */
+export declare class ReadableStreamBYOBReader {
+    constructor(stream: ReadableStream<Uint8Array>);
+    /**
+     * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
+     * the reader's lock is released before the stream finishes closing.
+     */
+    get closed(): Promise<undefined>;
+    /**
+     * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
+     */
+    cancel(reason?: any): Promise<void>;
+    /**
+     * Attempts to reads bytes into view, and returns a promise resolved with the result.
+     *
+     * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
+     */
+    read<T extends ArrayBufferView>(view: T, options?: ReadableStreamBYOBReaderReadOptions): Promise<ReadableStreamBYOBReadResult<T>>;
+    /**
+     * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
+     * If the associated stream is errored when the lock is released, the reader will appear errored in the same way
+     * from now on; otherwise, the reader will appear closed.
+     *
+     * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
+     * the reader's {@link ReadableStreamBYOBReader.read | read()} method has not yet been settled. Attempting to
+     * do so will throw a `TypeError` and leave the reader locked to the stream.
+     */
+    releaseLock(): void;
+}
+
+/**
+ * Options for {@link ReadableStreamBYOBReader.read | reading} a stream
+ * with a {@link ReadableStreamBYOBReader | BYOB reader}.
+ *
+ * @public
+ */
+export declare interface ReadableStreamBYOBReaderReadOptions {
+    min?: number;
+}
+
+/**
+ * A result returned by {@link ReadableStreamBYOBReader.read}.
+ *
+ * @public
+ */
+export declare type ReadableStreamBYOBReadResult<T extends ArrayBufferView> = {
+    done: false;
+    value: T;
+} | {
+    done: true;
+    value: T | undefined;
+};
+
+/**
+ * A pull-into request in a {@link ReadableByteStreamController}.
+ *
+ * @public
+ */
+export declare class ReadableStreamBYOBRequest {
+    private constructor();
+    /**
+     * Returns the view for writing in to, or `null` if the BYOB request has already been responded to.
+     */
+    get view(): ArrayBufferView<ArrayBuffer> | null;
+    /**
+     * Indicates to the associated readable byte stream that `bytesWritten` bytes were written into
+     * {@link ReadableStreamBYOBRequest.view | view}, causing the result be surfaced to the consumer.
+     *
+     * After this method is called, {@link ReadableStreamBYOBRequest.view | view} will be transferred and no longer
+     * modifiable.
+     */
+    respond(bytesWritten: number): void;
+    /**
+     * Indicates to the associated readable byte stream that instead of writing into
+     * {@link ReadableStreamBYOBRequest.view | view}, the underlying byte source is providing a new `ArrayBufferView`,
+     * which will be given to the consumer of the readable byte stream.
+     *
+     * After this method is called, `view` will be transferred and no longer modifiable.
+     */
+    respondWithNewView(view: ArrayBufferView): void;
+}
+
+/**
+ * Allows control of a {@link ReadableStream | readable stream}'s state and internal queue.
+ *
+ * @public
+ */
+export declare class ReadableStreamDefaultController<R> {
+    private constructor();
+    /**
+     * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
+     * over-full. An underlying source ought to use this information to determine when and how to apply backpressure.
+     */
+    get desiredSize(): number | null;
+    /**
+     * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from
+     * the stream, but once those are read, the stream will become closed.
+     */
+    close(): void;
+    /**
+     * Enqueues the given chunk `chunk` in the controlled readable stream.
+     */
+    enqueue(chunk: R): void;
+    /**
+     * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
+     */
+    error(e?: any): void;
+}
+
+/**
+ * A default reader vended by a {@link ReadableStream}.
+ *
+ * @public
+ */
+export declare class ReadableStreamDefaultReader<R = any> {
+    constructor(stream: ReadableStream<R>);
+    /**
+     * Returns a promise that will be fulfilled when the stream becomes closed,
+     * or rejected if the stream ever errors or the reader's lock is released before the stream finishes closing.
+     */
+    get closed(): Promise<undefined>;
+    /**
+     * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
+     */
+    cancel(reason?: any): Promise<void>;
+    /**
+     * Returns a promise that allows access to the next chunk from the stream's internal queue, if available.
+     *
+     * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
+     */
+    read(): Promise<ReadableStreamDefaultReadResult<R>>;
+    /**
+     * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
+     * If the associated stream is errored when the lock is released, the reader will appear errored in the same way
+     * from now on; otherwise, the reader will appear closed.
+     *
+     * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
+     * the reader's {@link ReadableStreamDefaultReader.read | read()} method has not yet been settled. Attempting to
+     * do so will throw a `TypeError` and leave the reader locked to the stream.
+     */
+    releaseLock(): void;
+}
+
+/**
+ * A common interface for a `ReadableStreamDefaultReader` implementation.
+ *
+ * @public
+ */
+export declare interface ReadableStreamDefaultReaderLike<R = any> {
+    readonly closed: Promise<undefined>;
+    cancel(reason?: any): Promise<void>;
+    read(): Promise<ReadableStreamDefaultReadResult<R>>;
+    releaseLock(): void;
+}
+
+/**
+ * A result returned by {@link ReadableStreamDefaultReader.read}.
+ *
+ * @public
+ */
+export declare type ReadableStreamDefaultReadResult<T> = {
+    done: false;
+    value: T;
+} | {
+    done: true;
+    value: undefined;
+};
+
+/**
+ * Options for {@link ReadableStream.(getReader:2)}.
+ *
+ * @public
+ */
+export declare interface ReadableStreamGetReaderOptions {
+    mode?: 'byob';
+}
+
+/**
+ * Options for {@link ReadableStream.values | async iterating} a stream.
+ *
+ * @public
+ */
+export declare interface ReadableStreamIteratorOptions {
+    preventCancel?: boolean;
+}
+
+/**
+ * A common interface for a `ReadadableStream` implementation.
+ *
+ * @public
+ */
+export declare interface ReadableStreamLike<R = any> {
+    readonly locked: boolean;
+    getReader(): ReadableStreamDefaultReaderLike<R>;
+}
+
+/**
+ * A reader vended by a {@link ReadableStream}.
+ *
+ * @public
+ */
+export declare type ReadableStreamReader<R> = ReadableStreamDefaultReader<R> | ReadableStreamBYOBReader;
+
+/**
+ * A pair of a {@link ReadableStream | readable stream} and {@link WritableStream | writable stream} that can be passed
+ * to {@link ReadableStream.pipeThrough}.
+ *
+ * @public
+ */
+export declare interface ReadableWritablePair<R, W> {
+    readable: ReadableStream<R>;
+    writable: WritableStream<W>;
+}
+
+/**
+ * Options for {@link ReadableStream.pipeTo | piping} a stream.
+ *
+ * @public
+ */
+export declare interface StreamPipeOptions {
+    /**
+     * If set to true, {@link ReadableStream.pipeTo} will not abort the writable stream if the readable stream errors.
+     */
+    preventAbort?: boolean;
+    /**
+     * If set to true, {@link ReadableStream.pipeTo} will not cancel the readable stream if the writable stream closes
+     * or errors.
+     */
+    preventCancel?: boolean;
+    /**
+     * If set to true, {@link ReadableStream.pipeTo} will not close the writable stream if the readable stream closes.
+     */
+    preventClose?: boolean;
+    /**
+     * Can be set to an {@link AbortSignal} to allow aborting an ongoing pipe operation via the corresponding
+     * `AbortController`. In this case, the source readable stream will be canceled, and the destination writable stream
+     * aborted, unless the respective options `preventCancel` or `preventAbort` are set.
+     */
+    signal?: AbortSignal;
+}
+
+/**
+ * A transformer for constructing a {@link TransformStream}.
+ *
+ * @public
+ */
+export declare interface Transformer<I = any, O = any> {
+    /**
+     * A function that is called immediately during creation of the {@link TransformStream}.
+     */
+    start?: TransformerStartCallback<O>;
+    /**
+     * A function called when a new chunk originally written to the writable side is ready to be transformed.
+     */
+    transform?: TransformerTransformCallback<I, O>;
+    /**
+     * A function called after all chunks written to the writable side have been transformed by successfully passing
+     * through {@link Transformer.transform | transform()}, and the writable side is about to be closed.
+     */
+    flush?: TransformerFlushCallback<O>;
+    /**
+     * A function called when the readable side is cancelled, or when the writable side is aborted.
+     */
+    cancel?: TransformerCancelCallback;
+    readableType?: undefined;
+    writableType?: undefined;
+}
+
+/** @public */
+export declare type TransformerCancelCallback = (reason: any) => void | PromiseLike<void>;
+
+/** @public */
+export declare type TransformerFlushCallback<O> = (controller: TransformStreamDefaultController<O>) => void | PromiseLike<void>;
+
+/** @public */
+export declare type TransformerStartCallback<O> = (controller: TransformStreamDefaultController<O>) => void | PromiseLike<void>;
+
+/** @public */
+export declare type TransformerTransformCallback<I, O> = (chunk: I, controller: TransformStreamDefaultController<O>) => void | PromiseLike<void>;
+
+/**
+ * A transform stream consists of a pair of streams: a {@link WritableStream | writable stream},
+ * known as its writable side, and a {@link ReadableStream | readable stream}, known as its readable side.
+ * In a manner specific to the transform stream in question, writes to the writable side result in new data being
+ * made available for reading from the readable side.
+ *
+ * @public
+ */
+export declare class TransformStream<I = any, O = any> {
+    constructor(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>);
+    /**
+     * The readable side of the transform stream.
+     */
+    get readable(): ReadableStream<O>;
+    /**
+     * The writable side of the transform stream.
+     */
+    get writable(): WritableStream<I>;
+}
+
+/**
+ * Allows control of the {@link ReadableStream} and {@link WritableStream} of the associated {@link TransformStream}.
+ *
+ * @public
+ */
+export declare class TransformStreamDefaultController<O> {
+    private constructor();
+    /**
+     * Returns the desired size to fill the readable side’s internal queue. It can be negative, if the queue is over-full.
+     */
+    get desiredSize(): number | null;
+    /**
+     * Enqueues the given chunk `chunk` in the readable side of the controlled transform stream.
+     */
+    enqueue(chunk: O): void;
+    /**
+     * Errors both the readable side and the writable side of the controlled transform stream, making all future
+     * interactions with it fail with the given error `e`. Any chunks queued for transformation will be discarded.
+     */
+    error(reason?: any): void;
+    /**
+     * Closes the readable side and errors the writable side of the controlled transform stream. This is useful when the
+     * transformer only needs to consume a portion of the chunks written to the writable side.
+     */
+    terminate(): void;
+}
+
+/**
+ * An underlying byte source for constructing a {@link ReadableStream}.
+ *
+ * @public
+ */
+export declare interface UnderlyingByteSource {
+    /**
+     * {@inheritDoc UnderlyingSource.start}
+     */
+    start?: UnderlyingByteSourceStartCallback;
+    /**
+     * {@inheritDoc UnderlyingSource.pull}
+     */
+    pull?: UnderlyingByteSourcePullCallback;
+    /**
+     * {@inheritDoc UnderlyingSource.cancel}
+     */
+    cancel?: UnderlyingSourceCancelCallback;
+    /**
+     * Can be set to "bytes" to signal that the constructed {@link ReadableStream} is a readable byte stream.
+     * This ensures that the resulting {@link ReadableStream} will successfully be able to vend BYOB readers via its
+     * {@link ReadableStream.(getReader:1) | getReader()} method.
+     * It also affects the controller argument passed to the {@link UnderlyingByteSource.start | start()}
+     * and {@link UnderlyingByteSource.pull | pull()} methods.
+     */
+    type: 'bytes';
+    /**
+     * Can be set to a positive integer to cause the implementation to automatically allocate buffers for the
+     * underlying source code to write into. In this case, when a consumer is using a default reader, the stream
+     * implementation will automatically allocate an ArrayBuffer of the given size, so that
+     * {@link ReadableByteStreamController.byobRequest | controller.byobRequest} is always present,
+     * as if the consumer was using a BYOB reader.
+     */
+    autoAllocateChunkSize?: number;
+}
+
+/** @public */
+export declare type UnderlyingByteSourcePullCallback = (controller: ReadableByteStreamController) => void | PromiseLike<void>;
+
+/** @public */
+export declare type UnderlyingByteSourceStartCallback = (controller: ReadableByteStreamController) => void | PromiseLike<void>;
+
+/**
+ * An underlying sink for constructing a {@link WritableStream}.
+ *
+ * @public
+ */
+export declare interface UnderlyingSink<W = any> {
+    /**
+     * A function that is called immediately during creation of the {@link WritableStream}.
+     */
+    start?: UnderlyingSinkStartCallback;
+    /**
+     * A function that is called when a new chunk of data is ready to be written to the underlying sink. The stream
+     * implementation guarantees that this function will be called only after previous writes have succeeded, and never
+     * before {@link UnderlyingSink.start | start()} has succeeded or after {@link UnderlyingSink.close | close()} or
+     * {@link UnderlyingSink.abort | abort()} have been called.
+     *
+     * This function is used to actually send the data to the resource presented by the underlying sink, for example by
+     * calling a lower-level API.
+     */
+    write?: UnderlyingSinkWriteCallback<W>;
+    /**
+     * A function that is called after the producer signals, via
+     * {@link WritableStreamDefaultWriter.close | writer.close()}, that they are done writing chunks to the stream, and
+     * subsequently all queued-up writes have successfully completed.
+     *
+     * This function can perform any actions necessary to finalize or flush writes to the underlying sink, and release
+     * access to any held resources.
+     */
+    close?: UnderlyingSinkCloseCallback;
+    /**
+     * A function that is called after the producer signals, via {@link WritableStream.abort | stream.abort()} or
+     * {@link WritableStreamDefaultWriter.abort | writer.abort()}, that they wish to abort the stream. It takes as its
+     * argument the same value as was passed to those methods by the producer.
+     *
+     * Writable streams can additionally be aborted under certain conditions during piping; see the definition of the
+     * {@link ReadableStream.pipeTo | pipeTo()} method for more details.
+     *
+     * This function can clean up any held resources, much like {@link UnderlyingSink.close | close()}, but perhaps with
+     * some custom handling.
+     */
+    abort?: UnderlyingSinkAbortCallback;
+    type?: undefined;
+}
+
+/** @public */
+export declare type UnderlyingSinkAbortCallback = (reason: any) => void | PromiseLike<void>;
+
+/** @public */
+export declare type UnderlyingSinkCloseCallback = () => void | PromiseLike<void>;
+
+/** @public */
+export declare type UnderlyingSinkStartCallback = (controller: WritableStreamDefaultController) => void | PromiseLike<void>;
+
+/** @public */
+export declare type UnderlyingSinkWriteCallback<W> = (chunk: W, controller: WritableStreamDefaultController) => void | PromiseLike<void>;
+
+/**
+ * An underlying source for constructing a {@link ReadableStream}.
+ *
+ * @public
+ */
+export declare interface UnderlyingSource<R = any> {
+    /**
+     * A function that is called immediately during creation of the {@link ReadableStream}.
+     */
+    start?: UnderlyingSourceStartCallback<R>;
+    /**
+     * A function that is called whenever the stream’s internal queue of chunks becomes not full,
+     * i.e. whenever the queue’s desired size becomes positive. Generally, it will be called repeatedly
+     * until the queue reaches its high water mark (i.e. until the desired size becomes non-positive).
+     */
+    pull?: UnderlyingSourcePullCallback<R>;
+    /**
+     * A function that is called whenever the consumer cancels the stream, via
+     * {@link ReadableStream.cancel | stream.cancel()},
+     * {@link ReadableStreamDefaultReader.cancel | defaultReader.cancel()}, or
+     * {@link ReadableStreamBYOBReader.cancel | byobReader.cancel()}.
+     * It takes as its argument the same value as was passed to those methods by the consumer.
+     */
+    cancel?: UnderlyingSourceCancelCallback;
+    type?: undefined;
+}
+
+/** @public */
+export declare type UnderlyingSourceCancelCallback = (reason: any) => void | PromiseLike<void>;
+
+/** @public */
+export declare type UnderlyingSourcePullCallback<R> = (controller: ReadableStreamDefaultController<R>) => void | PromiseLike<void>;
+
+/** @public */
+export declare type UnderlyingSourceStartCallback<R> = (controller: ReadableStreamDefaultController<R>) => void | PromiseLike<void>;
+
+/**
+ * A writable stream represents a destination for data, into which you can write.
+ *
+ * @public
+ */
+export declare class WritableStream<W = any> {
+    constructor(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>);
+    /**
+     * Returns whether or not the writable stream is locked to a writer.
+     */
+    get locked(): boolean;
+    /**
+     * Aborts the stream, signaling that the producer can no longer successfully write to the stream and it is to be
+     * immediately moved to an errored state, with any queued-up writes discarded. This will also execute any abort
+     * mechanism of the underlying sink.
+     *
+     * The returned promise will fulfill if the stream shuts down successfully, or reject if the underlying sink signaled
+     * that there was an error doing so. Additionally, it will reject with a `TypeError` (without attempting to cancel
+     * the stream) if the stream is currently locked.
+     */
+    abort(reason?: any): Promise<void>;
+    /**
+     * Closes the stream. The underlying sink will finish processing any previously-written chunks, before invoking its
+     * close behavior. During this time any further attempts to write will fail (without erroring the stream).
+     *
+     * The method returns a promise that will fulfill if all remaining chunks are successfully written and the stream
+     * successfully closes, or rejects if an error is encountered during this process. Additionally, it will reject with
+     * a `TypeError` (without attempting to cancel the stream) if the stream is currently locked.
+     */
+    close(): Promise<undefined>;
+    /**
+     * Creates a {@link WritableStreamDefaultWriter | writer} and locks the stream to the new writer. While the stream
+     * is locked, no other writer can be acquired until this one is released.
+     *
+     * This functionality is especially useful for creating abstractions that desire the ability to write to a stream
+     * without interruption or interleaving. By getting a writer for the stream, you can ensure nobody else can write at
+     * the same time, which would cause the resulting written data to be unpredictable and probably useless.
+     */
+    getWriter(): WritableStreamDefaultWriter<W>;
+}
+
+/**
+ * Allows control of a {@link WritableStream | writable stream}'s state and internal queue.
+ *
+ * @public
+ */
+export declare class WritableStreamDefaultController<W = any> {
+    private constructor();
+    /**
+     * The reason which was passed to `WritableStream.abort(reason)` when the stream was aborted.
+     *
+     * @deprecated
+     *  This property has been removed from the specification, see https://github.com/whatwg/streams/pull/1177.
+     *  Use {@link WritableStreamDefaultController.signal}'s `reason` instead.
+     */
+    get abortReason(): any;
+    /**
+     * An `AbortSignal` that can be used to abort the pending write or close operation when the stream is aborted.
+     */
+    get signal(): AbortSignal;
+    /**
+     * Closes the controlled writable stream, making all future interactions with it fail with the given error `e`.
+     *
+     * This method is rarely used, since usually it suffices to return a rejected promise from one of the underlying
+     * sink's methods. However, it can be useful for suddenly shutting down a stream in response to an event outside the
+     * normal lifecycle of interactions with the underlying sink.
+     */
+    error(e?: any): void;
+}
+
+/**
+ * A default writer vended by a {@link WritableStream}.
+ *
+ * @public
+ */
+export declare class WritableStreamDefaultWriter<W = any> {
+    constructor(stream: WritableStream<W>);
+    /**
+     * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
+     * the writer’s lock is released before the stream finishes closing.
+     */
+    get closed(): Promise<undefined>;
+    /**
+     * Returns the desired size to fill the stream’s internal queue. It can be negative, if the queue is over-full.
+     * A producer can use this information to determine the right amount of data to write.
+     *
+     * It will be `null` if the stream cannot be successfully written to (due to either being errored, or having an abort
+     * queued up). It will return zero if the stream is closed. And the getter will throw an exception if invoked when
+     * the writer’s lock is released.
+     */
+    get desiredSize(): number | null;
+    /**
+     * Returns a promise that will be fulfilled when the desired size to fill the stream’s internal queue transitions
+     * from non-positive to positive, signaling that it is no longer applying backpressure. Once the desired size dips
+     * back to zero or below, the getter will return a new promise that stays pending until the next transition.
+     *
+     * If the stream becomes errored or aborted, or the writer’s lock is released, the returned promise will become
+     * rejected.
+     */
+    get ready(): Promise<undefined>;
+    /**
+     * If the reader is active, behaves the same as {@link WritableStream.abort | stream.abort(reason)}.
+     */
+    abort(reason?: any): Promise<void>;
+    /**
+     * If the reader is active, behaves the same as {@link WritableStream.close | stream.close()}.
+     */
+    close(): Promise<void>;
+    /**
+     * Releases the writer’s lock on the corresponding stream. After the lock is released, the writer is no longer active.
+     * If the associated stream is errored when the lock is released, the writer will appear errored in the same way from
+     * now on; otherwise, the writer will appear closed.
+     *
+     * Note that the lock can still be released even if some ongoing writes have not yet finished (i.e. even if the
+     * promises returned from previous calls to {@link WritableStreamDefaultWriter.write | write()} have not yet settled).
+     * It’s not necessary to hold the lock on the writer for the duration of the write; the lock instead simply prevents
+     * other producers from writing in an interleaved manner.
+     */
+    releaseLock(): void;
+    /**
+     * Writes the given chunk to the writable stream, by waiting until any previous writes have finished successfully,
+     * and then sending the chunk to the underlying sink's {@link UnderlyingSink.write | write()} method. It will return
+     * a promise that fulfills with undefined upon a successful write, or rejects if the write fails or stream becomes
+     * errored before the writing process is initiated.
+     *
+     * Note that what "success" means is up to the underlying sink; it might indicate simply that the chunk has been
+     * accepted, and not necessarily that it is safely saved to its ultimate destination.
+     */
+    write(chunk: W): Promise<void>;
+}
+
+export { }

From 8659aba1df33fc0b1830410843c58f4ba9399a3a Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Mon, 7 Sep 2026 17:25:01 +0800
Subject: [PATCH 10/31] fix(runtime): preserve URL paths and decode malformed
 query bytes

Keep empty path segments and normalize default ports across URL mutations. Decode malformed form queries with replacement semantics and scalar normalization; cover the behavior with differential fixtures, QuickJS and Hono regressions.
---
 crates/tysel-engine-qjs/src/p1_tests.rs      | 17 +++++
 crates/tysel-engine-qjs/tests/hono_bundle.rs | 43 +++++++++++
 runtime-js/test/url.test.mjs                 | 59 +++++++++++++++
 runtime-js/web-api/compatibility.json        |  5 +-
 runtime-js/web-api/runtime.js                | 80 ++++++++++++++------
 runtime-js/web-api/source/url.js             | 80 ++++++++++++++------
 6 files changed, 233 insertions(+), 51 deletions(-)
 create mode 100644 runtime-js/test/url.test.mjs

diff --git a/crates/tysel-engine-qjs/src/p1_tests.rs b/crates/tysel-engine-qjs/src/p1_tests.rs
index 96ba101..6470bb4 100644
--- a/crates/tysel-engine-qjs/src/p1_tests.rs
+++ b/crates/tysel-engine-qjs/src/p1_tests.rs
@@ -601,6 +601,23 @@ fn p1_body_read_errors_do_not_wait_for_cancel() {
     assert_eq!(result, Value::Bool(true));
 }
 
+#[test]
+fn p1_url_preserves_paths_ports_and_query_bytes() {
+    let result=eval(r#"(()=>{
+      const u=new URL('https://example.com:00443/a//b?q=%E4%B8%AD+%FF');
+      if(u.pathname!=='/a//b'||u.port!==''||u.host!=='example.com'||u.searchParams.get('q')!=='中 �')return false;
+      if(new URL('../c//',u).pathname!=='/a/c//')return false;
+      u.pathname='/a//%2e/b/..';if(u.pathname!=='/a//')return false;
+      u.port='0080';u.protocol='http';if(u.port!==''||u.origin!=='http://example.com')return false;
+      u.host='[::1]:00080';if(u.host!=='[::1]')return false;
+      const params=u.searchParams;u.search='?q=%EF%BB%BF%FF+%41';
+      if(params!==u.searchParams||params.get('q')!=='\ufeff� A')return false;
+      params.set('q','\ud800😀');
+      return params.get('q')==='�😀' && u.search==='?q=%EF%BF%BD%F0%9F%98%80';
+    })()"#,config()).unwrap();
+    assert_eq!(result, Value::Bool(true));
+}
+
 #[test]
 fn p1_consumed_buffered_body_preserves_lazy_stream_state() {
     let result=eval(r#"(async()=>{
diff --git a/crates/tysel-engine-qjs/tests/hono_bundle.rs b/crates/tysel-engine-qjs/tests/hono_bundle.rs
index 203ed7d..27e46e9 100644
--- a/crates/tysel-engine-qjs/tests/hono_bundle.rs
+++ b/crates/tysel-engine-qjs/tests/hono_bundle.rs
@@ -163,3 +163,46 @@ async fn real_hono_example_handles_json_routes() {
     let text = body_text(body).await;
     assert!(text.contains("\"hello\":\"tysel\""), "GET /hello/:name body was {text}");
 }
+
+#[tokio::test]
+async fn real_hono_preserves_url_path_and_query_boundaries() {
+    let app = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../examples/hono-api");
+    assert!(app.join("node_modules/hono").is_dir(), "run pnpm install for real Hono acceptance");
+    let dir = std::env::temp_dir().join(format!("tysel-hono-url-{}", std::process::id()));
+    fs::create_dir_all(&dir).unwrap();
+    let modules = dir.join("node_modules");
+    if !modules.exists() {
+        std::os::unix::fs::symlink(app.join("node_modules"), &modules).unwrap();
+    }
+    let entry = dir.join("index.ts");
+    fs::write(
+        &entry,
+        r#"
+      import { Hono } from 'hono';
+      const app=new Hono();
+      app.get('/a//b',c=>{
+        const url=new URL(c.req.url);
+        return c.json({path:url.pathname,port:url.port,q:url.searchParams.get('q')});
+      });
+      app.get('/a/b',c=>c.text('distinct route'));
+      export default app;
+    "#,
+    )
+    .unwrap();
+    let (bundle, _) = tysel_build::read_bundle(&entry).unwrap();
+    let pool = IsolatePool::spawn(1, &String::from_utf8(bundle).unwrap(), config()).unwrap();
+    let (head, body) = pool
+        .dispatch(HttpRequest {
+            method: "GET".into(),
+            url: "https://tysel.local:443/a//b?q=%E4%B8%AD+%FF".into(),
+            headers: vec![],
+            body: vec![],
+            request_id: 0,
+        })
+        .await
+        .unwrap();
+    assert_eq!(head.status, 200);
+    let data: serde_json::Value = serde_json::from_str(&body_text(body).await).unwrap();
+    assert_eq!(data, serde_json::json!({"path":"/a//b","port":"","q":"中 �"}));
+    fs::remove_dir_all(dir).unwrap();
+}
diff --git a/runtime-js/test/url.test.mjs b/runtime-js/test/url.test.mjs
new file mode 100644
index 0000000..68561b0
--- /dev/null
+++ b/runtime-js/test/url.test.mjs
@@ -0,0 +1,59 @@
+import assert from 'node:assert/strict';
+import {readFileSync} from 'node:fs';
+import vm from 'node:vm';
+import test from 'node:test';
+
+const context=vm.createContext({TextEncoder,TextDecoder});
+vm.runInContext(readFileSync(new URL('../web-api/source/url.js',import.meta.url),'utf8'),context);
+const CustomURL=vm.runInContext('URL',context);
+const CustomParams=vm.runInContext('URLSearchParams',context);
+function state(url) { return [url.href,url.origin,url.host,url.hostname,url.port,url.pathname,url.search,String(url.searchParams)]; }
+
+test('authority paths preserve empty segments through parsing, resolution and setters',()=>{
+  const segments=['a','','.','..','%2e','.%2E','%2e%2e'];
+  for(const a of segments) for(const b of segments) for(const c of segments) {
+    const path='/'+[a,b,c].join('/');
+    for(const reference of ['https://example.com'+path,'.'+path]) {
+      const base='https://example.com/a//b/';
+      assert.deepEqual(state(new CustomURL(reference,base)),state(new URL(reference,base)),reference);
+    }
+    const custom=new CustomURL('https://example.com/'), native=new URL('https://example.com/');
+    custom.pathname=path;native.pathname=path;
+    assert.deepEqual(state(custom),state(native),path);
+  }
+});
+
+test('default ports normalize consistently across URL mutations',()=>{
+  for(const [scheme,port] of [['http',80],['https',443],['ws',80],['wss',443],['ftp',21]]) {
+    for(const host of ['example.com','[::1]']) {
+      const input=`${scheme}://${host}:00${port}/a//b`;
+      const custom=new CustomURL(input),native=new URL(input);
+      assert.deepEqual(state(custom),state(native));
+      for(const [key,value] of [['port','8080'],['port','00'+port],['host',host+':'+port],['href',input]]) {
+        custom[key]=value;native[key]=value;assert.deepEqual(state(custom),state(native),key);
+      }
+    }
+  }
+  const custom=new CustomURL('http://example.com:443/a'),native=new URL('http://example.com:443/a');
+  custom.protocol='https';native.protocol='https';assert.deepEqual(state(custom),state(native));
+});
+
+test('form-query decoding replaces invalid bytes and preserves valid neighbors and BOM',()=>{
+  const cases=['q=%E4%B8%AD+%FF','q=%EF%BB%BF','q=中+%FF','q=%E2%82','q=%GG+%41%','q=%00','q=\ud800','%FF=a+b'];
+  for(let i=0;i<256;i++)cases.push('q=%E4%B8%AD+%'+i.toString(16).padStart(2,'0')+'%41');
+  for(const query of cases) {
+    // Node 22's raw-Unicode malformed-percent path differs from the byte
+    // parser. Percent-encode non-ASCII scalars for the differential reference.
+    const reference=Array.from(query).map(c=>c.charCodeAt(0)>127 ? encodeURIComponent(c.toWellFormed()) : c).join('');
+    const custom=new CustomParams(query),native=new URLSearchParams(reference);
+    assert.equal(JSON.stringify([...custom]),JSON.stringify([...native]),query);
+    assert.equal(String(custom),String(native),query);
+    const u=new CustomURL('https://example.com/?'+query),n=new URL('https://example.com/?'+reference);
+    const retained=u.searchParams;
+    u.search='?'+query;n.search='?'+reference;
+    u.searchParams.append('x','\ud800😀');n.searchParams.append('x','\ud800😀');
+    assert.equal(u.search,n.search);assert.equal(u.searchParams,retained);
+  }
+  assert.equal(new CustomParams('q=中+%FF').get('q'),'中 �');
+  for(const init of [{x:'\ud800'},[['\ud800','\udfff']]])assert.equal(String(new CustomParams(init)),String(new URLSearchParams(init)));
+});
diff --git a/runtime-js/web-api/compatibility.json b/runtime-js/web-api/compatibility.json
index f470d26..c61d8a1 100644
--- a/runtime-js/web-api/compatibility.json
+++ b/runtime-js/web-api/compatibility.json
@@ -10,7 +10,10 @@
         "absolute and relative authority-based URLs",
         "dot-segment path normalization",
         "live search and searchParams mutation",
-        "iterable and record URLSearchParams initialization"
+        "iterable and record URLSearchParams initialization",
+        "empty path segments preserved through dot-segment normalization and URL mutations",
+        "default ports normalized for HTTP, HTTPS, WS, WSS and FTP",
+        "form-query replacement decoding for malformed UTF-8 and scalar string normalization"
       ],
       "unsupported": [
         "full WHATWG parsing",
diff --git a/runtime-js/web-api/runtime.js b/runtime-js/web-api/runtime.js
index be330ba..cc0cca4 100644
--- a/runtime-js/web-api/runtime.js
+++ b/runtime-js/web-api/runtime.js
@@ -129,11 +129,31 @@
 
 // source: web-api/source/url.js
 (() => {
+  function scalarString(value) {
+    return String(value).replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDFFF]/g,
+      unit => unit.length === 2 ? unit : "\ufffd");
+  }
+
   function decodeURIComponentSafe(value) {
+    const text = scalarString(value).replace(/\+/g, " ");
     try {
-      return decodeURIComponent(String(value).replace(/\+/g, " "));
+      return decodeURIComponent(text);
     } catch {
-      return String(value);
+      // Decode valid percent bytes even when an adjacent escape or UTF-8
+      // sequence is malformed. Compact in place; URL queries preserve BOM.
+      const bytes = new TextEncoder().encode(text);
+      let written = 0;
+      const hex = byte => byte >= 48 && byte <= 57 ? byte - 48
+        : byte >= 65 && byte <= 70 ? byte - 55
+        : byte >= 97 && byte <= 102 ? byte - 87 : -1;
+      for (let i = 0; i < bytes.length; i++) {
+        if (bytes[i] === 37 && i + 2 < bytes.length) {
+          const high = hex(bytes[i + 1]), low = hex(bytes[i + 2]);
+          if (high !== -1 && low !== -1) { bytes[written++] = high * 16 + low; i += 2; continue; }
+        }
+        bytes[written++] = bytes[i];
+      }
+      return new TextDecoder("utf-8", {ignoreBOM: true}).decode(bytes.subarray(0, written));
     }
   }
 
@@ -158,18 +178,25 @@
   }
 
   function normalizePath(pathname) {
-    const absolute = pathname.charAt(0) === "/";
-    const trailing = /\/(?:\.{0,2})?$/.test(pathname);
+    const input = pathname.split("/");
     const segments = [];
-    for (const segment of pathname.split("/")) {
-      if (!segment || segment === ".") continue;
-      if (segment === "..") segments.pop();
-      else segments.push(segment);
-    }
-    let result = (absolute ? "/" : "") + segments.join("/");
-    if (absolute && !result) result = "/";
-    if (trailing && result !== "/") result += "/";
-    return result;
+    for (let i = 1; i < input.length; i++) {
+      const segment = input[i];
+      const dots = segment.replace(/%2e/gi, ".");
+      if (dots === "." || dots === "..") {
+        if (dots === "..") segments.pop();
+        if (i === input.length - 1) segments.push("");
+      } else segments.push(segment);
+    }
+    return "/" + segments.join("/");
+  }
+
+  const defaultPorts = {"http:": 80, "https:": 443, "ws:": 80, "wss:": 443, "ftp:": 21};
+  function normalizePort(protocol, port) {
+    if (!port) return "";
+    if (!/^\d+$/.test(port) || Number(port) > 65535) throw new TypeError("Invalid URL port");
+    const number = Number(port);
+    return number === defaultPorts[protocol] ? "" : String(number);
   }
 
   function parseAbsolute(value) {
@@ -177,7 +204,7 @@
     if (!match) throw new TypeError("Invalid URL");
     const protocol = match[1].toLowerCase();
     const authority = match[2];
-    const host = authority.slice(authority.lastIndexOf("@") + 1);
+    let host = authority.slice(authority.lastIndexOf("@") + 1);
     let hostname = host;
     let port = "";
     if (host.charAt(0) === "[") {
@@ -193,8 +220,10 @@
       }
     }
     if (!hostname) throw new TypeError("Invalid URL");
+    port = normalizePort(protocol, port);
+    host = hostname + (port ? ":" + port : "");
     const pathname = normalizePath(match[3] || "/");
-    const origin = protocol + "//" + authority;
+    const origin = protocol + "//" + host;
     return {
       protocol,
       origin,
@@ -265,7 +294,7 @@
         }
       } else {
         for (const key of Object.keys(init)) {
-          this._pairs.push([String(key), String(init[key])]);
+          this._pairs.push([scalarString(key), scalarString(init[key])]);
         }
       }
     }
@@ -276,12 +305,12 @@
       return this._pairs.length;
     }
     append(name, value) {
-      this._pairs.push([String(name), String(value)]);
+      this._pairs.push([scalarString(name), scalarString(value)]);
       this._changed();
     }
     set(name, value) {
-      name = String(name);
-      value = String(value);
+      name = scalarString(name);
+      value = scalarString(value);
       const first = this._pairs.findIndex((pair) => pair[0] === name);
       if (first === -1) this._pairs.push([name, value]);
       else {
@@ -291,22 +320,22 @@
       this._changed();
     }
     get(name) {
-      name = String(name);
+      name = scalarString(name);
       for (const pair of this._pairs) {
         if (pair[0] === name) return pair[1];
       }
       return null;
     }
     getAll(name) {
-      name = String(name);
+      name = scalarString(name);
       return this._pairs.filter((pair) => pair[0] === name).map((pair) => pair[1]);
     }
     has(name) {
-      name = String(name);
+      name = scalarString(name);
       return this._pairs.some((pair) => pair[0] === name);
     }
     delete(name) {
-      name = String(name);
+      name = scalarString(name);
       this._pairs = this._pairs.filter((pair) => pair[0] !== name);
       this._changed();
     }
@@ -372,6 +401,8 @@
       if (!protocol.endsWith(":")) protocol += ":";
       if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:$/.test(protocol)) throw new TypeError("Invalid URL protocol");
       this._protocol = protocol.toLowerCase();
+      this._port = normalizePort(this._protocol, this._port);
+      this._host = this._hostname + (this._port ? ":" + this._port : "");
       this._commit();
     }
     get origin() { return this._origin; }
@@ -395,8 +426,7 @@
     }
     get port() { return this._port; }
     set port(value) {
-      const port = String(value);
-      if (port && (!/^\d+$/.test(port) || Number(port) > 65535)) throw new TypeError("Invalid URL port");
+      const port = normalizePort(this._protocol, String(value));
       this._port = port;
       this._host = this._hostname + (port ? ":" + port : "");
       this._commit();
diff --git a/runtime-js/web-api/source/url.js b/runtime-js/web-api/source/url.js
index 45baf41..93102b0 100644
--- a/runtime-js/web-api/source/url.js
+++ b/runtime-js/web-api/source/url.js
@@ -1,9 +1,29 @@
 (() => {
+  function scalarString(value) {
+    return String(value).replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDFFF]/g,
+      unit => unit.length === 2 ? unit : "\ufffd");
+  }
+
   function decodeURIComponentSafe(value) {
+    const text = scalarString(value).replace(/\+/g, " ");
     try {
-      return decodeURIComponent(String(value).replace(/\+/g, " "));
+      return decodeURIComponent(text);
     } catch {
-      return String(value);
+      // Decode valid percent bytes even when an adjacent escape or UTF-8
+      // sequence is malformed. Compact in place; URL queries preserve BOM.
+      const bytes = new TextEncoder().encode(text);
+      let written = 0;
+      const hex = byte => byte >= 48 && byte <= 57 ? byte - 48
+        : byte >= 65 && byte <= 70 ? byte - 55
+        : byte >= 97 && byte <= 102 ? byte - 87 : -1;
+      for (let i = 0; i < bytes.length; i++) {
+        if (bytes[i] === 37 && i + 2 < bytes.length) {
+          const high = hex(bytes[i + 1]), low = hex(bytes[i + 2]);
+          if (high !== -1 && low !== -1) { bytes[written++] = high * 16 + low; i += 2; continue; }
+        }
+        bytes[written++] = bytes[i];
+      }
+      return new TextDecoder("utf-8", {ignoreBOM: true}).decode(bytes.subarray(0, written));
     }
   }
 
@@ -28,18 +48,25 @@
   }
 
   function normalizePath(pathname) {
-    const absolute = pathname.charAt(0) === "/";
-    const trailing = /\/(?:\.{0,2})?$/.test(pathname);
+    const input = pathname.split("/");
     const segments = [];
-    for (const segment of pathname.split("/")) {
-      if (!segment || segment === ".") continue;
-      if (segment === "..") segments.pop();
-      else segments.push(segment);
-    }
-    let result = (absolute ? "/" : "") + segments.join("/");
-    if (absolute && !result) result = "/";
-    if (trailing && result !== "/") result += "/";
-    return result;
+    for (let i = 1; i < input.length; i++) {
+      const segment = input[i];
+      const dots = segment.replace(/%2e/gi, ".");
+      if (dots === "." || dots === "..") {
+        if (dots === "..") segments.pop();
+        if (i === input.length - 1) segments.push("");
+      } else segments.push(segment);
+    }
+    return "/" + segments.join("/");
+  }
+
+  const defaultPorts = {"http:": 80, "https:": 443, "ws:": 80, "wss:": 443, "ftp:": 21};
+  function normalizePort(protocol, port) {
+    if (!port) return "";
+    if (!/^\d+$/.test(port) || Number(port) > 65535) throw new TypeError("Invalid URL port");
+    const number = Number(port);
+    return number === defaultPorts[protocol] ? "" : String(number);
   }
 
   function parseAbsolute(value) {
@@ -47,7 +74,7 @@
     if (!match) throw new TypeError("Invalid URL");
     const protocol = match[1].toLowerCase();
     const authority = match[2];
-    const host = authority.slice(authority.lastIndexOf("@") + 1);
+    let host = authority.slice(authority.lastIndexOf("@") + 1);
     let hostname = host;
     let port = "";
     if (host.charAt(0) === "[") {
@@ -63,8 +90,10 @@
       }
     }
     if (!hostname) throw new TypeError("Invalid URL");
+    port = normalizePort(protocol, port);
+    host = hostname + (port ? ":" + port : "");
     const pathname = normalizePath(match[3] || "/");
-    const origin = protocol + "//" + authority;
+    const origin = protocol + "//" + host;
     return {
       protocol,
       origin,
@@ -135,7 +164,7 @@
         }
       } else {
         for (const key of Object.keys(init)) {
-          this._pairs.push([String(key), String(init[key])]);
+          this._pairs.push([scalarString(key), scalarString(init[key])]);
         }
       }
     }
@@ -146,12 +175,12 @@
       return this._pairs.length;
     }
     append(name, value) {
-      this._pairs.push([String(name), String(value)]);
+      this._pairs.push([scalarString(name), scalarString(value)]);
       this._changed();
     }
     set(name, value) {
-      name = String(name);
-      value = String(value);
+      name = scalarString(name);
+      value = scalarString(value);
       const first = this._pairs.findIndex((pair) => pair[0] === name);
       if (first === -1) this._pairs.push([name, value]);
       else {
@@ -161,22 +190,22 @@
       this._changed();
     }
     get(name) {
-      name = String(name);
+      name = scalarString(name);
       for (const pair of this._pairs) {
         if (pair[0] === name) return pair[1];
       }
       return null;
     }
     getAll(name) {
-      name = String(name);
+      name = scalarString(name);
       return this._pairs.filter((pair) => pair[0] === name).map((pair) => pair[1]);
     }
     has(name) {
-      name = String(name);
+      name = scalarString(name);
       return this._pairs.some((pair) => pair[0] === name);
     }
     delete(name) {
-      name = String(name);
+      name = scalarString(name);
       this._pairs = this._pairs.filter((pair) => pair[0] !== name);
       this._changed();
     }
@@ -242,6 +271,8 @@
       if (!protocol.endsWith(":")) protocol += ":";
       if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:$/.test(protocol)) throw new TypeError("Invalid URL protocol");
       this._protocol = protocol.toLowerCase();
+      this._port = normalizePort(this._protocol, this._port);
+      this._host = this._hostname + (this._port ? ":" + this._port : "");
       this._commit();
     }
     get origin() { return this._origin; }
@@ -265,8 +296,7 @@
     }
     get port() { return this._port; }
     set port(value) {
-      const port = String(value);
-      if (port && (!/^\d+$/.test(port) || Number(port) > 65535)) throw new TypeError("Invalid URL port");
+      const port = normalizePort(this._protocol, String(value));
       this._port = port;
       this._host = this._hostname + (port ? ":" + port : "");
       this._commit();

From 3429825d9c47b5b1a303e1d915df940b7bcc6a78 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Mon, 7 Sep 2026 17:25:24 +0800
Subject: [PATCH 11/31] docs(runtime): document the supported P1 JavaScript
 contract

Update English and reviewed Chinese references for Streams, body lifecycle, Headers, encoding, abort composition and URL semantics. Keep durable compatibility and benchmark instructions without committing iteration reports or local measurement artifacts.
---
 .../javascript-runtime-compatibility.md       | 110 ++++++++++++++++--
 docs/reference/javascript/index.md            |   7 +-
 .../reference/javascript/abortcontroller.mdx  |   3 +-
 .../content/reference/javascript/crypto.mdx   |   2 +-
 .../content/reference/javascript/fetch.mdx    |   4 +-
 .../content/reference/javascript/headers.mdx  |   7 +-
 .../content/reference/javascript/index.mdx    |   2 +
 .../content/reference/javascript/meta.json    |   4 +-
 .../reference/javascript/microtasks.mdx       |  23 ++++
 .../content/reference/javascript/request.mdx  |   9 +-
 .../content/reference/javascript/streams.mdx  |  29 +++++
 .../reference/javascript/textencoder.mdx      |   4 +-
 website/content/reference/javascript/url.mdx  |   4 +-
 .../reference/javascript/abortcontroller.mdx  |  19 +--
 .../content/reference/javascript/crypto.mdx   |  18 +--
 .../content/reference/javascript/fetch.mdx    |  24 ++--
 .../content/reference/javascript/headers.mdx  |  23 ++--
 .../content/reference/javascript/index.mdx    |  24 ++--
 .../content/reference/javascript/meta.json    |   4 +-
 .../reference/javascript/microtasks.mdx       |  22 ++++
 .../content/reference/javascript/request.mdx  |  31 ++---
 .../content/reference/javascript/streams.mdx  |  28 +++++
 .../reference/javascript/textencoder.mdx      |  20 ++--
 .../content/reference/javascript/url.mdx      |   4 +-
 website/locales/zh-CN/manifest.json           |  46 +++++---
 25 files changed, 355 insertions(+), 116 deletions(-)
 create mode 100644 website/content/reference/javascript/microtasks.mdx
 create mode 100644 website/content/reference/javascript/streams.mdx
 create mode 100644 website/locales/zh-CN/content/reference/javascript/microtasks.mdx
 create mode 100644 website/locales/zh-CN/content/reference/javascript/streams.mdx

diff --git a/docs/architecture/javascript-runtime-compatibility.md b/docs/architecture/javascript-runtime-compatibility.md
index 16b8079..ec06a45 100644
--- a/docs/architecture/javascript-runtime-compatibility.md
+++ b/docs/architecture/javascript-runtime-compatibility.md
@@ -14,21 +14,24 @@ in the [JavaScript reference](../reference/javascript/index.md).
 | API | Status | Supported contract | Important exclusions |
 | --- | --- | --- | --- |
 | URL / URLSearchParams | Partial | Authority URLs, relative resolution, dot segments, live query mutation, iterable parameters | Full WHATWG parsing, IDNA, credentials, file/blob URLs |
-| Headers | Partial | Common initializers and mutations, stable iteration | Header guards, Set-Cookie splitting, full token validation |
-| Request / Response | Partial | Byte-preserving string/ArrayBuffer/ArrayBufferView bodies, single-use text/JSON/arrayBuffer, bodyUsed, streamed host bodies, buffered clone | Public ReadableStream, form/blob helpers, stream teeing/clone, browser policy fields |
-| TextEncoder / TextDecoder | Partial | UTF-8 conversion | Legacy encodings and streaming decode options |
+| Headers | Partial | Iterable/record initializers, token validation, independent Set-Cookie values, getSetCookie | Browser header guards |
+| Request / Response | Partial | Byte-preserving string/ArrayBuffer/ArrayBufferView bodies, single-use text/JSON/arrayBuffer, bodyUsed, ReadableStream bodies and response output, buffered clone | Form/blob helpers, streamed Body.clone, browser policy fields |
+| TextEncoder / TextDecoder | Partial | UTF-8 conversion, stateful decode/flush, TextDecoderStream | Legacy encodings, encodeInto |
 | Timers | Supported | Timeout/interval creation, clearing, isolate-reset cleanup | Browser scheduling guarantees |
 | Event / EventTarget | Partial | Function/object listeners, deduplication, removal, once/signal options, cancellation | DOM trees, capture/bubble phases, browser exception reporting |
-| AbortController / AbortSignal | Partial | EventTarget inheritance, reasons, static abort/timeout, fetch and body cancellation | `AbortSignal.any` |
-| Crypto | Partial | Random values, SHA-2 digest, raw HMAC import/sign/verify | UUID, key export, encryption, asymmetric algorithms |
+| AbortController / AbortSignal | Partial | EventTarget inheritance, reasons, static abort/timeout/any, fetch and body cancellation | Browser task scheduling guarantees |
+| Crypto | Partial | Random values and UUID v4, SHA-2 digest, raw HMAC import/sign/verify | key export, encryption, asymmetric algorithms |
 | fetch | Partial | Policy-controlled HTTP, binary-safe buffered uploads and response reads, redirects, abort | Streaming uploads, multipart helpers, browser cache/credential/mode fields |
+| Streams | Partial | Default readers, async iteration, writers, TransformStream, pipeTo/pipeThrough, tee, strategies, cancellation | HTTP uploads/BYOB, transfer of host-owned buffers, streamed Body.clone |
+| Microtasks/base64 | Supported | Native queueMicrotask scheduling, atob/btoa validation | — |
 | WebSocket | Partial | Accepted/outbound text sockets, core events, listener lifecycle, reuse cleanup | Subprotocols, extensions, Blob messages, buffered amount |
 
 ## Contract evidence
 
 - Authored implementations live only in `runtime-js/web-api/source/` and
   `runtime-js/capability-client/source/`; generated runtime bundles are checked
-  for drift.
+  for drift. The pinned MIT-licensed Streams implementation is in
+  `runtime-js/web-api/vendor/web-streams-polyfill/`.
 - Public host types flow from `runtime-js` through `@tysel/types`.
 - `tysel-engine-qjs` tests exercise the supported behavior inside QuickJS,
   including native I/O, cancellation, backpressure, WebSocket lifecycle, and
@@ -62,7 +65,8 @@ modes; invalid input still allocates the required replacement text. Uploads take
 one native snapshot before asynchronous I/O, and redirects share that native buffer.
 The existing bounded channels, cancellation,
 body limits, and isolate cleanup remain in effect. Full-body helpers still require
-O(body size) memory; public Streams and streaming uploads remain unsupported.
+O(body size) memory; streaming uploads remain unsupported. Applications can use
+`body.getReader()` or `pipeThrough()` to avoid whole-body accumulation.
 
 Run the optional local throughput measurement with:
 
@@ -73,3 +77,95 @@ cargo test -p tysel-engine-qjs http_body_throughput -- --ignored --nocapture
 It checks 1 MiB ASCII bodies with both text and arrayBuffer consumption, one
 warm-up and 20 measured fetches, under a configured 16 MiB JS heap. Timings include
 local HTTP I/O and are diagnostic, not a CI threshold or an RSS measurement.
+
+## P1 Streams and lifecycle
+
+The public `Request.body` and `Response.body` properties now return a lazy
+`ReadableStream<Uint8Array>` (or null). Code that previously inspected raw body
+storage should use readers or `arrayBuffer()`. Untouched buffered responses retain
+the native buffered output fast path. Tysel chunk arrays remain an input extension;
+the public body is a stream, not that input array.
+
+Native HTTP body streams use a zero high-water mark and read only on demand. The
+existing bounded native queues remain in place. Canceling a reader cancels its
+in-flight native operation and drops the body receiver. Request generation checks
+prevent a retained body from reading I/O belonging to a later request. Whole-body
+helpers and individual reads share disturbance and lock state.
+
+`new Response(stream)` accepts Uint8Array chunks. Its pump awaits each bounded
+native write; slow consumers apply backpressure. A separate native close watcher
+cancels the source even while its next read is pending; an unresolved source
+cancel callback cannot retain the worker. The close race is installed once per
+response so promise reactions do not accumulate per chunk.
+The isolate stays assigned until the response stream finishes, fails, disconnects,
+or reaches its normal CPU/request deadline. After headers have been sent, failures
+are surfaced as HTTP body errors rather than a successful truncated response.
+`dispatch_response` exposes checked completion; the legacy chunk-only
+`dispatch_incoming` API cannot surface errors after its head. `dispatch_sync`
+collects checked completion and rejects on stream failure.
+
+Streams are embedded from web-streams-polyfill 4.3.0 in native read-only storage.
+Constructor access loads the implementation on demand; buffered bodies avoid that
+initialization. First-use loading is charged to the active isolate budgets. The reviewed contract covers
+default streams; native HTTP bodies do not expose BYOB readers. Buffered body clone
+remains supported, but streaming Body.clone is explicitly excluded. The vendor's
+`_disturbed` flag is an internal adapter dependency bound by lifecycle tests.
+
+TextDecoder preserves incomplete UTF-8 prefixes (at most three bytes), handles BOM
+only at the start of each decoding session, and flushes pending bytes on the final
+`decode()`. TextDecoderStream uses those same semantics. `atob`/`btoa` operate on
+binary Latin-1 strings, not Unicode text. `AbortSignal.any` propagates dependencies
+independently of whether a public abort listener stops event propagation. All
+dependents are marked before dispatching events, so reentrant abort callbacks
+cannot change the first reason. Weak dependencies and finalization cleanup allow
+discarded composites to be collected. Synchronous HTTP handlers also drain jobs
+within their request budgets, including microtasks and finalization callbacks.
+
+### Local performance checks
+
+The optional release profile separates bootstrap, first Streams initialization,
+fresh-isolate startup, small JSON dispatch, and buffered/streamed output:
+
+```sh
+cargo run --release -p tysel-engine-qjs --example p1_profile -- cold
+cargo run --release -p tysel-engine-qjs --example p1_profile -- bootstrap-streams
+cargo run --release -p tysel-engine-qjs --example p1_profile -- small
+cargo run --release -p tysel-engine-qjs --example p1_profile -- stream16k
+```
+
+Compare equivalent release builds on the same idle machine and alternate versions.
+These are local diagnostics; packaged startup, HTTP and Linux PSS use the existing
+[benchmark workflow](../performance/README.md).
+
+### URL subset semantics
+
+Dot-segment normalization preserves empty path segments, including repeated
+slashes and trailing slashes, through construction, relative resolution and
+pathname updates. Default ports are omitted for HTTP/HTTPS/WS/WSS/FTP, including
+host, port, href and protocol changes. Query parsing decodes valid percent bytes
+next to malformed input, replaces malformed UTF-8, preserves BOM and normalizes
+unpaired UTF-16 surrogates in parameter strings. Live searchParams identity is
+preserved when search is reassigned. These changes do not add full WHATWG URL
+parsing, IDNA or file/blob support.
+
+The focused differential fixtures use Node for comparable supported cases and
+explicit expectations for raw Unicode plus malformed percent input, where the
+local Node 22 reference differs from the [URL form-query parsing algorithm](https://url.spec.whatwg.org/#concept-urlencoded-parser).
+QuickJS regressions and a real bundled Hono route exercise the native runtime.
+
+### Body consumption and Headers iteration
+
+Buffered body helpers still avoid Streams initialization. If a consumed buffered
+body is subsequently exposed as a stream, it is materialized as closed and
+already disturbed using a public reader operation. This matches the existing
+helper path's closed, disturbed, unlocked state: Tysel releases its internal
+reader after whole-body consumption. The consumed stream cannot be accepted as a
+new Response body, regardless of when `.body` was first accessed. Request and
+Response helpers, clone rejection, bodyUsed and stream identity are covered.
+
+Headers iterators index the current sorted, flattened list, including separate
+Set-Cookie entries. Mutations invalidate a per-iterator snapshot; unchanged lists
+are not repeatedly sorted. Deletion, updates, insertion before/after the cursor,
+and append after a done result are covered for entries/keys/values. This follows
+the live cursor behavior in the [Web IDL iterator algorithm](https://webidl.spec.whatwg.org/#default-iterator-objects),
+without changing the native header serialization path.
diff --git a/docs/reference/javascript/index.md b/docs/reference/javascript/index.md
index 8915243..c802935 100644
--- a/docs/reference/javascript/index.md
+++ b/docs/reference/javascript/index.md
@@ -9,9 +9,10 @@ partial, and intentionally excluded behavior for every global.
 | Group | Included globals |
 | --- | --- |
 | HTTP values | `Request`, `Response`, `Headers`, `fetch` |
-| URLs and encoding | `URL`, `URLSearchParams`, `TextEncoder`, `TextDecoder` |
-| Scheduling and events | timers, `Event`, `EventTarget`, `AbortController`, `AbortSignal` |
-| Security | `crypto.getRandomValues`, supported `crypto.subtle` digest and HMAC operations |
+| URLs and encoding | `URL`, `URLSearchParams`, `TextEncoder`, `TextDecoder`, `TextDecoderStream`, `atob`, `btoa` |
+| Streams | `ReadableStream`, `WritableStream`, `TransformStream`, queuing strategies |
+| Scheduling and events | timers, `queueMicrotask`, `Event`, `EventTarget`, `AbortController`, `AbortSignal` |
+| Security | `crypto.getRandomValues`, `crypto.randomUUID`, supported `crypto.subtle` digest and HMAC operations |
 | Realtime | inbound and outbound `WebSocket` subsets |
 
 Use the per-global pages in the
diff --git a/website/content/reference/javascript/abortcontroller.mdx b/website/content/reference/javascript/abortcontroller.mdx
index 19f4d94..2fde223 100644
--- a/website/content/reference/javascript/abortcontroller.mdx
+++ b/website/content/reference/javascript/abortcontroller.mdx
@@ -17,10 +17,11 @@ Source of truth: `runtime-js/web-api/compatibility.json`
 - AbortSignal.abort
 - AbortSignal.timeout
 - fetch and response-body cancellation
+- AbortSignal.any with first reason and dependency cleanup
 
 ## Not supported
 
-- AbortSignal.any
+- browser task scheduling guarantees
 
 See the [JavaScript API index](/reference/javascript) and the
 [npm compatibility guide](/docs/compatibility).
diff --git a/website/content/reference/javascript/crypto.mdx b/website/content/reference/javascript/crypto.mdx
index 6aa93ed..c69a22f 100644
--- a/website/content/reference/javascript/crypto.mdx
+++ b/website/content/reference/javascript/crypto.mdx
@@ -15,10 +15,10 @@ Source of truth: `runtime-js/web-api/compatibility.json`
 - getRandomValues
 - SHA-256/384/512 digest
 - raw HMAC import/sign/verify
+- randomUUID (cryptographic UUID v4)
 
 ## Not supported
 
-- randomUUID
 - key export
 - encryption
 - asymmetric algorithms
diff --git a/website/content/reference/javascript/fetch.mdx b/website/content/reference/javascript/fetch.mdx
index bb4997b..263bca9 100644
--- a/website/content/reference/javascript/fetch.mdx
+++ b/website/content/reference/javascript/fetch.mdx
@@ -13,10 +13,12 @@ Source of truth: `runtime-js/web-api/compatibility.json`
 ## Supported
 
 - HTTP methods allowed by host policy
-- headers and buffered request bodies
+- headers and byte-preserving buffered request bodies
 - redirect policy
 - streamed response consumption
 - AbortSignal cancellation
+- response.body reader, async iteration and cancellation
+- multiple Set-Cookie headers preserved
 
 ## Not supported
 
diff --git a/website/content/reference/javascript/headers.mdx b/website/content/reference/javascript/headers.mdx
index ec17962..39caf53 100644
--- a/website/content/reference/javascript/headers.mdx
+++ b/website/content/reference/javascript/headers.mdx
@@ -14,13 +14,14 @@ Source of truth: `runtime-js/web-api/compatibility.json`
 
 - record, Headers, and pair initialization
 - get/set/append/delete/has
-- stable iteration
+- live sorted iteration across header mutations
+- iterable pair initialization
+- HTTP token and CR/LF validation
+- independent Set-Cookie values and getSetCookie snapshots
 
 ## Not supported
 
 - browser header guards
-- Set-Cookie splitting
-- full HTTP token validation
 
 See the [JavaScript API index](/reference/javascript) and the
 [npm compatibility guide](/docs/compatibility).
diff --git a/website/content/reference/javascript/index.mdx b/website/content/reference/javascript/index.mdx
index f3acf93..e6fe263 100644
--- a/website/content/reference/javascript/index.mdx
+++ b/website/content/reference/javascript/index.mdx
@@ -22,3 +22,5 @@ inventory is `runtime-js/web-api/compatibility.json`.
 | [Crypto](/reference/javascript/crypto) | `partial` |
 | [fetch](/reference/javascript/fetch) | `partial` |
 | [WebSocket](/reference/javascript/websocket) | `partial` |
+| [Streams](/reference/javascript/streams) | `partial` |
+| [Microtasks and base64](/reference/javascript/microtasks) | `supported` |
diff --git a/website/content/reference/javascript/meta.json b/website/content/reference/javascript/meta.json
index eb265a4..ceb80b0 100644
--- a/website/content/reference/javascript/meta.json
+++ b/website/content/reference/javascript/meta.json
@@ -11,6 +11,8 @@
     "abortcontroller",
     "crypto",
     "fetch",
-    "websocket"
+    "websocket",
+    "streams",
+    "microtasks"
   ]
 }
diff --git a/website/content/reference/javascript/microtasks.mdx b/website/content/reference/javascript/microtasks.mdx
new file mode 100644
index 0000000..8b6fb18
--- /dev/null
+++ b/website/content/reference/javascript/microtasks.mdx
@@ -0,0 +1,23 @@
+---
+title: "Microtasks and base64"
+description: "Supported Microtasks and base64 contract in the Tysel JavaScript runtime."
+---
+
+Status: `supported`. This page is the supported server-side subset, not
+the full browser specification. Behavior outside the lists below is not a
+contract.
+
+Source of truth: `runtime-js/web-api/compatibility.json`
+(`tysel-server-web-subset`, stable).
+
+## Supported
+
+- queueMicrotask with callback validation, native job ordering and request-generation cleanup
+- atob and btoa with Latin-1 binary strings and InvalidCharacterError
+
+## Not supported
+
+- None listed in the compatibility inventory.
+
+See the [JavaScript API index](/reference/javascript) and the
+[npm compatibility guide](/docs/compatibility).
diff --git a/website/content/reference/javascript/request.mdx b/website/content/reference/javascript/request.mdx
index c5c8ef9..f56c962 100644
--- a/website/content/reference/javascript/request.mdx
+++ b/website/content/reference/javascript/request.mdx
@@ -12,17 +12,20 @@ Source of truth: `runtime-js/web-api/compatibility.json`
 
 ## Supported
 
-- string, Uint8Array, and ArrayBuffer response bodies
+- string, ArrayBuffer, and ArrayBufferView request/response bodies with byte-preserving consumption
 - single-use json/text/arrayBuffer consumption
 - bodyUsed
 - buffered request and response clone
 - streamed host request and response bodies
+- UTF-8 decoding after byte collection, including split code points and BOM handling
+- Tysel response chunk arrays with snapshotted string/ArrayBuffer/ArrayBufferView elements
+- lazy ReadableStream body access with locking and disturbance
+- Response with a ReadableStream of Uint8Array chunks, native backpressure and cancellation
 
 ## Not supported
 
-- public ReadableStream bodies
 - formData/blob helpers
-- stream teeing and streamed response clone
+- streamed request and response clone
 - browser cache/credentials/mode semantics
 
 See the [JavaScript API index](/reference/javascript) and the
diff --git a/website/content/reference/javascript/streams.mdx b/website/content/reference/javascript/streams.mdx
new file mode 100644
index 0000000..5405757
--- /dev/null
+++ b/website/content/reference/javascript/streams.mdx
@@ -0,0 +1,29 @@
+---
+title: "Streams"
+description: "Supported Streams contract in the Tysel JavaScript runtime."
+---
+
+Status: `partial`. This page is the supported server-side subset, not
+the full browser specification. Behavior outside the lists below is not a
+contract.
+
+Source of truth: `runtime-js/web-api/compatibility.json`
+(`tysel-server-web-subset`, stable).
+
+## Supported
+
+- ReadableStream default readers and async iteration
+- WritableStream writer locks, ready and serial writes
+- TransformStream, pipeThrough, pipeTo with backpressure and AbortSignal
+- tee, cancellation and error propagation
+- ByteLengthQueuingStrategy and CountQueuingStrategy
+
+## Not supported
+
+- HTTP streaming uploads
+- HTTP body BYOB readers
+- transfer of host-owned external buffers
+- streamed Body.clone
+
+See the [JavaScript API index](/reference/javascript) and the
+[npm compatibility guide](/docs/compatibility).
diff --git a/website/content/reference/javascript/textencoder.mdx b/website/content/reference/javascript/textencoder.mdx
index ffc100b..889f97b 100644
--- a/website/content/reference/javascript/textencoder.mdx
+++ b/website/content/reference/javascript/textencoder.mdx
@@ -13,11 +13,13 @@ Source of truth: `runtime-js/web-api/compatibility.json`
 ## Supported
 
 - UTF-8 encode and decode
+- stateful UTF-8 decode with stream option and final flush
+- TextDecoderStream over TransformStream
 
 ## Not supported
 
 - legacy encodings
-- streaming decode options
+- TextEncoder.encodeInto
 
 See the [JavaScript API index](/reference/javascript) and the
 [npm compatibility guide](/docs/compatibility).
diff --git a/website/content/reference/javascript/url.mdx b/website/content/reference/javascript/url.mdx
index d114414..1ecbc4d 100644
--- a/website/content/reference/javascript/url.mdx
+++ b/website/content/reference/javascript/url.mdx
@@ -13,7 +13,9 @@ Source of truth: `runtime-js/web-api/compatibility.json`
 ## Supported
 
 - absolute and relative authority-based URLs
-- dot-segment path normalization
+- dot-segment path normalization while preserving repeated slashes
+- default-port normalization across parsing and property updates
+- query decoding with replacement for malformed UTF-8; Unicode scalar string normalization
 - live search and searchParams mutation
 - iterable and record URLSearchParams initialization
 
diff --git a/website/locales/zh-CN/content/reference/javascript/abortcontroller.mdx b/website/locales/zh-CN/content/reference/javascript/abortcontroller.mdx
index b8666f4..8bd11eb 100644
--- a/website/locales/zh-CN/content/reference/javascript/abortcontroller.mdx
+++ b/website/locales/zh-CN/content/reference/javascript/abortcontroller.mdx
@@ -1,13 +1,13 @@
 ---
-title: "AbortController 与 AbortSignal"
-description: "Tysel JavaScript 运行时支持的 AbortController 与 AbortSignal 约定。"
+title: "AbortController and AbortSignal"
+description: "Tysel JavaScript 运行时支持的 AbortController and AbortSignal 契约。"
 ---
 
-状态：`partial`。本页描述受支持的服务端子集，而非完整的浏览器规范。
-下列清单以外的行为不属于兼容性约定。
+状态： `partial`. 本页描述受支持的服务端子集，不涵盖完整浏览器规范。
+下列清单以外的行为不属于支持契约。
 
-事实来源：`runtime-js/web-api/compatibility.json`
-（稳定的 `tysel-server-web-subset`）。
+权威来源： `runtime-js/web-api/compatibility.json`
+(`tysel-server-web-subset`, stable).
 
 ## 支持
 
@@ -15,11 +15,12 @@ description: "Tysel JavaScript 运行时支持的 AbortController 与 AbortSigna
 - throwIfAborted
 - AbortSignal.abort
 - AbortSignal.timeout
-- 取消 fetch 和响应正文
+- 取消 fetch 和响应体读取
+- AbortSignal.any 保留首个中止原因并清理依赖订阅
 
 ## 不支持
 
-- AbortSignal.any
+- 浏览器任务调度保证
 
-另请参阅 [JavaScript API 索引](/reference/javascript)和
+参阅 [JavaScript API 索引](/reference/javascript)和
 [npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/crypto.mdx b/website/locales/zh-CN/content/reference/javascript/crypto.mdx
index b9b253e..b7084b8 100644
--- a/website/locales/zh-CN/content/reference/javascript/crypto.mdx
+++ b/website/locales/zh-CN/content/reference/javascript/crypto.mdx
@@ -1,26 +1,26 @@
 ---
 title: "Crypto"
-description: "Tysel JavaScript 运行时支持的 Crypto 约定。"
+description: "Tysel JavaScript 运行时支持的 Crypto 契约。"
 ---
 
-状态：`partial`。本页描述受支持的服务端子集，而非完整的浏览器规范。
-下列清单以外的行为不属于兼容性约定。
+状态： `partial`. 本页描述受支持的服务端子集，不涵盖完整浏览器规范。
+下列清单以外的行为不属于支持契约。
 
-事实来源：`runtime-js/web-api/compatibility.json`
-（稳定的 `tysel-server-web-subset`）。
+权威来源： `runtime-js/web-api/compatibility.json`
+(`tysel-server-web-subset`, stable).
 
 ## 支持
 
 - getRandomValues
 - SHA-256/384/512 摘要
-- 导入原始 HMAC 密钥以及签名和验证
+- 原始 HMAC 密钥导入、签名和验证
+- randomUUID（密码学安全的 UUID v4）
 
 ## 不支持
 
-- randomUUID
-- 导出密钥
+- 密钥导出
 - 加密
 - 非对称算法
 
-另请参阅 [JavaScript API 索引](/reference/javascript)和
+参阅 [JavaScript API 索引](/reference/javascript)和
 [npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/fetch.mdx b/website/locales/zh-CN/content/reference/javascript/fetch.mdx
index 872e20d..d9d48ca 100644
--- a/website/locales/zh-CN/content/reference/javascript/fetch.mdx
+++ b/website/locales/zh-CN/content/reference/javascript/fetch.mdx
@@ -1,27 +1,29 @@
 ---
 title: "fetch"
-description: "Tysel JavaScript 运行时支持的 fetch 约定。"
+description: "Tysel JavaScript 运行时支持的 fetch 契约。"
 ---
 
-状态：`partial`。本页描述受支持的服务端子集，而非完整的浏览器规范。
-下列清单以外的行为不属于兼容性约定。
+状态： `partial`. 本页描述受支持的服务端子集，不涵盖完整浏览器规范。
+下列清单以外的行为不属于支持契约。
 
-事实来源：`runtime-js/web-api/compatibility.json`
-（稳定的 `tysel-server-web-subset`）。
+权威来源： `runtime-js/web-api/compatibility.json`
+(`tysel-server-web-subset`, stable).
 
 ## 支持
 
 - 宿主策略允许的 HTTP 方法
-- 请求头和缓冲的请求正文
+- 请求头与保留原始字节的缓冲请求体
 - 重定向策略
-- 以流方式消费响应
-- 通过 AbortSignal 取消请求
+- 流式响应读取
+- AbortSignal 取消
+- response.body 读取器、异步迭代和取消
+- 保留多个 Set-Cookie 响应头
 
 ## 不支持
 
-- 流式请求正文
+- 流式请求体上传
 - multipart/form data
-- 浏览器的缓存、凭据和 mode 语义
+- 浏览器 cache、credentials 和 mode 语义
 
-另请参阅 [JavaScript API 索引](/reference/javascript)和
+参阅 [JavaScript API 索引](/reference/javascript)和
 [npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/headers.mdx b/website/locales/zh-CN/content/reference/javascript/headers.mdx
index dccf121..1bc9994 100644
--- a/website/locales/zh-CN/content/reference/javascript/headers.mdx
+++ b/website/locales/zh-CN/content/reference/javascript/headers.mdx
@@ -1,25 +1,26 @@
 ---
 title: "Headers"
-description: "Tysel JavaScript 运行时支持的 Headers 约定。"
+description: "Tysel JavaScript 运行时支持的 Headers 契约。"
 ---
 
-状态：`partial`。本页描述受支持的服务端子集，而非完整的浏览器规范。
-下列清单以外的行为不属于兼容性约定。
+状态： `partial`. 本页描述受支持的服务端子集，不涵盖完整浏览器规范。
+下列清单以外的行为不属于支持契约。
 
-事实来源：`runtime-js/web-api/compatibility.json`
-（稳定的 `tysel-server-web-subset`）。
+权威来源： `runtime-js/web-api/compatibility.json`
+(`tysel-server-web-subset`, stable).
 
 ## 支持
 
-- 使用 record、Headers 和键值对初始化
+- 使用对象、Headers 或键值对初始化
 - get/set/append/delete/has
-- 稳定迭代
+- 按排序顺序实时反映修改的迭代
+- 使用可迭代键值对初始化
+- HTTP token 和 CR/LF 校验
+- 独立的 Set-Cookie 值与 getSetCookie 快照
 
 ## 不支持
 
-- 浏览器请求头守卫
-- 拆分 Set-Cookie
-- 完整的 HTTP token 验证
+- 浏览器请求头保护规则
 
-另请参阅 [JavaScript API 索引](/reference/javascript)和
+参阅 [JavaScript API 索引](/reference/javascript)和
 [npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/index.mdx b/website/locales/zh-CN/content/reference/javascript/index.mdx
index 4ebaa77..252f33e 100644
--- a/website/locales/zh-CN/content/reference/javascript/index.mdx
+++ b/website/locales/zh-CN/content/reference/javascript/index.mdx
@@ -1,23 +1,25 @@
 ---
-title: "JavaScript API"
-description: "受支持的服务端 Web API 子集。每个页面都定义一个全局对象的兼容性约定。"
+title: "JavaScript APIs"
+description: "受支持的服务端 Web API 子集，每个页面定义一组全局 API 的契约。"
 ---
 
-Tysel 实现了一个有明确边界的服务端 Web API 执行配置。需要查询全局对象时使用这些页面；
-需要完成具体工作流时，请使用[指南](/docs/guides)。
+Tysel 实现了范围明确的服务端 Web API 子集。可通过这些页面查询全局 API，
+具体工作流程请参阅[指南](/docs/guides)。
 
-`partial` 表示列出的行为属于受支持约定，并不表示完整实现了对应的浏览器规范。
+`partial` 表示列出的行为属于受支持的契约，并不代表完整实现了对应的浏览器规范。
 机器可读清单位于 `runtime-js/web-api/compatibility.json`。
 
 | API | 状态 |
 | --- | --- |
-| [URL 与 URLSearchParams](/reference/javascript/url) | `partial` |
+| [URL and URLSearchParams](/reference/javascript/url) | `partial` |
 | [Headers](/reference/javascript/headers) | `partial` |
-| [Request 与 Response](/reference/javascript/request) | `partial` |
-| [TextEncoder 与 TextDecoder](/reference/javascript/textencoder) | `partial` |
-| [定时器](/reference/javascript/timers) | `supported` |
-| [Event 与 EventTarget](/reference/javascript/event) | `partial` |
-| [AbortController 与 AbortSignal](/reference/javascript/abortcontroller) | `partial` |
+| [Request and Response](/reference/javascript/request) | `partial` |
+| [TextEncoder and TextDecoder](/reference/javascript/textencoder) | `partial` |
+| [Timers](/reference/javascript/timers) | `supported` |
+| [Event and EventTarget](/reference/javascript/event) | `partial` |
+| [AbortController and AbortSignal](/reference/javascript/abortcontroller) | `partial` |
 | [Crypto](/reference/javascript/crypto) | `partial` |
 | [fetch](/reference/javascript/fetch) | `partial` |
 | [WebSocket](/reference/javascript/websocket) | `partial` |
+| [Streams](/reference/javascript/streams) | `partial` |
+| [Microtasks and base64](/reference/javascript/microtasks) | `supported` |
diff --git a/website/locales/zh-CN/content/reference/javascript/meta.json b/website/locales/zh-CN/content/reference/javascript/meta.json
index eb265a4..ceb80b0 100644
--- a/website/locales/zh-CN/content/reference/javascript/meta.json
+++ b/website/locales/zh-CN/content/reference/javascript/meta.json
@@ -11,6 +11,8 @@
     "abortcontroller",
     "crypto",
     "fetch",
-    "websocket"
+    "websocket",
+    "streams",
+    "microtasks"
   ]
 }
diff --git a/website/locales/zh-CN/content/reference/javascript/microtasks.mdx b/website/locales/zh-CN/content/reference/javascript/microtasks.mdx
new file mode 100644
index 0000000..08d72d5
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/javascript/microtasks.mdx
@@ -0,0 +1,22 @@
+---
+title: "Microtasks and base64"
+description: "Tysel JavaScript 运行时支持的 Microtasks and base64 契约。"
+---
+
+状态： `supported`. 本页描述受支持的服务端子集，不涵盖完整浏览器规范。
+下列清单以外的行为不属于支持契约。
+
+权威来源： `runtime-js/web-api/compatibility.json`
+(`tysel-server-web-subset`, stable).
+
+## 支持
+
+- queueMicrotask 回调校验、原生任务顺序与请求代次清理
+- atob 和 btoa 的 Latin-1 二进制字符串与 InvalidCharacterError
+
+## 不支持
+
+- 兼容性清单中未列出。
+
+参阅 [JavaScript API 索引](/reference/javascript)和
+[npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/request.mdx b/website/locales/zh-CN/content/reference/javascript/request.mdx
index 4d6d7b4..4528fb9 100644
--- a/website/locales/zh-CN/content/reference/javascript/request.mdx
+++ b/website/locales/zh-CN/content/reference/javascript/request.mdx
@@ -1,28 +1,31 @@
 ---
-title: "Request 与 Response"
-description: "Tysel JavaScript 运行时支持的 Request 与 Response 约定。"
+title: "Request and Response"
+description: "Tysel JavaScript 运行时支持的 Request and Response 契约。"
 ---
 
-状态：`partial`。本页描述受支持的服务端子集，而非完整的浏览器规范。
-下列清单以外的行为不属于兼容性约定。
+状态： `partial`. 本页描述受支持的服务端子集，不涵盖完整浏览器规范。
+下列清单以外的行为不属于支持契约。
 
-事实来源：`runtime-js/web-api/compatibility.json`
-（稳定的 `tysel-server-web-subset`）。
+权威来源： `runtime-js/web-api/compatibility.json`
+(`tysel-server-web-subset`, stable).
 
 ## 支持
 
-- 字符串、Uint8Array 和 ArrayBuffer 响应正文
-- 单次使用的 json/text/arrayBuffer 消费
+- 字符串、ArrayBuffer 和 ArrayBufferView 请求体及响应体，读取时保留原始字节
+- 只能读取一次的 json/text/arrayBuffer
 - bodyUsed
-- 克隆缓冲的请求和响应
-- 流式宿主请求和响应正文
+- 缓冲请求和响应的 clone
+- 宿主请求体和响应体的流式读取
+- 收集字节后进行 UTF-8 解码，包括跨块码点与 BOM 处理
+- Tysel 响应分块数组，对字符串、ArrayBuffer 和 ArrayBufferView 元素创建快照
+- 按需创建 ReadableStream body，并跟踪锁定与读取状态
+- Response 支持 Uint8Array 分块的 ReadableStream，以及原生背压和取消
 
 ## 不支持
 
-- 公开的 ReadableStream 正文
 - formData/blob 辅助方法
-- 流 tee 和克隆流式响应
-- 浏览器的缓存、凭据和 mode 语义
+- 流式请求和响应的 clone
+- 浏览器 cache、credentials 和 mode 语义
 
-另请参阅 [JavaScript API 索引](/reference/javascript)和
+参阅 [JavaScript API 索引](/reference/javascript)和
 [npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/streams.mdx b/website/locales/zh-CN/content/reference/javascript/streams.mdx
new file mode 100644
index 0000000..7a41332
--- /dev/null
+++ b/website/locales/zh-CN/content/reference/javascript/streams.mdx
@@ -0,0 +1,28 @@
+---
+title: "Streams"
+description: "Tysel JavaScript 运行时支持的 Streams 契约。"
+---
+
+状态： `partial`. 本页描述受支持的服务端子集，不涵盖完整浏览器规范。
+下列清单以外的行为不属于支持契约。
+
+权威来源： `runtime-js/web-api/compatibility.json`
+(`tysel-server-web-subset`, stable).
+
+## 支持
+
+- ReadableStream 默认读取器与异步迭代
+- WritableStream 写入器锁、ready 与串行写入
+- TransformStream、pipeThrough 和 pipeTo，支持背压与 AbortSignal
+- tee、取消与错误传播
+- ByteLengthQueuingStrategy 和 CountQueuingStrategy
+
+## 不支持
+
+- HTTP 流式上传
+- HTTP body 的 BYOB 读取器
+- 宿主持有的外部缓冲区转移
+- 流式 Body.clone
+
+参阅 [JavaScript API 索引](/reference/javascript)和
+[npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/textencoder.mdx b/website/locales/zh-CN/content/reference/javascript/textencoder.mdx
index 28aa756..c8bae01 100644
--- a/website/locales/zh-CN/content/reference/javascript/textencoder.mdx
+++ b/website/locales/zh-CN/content/reference/javascript/textencoder.mdx
@@ -1,22 +1,24 @@
 ---
-title: "TextEncoder 与 TextDecoder"
-description: "Tysel JavaScript 运行时支持的 TextEncoder 与 TextDecoder 约定。"
+title: "TextEncoder and TextDecoder"
+description: "Tysel JavaScript 运行时支持的 TextEncoder and TextDecoder 契约。"
 ---
 
-状态：`partial`。本页描述受支持的服务端子集，而非完整的浏览器规范。
-下列清单以外的行为不属于兼容性约定。
+状态： `partial`. 本页描述受支持的服务端子集，不涵盖完整浏览器规范。
+下列清单以外的行为不属于支持契约。
 
-事实来源：`runtime-js/web-api/compatibility.json`
-（稳定的 `tysel-server-web-subset`）。
+权威来源： `runtime-js/web-api/compatibility.json`
+(`tysel-server-web-subset`, stable).
 
 ## 支持
 
 - UTF-8 编码和解码
+- 带 stream 选项和最终刷新功能的有状态 UTF-8 解码
+- 基于 TransformStream 的 TextDecoderStream
 
 ## 不支持
 
-- 旧式字符编码
-- 流式解码选项
+- 传统编码
+- TextEncoder.encodeInto
 
-另请参阅 [JavaScript API 索引](/reference/javascript)和
+参阅 [JavaScript API 索引](/reference/javascript)和
 [npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/content/reference/javascript/url.mdx b/website/locales/zh-CN/content/reference/javascript/url.mdx
index fad5893..9cfa770 100644
--- a/website/locales/zh-CN/content/reference/javascript/url.mdx
+++ b/website/locales/zh-CN/content/reference/javascript/url.mdx
@@ -12,7 +12,9 @@ description: "Tysel JavaScript 运行时支持的 URL 与 URLSearchParams 约定
 ## 支持
 
 - 基于 authority 的绝对和相对 URL
-- 规范化路径中的点号段
+- 规范化路径中的点号段，同时保留重复斜杠
+- 在解析和属性修改时规范化默认端口
+- 查询参数中的非法 UTF-8 使用替换字符解码，并规范化 Unicode 标量字符串
 - 实时同步 search 与 searchParams 的修改
 - 使用可迭代对象和 record 初始化 URLSearchParams
 
diff --git a/website/locales/zh-CN/manifest.json b/website/locales/zh-CN/manifest.json
index 548ff51..20d5c66 100644
--- a/website/locales/zh-CN/manifest.json
+++ b/website/locales/zh-CN/manifest.json
@@ -1969,8 +1969,8 @@
       "status": "reviewed"
     },
     "reference/javascript/meta.json": {
-      "sourceHash": "a179ec0b7536d094fd767d48c9c226406e5f24e357466c926d3aae9af7e65fdf",
-      "translationHash": "a179ec0b7536d094fd767d48c9c226406e5f24e357466c926d3aae9af7e65fdf",
+      "sourceHash": "aca71ac67a278d4283f7e55119cd2af82e546f64a85908f7b19e98725d91e2f7",
+      "translationHash": "aca71ac67a278d4283f7e55119cd2af82e546f64a85908f7b19e98725d91e2f7",
       "status": "reviewed"
     },
     "reference/manifest/meta.json": {
@@ -2004,13 +2004,13 @@
       "status": "reviewed"
     },
     "reference/javascript/abortcontroller.mdx": {
-      "sourceHash": "862eec68e10e2387cf1bc3eb6731a1322b20a5b0d209acebbe6d0326e8a4de05",
-      "translationHash": "00043a6aa196621a863918d4bab7c2138ca269235d5dbf12356ef7fbf735ced2",
+      "sourceHash": "614353752df15801545608dcb6eb9f69429e9bef4f87b92ac6dc16b4a9a182cb",
+      "translationHash": "28d2a7cc26b20c044bf04eb4471551ba1dc74615ae044c382a5790e3779795c6",
       "status": "reviewed"
     },
     "reference/javascript/crypto.mdx": {
-      "sourceHash": "8b786a1e3fd23da8fe54171ac1829794e1f3f3a365cf9c288cece10a995c459f",
-      "translationHash": "2af8c80951b7f3d3a22d8feb0c9998be8a59768a4304e3a1bad71e60c892837b",
+      "sourceHash": "363b5fd0f21b5beccff9c66ff26bf68ea3d52fb7dcc8719156e3ddaa47792577",
+      "translationHash": "215d271ffd6781a6cd79b7f808dd89b786c2b9ecc0bad2da318059fc116ce770",
       "status": "reviewed"
     },
     "reference/javascript/event.mdx": {
@@ -2019,28 +2019,28 @@
       "status": "reviewed"
     },
     "reference/javascript/fetch.mdx": {
-      "sourceHash": "b344d495c86d2099b2eda4ac8a13c3c972139369eef4fd672057724b470060b9",
-      "translationHash": "928e200aca18e24264aa561afe62a946283b9d91295b8a2ae237ee89f7bab11f",
+      "sourceHash": "b4ecd07aeb7f9abb08c333b19b5577f8def505bc6bc6a04fa5b0dab3d2b7abbf",
+      "translationHash": "0bb42f75eac670031af006e7d95fc2d82487acd62a61df48713ca05db72102a1",
       "status": "reviewed"
     },
     "reference/javascript/headers.mdx": {
-      "sourceHash": "42f6c11191518ceb86be90d1a1f85d95a7dd9a42d52110f53932941fe9f624a4",
-      "translationHash": "6b80d7840ce3bde9b5a8841c3f8c8f09366e30f30a9c1e025fd7aba579d6cb80",
+      "sourceHash": "75aeb6ede4932675050a3d4e1c88105c69ddbe392c0411f9b982249272a572d3",
+      "translationHash": "4de9874abddebf20b52681f25643b43b69399fbe1047d3c8d419d4ecbed6a838",
       "status": "reviewed"
     },
     "reference/javascript/index.mdx": {
-      "sourceHash": "a7ba0a075b701bc1d8e93cebf1a761c5a715a5d478bcc7710c7d64af1bb48f89",
-      "translationHash": "ffe8c800ad04747db3a467d7a5dd797266c9a77ec76ddf59482f184aeeaa1557",
+      "sourceHash": "ad516b0b30e10294c73deb3bbf11c632e1a41868c23da016270ffce7f6db87c6",
+      "translationHash": "35dde47b939d84957aed2fdcf04851e5d3fbba1b7e424cba12b987329a20d3e1",
       "status": "reviewed"
     },
     "reference/javascript/request.mdx": {
-      "sourceHash": "995c228d413ae2ac1bbf92ac95004f535a1b6dfa1c2bb8ac578a0c13549899ef",
-      "translationHash": "ce4f359a67ee2d611f9e7362eacabffe98ffd96812b76daa098a1510db3f982e",
+      "sourceHash": "43c54ecd10e3ef02aaf0fb6b989da6f9f15f5451f2aba651533d91525a89d263",
+      "translationHash": "cb43fbddbe7588f8ebafd2e7fd7436a84d739ab6f9386947b2a2079adf627f5c",
       "status": "reviewed"
     },
     "reference/javascript/textencoder.mdx": {
-      "sourceHash": "52c8ba77b4919fe4545a676b63e167bc0b4b477ced4f8129bcc51756309d650d",
-      "translationHash": "1608224618c641be8af79456be3068ff1b82dc871649ebb28a3d875dd9663271",
+      "sourceHash": "19005b8316c8c0bfecd39d5087c5048183dda6d92541b177a2df19403b165334",
+      "translationHash": "46a960d189c0fce75dbe775c34cd95d4160033ea5b3c3dbc2b39c933d5959053",
       "status": "reviewed"
     },
     "reference/javascript/timers.mdx": {
@@ -2049,8 +2049,8 @@
       "status": "reviewed"
     },
     "reference/javascript/url.mdx": {
-      "sourceHash": "e7f09130d693bd2743626dbb570023dadcf1ceb99f28f35ffd76b9441d3ffa23",
-      "translationHash": "6c0d7a1785954db13cace77acea2b9b99e9f1203bf14c44e6c0f3c25bf5c6c47",
+      "sourceHash": "21b767831970673fdaf4836f6dba88c008202557005eae485a6288741cedbc28",
+      "translationHash": "68948fe018965ae1a7fa9c6589c7d426a6232c66a24a5549c85495d1309446f7",
       "status": "reviewed"
     },
     "reference/javascript/websocket.mdx": {
@@ -2372,6 +2372,16 @@
       "sourceHash": "23c9cd73c6ccb0abfdb06e1b36345a651b90136cee97297977e22e31fb3891b2",
       "translationHash": "558082d4f301e0457db8a7decd25373da1741b6c22549ea7f874378891c17c42",
       "status": "reviewed"
+    },
+    "reference/javascript/microtasks.mdx": {
+      "sourceHash": "6afa225c54e5a1d16e03756538bd7b8481763702244a6526a87b782a56043fda",
+      "translationHash": "55e6ee1048a6d1eebb1985889c9cbd2153b3a75d78b64d02ebad0c67d5685dc4",
+      "status": "reviewed"
+    },
+    "reference/javascript/streams.mdx": {
+      "sourceHash": "ca68f6cf3471aeb7fea3bd4c4f517b7f40ed3aaba5457c1a6c702d6b0fd1ce17",
+      "translationHash": "0c67852d58cdf0b90b14148d6c85286aa6cd2dd5348c27ef8d321ddfd1786ede",
+      "status": "reviewed"
     }
   }
 }

From aa8d5991faed0ca4ee8ede30aa2f0e61adb3fa52 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Mon, 7 Sep 2026 17:27:41 +0800
Subject: [PATCH 12/31] fix(docs): synchronize generated URL reference and
 translation

---
 website/content/reference/javascript/url.mdx               | 7 ++++---
 website/locales/zh-CN/content/reference/javascript/url.mdx | 7 ++++---
 website/locales/zh-CN/manifest.json                        | 4 ++--
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/website/content/reference/javascript/url.mdx b/website/content/reference/javascript/url.mdx
index 1ecbc4d..b4913fc 100644
--- a/website/content/reference/javascript/url.mdx
+++ b/website/content/reference/javascript/url.mdx
@@ -13,11 +13,12 @@ Source of truth: `runtime-js/web-api/compatibility.json`
 ## Supported
 
 - absolute and relative authority-based URLs
-- dot-segment path normalization while preserving repeated slashes
-- default-port normalization across parsing and property updates
-- query decoding with replacement for malformed UTF-8; Unicode scalar string normalization
+- dot-segment path normalization
 - live search and searchParams mutation
 - iterable and record URLSearchParams initialization
+- empty path segments preserved through dot-segment normalization and URL mutations
+- default ports normalized for HTTP, HTTPS, WS, WSS and FTP
+- form-query replacement decoding for malformed UTF-8 and scalar string normalization
 
 ## Not supported
 
diff --git a/website/locales/zh-CN/content/reference/javascript/url.mdx b/website/locales/zh-CN/content/reference/javascript/url.mdx
index 9cfa770..2a2fc0c 100644
--- a/website/locales/zh-CN/content/reference/javascript/url.mdx
+++ b/website/locales/zh-CN/content/reference/javascript/url.mdx
@@ -12,11 +12,12 @@ description: "Tysel JavaScript 运行时支持的 URL 与 URLSearchParams 约定
 ## 支持
 
 - 基于 authority 的绝对和相对 URL
-- 规范化路径中的点号段，同时保留重复斜杠
-- 在解析和属性修改时规范化默认端口
-- 查询参数中的非法 UTF-8 使用替换字符解码，并规范化 Unicode 标量字符串
+- 规范化路径中的点号段
 - 实时同步 search 与 searchParams 的修改
 - 使用可迭代对象和 record 初始化 URLSearchParams
+- 在点号段规范化和 URL 修改过程中保留空路径段
+- 规范化 HTTP、HTTPS、WS、WSS 和 FTP 的默认端口
+- 表单查询中的非法 UTF-8 使用替换字符解码，并规范化 Unicode 标量字符串
 
 ## 不支持
 
diff --git a/website/locales/zh-CN/manifest.json b/website/locales/zh-CN/manifest.json
index 20d5c66..3027ff9 100644
--- a/website/locales/zh-CN/manifest.json
+++ b/website/locales/zh-CN/manifest.json
@@ -2049,8 +2049,8 @@
       "status": "reviewed"
     },
     "reference/javascript/url.mdx": {
-      "sourceHash": "21b767831970673fdaf4836f6dba88c008202557005eae485a6288741cedbc28",
-      "translationHash": "68948fe018965ae1a7fa9c6589c7d426a6232c66a24a5549c85495d1309446f7",
+      "sourceHash": "dee8912d96f220d393ec92c7e9b2a18ca0d9a76572192d22972eed44bf101fe7",
+      "translationHash": "42918b6eb9b1c61ea02e7f8832692c18b7814ddc6bf07c02f86eabde8716bba0",
       "status": "reviewed"
     },
     "reference/javascript/websocket.mdx": {

From 8a8fb1d83973c7d49dbfe5d66e32018ba280794d Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Mon, 7 Sep 2026 19:41:35 +0800
Subject: [PATCH 13/31] feat(runtime): add bounded encodeInto and Response
 factories

---
 crates/tysel-engine-qjs/src/host.rs     | 86 +++++++++++++++++++++++++
 crates/tysel-engine-qjs/src/p1_tests.rs | 76 ++++++++++++++++++++++
 crates/tysel-engine-qjs/src/pool.rs     |  6 +-
 runtime-js/test/response.test.mjs       | 31 +++++++++
 runtime-js/web-api/compatibility.json   | 14 ++--
 runtime-js/web-api/index.ts             |  4 ++
 runtime-js/web-api/runtime.js           | 66 +++++++++++++++++--
 runtime-js/web-api/source/encoding.js   | 29 ++++++++-
 runtime-js/web-api/source/http.js       | 37 ++++++++++-
 runtime-js/web-api/type-contract.ts     |  4 ++
 10 files changed, 339 insertions(+), 14 deletions(-)
 create mode 100644 runtime-js/test/response.test.mjs

diff --git a/crates/tysel-engine-qjs/src/host.rs b/crates/tysel-engine-qjs/src/host.rs
index 030db87..3782027 100644
--- a/crates/tysel-engine-qjs/src/host.rs
+++ b/crates/tysel-engine-qjs/src/host.rs
@@ -151,6 +151,7 @@ fn install_inner(
             TypedArray::<u8>::new(ctx, text.into_bytes())
         })?,
     )?;
+    tysel.set("_utf8EncodeInto", Function::new(ctx.clone(), encode_into)?)?;
     tysel.set(
         "_utf8Decode",
         Function::new(ctx.clone(), |ctx, bytes: TypedArray<u8>, fatal: bool| {
@@ -651,3 +652,88 @@ fn load_streams(ctx: Ctx<'_>) -> rquickjs::Result<Object<'_>> {
         "\nreturn globalThis; })(Object.create(globalThis))"
     ))
 }
+
+// Keep conversion scratch bounded to one JS chunk, not the full source.
+// Use the UTF-8 API: the pinned engine's UTF-16 API cannot safely release
+// wide string slices. UTF-8 conversion always returns releasable storage.
+#[allow(unsafe_code)]
+fn encode_into<'js>(
+    ctx: Ctx<'js>,
+    text: rquickjs::String<'js>,
+    destination: TypedArray<'js, u8>,
+    offset: usize,
+) -> rquickjs::Result<Object<'js>> {
+    let raw =
+        destination.as_raw().ok_or_else(|| Exception::throw_type(&ctx, "detached destination"))?;
+    if offset > raw.len {
+        return Err(Exception::throw_range(&ctx, "invalid destination offset"));
+    }
+    let mut length = 0;
+    // SAFETY: the string and destination stay rooted; no JS callback can run
+    // while these pointers are used. The matching release occurs before allocation.
+    let ptr = unsafe {
+        rquickjs::qjs::JS_ToCStringLen2(ctx.as_raw().as_ptr(), &mut length, text.as_raw(), false)
+    };
+    if ptr.is_null() {
+        return Err(rquickjs::Error::Exception);
+    }
+    let (mut read, mut written, mut index) = (0, 0, 0);
+    unsafe {
+        let bytes = std::slice::from_raw_parts(ptr.cast::<u8>(), length as usize);
+        if bytes.is_ascii() {
+            written = bytes.len().min(raw.len - offset);
+            read = written;
+            std::ptr::copy_nonoverlapping(bytes.as_ptr(), raw.ptr.as_ptr().add(offset), written);
+            index = bytes.len();
+        }
+        // Scan complete code points, then copy each unchanged run once. WTF-8
+        // surrogate sequences and their U+FFFD replacements are both three bytes,
+        // so input and output byte offsets stay aligned within the accepted prefix.
+        let mut run_start = index;
+        while index < bytes.len() {
+            let first = bytes[index];
+            let size = if first < 128 {
+                1
+            } else if first < 224 {
+                2
+            } else if first < 240 {
+                3
+            } else {
+                4
+            };
+            if size > raw.len - offset - written {
+                break;
+            }
+            // QuickJS preserves lone surrogate code points in its UTF-8 API.
+            if first == 0xed && bytes[index + 1] >= 0xa0 {
+                let run = index - run_start;
+                std::ptr::copy_nonoverlapping(
+                    bytes.as_ptr().add(run_start),
+                    raw.ptr.as_ptr().add(offset + written - run),
+                    run,
+                );
+                let replacement = [0xef, 0xbf, 0xbd];
+                std::ptr::copy_nonoverlapping(
+                    replacement.as_ptr(),
+                    raw.ptr.as_ptr().add(offset + written),
+                    replacement.len(),
+                );
+                run_start = index + size;
+            }
+            index += size;
+            written += size;
+            read += if size == 4 { 2 } else { 1 };
+        }
+        let run = index - run_start;
+        std::ptr::copy_nonoverlapping(
+            bytes.as_ptr().add(run_start),
+            raw.ptr.as_ptr().add(offset + written - run),
+            run,
+        );
+        rquickjs::qjs::JS_FreeCString(ctx.as_raw().as_ptr(), ptr);
+    }
+    let result = Object::new(ctx)?;
+    result.set("read", read)?;
+    result.set("written", written)?;
+    Ok(result)
+}
diff --git a/crates/tysel-engine-qjs/src/p1_tests.rs b/crates/tysel-engine-qjs/src/p1_tests.rs
index 6470bb4..70ae0b3 100644
--- a/crates/tysel-engine-qjs/src/p1_tests.rs
+++ b/crates/tysel-engine-qjs/src/p1_tests.rs
@@ -664,3 +664,79 @@ fn p1_headers_live_iteration_tracks_mutation() {
     })()"#,config()).unwrap();
     assert_eq!(result, Value::Bool(true));
 }
+
+#[test]
+fn next_encode_into_matches_utf8_and_view_boundaries() {
+    let result=eval(r#"(()=>{
+      const encoder=new TextEncoder();
+      if(String(encoder.encode('\ud800'))!=='239,191,189'||new TextDecoder().decode(encoder.encode(null))!=='null')return false;
+      const inputs=['','ASCII','é中😀','\ud800','\udc00','A\ud800B','é中\ud800\ud800😀\udc00Z','\udc00é中\ud800','中'.repeat(16383)+'\ud800😀\udc00Z','a'.repeat(16383)+'😀Z','é'.repeat(20000),'中😀'.repeat(10000)];
+      for(const input of inputs)for(const capacity of [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,16384,49149,49150,49151,49152,49153,65536]) {
+        const storage=new Uint8Array(capacity+4).fill(99), target=storage.subarray(2,2+capacity);
+        const {read,written}=encoder.encodeInto(input,target);
+        const expected=encoder.encode(input.slice(0,read));
+        if(expected.length!==written||read>input.length||written>capacity)return false;
+        for(let i=0;i<written;i++)if(target[i]!==expected[i])return false;
+        for(let i=written;i<capacity;i++)if(target[i]!==99)return false;
+        if(storage[0]!==99||storage[1]!==99||storage[capacity+2]!==99)return false;
+        if(read<input.length && encoder.encode(String.fromCodePoint(input.codePointAt(read))).length<=capacity-written)return false;
+      }
+      for(const bad of [null,{},new Uint16Array(4),new DataView(new ArrayBuffer(4))]) {
+        try{encoder.encodeInto('a',bad);return false;}catch(e){if(!(e instanceof TypeError))return false;}
+      }
+      try{encoder.encodeInto(Symbol('x'),new Uint8Array(4));return false;}catch(e){if(!(e instanceof TypeError))return false;}
+      return true;
+    })()"#,IsolateConfig{request_timeout_ms:5000,cpu_ms_per_turn:5000,..config()}).unwrap();
+    assert_eq!(result, Value::Bool(true));
+}
+
+#[test]
+fn next_response_helpers_and_status_contract() {
+    let result=eval(r#"(async()=>{
+      for(const status of [0,101,199,600]){try{new Response(null,{status});return false;}catch(e){if(!(e instanceof RangeError))return false;}}
+      for(const status of [204,205,304]){try{new Response('',{status});return false;}catch(e){if(!(e instanceof TypeError))return false;}}
+      const redirect=Response.redirect('https://local:443/a',307);
+      if(redirect.status!==307||redirect.headers.get('location')!=='https://local/a')return false;
+      for(const response of [redirect,redirect.clone(),Response.error(),Response.error().clone()]) {
+        try{response.headers.set('a','b');return false;}catch(e){if(!(e instanceof TypeError))return false;}
+        if(await response.text()!==''||response.bodyUsed||await response.text()!=='')return false;
+      }
+      return !Response.error().ok && Response.error().type==='error';
+    })()"#,config()).unwrap();
+    assert_eq!(result, Value::Bool(true));
+    let pool =
+        IsolatePool::spawn(1, "export default {fetch(){return Response.error();}}", config())
+            .unwrap();
+    assert!(
+        pool.dispatch_sync(HttpRequest {
+            method: "GET".into(),
+            url: "http://local/".into(),
+            headers: vec![],
+            body: vec![],
+            request_id: 0
+        })
+        .is_err()
+    );
+}
+
+#[test]
+fn next_review_status_getter_and_typed_array_length() {
+    let result=eval(r#"(()=>{
+      for(const status of [undefined,200]) {
+        let reads=0;
+        const response=new Response('body',{get status(){if(++reads>1)throw new Error('read twice');return status;}});
+        if(response.status!==200||reads!==1)return false;
+      }
+      const encoder=new TextEncoder();
+      class Shadowed extends Uint8Array {get byteLength(){throw new Error('shadowed getter');}}
+      for(const mode of ['zero','throw','subclass']) {
+        const target=mode==='subclass'?new Shadowed(8):new Uint8Array(8);
+        if(mode==='zero')Object.defineProperty(target,'byteLength',{value:0});
+        if(mode==='throw')Object.defineProperty(target,'byteLength',{get(){throw new Error('own getter');}});
+        const result=encoder.encodeInto('abc😀',target);
+        if(result.read!==5||result.written!==7||String(target)!=='97,98,99,240,159,152,128,0')return false;
+      }
+      return true;
+    })()"#,config()).unwrap();
+    assert_eq!(result, Value::Bool(true));
+}
diff --git a/crates/tysel-engine-qjs/src/pool.rs b/crates/tysel-engine-qjs/src/pool.rs
index b976b30..08ef552 100644
--- a/crates/tysel-engine-qjs/src/pool.rs
+++ b/crates/tysel-engine-qjs/src/pool.rs
@@ -333,7 +333,11 @@ fn run_worker(
             request_id,
             Duration::from_millis(config.request_timeout_ms.max(100)),
         )?;
-        let _ = job_result;
+        // Failed body reads can leave promise/stream cycles holding buffers.
+        // Reclaim them after native operations and request roots are cleared.
+        if job_result.is_err() {
+            runtime.run_gc();
+        }
         drop(pending);
     }
 
diff --git a/runtime-js/test/response.test.mjs b/runtime-js/test/response.test.mjs
new file mode 100644
index 0000000..c49b4f0
--- /dev/null
+++ b/runtime-js/test/response.test.mjs
@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import vm from 'node:vm';
+import test from 'node:test';
+const context=vm.createContext({URL,TextEncoder,TextDecoder,__tysel_isReadableStream:()=>false});
+vm.runInContext(fs.readFileSync(new URL('../web-api/source/http.js',import.meta.url),'utf8'),context);
+const CustomResponse=vm.runInContext('Response',context);
+test('Response status and null-body rules match native constructors',()=>{
+  for(const status of [undefined,null,0,101,199,200,204,205,299,304,599,600,NaN,Infinity,-1,65736,200.9,'201'])for(const body of [null,undefined,'','A',new Uint8Array(0)]) {
+    const run=C=>{try{const r=new C(body,{status});return ['ok',r.status,r.ok,r.type];}catch(e){return [e.name];}};
+    assert.deepEqual(run(CustomResponse),run(Response),String(status));
+  }
+});
+test('Response redirect and error preserve immutable headers and clone semantics',async()=>{
+  for(const status of [undefined,200,301,302,303,304,307,308,65536+302]) {
+    const run=C=>{try{const r=C.redirect('https://example.com/a',status);return [r.status,r.headers.get('location'),r.type];}catch(e){return [e.name];}};
+    assert.deepEqual(run(CustomResponse),run(Response));
+  }
+  for(const r of [CustomResponse.error(),CustomResponse.redirect('https://example.com/')]) {
+    for(const h of [r.headers,r.clone().headers])for(const method of ['set','append','delete'])assert.throws(()=>h[method]('a','b'),{name:'TypeError'});
+    assert.equal(await r.text(),'');assert.equal(await r.text(),'');assert.equal(r.bodyUsed,false);
+  }
+  assert.equal(CustomResponse.error().clone().status,0);
+});
+
+test('Response reads the status dictionary member once',()=>{
+  for(const status of [undefined,200,204])for(const body of [null,'body']) {
+    const run=C=>{let reads=0;try{const r=new C(body,{get status(){if(++reads>1)throw new Error('read twice');return status;}});return [r.status,reads];}catch(e){return [e.name,reads];}};
+    assert.deepEqual(run(CustomResponse),run(Response));
+  }
+});
diff --git a/runtime-js/web-api/compatibility.json b/runtime-js/web-api/compatibility.json
index c61d8a1..7172e58 100644
--- a/runtime-js/web-api/compatibility.json
+++ b/runtime-js/web-api/compatibility.json
@@ -31,7 +31,8 @@
         "live sorted iteration across header mutations",
         "iterable pair initialization",
         "HTTP token and CR/LF validation",
-        "independent Set-Cookie values and getSetCookie snapshots"
+        "independent Set-Cookie values and getSetCookie snapshots",
+        "immutable headers on Response.redirect and Response.error results"
       ],
       "unsupported": [
         "browser header guards"
@@ -49,7 +50,10 @@
         "UTF-8 decoding after byte collection, including split code points and BOM handling",
         "Tysel response chunk arrays with snapshotted string/ArrayBuffer/ArrayBufferView elements",
         "lazy ReadableStream body access with locking and disturbance",
-        "Response with a ReadableStream of Uint8Array chunks, native backpressure and cancellation"
+        "Response with a ReadableStream of Uint8Array chunks, native backpressure and cancellation",
+        "Response.redirect and Response.error with immutable headers and clone preservation",
+        "response status range and null-body status validation; status 101 only after tysel.acceptWebSocket",
+        "null-body helpers are repeatable and do not set bodyUsed"
       ],
       "unsupported": [
         "formData/blob helpers",
@@ -63,11 +67,11 @@
       "supported": [
         "UTF-8 encode and decode",
         "stateful UTF-8 decode with stream option and final flush",
-        "TextDecoderStream over TransformStream"
+        "TextDecoderStream over TransformStream",
+        "TextEncoder.encodeInto with UTF-16 read counts, scalar replacement and bounded scratch storage"
       ],
       "unsupported": [
-        "legacy encodings",
-        "TextEncoder.encodeInto"
+        "legacy encodings"
       ]
     },
     {
diff --git a/runtime-js/web-api/index.ts b/runtime-js/web-api/index.ts
index 142220d..9fceff2 100644
--- a/runtime-js/web-api/index.ts
+++ b/runtime-js/web-api/index.ts
@@ -142,6 +142,7 @@ export interface TyselRequest extends TyselBody {
 export interface TyselResponse extends TyselBody {
   readonly body: Streams.ReadableStream<Uint8Array> | null;
   readonly status: number;
+  readonly type: "default" | "error";
   readonly ok: boolean;
   readonly headers: TyselHeaders;
   clone(): TyselResponse;
@@ -205,6 +206,7 @@ export interface TyselCrypto {
 export interface TyselTextEncoder {
   readonly encoding: "utf-8";
   encode(input?: string): Uint8Array;
+  encodeInto(source: string, destination: Uint8Array): { read: number; written: number };
 }
 
 export interface TyselTextDecoder {
@@ -235,6 +237,8 @@ export interface TyselWebApiGlobals {
   Response: {
     new (body?: TyselBodyInit | readonly TyselBodyInit[] | Streams.ReadableStream<Uint8Array> | null, init?: TyselResponseInit): TyselResponse;
     json(data: unknown, init?: TyselResponseInit): TyselResponse;
+    error(): TyselResponse;
+    redirect(url: string, status?: number): TyselResponse;
   };
   AbortController: new () => TyselAbortController;
   AbortSignal: {
diff --git a/runtime-js/web-api/runtime.js b/runtime-js/web-api/runtime.js
index cc0cca4..91a56f6 100644
--- a/runtime-js/web-api/runtime.js
+++ b/runtime-js/web-api/runtime.js
@@ -613,12 +613,14 @@ SOFTWARE.
     get(name) { return this._map[headerName(name)] ?? null; }
     getSetCookie() { return this._cookies.slice(); }
     set(name, value) {
+      if (this._immutable) throw new TypeError("headers are immutable");
       const key = headerName(name), text = headerValue(value);
       this._map[key] = text;
       this._version++;
       if (key === "set-cookie") this._cookies = [text];
     }
     append(name, value) {
+      if (this._immutable) throw new TypeError("headers are immutable");
       const key = headerName(name), text = headerValue(value);
       const prev = this._map[key];
       this._map[key] = prev == null ? text : prev + ", " + text;
@@ -627,6 +629,7 @@ SOFTWARE.
     }
     has(name) { return Object.hasOwn(this._map, headerName(name)); }
     delete(name) {
+      if (this._immutable) throw new TypeError("headers are immutable");
       const key = headerName(name);
       delete this._map[key];
       this._version++;
@@ -738,7 +741,7 @@ SOFTWARE.
   async function consumeBytes(owner) {
     if (used(owner)) throw new TypeError("body has already been consumed");
     if (!owner._stream && !owner._bodyStream) {
-      owner._bodyUsed = true;
+      if (owner._body != null) owner._bodyUsed = true;
       return bodyBytes(owner._body);
     }
     const reader = getBody(owner).getReader();
@@ -831,7 +834,15 @@ SOFTWARE.
       const stream = globalThis.__tysel_isReadableStream(body);
       if (stream && (body.locked || body._disturbed)) throw new TypeError("body stream is locked or consumed");
       this._body = stream ? null : body == null ? null : copyResponseBody(body);
-      this.status = init.status || 200;
+      let status = 200;
+      const initialStatus = init.status;
+      if (initialStatus !== undefined) {
+        const number = +initialStatus;
+        status = Number.isFinite(number) ? ((Math.trunc(number) % 65536) + 65536) % 65536 : 0;
+        if ((status < 200 || status > 599) && !(status === 101 && globalThis.__tysel_ws_accepted)) throw new RangeError("invalid response status");
+        if (body != null && (status === 101 || status === 204 || status === 205 || status === 304)) throw new TypeError("status cannot have a body");
+      }
+      this.status = status;
       this.headers = new Headers(init.headers);
       this._stream = false;
       this._signal = null;
@@ -841,9 +852,25 @@ SOFTWARE.
       this._customStream = stream;
       if (this._customStream) this._bodyStream = body;
     }
+    get type() { return this.status === 0 ? "error" : "default"; }
     get ok() {
       return this.status >= 200 && this.status < 300;
     }
+    static error() {
+      const response = new Response();
+      response.status = 0;
+      response.headers._immutable = true;
+      return response;
+    }
+    static redirect(url, status = 302) {
+      const location = new URL(String(url)).href;
+      const number = +status;
+      status = Number.isFinite(number) ? ((Math.trunc(number) % 65536) + 65536) % 65536 : 0;
+      if (![301, 302, 303, 307, 308].includes(status)) throw new RangeError("invalid redirect status");
+      const response = new Response(null, {status, headers: {location}});
+      response.headers._immutable = true;
+      return response;
+    }
     static json(data, init) {
       init = init || {};
       const body = JSON.stringify(data);
@@ -867,11 +894,15 @@ SOFTWARE.
       if (this._stream || this._customStream || used(this) || (this._bodyStream && this._bodyStream.locked)) {
         throw new TypeError("cannot clone a streaming or consumed response");
       }
-      return new Response(this._body, { status: this.status, headers: this.headers });
+      if (this.status === 0) return Response.error();
+      const response = new Response(this._body, { status: this.status, headers: this.headers });
+      response.headers._immutable = this.headers._immutable;
+      return response;
     }
   }
 
   globalThis.__tysel_responseBody = response => {
+    if (response.status === 0) throw new TypeError("cannot send a network-error Response");
     if (used(response)) throw new TypeError("response body has already been consumed");
     if (response._bodyStream && response._bodyStream.locked) throw new TypeError("response body is locked");
     return response._stream || response._bodyStream ? response.body : response._body;
@@ -912,12 +943,39 @@ SOFTWARE.
 
 // source: web-api/source/encoding.js
 (() => {
+  // Read the internal view length even when an instance or subclass shadows it.
+  const byteLength = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), "byteLength").get;
   class TextEncoder {
     constructor() {
       this.encoding = "utf-8";
     }
+    encodeInto(source, destination) {
+      if (arguments.length < 2) throw new TypeError("encodeInto requires source and destination");
+      source = `${source}`;
+      if (!(destination instanceof Uint8Array)) throw new TypeError("expected Uint8Array");
+      const capacity = byteLength.call(destination);
+      let read = 0, written = 0;
+      // Bound each native conversion, including a surrogate lookahead.
+      do {
+        let end = Math.min(source.length, read + Math.min(16384, capacity - written + 1));
+        if (end < source.length && end > read + 1 && source.charCodeAt(end - 1) >= 0xd800 && source.charCodeAt(end - 1) <= 0xdbff) end--;
+        const chunk = source.slice(read, end);
+        const result = tysel._utf8EncodeInto(chunk, destination, written);
+        read += result.read; written += result.written;
+        if (!result.read || result.read < chunk.length) break;
+      } while (read < source.length && written < capacity);
+      return { read, written };
+    }
     encode(input) {
-      return tysel._utf8Encode(input == null ? "" : String(input));
+      const text = input === undefined ? "" : `${input}`;
+      try { return tysel._utf8Encode(text); }
+      catch (error) {
+        // The native bridge rejects lone surrogate code points. Keep valid
+        // strings on the existing fast path; normalize only this fallback.
+        const scalar = text.replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDFFF]/g, unit => unit.length === 2 ? unit : "\ufffd");
+        if (scalar === text) throw error;
+        return tysel._utf8Encode(scalar);
+      }
     }
   }
 
diff --git a/runtime-js/web-api/source/encoding.js b/runtime-js/web-api/source/encoding.js
index 075dd27..a0346d7 100644
--- a/runtime-js/web-api/source/encoding.js
+++ b/runtime-js/web-api/source/encoding.js
@@ -1,10 +1,37 @@
 (() => {
+  // Read the internal view length even when an instance or subclass shadows it.
+  const byteLength = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), "byteLength").get;
   class TextEncoder {
     constructor() {
       this.encoding = "utf-8";
     }
+    encodeInto(source, destination) {
+      if (arguments.length < 2) throw new TypeError("encodeInto requires source and destination");
+      source = `${source}`;
+      if (!(destination instanceof Uint8Array)) throw new TypeError("expected Uint8Array");
+      const capacity = byteLength.call(destination);
+      let read = 0, written = 0;
+      // Bound each native conversion, including a surrogate lookahead.
+      do {
+        let end = Math.min(source.length, read + Math.min(16384, capacity - written + 1));
+        if (end < source.length && end > read + 1 && source.charCodeAt(end - 1) >= 0xd800 && source.charCodeAt(end - 1) <= 0xdbff) end--;
+        const chunk = source.slice(read, end);
+        const result = tysel._utf8EncodeInto(chunk, destination, written);
+        read += result.read; written += result.written;
+        if (!result.read || result.read < chunk.length) break;
+      } while (read < source.length && written < capacity);
+      return { read, written };
+    }
     encode(input) {
-      return tysel._utf8Encode(input == null ? "" : String(input));
+      const text = input === undefined ? "" : `${input}`;
+      try { return tysel._utf8Encode(text); }
+      catch (error) {
+        // The native bridge rejects lone surrogate code points. Keep valid
+        // strings on the existing fast path; normalize only this fallback.
+        const scalar = text.replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDFFF]/g, unit => unit.length === 2 ? unit : "\ufffd");
+        if (scalar === text) throw error;
+        return tysel._utf8Encode(scalar);
+      }
     }
   }
 
diff --git a/runtime-js/web-api/source/http.js b/runtime-js/web-api/source/http.js
index 160c34d..d58cdac 100644
--- a/runtime-js/web-api/source/http.js
+++ b/runtime-js/web-api/source/http.js
@@ -51,12 +51,14 @@
     get(name) { return this._map[headerName(name)] ?? null; }
     getSetCookie() { return this._cookies.slice(); }
     set(name, value) {
+      if (this._immutable) throw new TypeError("headers are immutable");
       const key = headerName(name), text = headerValue(value);
       this._map[key] = text;
       this._version++;
       if (key === "set-cookie") this._cookies = [text];
     }
     append(name, value) {
+      if (this._immutable) throw new TypeError("headers are immutable");
       const key = headerName(name), text = headerValue(value);
       const prev = this._map[key];
       this._map[key] = prev == null ? text : prev + ", " + text;
@@ -65,6 +67,7 @@
     }
     has(name) { return Object.hasOwn(this._map, headerName(name)); }
     delete(name) {
+      if (this._immutable) throw new TypeError("headers are immutable");
       const key = headerName(name);
       delete this._map[key];
       this._version++;
@@ -176,7 +179,7 @@
   async function consumeBytes(owner) {
     if (used(owner)) throw new TypeError("body has already been consumed");
     if (!owner._stream && !owner._bodyStream) {
-      owner._bodyUsed = true;
+      if (owner._body != null) owner._bodyUsed = true;
       return bodyBytes(owner._body);
     }
     const reader = getBody(owner).getReader();
@@ -269,7 +272,15 @@
       const stream = globalThis.__tysel_isReadableStream(body);
       if (stream && (body.locked || body._disturbed)) throw new TypeError("body stream is locked or consumed");
       this._body = stream ? null : body == null ? null : copyResponseBody(body);
-      this.status = init.status || 200;
+      let status = 200;
+      const initialStatus = init.status;
+      if (initialStatus !== undefined) {
+        const number = +initialStatus;
+        status = Number.isFinite(number) ? ((Math.trunc(number) % 65536) + 65536) % 65536 : 0;
+        if ((status < 200 || status > 599) && !(status === 101 && globalThis.__tysel_ws_accepted)) throw new RangeError("invalid response status");
+        if (body != null && (status === 101 || status === 204 || status === 205 || status === 304)) throw new TypeError("status cannot have a body");
+      }
+      this.status = status;
       this.headers = new Headers(init.headers);
       this._stream = false;
       this._signal = null;
@@ -279,9 +290,25 @@
       this._customStream = stream;
       if (this._customStream) this._bodyStream = body;
     }
+    get type() { return this.status === 0 ? "error" : "default"; }
     get ok() {
       return this.status >= 200 && this.status < 300;
     }
+    static error() {
+      const response = new Response();
+      response.status = 0;
+      response.headers._immutable = true;
+      return response;
+    }
+    static redirect(url, status = 302) {
+      const location = new URL(String(url)).href;
+      const number = +status;
+      status = Number.isFinite(number) ? ((Math.trunc(number) % 65536) + 65536) % 65536 : 0;
+      if (![301, 302, 303, 307, 308].includes(status)) throw new RangeError("invalid redirect status");
+      const response = new Response(null, {status, headers: {location}});
+      response.headers._immutable = true;
+      return response;
+    }
     static json(data, init) {
       init = init || {};
       const body = JSON.stringify(data);
@@ -305,11 +332,15 @@
       if (this._stream || this._customStream || used(this) || (this._bodyStream && this._bodyStream.locked)) {
         throw new TypeError("cannot clone a streaming or consumed response");
       }
-      return new Response(this._body, { status: this.status, headers: this.headers });
+      if (this.status === 0) return Response.error();
+      const response = new Response(this._body, { status: this.status, headers: this.headers });
+      response.headers._immutable = this.headers._immutable;
+      return response;
     }
   }
 
   globalThis.__tysel_responseBody = response => {
+    if (response.status === 0) throw new TypeError("cannot send a network-error Response");
     if (used(response)) throw new TypeError("response body has already been consumed");
     if (response._bodyStream && response._bodyStream.locked) throw new TypeError("response body is locked");
     return response._stream || response._bodyStream ? response.body : response._body;
diff --git a/runtime-js/web-api/type-contract.ts b/runtime-js/web-api/type-contract.ts
index 1d01ff9..451cf6a 100644
--- a/runtime-js/web-api/type-contract.ts
+++ b/runtime-js/web-api/type-contract.ts
@@ -11,5 +11,9 @@ export function checkStreamTypes(api: TyselWebApiGlobals) {
   const response = new api.Response(new api.ReadableStream<Uint8Array>());
   const cookie: string[] = response.headers.getSetCookie();
   const id: string = api.crypto.randomUUID();
+  const encoded = new api.TextEncoder().encodeInto("hello", new Uint8Array(8));
+  const redirect = api.Response.redirect("https://example.com/", 307);
+  const errorType: "default" | "error" = api.Response.error().type;
+  void [encoded.read, encoded.written, redirect, errorType];
   return { done, cookie, id };
 }

From 1621307341ce1b2cee1b90c1ff535fe360474df4 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Mon, 7 Sep 2026 19:41:50 +0800
Subject: [PATCH 14/31] perf(runtime): add equivalent-output encoding
 comparisons

---
 .../tysel-engine-qjs/examples/p1_profile.rs   | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/crates/tysel-engine-qjs/examples/p1_profile.rs b/crates/tysel-engine-qjs/examples/p1_profile.rs
index 320e9f1..caaa143 100644
--- a/crates/tysel-engine-qjs/examples/p1_profile.rs
+++ b/crates/tysel-engine-qjs/examples/p1_profile.rs
@@ -16,6 +16,40 @@ fn percentile(values: &mut [f64], p: usize) -> f64 {
 }
 fn main() {
     let mode = std::env::args().nth(1).unwrap_or_else(|| "cold".into());
+    if mode == "encode" {
+        let result = eval(r#"(()=>{
+          const encoder=new TextEncoder(), rows=[];
+          for(const unicode of [false,true])for(const small of [false,true]) {
+            const source=(unicode?'中😀':'a').repeat(unicode?150000:1048576);
+            const expected=encoder.encode(source);
+            const capacity=small?64:expected.length;
+            let expectedWritten=Math.min(expected.length,capacity);
+            while(expectedWritten<expected.length && expectedWritten>0 && (expected[expectedWritten]&0xc0)===0x80)expectedWritten--;
+            const target=new Uint8Array(capacity), rounds=small?1000:100;
+            for(const mode of ['encode-copy','encodeInto']) {
+              target.fill(99);
+              const start=Date.now();let written=0;
+              for(let i=0;i<rounds;i++) {
+                if(mode==='encodeInto')written+=encoder.encodeInto(source,target).written;
+                else {
+                  const bytes=encoder.encode(source);let end=Math.min(bytes.length,capacity);
+                  while(end<bytes.length && end>0 && (bytes[end]&0xc0)===0x80)end--;
+                  target.set(bytes.subarray(0,end));written+=end;
+                }
+              }
+              const milliseconds=Date.now()-start;
+              if(written!==expectedWritten*rounds)throw new Error('encoding byte count mismatch');
+              for(let i=0;i<capacity;i++)if(target[i] !== (i<expectedWritten?expected[i]:99))throw new Error('encoding output mismatch');
+              rows.push({unicode,small,mode,milliseconds,rounds,written});
+            }
+          }
+          return JSON.stringify(rows);
+        })()"#, config()).unwrap();
+        if let tysel_engine::Value::String(json) = result {
+            println!("{json}");
+        }
+        return;
+    }
     if mode == "cold" {
         let mut times = Vec::new();
         for i in 0..52 {

From 45fe230c43b26628c54b2fe743d89eea6b0b69b6 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Mon, 7 Sep 2026 19:42:05 +0800
Subject: [PATCH 15/31] docs(runtime): synchronize encoding and Response API
 contracts

---
 .../javascript-runtime-compatibility.md       | 26 ++++++++++++++++++-
 docs/editor-iteration-plan.md                 |  3 +--
 .../content/reference/javascript/headers.mdx  |  1 +
 .../content/reference/javascript/request.mdx  |  3 +++
 .../reference/javascript/textencoder.mdx      |  2 +-
 .../content/reference/javascript/headers.mdx  |  2 ++
 .../content/reference/javascript/request.mdx  |  4 +++
 .../reference/javascript/textencoder.mdx      |  3 ++-
 website/locales/zh-CN/manifest.json           | 12 ++++-----
 9 files changed, 45 insertions(+), 11 deletions(-)

diff --git a/docs/architecture/javascript-runtime-compatibility.md b/docs/architecture/javascript-runtime-compatibility.md
index ec06a45..1334566 100644
--- a/docs/architecture/javascript-runtime-compatibility.md
+++ b/docs/architecture/javascript-runtime-compatibility.md
@@ -16,7 +16,7 @@ in the [JavaScript reference](../reference/javascript/index.md).
 | URL / URLSearchParams | Partial | Authority URLs, relative resolution, dot segments, live query mutation, iterable parameters | Full WHATWG parsing, IDNA, credentials, file/blob URLs |
 | Headers | Partial | Iterable/record initializers, token validation, independent Set-Cookie values, getSetCookie | Browser header guards |
 | Request / Response | Partial | Byte-preserving string/ArrayBuffer/ArrayBufferView bodies, single-use text/JSON/arrayBuffer, bodyUsed, ReadableStream bodies and response output, buffered clone | Form/blob helpers, streamed Body.clone, browser policy fields |
-| TextEncoder / TextDecoder | Partial | UTF-8 conversion, stateful decode/flush, TextDecoderStream | Legacy encodings, encodeInto |
+| TextEncoder / TextDecoder | Partial | UTF-8 conversion, stateful decode/flush, TextDecoderStream, encodeInto | Legacy encodings |
 | Timers | Supported | Timeout/interval creation, clearing, isolate-reset cleanup | Browser scheduling guarantees |
 | Event / EventTarget | Partial | Function/object listeners, deduplication, removal, once/signal options, cancellation | DOM trees, capture/bubble phases, browser exception reporting |
 | AbortController / AbortSignal | Partial | EventTarget inheritance, reasons, static abort/timeout/any, fetch and body cancellation | Browser task scheduling guarantees |
@@ -169,3 +169,27 @@ are not repeatedly sorted. Deletion, updates, insertion before/after the cursor,
 and append after a done result are covered for entries/keys/values. This follows
 the live cursor behavior in the [Web IDL iterator algorithm](https://webidl.spec.whatwg.org/#default-iterator-objects),
 without changing the native header serialization path.
+
+### Encoding into caller buffers and Response factories
+
+`TextEncoder.encodeInto` writes into the selected Uint8Array view and reports
+UTF-16 code units read and UTF-8 bytes written. It replaces unmatched surrogates
+and never writes a partial code point. Conversion uses at most 16 Ki UTF-16 units
+per native call, producing at most 48 KiB of UTF-8 payload. This payload limit
+excludes the terminator, string metadata, allocator rounding and JS temporary
+objects; it is not an upper bound on allocated memory or request peak memory.
+It does not allocate an encoded result proportional to the full source when the
+destination is short. Chunking bounds conversion scratch, rather than promising
+zero allocation or faster execution for every size.
+
+`Response.redirect` accepts absolute URLs within the supported URL subset and
+301/302/303/307/308 statuses. It creates an immutable Location header.
+`Response.error` creates a status-0, type-error response with immutable headers;
+returning it from a handler fails native response preparation rather than sending
+an invalid HTTP status. Clones preserve these immutable headers. Other response
+header guards remain outside the supported subset.
+
+Ordinary Response construction accepts statuses 200–599 and rejects non-null
+bodies for 204, 205 and 304. Tysel's existing status-101 WebSocket upgrade remains
+available only after `tysel.acceptWebSocket()`, also with a null body. Null-body
+helpers remain repeatable and leave bodyUsed false.
diff --git a/docs/editor-iteration-plan.md b/docs/editor-iteration-plan.md
index fa7d428..916fc4e 100644
--- a/docs/editor-iteration-plan.md
+++ b/docs/editor-iteration-plan.md
@@ -37,8 +37,7 @@ an independent LSP is outside this iteration.
 
 - Relevant unit suites: 147 passed (manifest 24, build 39, supply-chain tool 6,
   CLI 78). CLI development integration suite: 66 passed.
-- `cargo clippy --offline -p tysel-manifest -p tysel-build -p tysel-cli --lib
-  --bins -- -D warnings`, formatting, and diff whitespace checks passed.
+- `cargo clippy --offline -p tysel-manifest -p tysel-build -p tysel-cli --lib --bins -- -D warnings`, formatting, and diff whitespace checks passed.
 - Strict MkDocs build passed with output outside the repository.
 - Taplo CLI 0.9.0 accepted a valid manifest through the local schema directive
   and rejected invalid workers, an unknown profile, and a Component/entry
diff --git a/website/content/reference/javascript/headers.mdx b/website/content/reference/javascript/headers.mdx
index 39caf53..eb2d1f1 100644
--- a/website/content/reference/javascript/headers.mdx
+++ b/website/content/reference/javascript/headers.mdx
@@ -18,6 +18,7 @@ Source of truth: `runtime-js/web-api/compatibility.json`
 - iterable pair initialization
 - HTTP token and CR/LF validation
 - independent Set-Cookie values and getSetCookie snapshots
+- immutable headers on Response.redirect and Response.error results
 
 ## Not supported
 
diff --git a/website/content/reference/javascript/request.mdx b/website/content/reference/javascript/request.mdx
index f56c962..8dd63e1 100644
--- a/website/content/reference/javascript/request.mdx
+++ b/website/content/reference/javascript/request.mdx
@@ -21,6 +21,9 @@ Source of truth: `runtime-js/web-api/compatibility.json`
 - Tysel response chunk arrays with snapshotted string/ArrayBuffer/ArrayBufferView elements
 - lazy ReadableStream body access with locking and disturbance
 - Response with a ReadableStream of Uint8Array chunks, native backpressure and cancellation
+- Response.redirect and Response.error with immutable headers and clone preservation
+- response status range and null-body status validation; status 101 only after tysel.acceptWebSocket
+- null-body helpers are repeatable and do not set bodyUsed
 
 ## Not supported
 
diff --git a/website/content/reference/javascript/textencoder.mdx b/website/content/reference/javascript/textencoder.mdx
index 889f97b..82fb056 100644
--- a/website/content/reference/javascript/textencoder.mdx
+++ b/website/content/reference/javascript/textencoder.mdx
@@ -15,11 +15,11 @@ Source of truth: `runtime-js/web-api/compatibility.json`
 - UTF-8 encode and decode
 - stateful UTF-8 decode with stream option and final flush
 - TextDecoderStream over TransformStream
+- TextEncoder.encodeInto with UTF-16 read counts, scalar replacement and bounded scratch storage
 
 ## Not supported
 
 - legacy encodings
-- TextEncoder.encodeInto
 
 See the [JavaScript API index](/reference/javascript) and the
 [npm compatibility guide](/docs/compatibility).
diff --git a/website/locales/zh-CN/content/reference/javascript/headers.mdx b/website/locales/zh-CN/content/reference/javascript/headers.mdx
index 1bc9994..642de72 100644
--- a/website/locales/zh-CN/content/reference/javascript/headers.mdx
+++ b/website/locales/zh-CN/content/reference/javascript/headers.mdx
@@ -18,6 +18,8 @@ description: "Tysel JavaScript 运行时支持的 Headers 契约。"
 - HTTP token 和 CR/LF 校验
 - 独立的 Set-Cookie 值与 getSetCookie 快照
 
+- Response.redirect 和 Response.error 返回值的响应头不可变
+
 ## 不支持
 
 - 浏览器请求头保护规则
diff --git a/website/locales/zh-CN/content/reference/javascript/request.mdx b/website/locales/zh-CN/content/reference/javascript/request.mdx
index 4528fb9..e32fd61 100644
--- a/website/locales/zh-CN/content/reference/javascript/request.mdx
+++ b/website/locales/zh-CN/content/reference/javascript/request.mdx
@@ -21,6 +21,10 @@ description: "Tysel JavaScript 运行时支持的 Request and Response 契约。
 - 按需创建 ReadableStream body，并跟踪锁定与读取状态
 - Response 支持 Uint8Array 分块的 ReadableStream，以及原生背压和取消
 
+- Response.redirect 和 Response.error：响应头不可变，clone 保留该属性
+- 校验响应状态码范围及无响应体状态；仅在 tysel.acceptWebSocket 后允许状态码 101
+- 空响应体的辅助读取方法可重复调用，不设置 bodyUsed
+
 ## 不支持
 
 - formData/blob 辅助方法
diff --git a/website/locales/zh-CN/content/reference/javascript/textencoder.mdx b/website/locales/zh-CN/content/reference/javascript/textencoder.mdx
index c8bae01..05ebcfa 100644
--- a/website/locales/zh-CN/content/reference/javascript/textencoder.mdx
+++ b/website/locales/zh-CN/content/reference/javascript/textencoder.mdx
@@ -15,10 +15,11 @@ description: "Tysel JavaScript 运行时支持的 TextEncoder and TextDecoder 
 - 带 stream 选项和最终刷新功能的有状态 UTF-8 解码
 - 基于 TransformStream 的 TextDecoderStream
 
+- TextEncoder.encodeInto：按 UTF-16 码元计数、替换非法代理项，并限制临时存储大小
+
 ## 不支持
 
 - 传统编码
-- TextEncoder.encodeInto
 
 参阅 [JavaScript API 索引](/reference/javascript)和
 [npm 兼容性指南](/docs/compatibility)。
diff --git a/website/locales/zh-CN/manifest.json b/website/locales/zh-CN/manifest.json
index 3027ff9..34c22ea 100644
--- a/website/locales/zh-CN/manifest.json
+++ b/website/locales/zh-CN/manifest.json
@@ -2024,8 +2024,8 @@
       "status": "reviewed"
     },
     "reference/javascript/headers.mdx": {
-      "sourceHash": "75aeb6ede4932675050a3d4e1c88105c69ddbe392c0411f9b982249272a572d3",
-      "translationHash": "4de9874abddebf20b52681f25643b43b69399fbe1047d3c8d419d4ecbed6a838",
+      "sourceHash": "62a7226aeafa85fa269ee46fd78cd5e77beceedbff389716f760cb513a7754bf",
+      "translationHash": "151add569280720e10ea6b72fa9abf6ac5a3221267b07bc3d28003d387550887",
       "status": "reviewed"
     },
     "reference/javascript/index.mdx": {
@@ -2034,13 +2034,13 @@
       "status": "reviewed"
     },
     "reference/javascript/request.mdx": {
-      "sourceHash": "43c54ecd10e3ef02aaf0fb6b989da6f9f15f5451f2aba651533d91525a89d263",
-      "translationHash": "cb43fbddbe7588f8ebafd2e7fd7436a84d739ab6f9386947b2a2079adf627f5c",
+      "sourceHash": "9c08f2bbac6b0529768554e520f66dc822071b2a00a8acfa8ae8cd1a9b8fa192",
+      "translationHash": "a11e0ded9a50af27d16a4d1b1b0bfd99c3281581b703fae83706369613c9360d",
       "status": "reviewed"
     },
     "reference/javascript/textencoder.mdx": {
-      "sourceHash": "19005b8316c8c0bfecd39d5087c5048183dda6d92541b177a2df19403b165334",
-      "translationHash": "46a960d189c0fce75dbe775c34cd95d4160033ea5b3c3dbc2b39c933d5959053",
+      "sourceHash": "8118953d1bd5d17f12f780401959b49c7c08bd7ad2709d6a9d36b58a6c2ccaee",
+      "translationHash": "dd00f343f3416bc4c8f9d8338996e66ed052d8471b8069dd0af6e9cae8b82a2a",
       "status": "reviewed"
     },
     "reference/javascript/timers.mdx": {

From 3f02b479b91b097be7b1d171d3640542f4066e68 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Mon, 7 Sep 2026 23:52:25 +0800
Subject: [PATCH 16/31] feat(runtime): add Body bytes and TextEncoderStream

---
 crates/tysel-engine-qjs/src/p1_tests.rs | 91 +++++++++++++++++++++++++
 runtime-js/test/encoding.test.mjs       | 31 +++++++++
 runtime-js/web-api/compatibility.json   |  6 +-
 runtime-js/web-api/index.ts             |  6 ++
 runtime-js/web-api/runtime.js           | 32 +++++++++
 runtime-js/web-api/source/encoding.js   | 30 ++++++++
 runtime-js/web-api/source/http.js       |  2 +
 runtime-js/web-api/type-contract.ts     |  4 ++
 8 files changed, 200 insertions(+), 2 deletions(-)

diff --git a/crates/tysel-engine-qjs/src/p1_tests.rs b/crates/tysel-engine-qjs/src/p1_tests.rs
index 70ae0b3..371bd39 100644
--- a/crates/tysel-engine-qjs/src/p1_tests.rs
+++ b/crates/tysel-engine-qjs/src/p1_tests.rs
@@ -740,3 +740,94 @@ fn next_review_status_getter_and_typed_array_length() {
     })()"#,config()).unwrap();
     assert_eq!(result, Value::Bool(true));
 }
+
+#[test]
+fn bytes_helpers_preserve_ownership_and_consumption() {
+    let result=eval(r#"(async()=>{
+      const lazy=()=>typeof Object.getOwnPropertyDescriptor(globalThis,'ReadableStream').get==='function';
+      for(const C of [Response,Request]) {
+        const make=body=>C===Response?new C(body):new C('https://local/',{method:'POST',body});
+        const input=new Uint8Array([99,0,128,255,99]);
+        const response=make(input.subarray(1,4)),clone=response.clone();
+        const bytes=await response.bytes();
+        if(String(bytes)!=='0,128,255'||!response.bodyUsed||!lazy())return false;
+        bytes[0]=42;
+        if(input[1]!==0||String(await clone.bytes())!=='0,128,255')return false;
+        try{await response.bytes();return false;}catch(e){if(!(e instanceof TypeError))return false;}
+        const empty=make(null);
+        if((await empty.bytes()).length||(await empty.bytes()).length||empty.bodyUsed)return false;
+      }
+      const chunk=new Uint8Array([99,1,2,99]);
+      const response=new Response(new ReadableStream({start(c){c.enqueue(chunk.subarray(1,3));c.close();}}));
+      const bytes=await response.bytes();bytes[0]=7;
+      if(chunk[1]!==1||String(bytes)!=='7,2')return false;
+      const locked=new Response('a'),reader=locked.body.getReader();
+      try{await locked.bytes();return false;}catch(e){if(!(e instanceof TypeError))return false;}
+      reader.releaseLock();
+      return String(await locked.bytes())==='97';
+    })()"#,config()).unwrap();
+    assert_eq!(result, Value::Bool(true));
+}
+
+#[test]
+fn encoder_stream_surrogates_backpressure_and_cancellation() {
+    let result=eval(r#"(async()=>{
+      const lazy=()=>typeof Object.getOwnPropertyDescriptor(globalThis,'ReadableStream').get==='function';
+      if(!lazy()||typeof TextEncoderStream!=='function'||!lazy())return false;
+      const stream=new TextEncoderStream();
+      if(lazy()||stream.encoding!=='utf-8')return false;
+      const writer=stream.writable.getWriter();let converted=0;
+      const write=writer.write({toString(){converted++;return 'a';}});
+      await Promise.resolve();await Promise.resolve();
+      if(converted!==0)return false;
+      const reader=stream.readable.getReader();
+      if(String((await reader.read()).value)!=='97')return false;
+      await write;
+      const cancel=reader.cancel('stop');
+      try{await writer.write('b');return false;}catch(e){if(e!=='stop')return false;}
+      await cancel;
+      for(const chunks of [['\ud83d','','\ude00'],['中','\ud800'],['\ud800','\ud800','\udc00']]) {
+        const source=new ReadableStream({start(c){for(const chunk of chunks)c.enqueue(chunk);c.close();}});
+        const actual=await new Response(source.pipeThrough(new TextEncoderStream())).bytes();
+        if(String(actual)!==String(new TextEncoder().encode(chunks.join(''))))return false;
+      }
+      const bad=new TextEncoderStream(),r=bad.readable.getReader(),w=bad.writable.getWriter();
+      const read=r.read().then(()=>false,e=>e instanceof TypeError);
+      try{await w.write(Symbol());return false;}catch(e){if(!(e instanceof TypeError))return false;}
+      return await read;
+    })()"#,config()).unwrap();
+    assert_eq!(result, Value::Bool(true));
+}
+
+#[test]
+fn bytes_and_encoder_stream_work_through_native_dispatch() {
+    let pool=IsolatePool::spawn(1,r#"export default {async fetch(request){
+      const bytes=await request.bytes();
+      const chunks=[String(bytes),'\ud83d','\ude00'];
+      return new Response(new ReadableStream({pull(c){if(chunks.length)c.enqueue(chunks.shift());else c.close();}}).pipeThrough(new TextEncoderStream()));
+    }}"#,config()).unwrap();
+    let response = pool
+        .dispatch_sync(HttpRequest {
+            method: "POST".into(),
+            url: "http://local/".into(),
+            headers: vec![],
+            body: vec![0, 128, 255],
+            request_id: 1,
+        })
+        .unwrap();
+    assert_eq!(response.1, "0,128,255😀".as_bytes());
+}
+
+#[test]
+fn encoder_stream_processes_more_than_the_heap_without_accumulation() {
+    let result=eval(r#"(async()=>{
+      let remaining=512,total=0;
+      const source=new ReadableStream({pull(c){if(remaining-- > 0)c.enqueue('a'.repeat(32768));else c.close();}});
+      for await(const bytes of source.pipeThrough(new TextEncoderStream())) {
+        if(bytes.length!==32768||bytes[0]!==97||bytes[32767]!==97)return false;
+        total+=bytes.length;
+      }
+      return total===16*1024*1024;
+    })()"#,IsolateConfig{memory_limit_bytes:4*1024*1024,request_timeout_ms:10000,cpu_ms_per_turn:10000}).unwrap();
+    assert_eq!(result, Value::Bool(true));
+}
diff --git a/runtime-js/test/encoding.test.mjs b/runtime-js/test/encoding.test.mjs
index 2db8993..c350109 100644
--- a/runtime-js/test/encoding.test.mjs
+++ b/runtime-js/test/encoding.test.mjs
@@ -38,3 +38,34 @@ test('incremental UTF-8 agrees with native decoding across malformed and split i
     assert.equal(custom(input,widths,fatal),expected,JSON.stringify({input,widths,fatal}));
   }
 });
+
+test('TextEncoderStream matches native chunk boundaries, conversion and surrogate flushing', async () => {
+  const context = vm.createContext({TransformStream, tysel: {
+    _utf8Encode(text) { return new TextEncoder().encode(text); },
+  }});
+  vm.runInContext(readFileSync(new URL('../web-api/source/encoding.js', import.meta.url), 'utf8'), context);
+  const Custom = vm.runInContext('TextEncoderStream', context);
+  const collect = async (C, chunks) => {
+    const stream = new C(), output = [];
+    const reading = (async () => { for await (const chunk of stream.readable) output.push(Array.from(chunk)); })();
+    const writer = stream.writable.getWriter();
+    for (const chunk of chunks) await writer.write(chunk);
+    await writer.close(); await reading;
+    return output;
+  };
+  const cases = [[], [''], ['\ud83d', '', '\ude00'], ['\ud800'], ['\udc00', '中'], ['\ud800', '\ud800', '\udc00'], [undefined, null, 42, {toString(){return '😀';}}]];
+  let seed = 451;
+  for (let i=0;i<80;i++) {
+    const chunks=[];
+    for(let j=0;j<8;j++) { seed=(Math.imul(seed,1664525)+1013904223)>>>0; chunks.push(String.fromCharCode(seed&0xffff)); }
+    cases.push(chunks);
+  }
+  for (const chunks of cases) assert.deepEqual(await collect(Custom,chunks), await collect(TextEncoderStream,chunks));
+  // DOMString conversion rejects Symbols; Node's encoder stream currently stringifies them.
+  for (const C of [Custom]) {
+    const stream = new C(), reader=stream.readable.getReader(), writer=stream.writable.getWriter();
+    const read=assert.rejects(reader.read(), {name:'TypeError'});
+    await assert.rejects(writer.write(Symbol('invalid')), {name:'TypeError'});
+    await read;
+  }
+});
diff --git a/runtime-js/web-api/compatibility.json b/runtime-js/web-api/compatibility.json
index 7172e58..3bbb017 100644
--- a/runtime-js/web-api/compatibility.json
+++ b/runtime-js/web-api/compatibility.json
@@ -53,7 +53,8 @@
         "Response with a ReadableStream of Uint8Array chunks, native backpressure and cancellation",
         "Response.redirect and Response.error with immutable headers and clone preservation",
         "response status range and null-body status validation; status 101 only after tysel.acceptWebSocket",
-        "null-body helpers are repeatable and do not set bodyUsed"
+        "null-body helpers are repeatable and do not set bodyUsed",
+        "bytes() returns independent Uint8Array bytes with the same body consumption rules as arrayBuffer()"
       ],
       "unsupported": [
         "formData/blob helpers",
@@ -68,7 +69,8 @@
         "UTF-8 encode and decode",
         "stateful UTF-8 decode with stream option and final flush",
         "TextDecoderStream over TransformStream",
-        "TextEncoder.encodeInto with UTF-16 read counts, scalar replacement and bounded scratch storage"
+        "TextEncoder.encodeInto with UTF-16 read counts, scalar replacement and bounded scratch storage",
+        "TextEncoderStream with cross-chunk surrogate pairs, final replacement, backpressure and cancellation"
       ],
       "unsupported": [
         "legacy encodings"
diff --git a/runtime-js/web-api/index.ts b/runtime-js/web-api/index.ts
index 9fceff2..73f84c0 100644
--- a/runtime-js/web-api/index.ts
+++ b/runtime-js/web-api/index.ts
@@ -128,6 +128,7 @@ export interface TyselBody {
   text(): Promise<string>;
   json(): Promise<unknown>;
   arrayBuffer(): Promise<ArrayBuffer>;
+  bytes(): Promise<Uint8Array>;
 }
 
 export interface TyselRequest extends TyselBody {
@@ -256,6 +257,11 @@ export interface TyselWebApiGlobals {
   TransformStream: typeof Streams.TransformStream;
   ByteLengthQueuingStrategy: typeof Streams.ByteLengthQueuingStrategy;
   CountQueuingStrategy: typeof Streams.CountQueuingStrategy;
+  TextEncoderStream: new () => {
+    readonly encoding: "utf-8";
+    readonly readable: Streams.ReadableStream<Uint8Array>;
+    readonly writable: Streams.WritableStream<any>; // Chunks undergo string conversion.
+  };
   TextDecoderStream: new (label?: "utf-8" | "utf8", options?: {fatal?: boolean; ignoreBOM?: boolean}) => {
     readonly encoding: "utf-8";
     readonly fatal: boolean;
diff --git a/runtime-js/web-api/runtime.js b/runtime-js/web-api/runtime.js
index 91a56f6..5ebbdfb 100644
--- a/runtime-js/web-api/runtime.js
+++ b/runtime-js/web-api/runtime.js
@@ -815,6 +815,7 @@ SOFTWARE.
     async text() { return consumeText(this); }
     async json() { return JSON.parse(await this.text()); }
     async arrayBuffer() { return consumeArrayBuffer(this); }
+    async bytes() { return new Uint8Array(await consumeArrayBuffer(this)); }
     clone() {
       if (this._stream || this._customStream || used(this) || (this._bodyStream && this._bodyStream.locked)) {
         throw new TypeError("cannot clone a streaming or consumed request");
@@ -890,6 +891,7 @@ SOFTWARE.
     async text() { return consumeText(this); }
     async json() { return JSON.parse(await this.text()); }
     async arrayBuffer() { return consumeArrayBuffer(this); }
+    async bytes() { return new Uint8Array(await consumeArrayBuffer(this)); }
     clone() {
       if (this._stream || this._customStream || used(this) || (this._bodyStream && this._bodyStream.locked)) {
         throw new TypeError("cannot clone a streaming or consumed response");
@@ -1036,6 +1038,36 @@ SOFTWARE.
     }
   }
 
+  class TextEncoderStream {
+    constructor() {
+      const encoder = new TextEncoder();
+      let pending = "";
+      const transform = new TransformStream({
+        transform(chunk, controller) {
+          // Convert before changing pending state; Symbols must reject the write.
+          let text = pending + `${chunk}`;
+          pending = "";
+          const last = text.charCodeAt(text.length - 1);
+          if (last >= 0xd800 && last <= 0xdbff) {
+            pending = text.slice(-1);
+            text = text.slice(0, -1);
+          }
+          if (text) controller.enqueue(encoder.encode(text));
+        },
+        flush(controller) {
+          if (pending) controller.enqueue(encoder.encode(pending));
+          pending = "";
+        },
+      });
+      Object.defineProperties(this, {
+        encoding: {value: "utf-8", enumerable: true},
+        readable: {value: transform.readable},
+        writable: {value: transform.writable},
+      });
+    }
+  }
+  globalThis.TextEncoderStream = TextEncoderStream;
+
   class TextDecoderStream {
     constructor(label, options) {
       const decoder = new TextDecoder(label, options);
diff --git a/runtime-js/web-api/source/encoding.js b/runtime-js/web-api/source/encoding.js
index a0346d7..8054e51 100644
--- a/runtime-js/web-api/source/encoding.js
+++ b/runtime-js/web-api/source/encoding.js
@@ -92,6 +92,36 @@
     }
   }
 
+  class TextEncoderStream {
+    constructor() {
+      const encoder = new TextEncoder();
+      let pending = "";
+      const transform = new TransformStream({
+        transform(chunk, controller) {
+          // Convert before changing pending state; Symbols must reject the write.
+          let text = pending + `${chunk}`;
+          pending = "";
+          const last = text.charCodeAt(text.length - 1);
+          if (last >= 0xd800 && last <= 0xdbff) {
+            pending = text.slice(-1);
+            text = text.slice(0, -1);
+          }
+          if (text) controller.enqueue(encoder.encode(text));
+        },
+        flush(controller) {
+          if (pending) controller.enqueue(encoder.encode(pending));
+          pending = "";
+        },
+      });
+      Object.defineProperties(this, {
+        encoding: {value: "utf-8", enumerable: true},
+        readable: {value: transform.readable},
+        writable: {value: transform.writable},
+      });
+    }
+  }
+  globalThis.TextEncoderStream = TextEncoderStream;
+
   class TextDecoderStream {
     constructor(label, options) {
       const decoder = new TextDecoder(label, options);
diff --git a/runtime-js/web-api/source/http.js b/runtime-js/web-api/source/http.js
index d58cdac..b3501f2 100644
--- a/runtime-js/web-api/source/http.js
+++ b/runtime-js/web-api/source/http.js
@@ -253,6 +253,7 @@
     async text() { return consumeText(this); }
     async json() { return JSON.parse(await this.text()); }
     async arrayBuffer() { return consumeArrayBuffer(this); }
+    async bytes() { return new Uint8Array(await consumeArrayBuffer(this)); }
     clone() {
       if (this._stream || this._customStream || used(this) || (this._bodyStream && this._bodyStream.locked)) {
         throw new TypeError("cannot clone a streaming or consumed request");
@@ -328,6 +329,7 @@
     async text() { return consumeText(this); }
     async json() { return JSON.parse(await this.text()); }
     async arrayBuffer() { return consumeArrayBuffer(this); }
+    async bytes() { return new Uint8Array(await consumeArrayBuffer(this)); }
     clone() {
       if (this._stream || this._customStream || used(this) || (this._bodyStream && this._bodyStream.locked)) {
         throw new TypeError("cannot clone a streaming or consumed response");
diff --git a/runtime-js/web-api/type-contract.ts b/runtime-js/web-api/type-contract.ts
index 451cf6a..7e82dde 100644
--- a/runtime-js/web-api/type-contract.ts
+++ b/runtime-js/web-api/type-contract.ts
@@ -5,6 +5,10 @@ export function checkStreamTypes(api: TyselWebApiGlobals) {
   const stream = new api.ReadableStream<Uint8Array>({
     start(controller) { controller.enqueue(new Uint8Array([65])); controller.close(); },
   });
+  const encoder = new api.TextEncoderStream();
+  const encodedStream: import("./index.js").ReadableStream<Uint8Array> = encoder.readable;
+  const bytes: Promise<Uint8Array> = new api.Response("hello").bytes();
+  void [encodedStream, bytes];
   const decoder = new api.TextDecoderStream();
   const text = stream.pipeThrough(decoder);
   const done = text.pipeTo(new api.WritableStream<string>({ write(value) { void value; } }), { signal });

From 25810a4a559776114522684184990d87b3358ad1 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Mon, 7 Sep 2026 23:52:45 +0800
Subject: [PATCH 17/31] fix(streams): bound promise retention during pipe
 backpressure

---
 crates/tysel-engine-qjs/src/p1_tests.rs       | 30 +++++++++++++++++++
 runtime-js/test/runtime.test.mjs              |  3 +-
 .../vendor/web-streams-polyfill/README.md     | 20 +++++++++++--
 .../vendor/web-streams-polyfill/polyfill.js   |  2 +-
 4 files changed, 50 insertions(+), 5 deletions(-)

diff --git a/crates/tysel-engine-qjs/src/p1_tests.rs b/crates/tysel-engine-qjs/src/p1_tests.rs
index 371bd39..891c3fa 100644
--- a/crates/tysel-engine-qjs/src/p1_tests.rs
+++ b/crates/tysel-engine-qjs/src/p1_tests.rs
@@ -831,3 +831,33 @@ fn encoder_stream_processes_more_than_the_heap_without_accumulation() {
     })()"#,IsolateConfig{memory_limit_bytes:4*1024*1024,request_timeout_ms:10000,cpu_ms_per_turn:10000}).unwrap();
     assert_eq!(result, Value::Bool(true));
 }
+
+#[test]
+fn long_small_chunk_pipes_do_not_retain_ready_promise_chains() {
+    for transform in [
+        "new TextEncoderStream()",
+        "new TransformStream({transform(chunk,c){c.enqueue(new TextEncoder().encode(chunk));}})",
+    ] {
+        let source = format!(
+            r#"(async()=>{{
+          let remaining=32768,total=0;
+          const source=new ReadableStream({{pull(c){{if(remaining-- > 0)c.enqueue('a'.repeat(64));else c.close();}}}});
+          for await(const bytes of source.pipeThrough({transform})) {{
+            if(bytes.length!==64||bytes[0]!==97||bytes[63]!==97)return false;
+            total+=bytes.length;
+          }}
+          return total===2*1024*1024;
+        }})()"#
+        );
+        let result = eval(
+            &source,
+            IsolateConfig {
+                memory_limit_bytes: 4 * 1024 * 1024,
+                request_timeout_ms: 10000,
+                cpu_ms_per_turn: 10000,
+            },
+        )
+        .unwrap();
+        assert_eq!(result, Value::Bool(true));
+    }
+}
diff --git a/runtime-js/test/runtime.test.mjs b/runtime-js/test/runtime.test.mjs
index ff2b470..f7cb9fe 100644
--- a/runtime-js/test/runtime.test.mjs
+++ b/runtime-js/test/runtime.test.mjs
@@ -169,7 +169,8 @@ test("vendored Streams snapshot matches its recorded checksum", async () => {
   const root = new URL('../web-api/vendor/web-streams-polyfill/', import.meta.url);
   const bytes = readFileSync(new URL('polyfill.js', root));
   const readme = readFileSync(new URL('README.md', root), 'utf8');
-  assert.ok(readme.includes(createHash('sha256').update(bytes).digest('hex')));
+  const checksum = readme.match(/^polyfill\.js SHA-256: `([a-f0-9]{64})`$/m);
+  assert.equal(createHash('sha256').update(bytes).digest('hex'), checksum?.[1]);
   assert.match(readFileSync(new URL('LICENSE', root), 'utf8'), /Permission is hereby granted/);
   assert.match(bytes.toString(), /web-streams-polyfill v4\.3\.0/);
   assert.ok(readFileSync(new URL('../web-api/runtime.js', import.meta.url), 'utf8').includes(readFileSync(new URL('LICENSE', root), 'utf8').trimEnd()));
diff --git a/runtime-js/web-api/vendor/web-streams-polyfill/README.md b/runtime-js/web-api/vendor/web-streams-polyfill/README.md
index 8d597ae..e2d7802 100644
--- a/runtime-js/web-api/vendor/web-streams-polyfill/README.md
+++ b/runtime-js/web-api/vendor/web-streams-polyfill/README.md
@@ -3,9 +3,10 @@
 web-streams-polyfill 4.3.0, MIT license (see LICENSE).
 Source: https://github.com/MattiasBuelens/web-streams-polyfill/tree/v4.3.0
 Package: https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-4.3.0.tgz
-polyfill.js SHA-256: `30835bf3c9af5236b16126f83512d5daaf5e6b53d93ae4e61efadce775857a95`
+Upstream SHA-256: `30835bf3c9af5236b16126f83512d5daaf5e6b53d93ae4e61efadce775857a95`
+polyfill.js SHA-256: `aa87937bc409a8c6b1588fc848d40241a1e3220a2ff47b0a0460ac2af03a7477`
 
-The unmodified published ES2015 polyfill is embedded by the QuickJS adapter in
+The ES2015 polyfill with the local patch below is embedded by the QuickJS adapter in
 native read-only storage. build-runtime.mjs embeds the full MIT license and a
 lazy loader; first access to a Streams constructor asks the native host to
 evaluate the fixed vendor source. Buffered HTTP bodies use a loader-owned brand
@@ -14,4 +15,17 @@ Update the pinned snapshot, types, license, checksum and QuickJS tests together.
 
 The type snapshot adapts its AbortSignal alias to TyselAbortSignal so explicit
 runtime types compose without depending on the complete ambient DOM interface.
-The runtime polyfill itself is unmodified.
+
+## Local pipe backpressure patch
+
+In `br` (ReadableStreamPipeTo), the `g` pipe step originally returns
+`f(s._readyPromise,g)` while waiting for backpressure to clear. Repeated waits
+retain a chain of adopted promises until piping finishes. On QuickJS this grows
+with the number of chunks and can exhaust the isolate heap.
+
+The snapshot replaces that expression with `f(s._readyPromise,()=>!1)`.
+The existing outer pipe loop receives `false` and schedules the next step after
+readiness, without linking each step's promise to the rest of the transfer.
+Readiness rejection still reaches the existing pipe-loop rejection handler.
+No other vendor runtime code is changed. Reassess this patch on vendor upgrades;
+low-heap long-pipe, cancellation and error-propagation tests cover it.
diff --git a/runtime-js/web-api/vendor/web-streams-polyfill/polyfill.js b/runtime-js/web-api/vendor/web-streams-polyfill/polyfill.js
index f4bca78..bfebd8d 100644
--- a/runtime-js/web-api/vendor/web-streams-polyfill/polyfill.js
+++ b/runtime-js/web-api/vendor/web-streams-polyfill/polyfill.js
@@ -5,4 +5,4 @@
  * This code is released under the MIT license.
  * SPDX-License-Identifier: MIT
  */
-!function(){"use strict";function e(){}function t(e){return"object"==typeof e&&null!==e||"function"==typeof e}const r=e;function o(e,t){try{Object.defineProperty(e,"name",{value:t,configurable:!0})}catch(e){}}const n=Promise,a=Promise.resolve.bind(n),i=Promise.prototype.then,s=Promise.reject.bind(n),l=a;function u(e){return new n(e)}function c(e){return u(t=>t(e))}function d(e){return s(e)}function f(e,t,r){return i.call(e,t,r)}function b(e,t,o){f(f(e,t,o),void 0,r)}function h(e,t){b(e,t)}function _(e,t){b(e,void 0,t)}function m(e,t,r){return f(e,t,r)}function p(e){f(e,void 0,r)}let y=e=>{if("function"==typeof queueMicrotask)y=queueMicrotask;else{const e=c(void 0);y=t=>f(e,t)}return y(e)};function S(e,t,r){if("function"!=typeof e)throw new TypeError("Argument is not a function");return Function.prototype.apply.call(e,t,r)}function g(e,t,r){try{return c(S(e,t,r))}catch(e){return d(e)}}class v{constructor(){this._cursor=0,this._size=0,this._front={_elements:[],_next:void 0},this._back=this._front,this._cursor=0,this._size=0}get length(){return this._size}push(e){const t=this._back;let r=t;16383===t._elements.length&&(r={_elements:[],_next:void 0}),t._elements.push(e),r!==t&&(this._back=r,t._next=r),++this._size}shift(){const e=this._front;let t=e;const r=this._cursor;let o=r+1;const n=e._elements,a=n[r];return 16384===o&&(t=e._next,o=0),--this._size,this._cursor=o,e!==t&&(this._front=t),n[r]=void 0,a}forEach(e){let t=this._cursor,r=this._front,o=r._elements;for(;!(t===o.length&&void 0===r._next||t===o.length&&(r=r._next,o=r._elements,t=0,0===o.length));)e(o[t]),++t}peek(){const e=this._front,t=this._cursor;return e._elements[t]}}const w=Symbol("[[AbortSteps]]"),R=Symbol("[[ErrorSteps]]"),T=Symbol("[[CancelSteps]]"),P=Symbol("[[PullSteps]]"),C=Symbol("[[CanPullSyncSteps]]"),q=Symbol("[[ReleaseSteps]]");function E(e,t){e._ownerReadableStream=t,t._reader=e,"readable"===t._state?j(e):"closed"===t._state?function(e){j(e),z(e)}(e):k(e,t._storedError)}function W(e,t){return Mr(e._ownerReadableStream,t)}function B(e){const t=e._ownerReadableStream;"readable"===t._state?A(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")):function(e,t){k(e,t)}(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")),t._readableStreamController[q](),t._reader=void 0,e._ownerReadableStream=void 0}function O(e){return new TypeError("Cannot "+e+" a stream using a released reader")}function j(e){e._closedPromise=u((t,r)=>{e._closedPromise_resolve=t,e._closedPromise_reject=r})}function k(e,t){j(e),A(e,t)}function A(e,t){void 0!==e._closedPromise_reject&&(p(e._closedPromise),e._closedPromise_reject(t),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}function z(e){void 0!==e._closedPromise_resolve&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}const D=Number.isFinite||function(e){return"number"==typeof e&&isFinite(e)},F=Math.trunc||function(e){return e<0?Math.ceil(e):Math.floor(e)};function L(e,t){if(void 0!==e&&("object"!=typeof(r=e)&&"function"!=typeof r))throw new TypeError(`${t} is not an object.`);var r}function I(e,t){if("function"!=typeof e)throw new TypeError(`${t} is not a function.`)}function $(e,t){if(!function(e){return"object"==typeof e&&null!==e||"function"==typeof e}(e))throw new TypeError(`${t} is not an object.`)}function M(e,t,r){if(void 0===e)throw new TypeError(`Parameter ${t} is required in '${r}'.`)}function Y(e,t,r){if(void 0===e)throw new TypeError(`${t} is required in '${r}'.`)}function Q(e){return Number(e)}function x(e){return 0===e?0:e}function N(e,t){const r=Number.MAX_SAFE_INTEGER;let o=Number(e);if(o=x(o),!D(o))throw new TypeError(`${t} is not a finite number`);if(o=function(e){return x(F(e))}(o),o<0||o>r)throw new TypeError(`${t} is outside the accepted range of 0 to ${r}, inclusive`);return D(o)&&0!==o?o:0}function H(e,t){if(!Ir(e))throw new TypeError(`${t} is not a ReadableStream.`)}function V(e){return new ReadableStreamDefaultReader(e)}function U(e,t){e._reader._readRequests.push(t)}function G(e,t,r){const o=e._reader._readRequests.shift();r?o._closeSteps():o._chunkSteps(t)}function X(e){return e._reader._readRequests.length}function J(e){const t=e._reader;return void 0!==t&&!!ee(t)}class ReadableStreamDefaultReader{constructor(e){if(M(e,1,"ReadableStreamDefaultReader"),H(e,"First parameter"),$r(e))throw new TypeError("This stream has already been locked for exclusive reading by another reader");E(this,e),this._readRequests=new v}get closed(){return ee(this)?this._closedPromise:d(ne("closed"))}cancel(e=void 0){return ee(this)?void 0===this._ownerReadableStream?d(O("cancel")):W(this,e):d(ne("cancel"))}read(){if(!ee(this))return d(ne("read"));if(void 0===this._ownerReadableStream)return d(O("read from"));const e=re(this)?new Z:new K;return te(this,e),e._promise}releaseLock(){if(!ee(this))throw ne("releaseLock");void 0!==this._ownerReadableStream&&function(e){B(e);const t=new TypeError("Reader was released");oe(e,t)}(this)}}Object.defineProperties(ReadableStreamDefaultReader.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),o(ReadableStreamDefaultReader.prototype.cancel,"cancel"),o(ReadableStreamDefaultReader.prototype.read,"read"),o(ReadableStreamDefaultReader.prototype.releaseLock,"releaseLock"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableStreamDefaultReader.prototype,Symbol.toStringTag,{value:"ReadableStreamDefaultReader",configurable:!0});class K{constructor(){this._promise=u((e,t)=>{this._resolvePromise=e,this._rejectPromise=t})}_chunkSteps(e){this._resolvePromise({value:e,done:!1})}_closeSteps(){this._resolvePromise({value:void 0,done:!0})}_errorSteps(e){this._rejectPromise(e)}}class Z{constructor(){this._promise=void 0}_chunkSteps(e){this._promise=l({value:e,done:!1})}_closeSteps(){this._promise=l({value:void 0,done:!0})}_errorSteps(e){this._promise=d(e)}}function ee(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readRequests")&&e instanceof ReadableStreamDefaultReader)}function te(e,t){const r=e._ownerReadableStream;r._disturbed=!0,"closed"===r._state?t._closeSteps():"errored"===r._state?t._errorSteps(r._storedError):r._readableStreamController[P](t)}function re(e){const t=e._ownerReadableStream;return"closed"===t._state||("errored"===t._state||t._readableStreamController[C]())}function oe(e,t){const r=e._readRequests;e._readRequests=new v,r.forEach(e=>{e._errorSteps(t)})}function ne(e){return new TypeError(`ReadableStreamDefaultReader.prototype.${e} can only be used on a ReadableStreamDefaultReader`)}var ae,ie,se;function le(e){return e.slice()}function ue(e,t,r,o,n){new Uint8Array(e).set(new Uint8Array(r,o,n),t)}let ce=e=>(ce="function"==typeof e.transfer?e=>e.transfer():"function"==typeof structuredClone?e=>structuredClone(e,{transfer:[e]}):e=>e,ce(e)),de=e=>(de="boolean"==typeof e.detached?e=>e.detached:e=>0===e.byteLength,de(e));function fe(e,t,r){if(e.slice)return e.slice(t,r);const o=r-t,n=new ArrayBuffer(o);return ue(n,0,e,t,o),n}function be(e,t){const r=e[t];if(null!=r){if("function"!=typeof r)throw new TypeError(`${String(t)} is not a function`);return r}}function he(e){try{const t=e.done,r=e.value;return f(l(r),e=>({done:t,value:e}))}catch(e){return d(e)}}const _e=null!==(se=null!==(ae=Symbol.asyncIterator)&&void 0!==ae?ae:null===(ie=Symbol.for)||void 0===ie?void 0:ie.call(Symbol,"Symbol.asyncIterator"))&&void 0!==se?se:"@@asyncIterator";function me(e,r="sync",o){if(void 0===o)if("async"===r){if(void 0===(o=be(e,_e))){return function(e){const r={next(){let t;try{t=pe(e)}catch(e){return d(e)}return he(t)},return(r){let o;try{const t=be(e.iterator,"return");if(void 0===t)return c({done:!0,value:r});o=S(t,e.iterator,[r])}catch(e){return d(e)}return t(o)?he(o):d(new TypeError("The iterator.return() method must return an object"))}};return{iterator:r,nextMethod:r.next,done:!1}}(me(e,"sync",be(e,Symbol.iterator)))}}else o=be(e,Symbol.iterator);if(void 0===o)throw new TypeError("The object is not iterable");const n=S(o,e,[]);if(!t(n))throw new TypeError("The iterator method must return an object");return{iterator:n,nextMethod:n.next,done:!1}}function pe(e){const r=S(e.nextMethod,e.iterator,[]);if(!t(r))throw new TypeError("The iterator.next() method must return an object");return r}class ye{constructor(e,t){this._ongoingPromise=void 0,this._isFinished=!1,this._reader=e,this._preventCancel=t}next(){const e=()=>this._nextSteps();return this._ongoingPromise=this._ongoingPromise?m(this._ongoingPromise,e,e):e(),this._ongoingPromise}return(e){const t=()=>this._returnSteps(e);return this._ongoingPromise=this._ongoingPromise?m(this._ongoingPromise,t,t):t(),this._ongoingPromise}_nextSteps(){if(this._isFinished)return Promise.resolve({value:void 0,done:!0});const e=this._reader,t=new Se(this);return te(e,t),t._promise}_returnSteps(e){if(this._isFinished)return Promise.resolve({value:e,done:!0});this._isFinished=!0;const t=this._reader;if(!this._preventCancel){const r=W(t,e);return B(t),m(r,()=>({value:e,done:!0}))}return B(t),c({value:e,done:!0})}}class Se{constructor(e){this._iterator=e,this._promise=u((e,t)=>{this._resolvePromise=e,this._rejectPromise=t})}_chunkSteps(e){this._iterator._ongoingPromise=void 0,y(()=>this._resolvePromise({value:e,done:!1}))}_closeSteps(){const e=this._iterator;e._ongoingPromise=void 0,e._isFinished=!0,B(e._reader),this._resolvePromise({value:void 0,done:!0})}_errorSteps(e){const t=this._iterator;t._ongoingPromise=void 0,t._isFinished=!0,B(t._reader),this._rejectPromise(e)}}const ge={next(){return ve(this)?this._asyncIteratorImpl.next():d(we("next"))},return(e){return ve(this)?this._asyncIteratorImpl.return(e):d(we("return"))},[_e](){return this}};function ve(e){if(!t(e))return!1;if(!Object.prototype.hasOwnProperty.call(e,"_asyncIteratorImpl"))return!1;try{return e._asyncIteratorImpl instanceof ye}catch(e){return!1}}function we(e){return new TypeError(`ReadableStreamAsyncIterator.${e} can only be used on a ReadableSteamAsyncIterator`)}Object.defineProperty(ge,_e,{enumerable:!1});const Re=Number.isNaN||function(e){return e!=e};function Te(e){const t=fe(e.buffer,e.byteOffset,e.byteOffset+e.byteLength);return new Uint8Array(t)}function Pe(e){const t=e._queue.shift();return e._queueTotalSize-=t.size,e._queueTotalSize<0&&(e._queueTotalSize=0),t.value}function Ce(e,t,r){if("number"!=typeof(o=r)||Re(o)||o<0||r===1/0)throw new RangeError("Size must be a finite, non-NaN, non-negative number.");var o;e._queue.push({value:t,size:r}),e._queueTotalSize+=r}function qe(e){e._queue=new v,e._queueTotalSize=0}function Ee(e){return e===DataView}function We(e){return Ee(e)?1:e.BYTES_PER_ELEMENT}class ReadableStreamBYOBRequest{constructor(){throw new TypeError("Illegal constructor")}get view(){if(!Oe(this))throw ot("view");return this._view}respond(e){if(!Oe(this))throw ot("respond");if(M(e,1,"respond"),e=N(e,"First parameter"),void 0===this._associatedReadableByteStreamController)throw new TypeError("This BYOB request has been invalidated");if(de(this._view.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");et(this._associatedReadableByteStreamController,e)}respondWithNewView(e){if(!Oe(this))throw ot("respondWithNewView");if(M(e,1,"respondWithNewView"),!ArrayBuffer.isView(e))throw new TypeError("You can only respond with array buffer views");if(void 0===this._associatedReadableByteStreamController)throw new TypeError("This BYOB request has been invalidated");if(de(e.buffer))throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");tt(this._associatedReadableByteStreamController,e)}}Object.defineProperties(ReadableStreamBYOBRequest.prototype,{respond:{enumerable:!0},respondWithNewView:{enumerable:!0},view:{enumerable:!0}}),o(ReadableStreamBYOBRequest.prototype.respond,"respond"),o(ReadableStreamBYOBRequest.prototype.respondWithNewView,"respondWithNewView"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableStreamBYOBRequest.prototype,Symbol.toStringTag,{value:"ReadableStreamBYOBRequest",configurable:!0});class ReadableByteStreamController{constructor(){throw new TypeError("Illegal constructor")}get byobRequest(){if(!Be(this))throw nt("byobRequest");return Ke(this)}get desiredSize(){if(!Be(this))throw nt("desiredSize");return Ze(this)}close(){if(!Be(this))throw nt("close");if(this._closeRequested)throw new TypeError("The stream has already been closed; do not close it again!");const e=this._controlledReadableByteStream._state;if("readable"!==e)throw new TypeError(`The stream (in ${e} state) is not in the readable state and cannot be closed`);Ue(this)}enqueue(e){if(!Be(this))throw nt("enqueue");if(M(e,1,"enqueue"),!ArrayBuffer.isView(e))throw new TypeError("chunk must be an array buffer view");if(0===e.byteLength)throw new TypeError("chunk must have non-zero byteLength");if(0===e.buffer.byteLength)throw new TypeError("chunk's buffer must have non-zero byteLength");if(this._closeRequested)throw new TypeError("stream is closed or draining");const t=this._controlledReadableByteStream._state;if("readable"!==t)throw new TypeError(`The stream (in ${t} state) is not in the readable state and cannot be enqueued to`);Ge(this,e)}error(e=void 0){if(!Be(this))throw nt("error");Xe(this,e)}[T](e){ke(this),qe(this);const t=this._cancelAlgorithm(e);return Ve(this),t}[P](e){const t=this._controlledReadableByteStream;if(this._queueTotalSize>0)return void Je(this,e);const r=this._autoAllocateChunkSize;if(void 0!==r){let t;try{t=new ArrayBuffer(r)}catch(t){return void e._errorSteps(t)}const o={buffer:t,bufferByteLength:r,byteOffset:0,byteLength:r,bytesFilled:0,minimumFill:1,elementSize:1,viewConstructor:Uint8Array,readerType:"default"};this._pendingPullIntos.push(o)}U(t,e),je(this)}[C](){return this._queueTotalSize>0}[q](){if(this._pendingPullIntos.length>0){const e=this._pendingPullIntos.peek();e.readerType="none",this._pendingPullIntos=new v,this._pendingPullIntos.push(e)}}}function Be(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledReadableByteStream")&&e instanceof ReadableByteStreamController)}function Oe(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_associatedReadableByteStreamController")&&e instanceof ReadableStreamBYOBRequest)}function je(e){const t=function(e){const t=e._controlledReadableByteStream;if("readable"!==t._state)return!1;if(e._closeRequested)return!1;if(!e._started)return!1;if(J(t)&&X(t)>0)return!0;if(ut(t)&&lt(t)>0)return!0;const r=Ze(e);if(r>0)return!0;return!1}(e);if(!t)return;if(e._pulling)return void(e._pullAgain=!0);e._pulling=!0;b(e._pullAlgorithm(),()=>(e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,je(e)),null),t=>(Xe(e,t),null))}function ke(e){Qe(e),e._pendingPullIntos=new v}function Ae(e,t){let r=!1;"closed"===e._state&&(r=!0);const o=De(t);"default"===t.readerType?G(e,o,r):function(e,t,r){const o=e._reader,n=o._readIntoRequests.shift();r?n._closeSteps(t):n._chunkSteps(t)}(e,o,r)}function ze(e,t){for(let r=0;r<t.length;++r)Ae(e,t[r])}function De(e){const t=e.bytesFilled,r=e.elementSize;return new e.viewConstructor(e.buffer,e.byteOffset,t/r)}function Fe(e,t,r,o){e._queue.push({buffer:t,byteOffset:r,byteLength:o}),e._queueTotalSize+=o}function Le(e,t,r,o){let n;try{n=fe(t,r,r+o)}catch(t){throw Xe(e,t),t}Fe(e,n,0,o)}function Ie(e,t){t.bytesFilled>0&&Le(e,t.buffer,t.byteOffset,t.bytesFilled),He(e)}function $e(e,t){const r=Math.min(e._queueTotalSize,t.byteLength-t.bytesFilled),o=t.bytesFilled+r;let n=r,a=!1;const i=o-o%t.elementSize;i>=t.minimumFill&&(n=i-t.bytesFilled,a=!0);const s=e._queue;for(;n>0;){const r=s.peek(),o=Math.min(n,r.byteLength),a=t.byteOffset+t.bytesFilled;ue(t.buffer,a,r.buffer,r.byteOffset,o),r.byteLength===o?s.shift():(r.byteOffset+=o,r.byteLength-=o),e._queueTotalSize-=o,Me(e,o,t),n-=o}return a}function Me(e,t,r){r.bytesFilled+=t}function Ye(e){0===e._queueTotalSize&&e._closeRequested?(Ve(e),Yr(e._controlledReadableByteStream)):je(e)}function Qe(e){null!==e._byobRequest&&(e._byobRequest._associatedReadableByteStreamController=void 0,e._byobRequest._view=null,e._byobRequest=null)}function xe(e){const t=[];for(;e._pendingPullIntos.length>0&&0!==e._queueTotalSize;){const r=e._pendingPullIntos.peek();$e(e,r)&&(He(e),t.push(r))}return t}function Ne(e,t){const r=e._pendingPullIntos.peek();Qe(e);"closed"===e._controlledReadableByteStream._state?function(e,t){"none"===t.readerType&&He(e);const r=e._controlledReadableByteStream;if(ut(r)){const t=[];for(;t.length<lt(r);)t.push(He(e));ze(r,t)}}(e,r):function(e,t,r){if(Me(0,t,r),"none"===r.readerType){Ie(e,r);const t=xe(e);return void ze(e._controlledReadableByteStream,t)}if(r.bytesFilled<r.minimumFill)return;He(e);const o=r.bytesFilled%r.elementSize;if(o>0){const t=r.byteOffset+r.bytesFilled;Le(e,r.buffer,t-o,o)}r.bytesFilled-=o;const n=xe(e);Ae(e._controlledReadableByteStream,r),ze(e._controlledReadableByteStream,n)}(e,t,r),je(e)}function He(e){return e._pendingPullIntos.shift()}function Ve(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0}function Ue(e){const t=e._controlledReadableByteStream;if(!e._closeRequested&&"readable"===t._state)if(e._queueTotalSize>0)e._closeRequested=!0;else{if(e._pendingPullIntos.length>0){const t=e._pendingPullIntos.peek();if(t.bytesFilled%t.elementSize!==0){const t=new TypeError("Insufficient bytes to fill elements in the given buffer");throw Xe(e,t),t}}Ve(e),Yr(t)}}function Ge(e,t){const r=e._controlledReadableByteStream;if(e._closeRequested||"readable"!==r._state)return;const{buffer:o,byteOffset:n,byteLength:a}=t;if(de(o))throw new TypeError("chunk's buffer is detached and so cannot be enqueued");const i=ce(o);if(e._pendingPullIntos.length>0){const t=e._pendingPullIntos.peek();if(de(t.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");Qe(e),t.buffer=ce(t.buffer),"none"===t.readerType&&Ie(e,t)}if(J(r))if(function(e){const t=e._controlledReadableByteStream._reader;for(;t._readRequests.length>0;){if(0===e._queueTotalSize)return;Je(e,t._readRequests.shift())}}(e),0===X(r))Fe(e,i,n,a);else{e._pendingPullIntos.length>0&&He(e);G(r,new Uint8Array(i,n,a),!1)}else if(ut(r)){Fe(e,i,n,a);ze(r,xe(e))}else Fe(e,i,n,a);je(e)}function Xe(e,t){const r=e._controlledReadableByteStream;"readable"===r._state&&(ke(e),qe(e),Ve(e),Qr(r,t))}function Je(e,t){const r=e._queue.shift();e._queueTotalSize-=r.byteLength,Ye(e);const o=new Uint8Array(r.buffer,r.byteOffset,r.byteLength);t._chunkSteps(o)}function Ke(e){if(null===e._byobRequest&&e._pendingPullIntos.length>0){const t=e._pendingPullIntos.peek(),r=new Uint8Array(t.buffer,t.byteOffset+t.bytesFilled,t.byteLength-t.bytesFilled),o=Object.create(ReadableStreamBYOBRequest.prototype);!function(e,t,r){e._associatedReadableByteStreamController=t,e._view=r}(o,e,r),e._byobRequest=o}return e._byobRequest}function Ze(e){const t=e._controlledReadableByteStream._state;return"errored"===t?null:"closed"===t?0:e._strategyHWM-e._queueTotalSize}function et(e,t){const r=e._pendingPullIntos.peek();if("closed"===e._controlledReadableByteStream._state){if(0!==t)throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream")}else{if(0===t)throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");if(r.bytesFilled+t>r.byteLength)throw new RangeError("bytesWritten out of range")}r.buffer=ce(r.buffer),Ne(e,t)}function tt(e,t){const r=e._pendingPullIntos.peek();if("closed"===e._controlledReadableByteStream._state){if(0!==t.byteLength)throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream")}else if(0===t.byteLength)throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");if(r.byteOffset+r.bytesFilled!==t.byteOffset)throw new RangeError("The region specified by view does not match byobRequest");if(r.bufferByteLength!==t.buffer.byteLength)throw new RangeError("The buffer of view has different capacity than byobRequest");if(r.bytesFilled+t.byteLength>r.byteLength)throw new RangeError("The region specified by view is larger than byobRequest");const o=t.byteLength;r.buffer=ce(t.buffer),Ne(e,o)}function rt(e,t,r,o,n,a,i){t._controlledReadableByteStream=e,t._pullAgain=!1,t._pulling=!1,t._byobRequest=null,t._queue=t._queueTotalSize=void 0,qe(t),t._closeRequested=!1,t._started=!1,t._strategyHWM=a,t._pullAlgorithm=o,t._cancelAlgorithm=n,t._autoAllocateChunkSize=i,t._pendingPullIntos=new v,e._readableStreamController=t;b(c(r()),()=>(t._started=!0,je(t),null),e=>(Xe(t,e),null))}function ot(e){return new TypeError(`ReadableStreamBYOBRequest.prototype.${e} can only be used on a ReadableStreamBYOBRequest`)}function nt(e){return new TypeError(`ReadableByteStreamController.prototype.${e} can only be used on a ReadableByteStreamController`)}function at(e,t){if("byob"!==(e=`${e}`))throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamReaderMode`);return e}function it(e){return new ReadableStreamBYOBReader(e)}function st(e,t){e._reader._readIntoRequests.push(t)}function lt(e){return e._reader._readIntoRequests.length}function ut(e){const t=e._reader;return void 0!==t&&!!ft(t)}Object.defineProperties(ReadableByteStreamController.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},byobRequest:{enumerable:!0},desiredSize:{enumerable:!0}}),o(ReadableByteStreamController.prototype.close,"close"),o(ReadableByteStreamController.prototype.enqueue,"enqueue"),o(ReadableByteStreamController.prototype.error,"error"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableByteStreamController.prototype,Symbol.toStringTag,{value:"ReadableByteStreamController",configurable:!0});class ReadableStreamBYOBReader{constructor(e){if(M(e,1,"ReadableStreamBYOBReader"),H(e,"First parameter"),$r(e))throw new TypeError("This stream has already been locked for exclusive reading by another reader");if(!Be(e._readableStreamController))throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");E(this,e),this._readIntoRequests=new v}get closed(){return ft(this)?this._closedPromise:d(_t("closed"))}cancel(e=void 0){return ft(this)?void 0===this._ownerReadableStream?d(O("cancel")):W(this,e):d(_t("cancel"))}read(e,t={}){if(!ft(this))return d(_t("read"));if(!ArrayBuffer.isView(e))return d(new TypeError("view must be an array buffer view"));if(0===e.byteLength)return d(new TypeError("view must have non-zero byteLength"));if(0===e.buffer.byteLength)return d(new TypeError("view's buffer must have non-zero byteLength"));if(de(e.buffer))return d(new TypeError("view's buffer has been detached"));let r;try{r=function(e,t){var r;return L(e,t),{min:N(null!==(r=null==e?void 0:e.min)&&void 0!==r?r:1,`${t} has member 'min' that`)}}(t,"options")}catch(e){return d(e)}const o=r.min;if(0===o)return d(new TypeError("options.min must be greater than 0"));if(function(e){return Ee(e.constructor)}(e)){if(o>e.byteLength)return d(new RangeError("options.min must be less than or equal to view's byteLength"))}else if(o>e.length)return d(new RangeError("options.min must be less than or equal to view's length"));if(void 0===this._ownerReadableStream)return d(O("read from"));const n=function(e,t,r){const o=e._ownerReadableStream;return"errored"===o._state||function(e,t,r){const o=e._controlledReadableByteStream,n=We(t.constructor),{byteLength:a}=t,i=r*n;return!(e._pendingPullIntos.length>0)&&("closed"===o._state||e._queueTotalSize>=i)}(o._readableStreamController,t,r)}(this,e,o)?new dt:new ct;return bt(this,e,o,n),n._promise}releaseLock(){if(!ft(this))throw _t("releaseLock");void 0!==this._ownerReadableStream&&function(e){B(e);const t=new TypeError("Reader was released");ht(e,t)}(this)}}Object.defineProperties(ReadableStreamBYOBReader.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),o(ReadableStreamBYOBReader.prototype.cancel,"cancel"),o(ReadableStreamBYOBReader.prototype.read,"read"),o(ReadableStreamBYOBReader.prototype.releaseLock,"releaseLock"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableStreamBYOBReader.prototype,Symbol.toStringTag,{value:"ReadableStreamBYOBReader",configurable:!0});class ct{constructor(){this._promise=u((e,t)=>{this._resolvePromise=e,this._rejectPromise=t})}_chunkSteps(e){this._resolvePromise({value:e,done:!1})}_closeSteps(e){this._resolvePromise({value:e,done:!0})}_errorSteps(e){this._rejectPromise(e)}}class dt{constructor(){this._promise=void 0}_chunkSteps(e){this._promise=l({value:e,done:!1})}_closeSteps(e){this._promise=l({value:e,done:!0})}_errorSteps(e){this._promise=d(e)}}function ft(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readIntoRequests")&&e instanceof ReadableStreamBYOBReader)}function bt(e,t,r,o){const n=e._ownerReadableStream;n._disturbed=!0,"errored"===n._state?o._errorSteps(n._storedError):function(e,t,r,o){const n=e._controlledReadableByteStream,a=t.constructor,i=We(a),{byteOffset:s,byteLength:l}=t,u=r*i;let c;try{c=ce(t.buffer)}catch(e){return void o._errorSteps(e)}const d={buffer:c,bufferByteLength:c.byteLength,byteOffset:s,byteLength:l,bytesFilled:0,minimumFill:u,elementSize:i,viewConstructor:a,readerType:"byob"};if(e._pendingPullIntos.length>0)return e._pendingPullIntos.push(d),void st(n,o);if("closed"===n._state){const e=new a(d.buffer,d.byteOffset,0);return void o._closeSteps(e)}if(e._queueTotalSize>0){if($e(e,d)){const t=De(d);return Ye(e),void o._chunkSteps(t)}if(e._closeRequested){const t=new TypeError("Insufficient bytes to fill elements in the given buffer");return Xe(e,t),void o._errorSteps(t)}}e._pendingPullIntos.push(d),st(n,o),je(e)}(n._readableStreamController,t,r,o)}function ht(e,t){const r=e._readIntoRequests;e._readIntoRequests=new v,r.forEach(e=>{e._errorSteps(t)})}function _t(e){return new TypeError(`ReadableStreamBYOBReader.prototype.${e} can only be used on a ReadableStreamBYOBReader`)}function mt(e,t){const{highWaterMark:r}=e;if(void 0===r)return t;if(Re(r)||r<0)throw new RangeError("Invalid highWaterMark");return r}function pt(e){const{size:t}=e;return t||(()=>1)}function yt(e,t){L(e,t);const r=null==e?void 0:e.highWaterMark,o=null==e?void 0:e.size;return{highWaterMark:void 0===r?void 0:Q(r),size:void 0===o?void 0:St(o,`${t} has member 'size' that`)}}function St(e,t){return I(e,t),t=>Q(e(t))}function gt(e,t,r){return I(e,r),r=>g(e,t,[r])}function vt(e,t,r){return I(e,r),()=>g(e,t,[])}function wt(e,t,r){return I(e,r),r=>S(e,t,[r])}function Rt(e,t,r){return I(e,r),(r,o)=>g(e,t,[r,o])}function Tt(e,t){if(!qt(e))throw new TypeError(`${t} is not a WritableStream.`)}class WritableStream{constructor(e={},t={}){void 0===e?e=null:$(e,"First parameter");const r=yt(t,"Second parameter"),o=function(e,t){L(e,t);const r=null==e?void 0:e.abort,o=null==e?void 0:e.close,n=null==e?void 0:e.start,a=null==e?void 0:e.type,i=null==e?void 0:e.write;return{abort:void 0===r?void 0:gt(r,e,`${t} has member 'abort' that`),close:void 0===o?void 0:vt(o,e,`${t} has member 'close' that`),start:void 0===n?void 0:wt(n,e,`${t} has member 'start' that`),write:void 0===i?void 0:Rt(i,e,`${t} has member 'write' that`),type:a}}(e,"First parameter");Ct(this);if(void 0!==o.type)throw new RangeError("Invalid type is specified");const n=pt(r);!function(e,t,r,o){const n=Object.create(WritableStreamDefaultController.prototype);let a,i,s,l;a=void 0!==t.start?()=>t.start(n):()=>{};i=void 0!==t.write?e=>t.write(e,n):()=>c(void 0);s=void 0!==t.close?()=>t.close():()=>c(void 0);l=void 0!==t.abort?e=>t.abort(e):()=>c(void 0);Nt(e,n,a,i,s,l,r,o)}(this,o,mt(r,1),n)}get locked(){if(!qt(this))throw Kt("locked");return Et(this)}abort(e=void 0){return qt(this)?Et(this)?d(new TypeError("Cannot abort a stream that already has a writer")):Wt(this,e):d(Kt("abort"))}close(){return qt(this)?Et(this)?d(new TypeError("Cannot close a stream that already has a writer")):At(this)?d(new TypeError("Cannot close an already-closing stream")):Bt(this):d(Kt("close"))}getWriter(){if(!qt(this))throw Kt("getWriter");return Pt(this)}}function Pt(e){return new WritableStreamDefaultWriter(e)}function Ct(e){e._state="writable",e._storedError=void 0,e._writer=void 0,e._writableStreamController=void 0,e._writeRequests=new v,e._inFlightWriteRequest=void 0,e._closeRequest=void 0,e._inFlightCloseRequest=void 0,e._pendingAbortRequest=void 0,e._backpressure=!1}function qt(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_writableStreamController")&&e instanceof WritableStream)}function Et(e){return void 0!==e._writer}function Wt(e,t){var r;if("closed"===e._state||"errored"===e._state)return c(void 0);e._writableStreamController._abortReason=t,null===(r=e._writableStreamController._abortController)||void 0===r||r.abort(t);const o=e._state;if("closed"===o||"errored"===o)return c(void 0);if(void 0!==e._pendingAbortRequest)return e._pendingAbortRequest._promise;let n=!1;"erroring"===o&&(n=!0,t=void 0);const a=u((r,o)=>{e._pendingAbortRequest={_promise:void 0,_resolve:r,_reject:o,_reason:t,_wasAlreadyErroring:n}});return e._pendingAbortRequest._promise=a,n||jt(e,t),a}function Bt(e){const t=e._state;if("closed"===t||"errored"===t)return d(new TypeError(`The stream (in ${t} state) is not in the writable state and cannot be closed`));const r=u((t,r)=>{const o={_resolve:t,_reject:r};e._closeRequest=o}),o=e._writer;var n;return void 0!==o&&e._backpressure&&"writable"===t&&cr(o),Ce(n=e._writableStreamController,Qt,0),Ut(n),r}function Ot(e,t){"writable"!==e._state?kt(e):jt(e,t)}function jt(e,t){const r=e._writableStreamController;e._state="erroring",e._storedError=t;const o=e._writer;void 0!==o&&$t(o,t),!function(e){if(void 0===e._inFlightWriteRequest&&void 0===e._inFlightCloseRequest)return!1;return!0}(e)&&r._started&&kt(e)}function kt(e){e._state="errored",e._writableStreamController[R]();const t=e._storedError;if(e._writeRequests.forEach(e=>{e._reject(t)}),e._writeRequests=new v,void 0===e._pendingAbortRequest)return void zt(e);const r=e._pendingAbortRequest;if(e._pendingAbortRequest=void 0,r._wasAlreadyErroring)return r._reject(t),void zt(e);b(e._writableStreamController[w](r._reason),()=>(r._resolve(),zt(e),null),t=>(r._reject(t),zt(e),null))}function At(e){return void 0!==e._closeRequest||void 0!==e._inFlightCloseRequest}function zt(e){void 0!==e._closeRequest&&(e._closeRequest._reject(e._storedError),e._closeRequest=void 0);const t=e._writer;void 0!==t&&nr(t,e._storedError)}function Dt(e,t){const r=e._writer;void 0!==r&&t!==e._backpressure&&(t?function(e){ir(e)}(r):cr(r)),e._backpressure=t}Object.defineProperties(WritableStream.prototype,{abort:{enumerable:!0},close:{enumerable:!0},getWriter:{enumerable:!0},locked:{enumerable:!0}}),o(WritableStream.prototype.abort,"abort"),o(WritableStream.prototype.close,"close"),o(WritableStream.prototype.getWriter,"getWriter"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(WritableStream.prototype,Symbol.toStringTag,{value:"WritableStream",configurable:!0});class WritableStreamDefaultWriter{constructor(e){if(M(e,1,"WritableStreamDefaultWriter"),Tt(e,"First parameter"),Et(e))throw new TypeError("This stream has already been locked for exclusive writing by another writer");this._ownerWritableStream=e,e._writer=this;const t=e._state;if("writable"===t)!At(e)&&e._backpressure?ir(this):lr(this),rr(this);else if("erroring"===t)sr(this,e._storedError),rr(this);else if("closed"===t)lr(this),rr(r=this),ar(r);else{const t=e._storedError;sr(this,t),or(this,t)}var r}get closed(){return Ft(this)?this._closedPromise:d(er("closed"))}get desiredSize(){if(!Ft(this))throw er("desiredSize");if(void 0===this._ownerWritableStream)throw tr("desiredSize");return function(e){const t=e._ownerWritableStream,r=t._state;if("errored"===r||"erroring"===r)return null;if("closed"===r)return 0;return Vt(t._writableStreamController)}(this)}get ready(){return Ft(this)?this._readyPromise:d(er("ready"))}abort(e=void 0){return Ft(this)?void 0===this._ownerWritableStream?d(tr("abort")):function(e,t){return Wt(e._ownerWritableStream,t)}(this,e):d(er("abort"))}close(){if(!Ft(this))return d(er("close"));const e=this._ownerWritableStream;return void 0===e?d(tr("close")):At(e)?d(new TypeError("Cannot close an already-closing stream")):Lt(this)}releaseLock(){if(!Ft(this))throw er("releaseLock");void 0!==this._ownerWritableStream&&Mt(this)}write(e=void 0){return Ft(this)?void 0===this._ownerWritableStream?d(tr("write to")):Yt(this,e):d(er("write"))}}function Ft(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_ownerWritableStream")&&e instanceof WritableStreamDefaultWriter)}function Lt(e){return Bt(e._ownerWritableStream)}function It(e,t){"pending"===e._closedPromiseState?nr(e,t):function(e,t){or(e,t)}(e,t)}function $t(e,t){"pending"===e._readyPromiseState?ur(e,t):function(e,t){sr(e,t)}(e,t)}function Mt(e){const t=e._ownerWritableStream,r=new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");$t(e,r),It(e,r),t._writer=void 0,e._ownerWritableStream=void 0}function Yt(e,t){const r=e._ownerWritableStream,o=r._writableStreamController,n=function(e,t){if(void 0===e._strategySizeAlgorithm)return 1;try{return e._strategySizeAlgorithm(t)}catch(t){return Gt(e,t),1}}(o,t);if(r!==e._ownerWritableStream)return d(tr("write to"));const a=r._state;if("errored"===a)return d(r._storedError);if(At(r)||"closed"===a)return d(new TypeError("The stream is closing or closed and cannot be written to"));if("erroring"===a)return d(r._storedError);const i=function(e){return u((t,r)=>{const o={_resolve:t,_reject:r};e._writeRequests.push(o)})}(r);return function(e,t,r){try{Ce(e,t,r)}catch(t){return void Gt(e,t)}const o=e._controlledWritableStream;if(!At(o)&&"writable"===o._state){Dt(o,Xt(e))}Ut(e)}(o,t,n),i}Object.defineProperties(WritableStreamDefaultWriter.prototype,{abort:{enumerable:!0},close:{enumerable:!0},releaseLock:{enumerable:!0},write:{enumerable:!0},closed:{enumerable:!0},desiredSize:{enumerable:!0},ready:{enumerable:!0}}),o(WritableStreamDefaultWriter.prototype.abort,"abort"),o(WritableStreamDefaultWriter.prototype.close,"close"),o(WritableStreamDefaultWriter.prototype.releaseLock,"releaseLock"),o(WritableStreamDefaultWriter.prototype.write,"write"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(WritableStreamDefaultWriter.prototype,Symbol.toStringTag,{value:"WritableStreamDefaultWriter",configurable:!0});const Qt={};class WritableStreamDefaultController{constructor(){throw new TypeError("Illegal constructor")}get abortReason(){if(!xt(this))throw Zt("abortReason");return this._abortReason}get signal(){if(!xt(this))throw Zt("signal");if(void 0===this._abortController)throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");return this._abortController.signal}error(e=void 0){if(!xt(this))throw Zt("error");"writable"===this._controlledWritableStream._state&&Jt(this,e)}[w](e){const t=this._abortAlgorithm(e);return Ht(this),t}[R](){qe(this)}}function xt(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledWritableStream")&&e instanceof WritableStreamDefaultController)}function Nt(e,t,r,o,n,a,i,s){t._controlledWritableStream=e,e._writableStreamController=t,t._queue=void 0,t._queueTotalSize=void 0,qe(t),t._abortReason=void 0,t._abortController=function(){if("function"==typeof AbortController)return new AbortController}(),t._started=!1,t._strategySizeAlgorithm=s,t._strategyHWM=i,t._writeAlgorithm=o,t._closeAlgorithm=n,t._abortAlgorithm=a;const l=Xt(t);Dt(e,l);b(c(r()),()=>(t._started=!0,Ut(t),null),r=>(t._started=!0,Ot(e,r),null))}function Ht(e){e._writeAlgorithm=void 0,e._closeAlgorithm=void 0,e._abortAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function Vt(e){return e._strategyHWM-e._queueTotalSize}function Ut(e){const t=e._controlledWritableStream;if(!e._started)return;if(void 0!==t._inFlightWriteRequest)return;if("erroring"===t._state)return void kt(t);if(0===e._queue.length)return;const r=e._queue.peek().value;r===Qt?function(e){const t=e._controlledWritableStream;(function(e){e._inFlightCloseRequest=e._closeRequest,e._closeRequest=void 0})(t),Pe(e);const r=e._closeAlgorithm();Ht(e),b(r,()=>(function(e){e._inFlightCloseRequest._resolve(void 0),e._inFlightCloseRequest=void 0,"erroring"===e._state&&(e._storedError=void 0,void 0!==e._pendingAbortRequest&&(e._pendingAbortRequest._resolve(),e._pendingAbortRequest=void 0)),e._state="closed";const t=e._writer;void 0!==t&&ar(t)}(t),null),e=>(function(e,t){e._inFlightCloseRequest._reject(t),e._inFlightCloseRequest=void 0,void 0!==e._pendingAbortRequest&&(e._pendingAbortRequest._reject(t),e._pendingAbortRequest=void 0),Ot(e,t)}(t,e),null))}(e):function(e,t){const r=e._controlledWritableStream;!function(e){e._inFlightWriteRequest=e._writeRequests.shift()}(r);const o=e._writeAlgorithm(t);b(o,()=>{!function(e){e._inFlightWriteRequest._resolve(void 0),e._inFlightWriteRequest=void 0}(r);const t=r._state;if(Pe(e),!At(r)&&"writable"===t){const t=Xt(e);Dt(r,t)}return Ut(e),null},t=>("writable"===r._state&&Ht(e),function(e,t){e._inFlightWriteRequest._reject(t),e._inFlightWriteRequest=void 0,Ot(e,t)}(r,t),null))}(e,r)}function Gt(e,t){"writable"===e._controlledWritableStream._state&&Jt(e,t)}function Xt(e){return Vt(e)<=0}function Jt(e,t){const r=e._controlledWritableStream;Ht(e),jt(r,t)}function Kt(e){return new TypeError(`WritableStream.prototype.${e} can only be used on a WritableStream`)}function Zt(e){return new TypeError(`WritableStreamDefaultController.prototype.${e} can only be used on a WritableStreamDefaultController`)}function er(e){return new TypeError(`WritableStreamDefaultWriter.prototype.${e} can only be used on a WritableStreamDefaultWriter`)}function tr(e){return new TypeError("Cannot "+e+" a stream using a released writer")}function rr(e){e._closedPromise=u((t,r)=>{e._closedPromise_resolve=t,e._closedPromise_reject=r,e._closedPromiseState="pending"})}function or(e,t){rr(e),nr(e,t)}function nr(e,t){void 0!==e._closedPromise_reject&&(p(e._closedPromise),e._closedPromise_reject(t),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="rejected")}function ar(e){void 0!==e._closedPromise_resolve&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="resolved")}function ir(e){e._readyPromise=u((t,r)=>{e._readyPromise_resolve=t,e._readyPromise_reject=r}),e._readyPromiseState="pending"}function sr(e,t){ir(e),ur(e,t)}function lr(e){ir(e),cr(e)}function ur(e,t){void 0!==e._readyPromise_reject&&(p(e._readyPromise),e._readyPromise_reject(t),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="rejected")}function cr(e){void 0!==e._readyPromise_resolve&&(e._readyPromise_resolve(void 0),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="fulfilled")}Object.defineProperties(WritableStreamDefaultController.prototype,{abortReason:{enumerable:!0},signal:{enumerable:!0},error:{enumerable:!0}}),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(WritableStreamDefaultController.prototype,Symbol.toStringTag,{value:"WritableStreamDefaultController",configurable:!0});const dr="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:"undefined"!=typeof global?global:void 0;const fr=function(){const e=null==dr?void 0:dr.DOMException;return function(e){if("function"!=typeof e&&"object"!=typeof e)return!1;if("DOMException"!==e.name)return!1;try{return new e,!0}catch(e){return!1}}(e)?e:void 0}()||function(){const e=function(e,t){this.message=e||"",this.name=t||"Error",Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)};return o(e,"DOMException"),e.prototype=Object.create(Error.prototype),Object.defineProperty(e.prototype,"constructor",{value:e,writable:!0,configurable:!0}),e}();function br(e,t,r,o,n,a){const i=V(e),s=Pt(t);e._disturbed=!0;const l=new hr(s),_=new mr(l);return u((m,y)=>{let S;if(void 0!==a){if(S=()=>{const r=void 0!==a.reason?a.reason:new fr("Aborted","AbortError"),i=[];o||i.push(()=>"writable"===t._state?Wt(t,r):c(void 0)),n||i.push(()=>"readable"===e._state?Mr(e,r):c(void 0)),T(()=>Promise.all(i.map(e=>e())),!0,r)},a.aborted)return void S();a.addEventListener("abort",S)}function g(){for(;!l._shuttingDown&&!t._backpressure&&"writable"===t._state&&!At(t)&&"readable"===e._state&&re(i);)te(i,_);if(l._shuttingDown)return c(!0);if(t._backpressure)return f(s._readyPromise,g);const r=new _r(l);return te(i,r),r._promise}var v,w,R;if(pr(e,i._closedPromise,e=>(o?P(!0,e):T(()=>Wt(t,e),!0,e),null)),pr(t,s._closedPromise,t=>(n?P(!0,t):T(()=>Mr(e,t),!0,t),null)),v=e,w=i._closedPromise,R=()=>(r?P():T(()=>function(e){const t=e._ownerWritableStream,r=t._state;return At(t)||"closed"===r?c(void 0):"errored"===r?d(t._storedError):Lt(e)}(s)),null),"closed"===v._state?R():h(w,R),At(t)||"closed"===t._state){const t=new TypeError("the destination writable stream closed before all data could be piped to it");n?P(!0,t):T(()=>Mr(e,t),!0,t)}function T(e,r,o){function n(){return b(e(),()=>C(r,o),e=>C(!0,e)),null}l._shuttingDown||(l._shuttingDown=!0,"writable"!==t._state||At(t)?n():h(l._waitForWritesToFinish(),n))}function P(e,r){l._shuttingDown||(l._shuttingDown=!0,"writable"!==t._state||At(t)?C(e,r):h(l._waitForWritesToFinish(),()=>C(e,r)))}function C(e,t){return Mt(s),B(i),void 0!==a&&a.removeEventListener("abort",S),e?y(t):m(void 0),null}p(u((e,t)=>{!function r(o){o?e():f(g(),r,t)}(!1)}))})}class hr{constructor(e){this._writer=e,this._shuttingDown=!1,this._currentWrite=c(void 0)}_waitForWritesToFinish(){const e=this._currentWrite;return f(this._currentWrite,()=>e!==this._currentWrite?this._waitForWritesToFinish():void 0)}}class _r{constructor(e){this._state=e,this._promise=u((e,t)=>{this._resolvePromise=e,this._rejectPromise=t})}_chunkSteps(t){this._state._currentWrite=f(Yt(this._state._writer,t),void 0,e),this._resolvePromise(!1)}_closeSteps(){this._resolvePromise(!0)}_errorSteps(e){this._rejectPromise(e)}}class mr{constructor(e){this._state=e}_chunkSteps(t){this._state._currentWrite=f(Yt(this._state._writer,t),void 0,e)}_closeSteps(){}_errorSteps(e){}}function pr(e,t,r){"errored"===e._state?r(e._storedError):_(t,r)}class ReadableStreamDefaultController{constructor(){throw new TypeError("Illegal constructor")}get desiredSize(){if(!yr(this))throw Er("desiredSize");return Pr(this)}close(){if(!yr(this))throw Er("close");if(!Cr(this))throw new TypeError("The stream is not in a state that permits close");wr(this)}enqueue(e=void 0){if(!yr(this))throw Er("enqueue");if(!Cr(this))throw new TypeError("The stream is not in a state that permits enqueue");return Rr(this,e)}error(e=void 0){if(!yr(this))throw Er("error");Tr(this,e)}[T](e){qe(this);const t=this._cancelAlgorithm(e);return vr(this),t}[P](e){const t=this._controlledReadableStream;if(this._queue.length>0){const r=Pe(this);this._closeRequested&&0===this._queue.length?(vr(this),Yr(t)):Sr(this),e._chunkSteps(r)}else U(t,e),Sr(this)}[C](){return this._queue.length>0}[q](){}}function yr(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledReadableStream")&&e instanceof ReadableStreamDefaultController)}function Sr(e){if(!gr(e))return;if(e._pulling)return void(e._pullAgain=!0);e._pulling=!0;b(e._pullAlgorithm(),()=>(e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,Sr(e)),null),t=>(Tr(e,t),null))}function gr(e){const t=e._controlledReadableStream;if(!Cr(e))return!1;if(!e._started)return!1;if($r(t)&&X(t)>0)return!0;return Pr(e)>0}function vr(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function wr(e){if(!Cr(e))return;const t=e._controlledReadableStream;e._closeRequested=!0,0===e._queue.length&&(vr(e),Yr(t))}function Rr(e,t){if(!Cr(e))return;const r=e._controlledReadableStream;if($r(r)&&X(r)>0)G(r,t,!1);else{let r;try{r=e._strategySizeAlgorithm(t)}catch(t){throw Tr(e,t),t}try{Ce(e,t,r)}catch(t){throw Tr(e,t),t}}Sr(e)}function Tr(e,t){const r=e._controlledReadableStream;"readable"===r._state&&(qe(e),vr(e),Qr(r,t))}function Pr(e){const t=e._controlledReadableStream._state;return"errored"===t?null:"closed"===t?0:e._strategyHWM-e._queueTotalSize}function Cr(e){const t=e._controlledReadableStream._state;return!e._closeRequested&&"readable"===t}function qr(e,t,r,o,n,a,i){t._controlledReadableStream=e,t._queue=void 0,t._queueTotalSize=void 0,qe(t),t._started=!1,t._closeRequested=!1,t._pullAgain=!1,t._pulling=!1,t._strategySizeAlgorithm=i,t._strategyHWM=a,t._pullAlgorithm=o,t._cancelAlgorithm=n,e._readableStreamController=t;b(c(r()),()=>(t._started=!0,Sr(t),null),e=>(Tr(t,e),null))}function Er(e){return new TypeError(`ReadableStreamDefaultController.prototype.${e} can only be used on a ReadableStreamDefaultController`)}function Wr(e,t){return Be(e._readableStreamController)?function(e){let t,r,o,n,a,i=V(e),s=!1,l=!1,d=!1,f=!1,b=!1;const h=u(e=>{a=e});function m(e){_(e._closedPromise,t=>(e!==i||(Xe(o._readableStreamController,t),Xe(n._readableStreamController,t),f&&b||a(void 0)),null))}function p(){ft(i)&&(B(i),i=V(e),m(i));te(i,{_chunkSteps:t=>{y(()=>{l=!1,d=!1;const r=t;let i=t;if(!f&&!b)try{i=Te(t)}catch(t){return Xe(o._readableStreamController,t),Xe(n._readableStreamController,t),void a(Mr(e,t))}f||Ge(o._readableStreamController,r),b||Ge(n._readableStreamController,i),s=!1,l?g():d&&v()})},_closeSteps:()=>{s=!1,f||Ue(o._readableStreamController),b||Ue(n._readableStreamController),o._readableStreamController._pendingPullIntos.length>0&&et(o._readableStreamController,0),n._readableStreamController._pendingPullIntos.length>0&&et(n._readableStreamController,0),f&&b||a(void 0)},_errorSteps:()=>{s=!1}})}function S(t,r){ee(i)&&(B(i),i=it(e),m(i));const u=r?n:o,c=r?o:n;bt(i,t,1,{_chunkSteps:t=>{y(()=>{l=!1,d=!1;const o=r?b:f;if(r?f:b)o||tt(u._readableStreamController,t);else{let r;try{r=Te(t)}catch(t){return Xe(u._readableStreamController,t),Xe(c._readableStreamController,t),void a(Mr(e,t))}o||tt(u._readableStreamController,t),Ge(c._readableStreamController,r)}s=!1,l?g():d&&v()})},_closeSteps:e=>{s=!1;const t=r?b:f,o=r?f:b;t||Ue(u._readableStreamController),o||Ue(c._readableStreamController),void 0!==e&&(t||tt(u._readableStreamController,e),!o&&c._readableStreamController._pendingPullIntos.length>0&&et(c._readableStreamController,0)),t&&o||a(void 0)},_errorSteps:()=>{s=!1}})}function g(){if(s)return l=!0,c(void 0);s=!0;const e=Ke(o._readableStreamController);return null===e?p():S(e._view,!1),c(void 0)}function v(){if(s)return d=!0,c(void 0);s=!0;const e=Ke(n._readableStreamController);return null===e?p():S(e._view,!0),c(void 0)}function w(o){if(f=!0,t=o,b){const o=le([t,r]),n=Mr(e,o);a(n)}return h}function R(o){if(b=!0,r=o,f){const o=le([t,r]),n=Mr(e,o);a(n)}return h}function T(){}return o=Fr(T,g,w),n=Fr(T,v,R),m(i),[o,n]}(e):function(e){const t=V(e);let r,o,n,a,i,s=!1,l=!1,d=!1,f=!1;const b=u(e=>{i=e});function h(){if(s)return l=!0,c(void 0);s=!0;return te(t,{_chunkSteps:e=>{y(()=>{l=!1;const t=e,r=e;d||Rr(n._readableStreamController,t),f||Rr(a._readableStreamController,r),s=!1,l&&h()})},_closeSteps:()=>{s=!1,d||wr(n._readableStreamController),f||wr(a._readableStreamController),d&&f||i(void 0)},_errorSteps:()=>{s=!1}}),c(void 0)}function m(t){if(d=!0,r=t,f){const t=le([r,o]),n=Mr(e,t);i(n)}return b}function p(t){if(f=!0,o=t,d){const t=le([r,o]),n=Mr(e,t);i(n)}return b}function S(){}return n=Dr(S,h,m),a=Dr(S,h,p),_(t._closedPromise,e=>(Tr(n._readableStreamController,e),Tr(a._readableStreamController,e),d&&f||i(void 0),null)),[n,a]}(e)}function Br(r){return t(o=r)&&void 0!==o.getReader?function(r){let o;function n(){let e;try{e=r.read()}catch(e){return d(e)}return m(e,e=>{if(!t(e))throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");if(e.done)wr(o._readableStreamController);else{const t=e.value;Rr(o._readableStreamController,t)}})}function a(e){try{return c(r.cancel(e))}catch(e){return d(e)}}return o=Dr(e,n,a,0),o}(r.getReader()):function(r){let o;const n=me(r,"async");function a(){let e;try{e=pe(n)}catch(e){return d(e)}return m(c(e),e=>{if(!t(e))throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");if(e.done)wr(o._readableStreamController);else{const t=e.value;Rr(o._readableStreamController,t)}})}function i(e){const r=n.iterator;let o;try{o=be(r,"return")}catch(e){return d(e)}if(void 0===o)return c(void 0);return m(g(o,r,[e]),e=>{if(!t(e))throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object")})}return o=Dr(e,a,i,0),o}(r);var o}function Or(e,t,r){return I(e,r),r=>g(e,t,[r])}function jr(e,t,r){return I(e,r),r=>g(e,t,[r])}function kr(e,t,r){return I(e,r),r=>S(e,t,[r])}function Ar(e,t){if("bytes"!==(e=`${e}`))throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamType`);return e}function zr(e,t){L(e,t);const r=null==e?void 0:e.preventAbort,o=null==e?void 0:e.preventCancel,n=null==e?void 0:e.preventClose,a=null==e?void 0:e.signal;return void 0!==a&&function(e,t){if(!function(e){if("object"!=typeof e||null===e)return!1;try{return"boolean"==typeof e.aborted}catch(e){return!1}}(e))throw new TypeError(`${t} is not an AbortSignal.`)}(a,`${t} has member 'signal' that`),{preventAbort:Boolean(r),preventCancel:Boolean(o),preventClose:Boolean(n),signal:a}}Object.defineProperties(ReadableStreamDefaultController.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},desiredSize:{enumerable:!0}}),o(ReadableStreamDefaultController.prototype.close,"close"),o(ReadableStreamDefaultController.prototype.enqueue,"enqueue"),o(ReadableStreamDefaultController.prototype.error,"error"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableStreamDefaultController.prototype,Symbol.toStringTag,{value:"ReadableStreamDefaultController",configurable:!0});class ReadableStream{constructor(e={},t={}){void 0===e?e=null:$(e,"First parameter");const r=yt(t,"Second parameter"),o=function(e,t){L(e,t);const r=e,o=null==r?void 0:r.autoAllocateChunkSize,n=null==r?void 0:r.cancel,a=null==r?void 0:r.pull,i=null==r?void 0:r.start,s=null==r?void 0:r.type;return{autoAllocateChunkSize:void 0===o?void 0:N(o,`${t} has member 'autoAllocateChunkSize' that`),cancel:void 0===n?void 0:Or(n,r,`${t} has member 'cancel' that`),pull:void 0===a?void 0:jr(a,r,`${t} has member 'pull' that`),start:void 0===i?void 0:kr(i,r,`${t} has member 'start' that`),type:void 0===s?void 0:Ar(s,`${t} has member 'type' that`)}}(e,"First parameter");if(Lr(this),"bytes"===o.type){if(void 0!==r.size)throw new RangeError("The strategy for a byte stream cannot have a size function");!function(e,t,r){const o=Object.create(ReadableByteStreamController.prototype);let n,a,i;n=void 0!==t.start?()=>t.start(o):()=>{},a=void 0!==t.pull?()=>t.pull(o):()=>c(void 0),i=void 0!==t.cancel?e=>t.cancel(e):()=>c(void 0);const s=t.autoAllocateChunkSize;if(0===s)throw new TypeError("autoAllocateChunkSize must be greater than 0");rt(e,o,n,a,i,r,s)}(this,o,mt(r,0))}else{const e=pt(r);!function(e,t,r,o){const n=Object.create(ReadableStreamDefaultController.prototype);let a,i,s;a=void 0!==t.start?()=>t.start(n):()=>{},i=void 0!==t.pull?()=>t.pull(n):()=>c(void 0),s=void 0!==t.cancel?e=>t.cancel(e):()=>c(void 0),qr(e,n,a,i,s,r,o)}(this,o,mt(r,1),e)}}get locked(){if(!Ir(this))throw xr("locked");return $r(this)}cancel(e=void 0){return Ir(this)?$r(this)?d(new TypeError("Cannot cancel a stream that already has a reader")):Mr(this,e):d(xr("cancel"))}getReader(e=void 0){if(!Ir(this))throw xr("getReader");return void 0===function(e,t){L(e,t);const r=null==e?void 0:e.mode;return{mode:void 0===r?void 0:at(r,`${t} has member 'mode' that`)}}(e,"First parameter").mode?V(this):it(this)}pipeThrough(e,t={}){if(!Ir(this))throw xr("pipeThrough");M(e,1,"pipeThrough");const r=function(e,t){L(e,t);const r=null==e?void 0:e.readable;Y(r,"readable","ReadableWritablePair"),H(r,`${t} has member 'readable' that`);const o=null==e?void 0:e.writable;return Y(o,"writable","ReadableWritablePair"),Tt(o,`${t} has member 'writable' that`),{readable:r,writable:o}}(e,"First parameter"),o=zr(t,"Second parameter");if($r(this))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");if(Et(r.writable))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");return p(br(this,r.writable,o.preventClose,o.preventAbort,o.preventCancel,o.signal)),r.readable}pipeTo(e,t={}){if(!Ir(this))return d(xr("pipeTo"));if(void 0===e)return d("Parameter 1 is required in 'pipeTo'.");if(!qt(e))return d(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));let r;try{r=zr(t,"Second parameter")}catch(e){return d(e)}return $r(this)?d(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")):Et(e)?d(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")):br(this,e,r.preventClose,r.preventAbort,r.preventCancel,r.signal)}tee(){if(!Ir(this))throw xr("tee");return le(Wr(this))}values(e=void 0){if(!Ir(this))throw xr("values");return function(e,t){const r=V(e),o=new ye(r,t),n=Object.create(ge);return n._asyncIteratorImpl=o,n}(this,function(e,t){L(e,t);const r=null==e?void 0:e.preventCancel;return{preventCancel:Boolean(r)}}(e,"First parameter").preventCancel)}[_e](e){return this.values(e)}static from(e){return Br(e)}}function Dr(e,t,r,o=1,n=()=>1){const a=Object.create(ReadableStream.prototype);Lr(a);return qr(a,Object.create(ReadableStreamDefaultController.prototype),e,t,r,o,n),a}function Fr(e,t,r){const o=Object.create(ReadableStream.prototype);Lr(o);return rt(o,Object.create(ReadableByteStreamController.prototype),e,t,r,0,void 0),o}function Lr(e){e._state="readable",e._reader=void 0,e._storedError=void 0,e._disturbed=!1}function Ir(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readableStreamController")&&e instanceof ReadableStream)}function $r(e){return void 0!==e._reader}function Mr(t,r){if(t._disturbed=!0,"closed"===t._state)return c(void 0);if("errored"===t._state)return d(t._storedError);Yr(t);const o=t._reader;if(void 0!==o&&ft(o)){const e=o._readIntoRequests;o._readIntoRequests=new v,e.forEach(e=>{e._closeSteps(void 0)})}return m(t._readableStreamController[T](r),e)}function Yr(e){e._state="closed";const t=e._reader;if(void 0!==t&&(z(t),ee(t))){const e=t._readRequests;t._readRequests=new v,e.forEach(e=>{e._closeSteps()})}}function Qr(e,t){e._state="errored",e._storedError=t;const r=e._reader;void 0!==r&&(A(r,t),ee(r)?oe(r,t):ht(r,t))}function xr(e){return new TypeError(`ReadableStream.prototype.${e} can only be used on a ReadableStream`)}function Nr(e,t){L(e,t);const r=null==e?void 0:e.highWaterMark;return Y(r,"highWaterMark","QueuingStrategyInit"),{highWaterMark:Q(r)}}Object.defineProperties(ReadableStream,{from:{enumerable:!0}}),Object.defineProperties(ReadableStream.prototype,{cancel:{enumerable:!0},getReader:{enumerable:!0},pipeThrough:{enumerable:!0},pipeTo:{enumerable:!0},tee:{enumerable:!0},values:{enumerable:!0},locked:{enumerable:!0}}),o(ReadableStream.from,"from"),o(ReadableStream.prototype.cancel,"cancel"),o(ReadableStream.prototype.getReader,"getReader"),o(ReadableStream.prototype.pipeThrough,"pipeThrough"),o(ReadableStream.prototype.pipeTo,"pipeTo"),o(ReadableStream.prototype.tee,"tee"),o(ReadableStream.prototype.values,"values"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableStream.prototype,Symbol.toStringTag,{value:"ReadableStream",configurable:!0}),Object.defineProperty(ReadableStream.prototype,_e,{value:ReadableStream.prototype.values,writable:!0,configurable:!0});const Hr=e=>e.byteLength;o(Hr,"size");class ByteLengthQueuingStrategy{constructor(e){M(e,1,"ByteLengthQueuingStrategy"),e=Nr(e,"First parameter"),this._byteLengthQueuingStrategyHighWaterMark=e.highWaterMark}get highWaterMark(){if(!Ur(this))throw Vr("highWaterMark");return this._byteLengthQueuingStrategyHighWaterMark}get size(){if(!Ur(this))throw Vr("size");return Hr}}function Vr(e){return new TypeError(`ByteLengthQueuingStrategy.prototype.${e} can only be used on a ByteLengthQueuingStrategy`)}function Ur(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_byteLengthQueuingStrategyHighWaterMark")&&e instanceof ByteLengthQueuingStrategy)}Object.defineProperties(ByteLengthQueuingStrategy.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ByteLengthQueuingStrategy.prototype,Symbol.toStringTag,{value:"ByteLengthQueuingStrategy",configurable:!0});const Gr=()=>1;o(Gr,"size");class CountQueuingStrategy{constructor(e){M(e,1,"CountQueuingStrategy"),e=Nr(e,"First parameter"),this._countQueuingStrategyHighWaterMark=e.highWaterMark}get highWaterMark(){if(!Jr(this))throw Xr("highWaterMark");return this._countQueuingStrategyHighWaterMark}get size(){if(!Jr(this))throw Xr("size");return Gr}}function Xr(e){return new TypeError(`CountQueuingStrategy.prototype.${e} can only be used on a CountQueuingStrategy`)}function Jr(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_countQueuingStrategyHighWaterMark")&&e instanceof CountQueuingStrategy)}function Kr(e,t,r){return I(e,r),r=>g(e,t,[r])}function Zr(e,t,r){return I(e,r),r=>S(e,t,[r])}function eo(e,t,r){return I(e,r),(r,o)=>g(e,t,[r,o])}function to(e,t,r){return I(e,r),r=>g(e,t,[r])}Object.defineProperties(CountQueuingStrategy.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(CountQueuingStrategy.prototype,Symbol.toStringTag,{value:"CountQueuingStrategy",configurable:!0});class TransformStream{constructor(e={},t={},r={}){void 0===e&&(e=null);const o=yt(t,"Second parameter"),n=yt(r,"Third parameter"),a=function(e,t){L(e,t);const r=null==e?void 0:e.cancel,o=null==e?void 0:e.flush,n=null==e?void 0:e.readableType,a=null==e?void 0:e.start,i=null==e?void 0:e.transform,s=null==e?void 0:e.writableType;return{cancel:void 0===r?void 0:to(r,e,`${t} has member 'cancel' that`),flush:void 0===o?void 0:Kr(o,e,`${t} has member 'flush' that`),readableType:n,start:void 0===a?void 0:Zr(a,e,`${t} has member 'start' that`),transform:void 0===i?void 0:eo(i,e,`${t} has member 'transform' that`),writableType:s}}(e,"First parameter");if(void 0!==a.readableType)throw new RangeError("Invalid readableType specified");if(void 0!==a.writableType)throw new RangeError("Invalid writableType specified");const i=mt(n,0),s=pt(n),l=mt(o,1),f=pt(o);let h;!function(e,t,r,o,n,a){function i(){return t}function s(t){return function(e,t){const r=e._transformStreamController;if(e._backpressure){return m(e._backpressureChangePromise,()=>{const o=e._writable;if("erroring"===o._state)throw o._storedError;return co(r,t)})}return co(r,t)}(e,t)}function l(t){return function(e,t){const r=e._transformStreamController;if(void 0!==r._finishPromise)return r._finishPromise;const o=e._readable;r._finishPromise=u((e,t)=>{r._finishPromise_resolve=e,r._finishPromise_reject=t});const n=r._cancelAlgorithm(t);return lo(r),b(n,()=>("errored"===o._state?ho(r,o._storedError):(Tr(o._readableStreamController,t),bo(r)),null),e=>(Tr(o._readableStreamController,e),ho(r,e),null)),r._finishPromise}(e,t)}function c(){return function(e){const t=e._transformStreamController;if(void 0!==t._finishPromise)return t._finishPromise;const r=e._readable;t._finishPromise=u((e,r)=>{t._finishPromise_resolve=e,t._finishPromise_reject=r});const o=t._flushAlgorithm();return lo(t),b(o,()=>("errored"===r._state?ho(t,r._storedError):(wr(r._readableStreamController),bo(t)),null),e=>(Tr(r._readableStreamController,e),ho(t,e),null)),t._finishPromise}(e)}function d(){return function(e){return io(e,!1),e._backpressureChangePromise}(e)}function f(t){return function(e,t){const r=e._transformStreamController;if(void 0!==r._finishPromise)return r._finishPromise;const o=e._writable;r._finishPromise=u((e,t)=>{r._finishPromise_resolve=e,r._finishPromise_reject=t});const n=r._cancelAlgorithm(t);return lo(r),b(n,()=>("errored"===o._state?ho(r,o._storedError):(Gt(o._writableStreamController,t),ao(e),bo(r)),null),t=>(Gt(o._writableStreamController,t),ao(e),ho(r,t),null)),r._finishPromise}(e,t)}e._writable=function(e,t,r,o,n=1,a=()=>1){const i=Object.create(WritableStream.prototype);return Ct(i),Nt(i,Object.create(WritableStreamDefaultController.prototype),e,t,r,o,n,a),i}(i,s,c,l,r,o),e._readable=Dr(i,d,f,n,a),e._backpressure=void 0,e._backpressureChangePromise=void 0,e._backpressureChangePromise_resolve=void 0,io(e,!0),e._transformStreamController=void 0}(this,u(e=>{h=e}),l,f,i,s),function(e,t){const r=Object.create(TransformStreamDefaultController.prototype);let o,n,a;o=void 0!==t.transform?e=>t.transform(e,r):e=>{try{return uo(r,e),c(void 0)}catch(e){return d(e)}};n=void 0!==t.flush?()=>t.flush(r):()=>c(void 0);a=void 0!==t.cancel?e=>t.cancel(e):()=>c(void 0);!function(e,t,r,o,n){t._controlledTransformStream=e,e._transformStreamController=t,t._transformAlgorithm=r,t._flushAlgorithm=o,t._cancelAlgorithm=n,t._finishPromise=void 0,t._finishPromise_resolve=void 0,t._finishPromise_reject=void 0}(e,r,o,n,a)}(this,a),void 0!==a.start?h(a.start(this._transformStreamController)):h(void 0)}get readable(){if(!ro(this))throw _o("readable");return this._readable}get writable(){if(!ro(this))throw _o("writable");return this._writable}}function ro(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_transformStreamController")&&e instanceof TransformStream)}function oo(e,t){Tr(e._readable._readableStreamController,t),no(e,t)}function no(e,t){lo(e._transformStreamController),Gt(e._writable._writableStreamController,t),ao(e)}function ao(e){e._backpressure&&io(e,!1)}function io(e,t){void 0!==e._backpressureChangePromise&&e._backpressureChangePromise_resolve(),e._backpressureChangePromise=u(t=>{e._backpressureChangePromise_resolve=t}),e._backpressure=t}Object.defineProperties(TransformStream.prototype,{readable:{enumerable:!0},writable:{enumerable:!0}}),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(TransformStream.prototype,Symbol.toStringTag,{value:"TransformStream",configurable:!0});class TransformStreamDefaultController{constructor(){throw new TypeError("Illegal constructor")}get desiredSize(){if(!so(this))throw fo("desiredSize");return Pr(this._controlledTransformStream._readable._readableStreamController)}enqueue(e=void 0){if(!so(this))throw fo("enqueue");uo(this,e)}error(e=void 0){if(!so(this))throw fo("error");var t;t=e,oo(this._controlledTransformStream,t)}terminate(){if(!so(this))throw fo("terminate");!function(e){const t=e._controlledTransformStream;wr(t._readable._readableStreamController);const r=new TypeError("TransformStream terminated");no(t,r)}(this)}}function so(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledTransformStream")&&e instanceof TransformStreamDefaultController)}function lo(e){e._transformAlgorithm=void 0,e._flushAlgorithm=void 0,e._cancelAlgorithm=void 0}function uo(e,t){const r=e._controlledTransformStream,o=r._readable._readableStreamController;if(!Cr(o))throw new TypeError("Readable side is not in a state that permits enqueue");try{Rr(o,t)}catch(e){throw no(r,e),r._readable._storedError}const n=function(e){return!gr(e)}(o);n!==r._backpressure&&io(r,!0)}function co(e,t){return m(e._transformAlgorithm(t),void 0,t=>{throw oo(e._controlledTransformStream,t),t})}function fo(e){return new TypeError(`TransformStreamDefaultController.prototype.${e} can only be used on a TransformStreamDefaultController`)}function bo(e){void 0!==e._finishPromise_resolve&&(e._finishPromise_resolve(),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}function ho(e,t){void 0!==e._finishPromise_reject&&(p(e._finishPromise),e._finishPromise_reject(t),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}function _o(e){return new TypeError(`TransformStream.prototype.${e} can only be used on a TransformStream`)}Object.defineProperties(TransformStreamDefaultController.prototype,{enqueue:{enumerable:!0},error:{enumerable:!0},terminate:{enumerable:!0},desiredSize:{enumerable:!0}}),o(TransformStreamDefaultController.prototype.enqueue,"enqueue"),o(TransformStreamDefaultController.prototype.error,"error"),o(TransformStreamDefaultController.prototype.terminate,"terminate"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(TransformStreamDefaultController.prototype,Symbol.toStringTag,{value:"TransformStreamDefaultController",configurable:!0});const mo={ReadableStream:ReadableStream,ReadableStreamDefaultController:ReadableStreamDefaultController,ReadableByteStreamController:ReadableByteStreamController,ReadableStreamBYOBRequest:ReadableStreamBYOBRequest,ReadableStreamDefaultReader:ReadableStreamDefaultReader,ReadableStreamBYOBReader:ReadableStreamBYOBReader,WritableStream:WritableStream,WritableStreamDefaultController:WritableStreamDefaultController,WritableStreamDefaultWriter:WritableStreamDefaultWriter,ByteLengthQueuingStrategy:ByteLengthQueuingStrategy,CountQueuingStrategy:CountQueuingStrategy,TransformStream:TransformStream,TransformStreamDefaultController:TransformStreamDefaultController};for(const e in mo)Object.prototype.hasOwnProperty.call(mo,e)&&Object.defineProperty(dr,e,{value:mo[e],writable:!0,configurable:!0})}();
+!function(){"use strict";function e(){}function t(e){return"object"==typeof e&&null!==e||"function"==typeof e}const r=e;function o(e,t){try{Object.defineProperty(e,"name",{value:t,configurable:!0})}catch(e){}}const n=Promise,a=Promise.resolve.bind(n),i=Promise.prototype.then,s=Promise.reject.bind(n),l=a;function u(e){return new n(e)}function c(e){return u(t=>t(e))}function d(e){return s(e)}function f(e,t,r){return i.call(e,t,r)}function b(e,t,o){f(f(e,t,o),void 0,r)}function h(e,t){b(e,t)}function _(e,t){b(e,void 0,t)}function m(e,t,r){return f(e,t,r)}function p(e){f(e,void 0,r)}let y=e=>{if("function"==typeof queueMicrotask)y=queueMicrotask;else{const e=c(void 0);y=t=>f(e,t)}return y(e)};function S(e,t,r){if("function"!=typeof e)throw new TypeError("Argument is not a function");return Function.prototype.apply.call(e,t,r)}function g(e,t,r){try{return c(S(e,t,r))}catch(e){return d(e)}}class v{constructor(){this._cursor=0,this._size=0,this._front={_elements:[],_next:void 0},this._back=this._front,this._cursor=0,this._size=0}get length(){return this._size}push(e){const t=this._back;let r=t;16383===t._elements.length&&(r={_elements:[],_next:void 0}),t._elements.push(e),r!==t&&(this._back=r,t._next=r),++this._size}shift(){const e=this._front;let t=e;const r=this._cursor;let o=r+1;const n=e._elements,a=n[r];return 16384===o&&(t=e._next,o=0),--this._size,this._cursor=o,e!==t&&(this._front=t),n[r]=void 0,a}forEach(e){let t=this._cursor,r=this._front,o=r._elements;for(;!(t===o.length&&void 0===r._next||t===o.length&&(r=r._next,o=r._elements,t=0,0===o.length));)e(o[t]),++t}peek(){const e=this._front,t=this._cursor;return e._elements[t]}}const w=Symbol("[[AbortSteps]]"),R=Symbol("[[ErrorSteps]]"),T=Symbol("[[CancelSteps]]"),P=Symbol("[[PullSteps]]"),C=Symbol("[[CanPullSyncSteps]]"),q=Symbol("[[ReleaseSteps]]");function E(e,t){e._ownerReadableStream=t,t._reader=e,"readable"===t._state?j(e):"closed"===t._state?function(e){j(e),z(e)}(e):k(e,t._storedError)}function W(e,t){return Mr(e._ownerReadableStream,t)}function B(e){const t=e._ownerReadableStream;"readable"===t._state?A(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")):function(e,t){k(e,t)}(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")),t._readableStreamController[q](),t._reader=void 0,e._ownerReadableStream=void 0}function O(e){return new TypeError("Cannot "+e+" a stream using a released reader")}function j(e){e._closedPromise=u((t,r)=>{e._closedPromise_resolve=t,e._closedPromise_reject=r})}function k(e,t){j(e),A(e,t)}function A(e,t){void 0!==e._closedPromise_reject&&(p(e._closedPromise),e._closedPromise_reject(t),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}function z(e){void 0!==e._closedPromise_resolve&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}const D=Number.isFinite||function(e){return"number"==typeof e&&isFinite(e)},F=Math.trunc||function(e){return e<0?Math.ceil(e):Math.floor(e)};function L(e,t){if(void 0!==e&&("object"!=typeof(r=e)&&"function"!=typeof r))throw new TypeError(`${t} is not an object.`);var r}function I(e,t){if("function"!=typeof e)throw new TypeError(`${t} is not a function.`)}function $(e,t){if(!function(e){return"object"==typeof e&&null!==e||"function"==typeof e}(e))throw new TypeError(`${t} is not an object.`)}function M(e,t,r){if(void 0===e)throw new TypeError(`Parameter ${t} is required in '${r}'.`)}function Y(e,t,r){if(void 0===e)throw new TypeError(`${t} is required in '${r}'.`)}function Q(e){return Number(e)}function x(e){return 0===e?0:e}function N(e,t){const r=Number.MAX_SAFE_INTEGER;let o=Number(e);if(o=x(o),!D(o))throw new TypeError(`${t} is not a finite number`);if(o=function(e){return x(F(e))}(o),o<0||o>r)throw new TypeError(`${t} is outside the accepted range of 0 to ${r}, inclusive`);return D(o)&&0!==o?o:0}function H(e,t){if(!Ir(e))throw new TypeError(`${t} is not a ReadableStream.`)}function V(e){return new ReadableStreamDefaultReader(e)}function U(e,t){e._reader._readRequests.push(t)}function G(e,t,r){const o=e._reader._readRequests.shift();r?o._closeSteps():o._chunkSteps(t)}function X(e){return e._reader._readRequests.length}function J(e){const t=e._reader;return void 0!==t&&!!ee(t)}class ReadableStreamDefaultReader{constructor(e){if(M(e,1,"ReadableStreamDefaultReader"),H(e,"First parameter"),$r(e))throw new TypeError("This stream has already been locked for exclusive reading by another reader");E(this,e),this._readRequests=new v}get closed(){return ee(this)?this._closedPromise:d(ne("closed"))}cancel(e=void 0){return ee(this)?void 0===this._ownerReadableStream?d(O("cancel")):W(this,e):d(ne("cancel"))}read(){if(!ee(this))return d(ne("read"));if(void 0===this._ownerReadableStream)return d(O("read from"));const e=re(this)?new Z:new K;return te(this,e),e._promise}releaseLock(){if(!ee(this))throw ne("releaseLock");void 0!==this._ownerReadableStream&&function(e){B(e);const t=new TypeError("Reader was released");oe(e,t)}(this)}}Object.defineProperties(ReadableStreamDefaultReader.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),o(ReadableStreamDefaultReader.prototype.cancel,"cancel"),o(ReadableStreamDefaultReader.prototype.read,"read"),o(ReadableStreamDefaultReader.prototype.releaseLock,"releaseLock"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableStreamDefaultReader.prototype,Symbol.toStringTag,{value:"ReadableStreamDefaultReader",configurable:!0});class K{constructor(){this._promise=u((e,t)=>{this._resolvePromise=e,this._rejectPromise=t})}_chunkSteps(e){this._resolvePromise({value:e,done:!1})}_closeSteps(){this._resolvePromise({value:void 0,done:!0})}_errorSteps(e){this._rejectPromise(e)}}class Z{constructor(){this._promise=void 0}_chunkSteps(e){this._promise=l({value:e,done:!1})}_closeSteps(){this._promise=l({value:void 0,done:!0})}_errorSteps(e){this._promise=d(e)}}function ee(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readRequests")&&e instanceof ReadableStreamDefaultReader)}function te(e,t){const r=e._ownerReadableStream;r._disturbed=!0,"closed"===r._state?t._closeSteps():"errored"===r._state?t._errorSteps(r._storedError):r._readableStreamController[P](t)}function re(e){const t=e._ownerReadableStream;return"closed"===t._state||("errored"===t._state||t._readableStreamController[C]())}function oe(e,t){const r=e._readRequests;e._readRequests=new v,r.forEach(e=>{e._errorSteps(t)})}function ne(e){return new TypeError(`ReadableStreamDefaultReader.prototype.${e} can only be used on a ReadableStreamDefaultReader`)}var ae,ie,se;function le(e){return e.slice()}function ue(e,t,r,o,n){new Uint8Array(e).set(new Uint8Array(r,o,n),t)}let ce=e=>(ce="function"==typeof e.transfer?e=>e.transfer():"function"==typeof structuredClone?e=>structuredClone(e,{transfer:[e]}):e=>e,ce(e)),de=e=>(de="boolean"==typeof e.detached?e=>e.detached:e=>0===e.byteLength,de(e));function fe(e,t,r){if(e.slice)return e.slice(t,r);const o=r-t,n=new ArrayBuffer(o);return ue(n,0,e,t,o),n}function be(e,t){const r=e[t];if(null!=r){if("function"!=typeof r)throw new TypeError(`${String(t)} is not a function`);return r}}function he(e){try{const t=e.done,r=e.value;return f(l(r),e=>({done:t,value:e}))}catch(e){return d(e)}}const _e=null!==(se=null!==(ae=Symbol.asyncIterator)&&void 0!==ae?ae:null===(ie=Symbol.for)||void 0===ie?void 0:ie.call(Symbol,"Symbol.asyncIterator"))&&void 0!==se?se:"@@asyncIterator";function me(e,r="sync",o){if(void 0===o)if("async"===r){if(void 0===(o=be(e,_e))){return function(e){const r={next(){let t;try{t=pe(e)}catch(e){return d(e)}return he(t)},return(r){let o;try{const t=be(e.iterator,"return");if(void 0===t)return c({done:!0,value:r});o=S(t,e.iterator,[r])}catch(e){return d(e)}return t(o)?he(o):d(new TypeError("The iterator.return() method must return an object"))}};return{iterator:r,nextMethod:r.next,done:!1}}(me(e,"sync",be(e,Symbol.iterator)))}}else o=be(e,Symbol.iterator);if(void 0===o)throw new TypeError("The object is not iterable");const n=S(o,e,[]);if(!t(n))throw new TypeError("The iterator method must return an object");return{iterator:n,nextMethod:n.next,done:!1}}function pe(e){const r=S(e.nextMethod,e.iterator,[]);if(!t(r))throw new TypeError("The iterator.next() method must return an object");return r}class ye{constructor(e,t){this._ongoingPromise=void 0,this._isFinished=!1,this._reader=e,this._preventCancel=t}next(){const e=()=>this._nextSteps();return this._ongoingPromise=this._ongoingPromise?m(this._ongoingPromise,e,e):e(),this._ongoingPromise}return(e){const t=()=>this._returnSteps(e);return this._ongoingPromise=this._ongoingPromise?m(this._ongoingPromise,t,t):t(),this._ongoingPromise}_nextSteps(){if(this._isFinished)return Promise.resolve({value:void 0,done:!0});const e=this._reader,t=new Se(this);return te(e,t),t._promise}_returnSteps(e){if(this._isFinished)return Promise.resolve({value:e,done:!0});this._isFinished=!0;const t=this._reader;if(!this._preventCancel){const r=W(t,e);return B(t),m(r,()=>({value:e,done:!0}))}return B(t),c({value:e,done:!0})}}class Se{constructor(e){this._iterator=e,this._promise=u((e,t)=>{this._resolvePromise=e,this._rejectPromise=t})}_chunkSteps(e){this._iterator._ongoingPromise=void 0,y(()=>this._resolvePromise({value:e,done:!1}))}_closeSteps(){const e=this._iterator;e._ongoingPromise=void 0,e._isFinished=!0,B(e._reader),this._resolvePromise({value:void 0,done:!0})}_errorSteps(e){const t=this._iterator;t._ongoingPromise=void 0,t._isFinished=!0,B(t._reader),this._rejectPromise(e)}}const ge={next(){return ve(this)?this._asyncIteratorImpl.next():d(we("next"))},return(e){return ve(this)?this._asyncIteratorImpl.return(e):d(we("return"))},[_e](){return this}};function ve(e){if(!t(e))return!1;if(!Object.prototype.hasOwnProperty.call(e,"_asyncIteratorImpl"))return!1;try{return e._asyncIteratorImpl instanceof ye}catch(e){return!1}}function we(e){return new TypeError(`ReadableStreamAsyncIterator.${e} can only be used on a ReadableSteamAsyncIterator`)}Object.defineProperty(ge,_e,{enumerable:!1});const Re=Number.isNaN||function(e){return e!=e};function Te(e){const t=fe(e.buffer,e.byteOffset,e.byteOffset+e.byteLength);return new Uint8Array(t)}function Pe(e){const t=e._queue.shift();return e._queueTotalSize-=t.size,e._queueTotalSize<0&&(e._queueTotalSize=0),t.value}function Ce(e,t,r){if("number"!=typeof(o=r)||Re(o)||o<0||r===1/0)throw new RangeError("Size must be a finite, non-NaN, non-negative number.");var o;e._queue.push({value:t,size:r}),e._queueTotalSize+=r}function qe(e){e._queue=new v,e._queueTotalSize=0}function Ee(e){return e===DataView}function We(e){return Ee(e)?1:e.BYTES_PER_ELEMENT}class ReadableStreamBYOBRequest{constructor(){throw new TypeError("Illegal constructor")}get view(){if(!Oe(this))throw ot("view");return this._view}respond(e){if(!Oe(this))throw ot("respond");if(M(e,1,"respond"),e=N(e,"First parameter"),void 0===this._associatedReadableByteStreamController)throw new TypeError("This BYOB request has been invalidated");if(de(this._view.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");et(this._associatedReadableByteStreamController,e)}respondWithNewView(e){if(!Oe(this))throw ot("respondWithNewView");if(M(e,1,"respondWithNewView"),!ArrayBuffer.isView(e))throw new TypeError("You can only respond with array buffer views");if(void 0===this._associatedReadableByteStreamController)throw new TypeError("This BYOB request has been invalidated");if(de(e.buffer))throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");tt(this._associatedReadableByteStreamController,e)}}Object.defineProperties(ReadableStreamBYOBRequest.prototype,{respond:{enumerable:!0},respondWithNewView:{enumerable:!0},view:{enumerable:!0}}),o(ReadableStreamBYOBRequest.prototype.respond,"respond"),o(ReadableStreamBYOBRequest.prototype.respondWithNewView,"respondWithNewView"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableStreamBYOBRequest.prototype,Symbol.toStringTag,{value:"ReadableStreamBYOBRequest",configurable:!0});class ReadableByteStreamController{constructor(){throw new TypeError("Illegal constructor")}get byobRequest(){if(!Be(this))throw nt("byobRequest");return Ke(this)}get desiredSize(){if(!Be(this))throw nt("desiredSize");return Ze(this)}close(){if(!Be(this))throw nt("close");if(this._closeRequested)throw new TypeError("The stream has already been closed; do not close it again!");const e=this._controlledReadableByteStream._state;if("readable"!==e)throw new TypeError(`The stream (in ${e} state) is not in the readable state and cannot be closed`);Ue(this)}enqueue(e){if(!Be(this))throw nt("enqueue");if(M(e,1,"enqueue"),!ArrayBuffer.isView(e))throw new TypeError("chunk must be an array buffer view");if(0===e.byteLength)throw new TypeError("chunk must have non-zero byteLength");if(0===e.buffer.byteLength)throw new TypeError("chunk's buffer must have non-zero byteLength");if(this._closeRequested)throw new TypeError("stream is closed or draining");const t=this._controlledReadableByteStream._state;if("readable"!==t)throw new TypeError(`The stream (in ${t} state) is not in the readable state and cannot be enqueued to`);Ge(this,e)}error(e=void 0){if(!Be(this))throw nt("error");Xe(this,e)}[T](e){ke(this),qe(this);const t=this._cancelAlgorithm(e);return Ve(this),t}[P](e){const t=this._controlledReadableByteStream;if(this._queueTotalSize>0)return void Je(this,e);const r=this._autoAllocateChunkSize;if(void 0!==r){let t;try{t=new ArrayBuffer(r)}catch(t){return void e._errorSteps(t)}const o={buffer:t,bufferByteLength:r,byteOffset:0,byteLength:r,bytesFilled:0,minimumFill:1,elementSize:1,viewConstructor:Uint8Array,readerType:"default"};this._pendingPullIntos.push(o)}U(t,e),je(this)}[C](){return this._queueTotalSize>0}[q](){if(this._pendingPullIntos.length>0){const e=this._pendingPullIntos.peek();e.readerType="none",this._pendingPullIntos=new v,this._pendingPullIntos.push(e)}}}function Be(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledReadableByteStream")&&e instanceof ReadableByteStreamController)}function Oe(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_associatedReadableByteStreamController")&&e instanceof ReadableStreamBYOBRequest)}function je(e){const t=function(e){const t=e._controlledReadableByteStream;if("readable"!==t._state)return!1;if(e._closeRequested)return!1;if(!e._started)return!1;if(J(t)&&X(t)>0)return!0;if(ut(t)&&lt(t)>0)return!0;const r=Ze(e);if(r>0)return!0;return!1}(e);if(!t)return;if(e._pulling)return void(e._pullAgain=!0);e._pulling=!0;b(e._pullAlgorithm(),()=>(e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,je(e)),null),t=>(Xe(e,t),null))}function ke(e){Qe(e),e._pendingPullIntos=new v}function Ae(e,t){let r=!1;"closed"===e._state&&(r=!0);const o=De(t);"default"===t.readerType?G(e,o,r):function(e,t,r){const o=e._reader,n=o._readIntoRequests.shift();r?n._closeSteps(t):n._chunkSteps(t)}(e,o,r)}function ze(e,t){for(let r=0;r<t.length;++r)Ae(e,t[r])}function De(e){const t=e.bytesFilled,r=e.elementSize;return new e.viewConstructor(e.buffer,e.byteOffset,t/r)}function Fe(e,t,r,o){e._queue.push({buffer:t,byteOffset:r,byteLength:o}),e._queueTotalSize+=o}function Le(e,t,r,o){let n;try{n=fe(t,r,r+o)}catch(t){throw Xe(e,t),t}Fe(e,n,0,o)}function Ie(e,t){t.bytesFilled>0&&Le(e,t.buffer,t.byteOffset,t.bytesFilled),He(e)}function $e(e,t){const r=Math.min(e._queueTotalSize,t.byteLength-t.bytesFilled),o=t.bytesFilled+r;let n=r,a=!1;const i=o-o%t.elementSize;i>=t.minimumFill&&(n=i-t.bytesFilled,a=!0);const s=e._queue;for(;n>0;){const r=s.peek(),o=Math.min(n,r.byteLength),a=t.byteOffset+t.bytesFilled;ue(t.buffer,a,r.buffer,r.byteOffset,o),r.byteLength===o?s.shift():(r.byteOffset+=o,r.byteLength-=o),e._queueTotalSize-=o,Me(e,o,t),n-=o}return a}function Me(e,t,r){r.bytesFilled+=t}function Ye(e){0===e._queueTotalSize&&e._closeRequested?(Ve(e),Yr(e._controlledReadableByteStream)):je(e)}function Qe(e){null!==e._byobRequest&&(e._byobRequest._associatedReadableByteStreamController=void 0,e._byobRequest._view=null,e._byobRequest=null)}function xe(e){const t=[];for(;e._pendingPullIntos.length>0&&0!==e._queueTotalSize;){const r=e._pendingPullIntos.peek();$e(e,r)&&(He(e),t.push(r))}return t}function Ne(e,t){const r=e._pendingPullIntos.peek();Qe(e);"closed"===e._controlledReadableByteStream._state?function(e,t){"none"===t.readerType&&He(e);const r=e._controlledReadableByteStream;if(ut(r)){const t=[];for(;t.length<lt(r);)t.push(He(e));ze(r,t)}}(e,r):function(e,t,r){if(Me(0,t,r),"none"===r.readerType){Ie(e,r);const t=xe(e);return void ze(e._controlledReadableByteStream,t)}if(r.bytesFilled<r.minimumFill)return;He(e);const o=r.bytesFilled%r.elementSize;if(o>0){const t=r.byteOffset+r.bytesFilled;Le(e,r.buffer,t-o,o)}r.bytesFilled-=o;const n=xe(e);Ae(e._controlledReadableByteStream,r),ze(e._controlledReadableByteStream,n)}(e,t,r),je(e)}function He(e){return e._pendingPullIntos.shift()}function Ve(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0}function Ue(e){const t=e._controlledReadableByteStream;if(!e._closeRequested&&"readable"===t._state)if(e._queueTotalSize>0)e._closeRequested=!0;else{if(e._pendingPullIntos.length>0){const t=e._pendingPullIntos.peek();if(t.bytesFilled%t.elementSize!==0){const t=new TypeError("Insufficient bytes to fill elements in the given buffer");throw Xe(e,t),t}}Ve(e),Yr(t)}}function Ge(e,t){const r=e._controlledReadableByteStream;if(e._closeRequested||"readable"!==r._state)return;const{buffer:o,byteOffset:n,byteLength:a}=t;if(de(o))throw new TypeError("chunk's buffer is detached and so cannot be enqueued");const i=ce(o);if(e._pendingPullIntos.length>0){const t=e._pendingPullIntos.peek();if(de(t.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");Qe(e),t.buffer=ce(t.buffer),"none"===t.readerType&&Ie(e,t)}if(J(r))if(function(e){const t=e._controlledReadableByteStream._reader;for(;t._readRequests.length>0;){if(0===e._queueTotalSize)return;Je(e,t._readRequests.shift())}}(e),0===X(r))Fe(e,i,n,a);else{e._pendingPullIntos.length>0&&He(e);G(r,new Uint8Array(i,n,a),!1)}else if(ut(r)){Fe(e,i,n,a);ze(r,xe(e))}else Fe(e,i,n,a);je(e)}function Xe(e,t){const r=e._controlledReadableByteStream;"readable"===r._state&&(ke(e),qe(e),Ve(e),Qr(r,t))}function Je(e,t){const r=e._queue.shift();e._queueTotalSize-=r.byteLength,Ye(e);const o=new Uint8Array(r.buffer,r.byteOffset,r.byteLength);t._chunkSteps(o)}function Ke(e){if(null===e._byobRequest&&e._pendingPullIntos.length>0){const t=e._pendingPullIntos.peek(),r=new Uint8Array(t.buffer,t.byteOffset+t.bytesFilled,t.byteLength-t.bytesFilled),o=Object.create(ReadableStreamBYOBRequest.prototype);!function(e,t,r){e._associatedReadableByteStreamController=t,e._view=r}(o,e,r),e._byobRequest=o}return e._byobRequest}function Ze(e){const t=e._controlledReadableByteStream._state;return"errored"===t?null:"closed"===t?0:e._strategyHWM-e._queueTotalSize}function et(e,t){const r=e._pendingPullIntos.peek();if("closed"===e._controlledReadableByteStream._state){if(0!==t)throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream")}else{if(0===t)throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");if(r.bytesFilled+t>r.byteLength)throw new RangeError("bytesWritten out of range")}r.buffer=ce(r.buffer),Ne(e,t)}function tt(e,t){const r=e._pendingPullIntos.peek();if("closed"===e._controlledReadableByteStream._state){if(0!==t.byteLength)throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream")}else if(0===t.byteLength)throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");if(r.byteOffset+r.bytesFilled!==t.byteOffset)throw new RangeError("The region specified by view does not match byobRequest");if(r.bufferByteLength!==t.buffer.byteLength)throw new RangeError("The buffer of view has different capacity than byobRequest");if(r.bytesFilled+t.byteLength>r.byteLength)throw new RangeError("The region specified by view is larger than byobRequest");const o=t.byteLength;r.buffer=ce(t.buffer),Ne(e,o)}function rt(e,t,r,o,n,a,i){t._controlledReadableByteStream=e,t._pullAgain=!1,t._pulling=!1,t._byobRequest=null,t._queue=t._queueTotalSize=void 0,qe(t),t._closeRequested=!1,t._started=!1,t._strategyHWM=a,t._pullAlgorithm=o,t._cancelAlgorithm=n,t._autoAllocateChunkSize=i,t._pendingPullIntos=new v,e._readableStreamController=t;b(c(r()),()=>(t._started=!0,je(t),null),e=>(Xe(t,e),null))}function ot(e){return new TypeError(`ReadableStreamBYOBRequest.prototype.${e} can only be used on a ReadableStreamBYOBRequest`)}function nt(e){return new TypeError(`ReadableByteStreamController.prototype.${e} can only be used on a ReadableByteStreamController`)}function at(e,t){if("byob"!==(e=`${e}`))throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamReaderMode`);return e}function it(e){return new ReadableStreamBYOBReader(e)}function st(e,t){e._reader._readIntoRequests.push(t)}function lt(e){return e._reader._readIntoRequests.length}function ut(e){const t=e._reader;return void 0!==t&&!!ft(t)}Object.defineProperties(ReadableByteStreamController.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},byobRequest:{enumerable:!0},desiredSize:{enumerable:!0}}),o(ReadableByteStreamController.prototype.close,"close"),o(ReadableByteStreamController.prototype.enqueue,"enqueue"),o(ReadableByteStreamController.prototype.error,"error"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableByteStreamController.prototype,Symbol.toStringTag,{value:"ReadableByteStreamController",configurable:!0});class ReadableStreamBYOBReader{constructor(e){if(M(e,1,"ReadableStreamBYOBReader"),H(e,"First parameter"),$r(e))throw new TypeError("This stream has already been locked for exclusive reading by another reader");if(!Be(e._readableStreamController))throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");E(this,e),this._readIntoRequests=new v}get closed(){return ft(this)?this._closedPromise:d(_t("closed"))}cancel(e=void 0){return ft(this)?void 0===this._ownerReadableStream?d(O("cancel")):W(this,e):d(_t("cancel"))}read(e,t={}){if(!ft(this))return d(_t("read"));if(!ArrayBuffer.isView(e))return d(new TypeError("view must be an array buffer view"));if(0===e.byteLength)return d(new TypeError("view must have non-zero byteLength"));if(0===e.buffer.byteLength)return d(new TypeError("view's buffer must have non-zero byteLength"));if(de(e.buffer))return d(new TypeError("view's buffer has been detached"));let r;try{r=function(e,t){var r;return L(e,t),{min:N(null!==(r=null==e?void 0:e.min)&&void 0!==r?r:1,`${t} has member 'min' that`)}}(t,"options")}catch(e){return d(e)}const o=r.min;if(0===o)return d(new TypeError("options.min must be greater than 0"));if(function(e){return Ee(e.constructor)}(e)){if(o>e.byteLength)return d(new RangeError("options.min must be less than or equal to view's byteLength"))}else if(o>e.length)return d(new RangeError("options.min must be less than or equal to view's length"));if(void 0===this._ownerReadableStream)return d(O("read from"));const n=function(e,t,r){const o=e._ownerReadableStream;return"errored"===o._state||function(e,t,r){const o=e._controlledReadableByteStream,n=We(t.constructor),{byteLength:a}=t,i=r*n;return!(e._pendingPullIntos.length>0)&&("closed"===o._state||e._queueTotalSize>=i)}(o._readableStreamController,t,r)}(this,e,o)?new dt:new ct;return bt(this,e,o,n),n._promise}releaseLock(){if(!ft(this))throw _t("releaseLock");void 0!==this._ownerReadableStream&&function(e){B(e);const t=new TypeError("Reader was released");ht(e,t)}(this)}}Object.defineProperties(ReadableStreamBYOBReader.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),o(ReadableStreamBYOBReader.prototype.cancel,"cancel"),o(ReadableStreamBYOBReader.prototype.read,"read"),o(ReadableStreamBYOBReader.prototype.releaseLock,"releaseLock"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableStreamBYOBReader.prototype,Symbol.toStringTag,{value:"ReadableStreamBYOBReader",configurable:!0});class ct{constructor(){this._promise=u((e,t)=>{this._resolvePromise=e,this._rejectPromise=t})}_chunkSteps(e){this._resolvePromise({value:e,done:!1})}_closeSteps(e){this._resolvePromise({value:e,done:!0})}_errorSteps(e){this._rejectPromise(e)}}class dt{constructor(){this._promise=void 0}_chunkSteps(e){this._promise=l({value:e,done:!1})}_closeSteps(e){this._promise=l({value:e,done:!0})}_errorSteps(e){this._promise=d(e)}}function ft(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readIntoRequests")&&e instanceof ReadableStreamBYOBReader)}function bt(e,t,r,o){const n=e._ownerReadableStream;n._disturbed=!0,"errored"===n._state?o._errorSteps(n._storedError):function(e,t,r,o){const n=e._controlledReadableByteStream,a=t.constructor,i=We(a),{byteOffset:s,byteLength:l}=t,u=r*i;let c;try{c=ce(t.buffer)}catch(e){return void o._errorSteps(e)}const d={buffer:c,bufferByteLength:c.byteLength,byteOffset:s,byteLength:l,bytesFilled:0,minimumFill:u,elementSize:i,viewConstructor:a,readerType:"byob"};if(e._pendingPullIntos.length>0)return e._pendingPullIntos.push(d),void st(n,o);if("closed"===n._state){const e=new a(d.buffer,d.byteOffset,0);return void o._closeSteps(e)}if(e._queueTotalSize>0){if($e(e,d)){const t=De(d);return Ye(e),void o._chunkSteps(t)}if(e._closeRequested){const t=new TypeError("Insufficient bytes to fill elements in the given buffer");return Xe(e,t),void o._errorSteps(t)}}e._pendingPullIntos.push(d),st(n,o),je(e)}(n._readableStreamController,t,r,o)}function ht(e,t){const r=e._readIntoRequests;e._readIntoRequests=new v,r.forEach(e=>{e._errorSteps(t)})}function _t(e){return new TypeError(`ReadableStreamBYOBReader.prototype.${e} can only be used on a ReadableStreamBYOBReader`)}function mt(e,t){const{highWaterMark:r}=e;if(void 0===r)return t;if(Re(r)||r<0)throw new RangeError("Invalid highWaterMark");return r}function pt(e){const{size:t}=e;return t||(()=>1)}function yt(e,t){L(e,t);const r=null==e?void 0:e.highWaterMark,o=null==e?void 0:e.size;return{highWaterMark:void 0===r?void 0:Q(r),size:void 0===o?void 0:St(o,`${t} has member 'size' that`)}}function St(e,t){return I(e,t),t=>Q(e(t))}function gt(e,t,r){return I(e,r),r=>g(e,t,[r])}function vt(e,t,r){return I(e,r),()=>g(e,t,[])}function wt(e,t,r){return I(e,r),r=>S(e,t,[r])}function Rt(e,t,r){return I(e,r),(r,o)=>g(e,t,[r,o])}function Tt(e,t){if(!qt(e))throw new TypeError(`${t} is not a WritableStream.`)}class WritableStream{constructor(e={},t={}){void 0===e?e=null:$(e,"First parameter");const r=yt(t,"Second parameter"),o=function(e,t){L(e,t);const r=null==e?void 0:e.abort,o=null==e?void 0:e.close,n=null==e?void 0:e.start,a=null==e?void 0:e.type,i=null==e?void 0:e.write;return{abort:void 0===r?void 0:gt(r,e,`${t} has member 'abort' that`),close:void 0===o?void 0:vt(o,e,`${t} has member 'close' that`),start:void 0===n?void 0:wt(n,e,`${t} has member 'start' that`),write:void 0===i?void 0:Rt(i,e,`${t} has member 'write' that`),type:a}}(e,"First parameter");Ct(this);if(void 0!==o.type)throw new RangeError("Invalid type is specified");const n=pt(r);!function(e,t,r,o){const n=Object.create(WritableStreamDefaultController.prototype);let a,i,s,l;a=void 0!==t.start?()=>t.start(n):()=>{};i=void 0!==t.write?e=>t.write(e,n):()=>c(void 0);s=void 0!==t.close?()=>t.close():()=>c(void 0);l=void 0!==t.abort?e=>t.abort(e):()=>c(void 0);Nt(e,n,a,i,s,l,r,o)}(this,o,mt(r,1),n)}get locked(){if(!qt(this))throw Kt("locked");return Et(this)}abort(e=void 0){return qt(this)?Et(this)?d(new TypeError("Cannot abort a stream that already has a writer")):Wt(this,e):d(Kt("abort"))}close(){return qt(this)?Et(this)?d(new TypeError("Cannot close a stream that already has a writer")):At(this)?d(new TypeError("Cannot close an already-closing stream")):Bt(this):d(Kt("close"))}getWriter(){if(!qt(this))throw Kt("getWriter");return Pt(this)}}function Pt(e){return new WritableStreamDefaultWriter(e)}function Ct(e){e._state="writable",e._storedError=void 0,e._writer=void 0,e._writableStreamController=void 0,e._writeRequests=new v,e._inFlightWriteRequest=void 0,e._closeRequest=void 0,e._inFlightCloseRequest=void 0,e._pendingAbortRequest=void 0,e._backpressure=!1}function qt(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_writableStreamController")&&e instanceof WritableStream)}function Et(e){return void 0!==e._writer}function Wt(e,t){var r;if("closed"===e._state||"errored"===e._state)return c(void 0);e._writableStreamController._abortReason=t,null===(r=e._writableStreamController._abortController)||void 0===r||r.abort(t);const o=e._state;if("closed"===o||"errored"===o)return c(void 0);if(void 0!==e._pendingAbortRequest)return e._pendingAbortRequest._promise;let n=!1;"erroring"===o&&(n=!0,t=void 0);const a=u((r,o)=>{e._pendingAbortRequest={_promise:void 0,_resolve:r,_reject:o,_reason:t,_wasAlreadyErroring:n}});return e._pendingAbortRequest._promise=a,n||jt(e,t),a}function Bt(e){const t=e._state;if("closed"===t||"errored"===t)return d(new TypeError(`The stream (in ${t} state) is not in the writable state and cannot be closed`));const r=u((t,r)=>{const o={_resolve:t,_reject:r};e._closeRequest=o}),o=e._writer;var n;return void 0!==o&&e._backpressure&&"writable"===t&&cr(o),Ce(n=e._writableStreamController,Qt,0),Ut(n),r}function Ot(e,t){"writable"!==e._state?kt(e):jt(e,t)}function jt(e,t){const r=e._writableStreamController;e._state="erroring",e._storedError=t;const o=e._writer;void 0!==o&&$t(o,t),!function(e){if(void 0===e._inFlightWriteRequest&&void 0===e._inFlightCloseRequest)return!1;return!0}(e)&&r._started&&kt(e)}function kt(e){e._state="errored",e._writableStreamController[R]();const t=e._storedError;if(e._writeRequests.forEach(e=>{e._reject(t)}),e._writeRequests=new v,void 0===e._pendingAbortRequest)return void zt(e);const r=e._pendingAbortRequest;if(e._pendingAbortRequest=void 0,r._wasAlreadyErroring)return r._reject(t),void zt(e);b(e._writableStreamController[w](r._reason),()=>(r._resolve(),zt(e),null),t=>(r._reject(t),zt(e),null))}function At(e){return void 0!==e._closeRequest||void 0!==e._inFlightCloseRequest}function zt(e){void 0!==e._closeRequest&&(e._closeRequest._reject(e._storedError),e._closeRequest=void 0);const t=e._writer;void 0!==t&&nr(t,e._storedError)}function Dt(e,t){const r=e._writer;void 0!==r&&t!==e._backpressure&&(t?function(e){ir(e)}(r):cr(r)),e._backpressure=t}Object.defineProperties(WritableStream.prototype,{abort:{enumerable:!0},close:{enumerable:!0},getWriter:{enumerable:!0},locked:{enumerable:!0}}),o(WritableStream.prototype.abort,"abort"),o(WritableStream.prototype.close,"close"),o(WritableStream.prototype.getWriter,"getWriter"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(WritableStream.prototype,Symbol.toStringTag,{value:"WritableStream",configurable:!0});class WritableStreamDefaultWriter{constructor(e){if(M(e,1,"WritableStreamDefaultWriter"),Tt(e,"First parameter"),Et(e))throw new TypeError("This stream has already been locked for exclusive writing by another writer");this._ownerWritableStream=e,e._writer=this;const t=e._state;if("writable"===t)!At(e)&&e._backpressure?ir(this):lr(this),rr(this);else if("erroring"===t)sr(this,e._storedError),rr(this);else if("closed"===t)lr(this),rr(r=this),ar(r);else{const t=e._storedError;sr(this,t),or(this,t)}var r}get closed(){return Ft(this)?this._closedPromise:d(er("closed"))}get desiredSize(){if(!Ft(this))throw er("desiredSize");if(void 0===this._ownerWritableStream)throw tr("desiredSize");return function(e){const t=e._ownerWritableStream,r=t._state;if("errored"===r||"erroring"===r)return null;if("closed"===r)return 0;return Vt(t._writableStreamController)}(this)}get ready(){return Ft(this)?this._readyPromise:d(er("ready"))}abort(e=void 0){return Ft(this)?void 0===this._ownerWritableStream?d(tr("abort")):function(e,t){return Wt(e._ownerWritableStream,t)}(this,e):d(er("abort"))}close(){if(!Ft(this))return d(er("close"));const e=this._ownerWritableStream;return void 0===e?d(tr("close")):At(e)?d(new TypeError("Cannot close an already-closing stream")):Lt(this)}releaseLock(){if(!Ft(this))throw er("releaseLock");void 0!==this._ownerWritableStream&&Mt(this)}write(e=void 0){return Ft(this)?void 0===this._ownerWritableStream?d(tr("write to")):Yt(this,e):d(er("write"))}}function Ft(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_ownerWritableStream")&&e instanceof WritableStreamDefaultWriter)}function Lt(e){return Bt(e._ownerWritableStream)}function It(e,t){"pending"===e._closedPromiseState?nr(e,t):function(e,t){or(e,t)}(e,t)}function $t(e,t){"pending"===e._readyPromiseState?ur(e,t):function(e,t){sr(e,t)}(e,t)}function Mt(e){const t=e._ownerWritableStream,r=new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");$t(e,r),It(e,r),t._writer=void 0,e._ownerWritableStream=void 0}function Yt(e,t){const r=e._ownerWritableStream,o=r._writableStreamController,n=function(e,t){if(void 0===e._strategySizeAlgorithm)return 1;try{return e._strategySizeAlgorithm(t)}catch(t){return Gt(e,t),1}}(o,t);if(r!==e._ownerWritableStream)return d(tr("write to"));const a=r._state;if("errored"===a)return d(r._storedError);if(At(r)||"closed"===a)return d(new TypeError("The stream is closing or closed and cannot be written to"));if("erroring"===a)return d(r._storedError);const i=function(e){return u((t,r)=>{const o={_resolve:t,_reject:r};e._writeRequests.push(o)})}(r);return function(e,t,r){try{Ce(e,t,r)}catch(t){return void Gt(e,t)}const o=e._controlledWritableStream;if(!At(o)&&"writable"===o._state){Dt(o,Xt(e))}Ut(e)}(o,t,n),i}Object.defineProperties(WritableStreamDefaultWriter.prototype,{abort:{enumerable:!0},close:{enumerable:!0},releaseLock:{enumerable:!0},write:{enumerable:!0},closed:{enumerable:!0},desiredSize:{enumerable:!0},ready:{enumerable:!0}}),o(WritableStreamDefaultWriter.prototype.abort,"abort"),o(WritableStreamDefaultWriter.prototype.close,"close"),o(WritableStreamDefaultWriter.prototype.releaseLock,"releaseLock"),o(WritableStreamDefaultWriter.prototype.write,"write"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(WritableStreamDefaultWriter.prototype,Symbol.toStringTag,{value:"WritableStreamDefaultWriter",configurable:!0});const Qt={};class WritableStreamDefaultController{constructor(){throw new TypeError("Illegal constructor")}get abortReason(){if(!xt(this))throw Zt("abortReason");return this._abortReason}get signal(){if(!xt(this))throw Zt("signal");if(void 0===this._abortController)throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");return this._abortController.signal}error(e=void 0){if(!xt(this))throw Zt("error");"writable"===this._controlledWritableStream._state&&Jt(this,e)}[w](e){const t=this._abortAlgorithm(e);return Ht(this),t}[R](){qe(this)}}function xt(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledWritableStream")&&e instanceof WritableStreamDefaultController)}function Nt(e,t,r,o,n,a,i,s){t._controlledWritableStream=e,e._writableStreamController=t,t._queue=void 0,t._queueTotalSize=void 0,qe(t),t._abortReason=void 0,t._abortController=function(){if("function"==typeof AbortController)return new AbortController}(),t._started=!1,t._strategySizeAlgorithm=s,t._strategyHWM=i,t._writeAlgorithm=o,t._closeAlgorithm=n,t._abortAlgorithm=a;const l=Xt(t);Dt(e,l);b(c(r()),()=>(t._started=!0,Ut(t),null),r=>(t._started=!0,Ot(e,r),null))}function Ht(e){e._writeAlgorithm=void 0,e._closeAlgorithm=void 0,e._abortAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function Vt(e){return e._strategyHWM-e._queueTotalSize}function Ut(e){const t=e._controlledWritableStream;if(!e._started)return;if(void 0!==t._inFlightWriteRequest)return;if("erroring"===t._state)return void kt(t);if(0===e._queue.length)return;const r=e._queue.peek().value;r===Qt?function(e){const t=e._controlledWritableStream;(function(e){e._inFlightCloseRequest=e._closeRequest,e._closeRequest=void 0})(t),Pe(e);const r=e._closeAlgorithm();Ht(e),b(r,()=>(function(e){e._inFlightCloseRequest._resolve(void 0),e._inFlightCloseRequest=void 0,"erroring"===e._state&&(e._storedError=void 0,void 0!==e._pendingAbortRequest&&(e._pendingAbortRequest._resolve(),e._pendingAbortRequest=void 0)),e._state="closed";const t=e._writer;void 0!==t&&ar(t)}(t),null),e=>(function(e,t){e._inFlightCloseRequest._reject(t),e._inFlightCloseRequest=void 0,void 0!==e._pendingAbortRequest&&(e._pendingAbortRequest._reject(t),e._pendingAbortRequest=void 0),Ot(e,t)}(t,e),null))}(e):function(e,t){const r=e._controlledWritableStream;!function(e){e._inFlightWriteRequest=e._writeRequests.shift()}(r);const o=e._writeAlgorithm(t);b(o,()=>{!function(e){e._inFlightWriteRequest._resolve(void 0),e._inFlightWriteRequest=void 0}(r);const t=r._state;if(Pe(e),!At(r)&&"writable"===t){const t=Xt(e);Dt(r,t)}return Ut(e),null},t=>("writable"===r._state&&Ht(e),function(e,t){e._inFlightWriteRequest._reject(t),e._inFlightWriteRequest=void 0,Ot(e,t)}(r,t),null))}(e,r)}function Gt(e,t){"writable"===e._controlledWritableStream._state&&Jt(e,t)}function Xt(e){return Vt(e)<=0}function Jt(e,t){const r=e._controlledWritableStream;Ht(e),jt(r,t)}function Kt(e){return new TypeError(`WritableStream.prototype.${e} can only be used on a WritableStream`)}function Zt(e){return new TypeError(`WritableStreamDefaultController.prototype.${e} can only be used on a WritableStreamDefaultController`)}function er(e){return new TypeError(`WritableStreamDefaultWriter.prototype.${e} can only be used on a WritableStreamDefaultWriter`)}function tr(e){return new TypeError("Cannot "+e+" a stream using a released writer")}function rr(e){e._closedPromise=u((t,r)=>{e._closedPromise_resolve=t,e._closedPromise_reject=r,e._closedPromiseState="pending"})}function or(e,t){rr(e),nr(e,t)}function nr(e,t){void 0!==e._closedPromise_reject&&(p(e._closedPromise),e._closedPromise_reject(t),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="rejected")}function ar(e){void 0!==e._closedPromise_resolve&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="resolved")}function ir(e){e._readyPromise=u((t,r)=>{e._readyPromise_resolve=t,e._readyPromise_reject=r}),e._readyPromiseState="pending"}function sr(e,t){ir(e),ur(e,t)}function lr(e){ir(e),cr(e)}function ur(e,t){void 0!==e._readyPromise_reject&&(p(e._readyPromise),e._readyPromise_reject(t),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="rejected")}function cr(e){void 0!==e._readyPromise_resolve&&(e._readyPromise_resolve(void 0),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="fulfilled")}Object.defineProperties(WritableStreamDefaultController.prototype,{abortReason:{enumerable:!0},signal:{enumerable:!0},error:{enumerable:!0}}),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(WritableStreamDefaultController.prototype,Symbol.toStringTag,{value:"WritableStreamDefaultController",configurable:!0});const dr="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:"undefined"!=typeof global?global:void 0;const fr=function(){const e=null==dr?void 0:dr.DOMException;return function(e){if("function"!=typeof e&&"object"!=typeof e)return!1;if("DOMException"!==e.name)return!1;try{return new e,!0}catch(e){return!1}}(e)?e:void 0}()||function(){const e=function(e,t){this.message=e||"",this.name=t||"Error",Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)};return o(e,"DOMException"),e.prototype=Object.create(Error.prototype),Object.defineProperty(e.prototype,"constructor",{value:e,writable:!0,configurable:!0}),e}();function br(e,t,r,o,n,a){const i=V(e),s=Pt(t);e._disturbed=!0;const l=new hr(s),_=new mr(l);return u((m,y)=>{let S;if(void 0!==a){if(S=()=>{const r=void 0!==a.reason?a.reason:new fr("Aborted","AbortError"),i=[];o||i.push(()=>"writable"===t._state?Wt(t,r):c(void 0)),n||i.push(()=>"readable"===e._state?Mr(e,r):c(void 0)),T(()=>Promise.all(i.map(e=>e())),!0,r)},a.aborted)return void S();a.addEventListener("abort",S)}function g(){for(;!l._shuttingDown&&!t._backpressure&&"writable"===t._state&&!At(t)&&"readable"===e._state&&re(i);)te(i,_);if(l._shuttingDown)return c(!0);if(t._backpressure)return f(s._readyPromise,()=>!1);const r=new _r(l);return te(i,r),r._promise}var v,w,R;if(pr(e,i._closedPromise,e=>(o?P(!0,e):T(()=>Wt(t,e),!0,e),null)),pr(t,s._closedPromise,t=>(n?P(!0,t):T(()=>Mr(e,t),!0,t),null)),v=e,w=i._closedPromise,R=()=>(r?P():T(()=>function(e){const t=e._ownerWritableStream,r=t._state;return At(t)||"closed"===r?c(void 0):"errored"===r?d(t._storedError):Lt(e)}(s)),null),"closed"===v._state?R():h(w,R),At(t)||"closed"===t._state){const t=new TypeError("the destination writable stream closed before all data could be piped to it");n?P(!0,t):T(()=>Mr(e,t),!0,t)}function T(e,r,o){function n(){return b(e(),()=>C(r,o),e=>C(!0,e)),null}l._shuttingDown||(l._shuttingDown=!0,"writable"!==t._state||At(t)?n():h(l._waitForWritesToFinish(),n))}function P(e,r){l._shuttingDown||(l._shuttingDown=!0,"writable"!==t._state||At(t)?C(e,r):h(l._waitForWritesToFinish(),()=>C(e,r)))}function C(e,t){return Mt(s),B(i),void 0!==a&&a.removeEventListener("abort",S),e?y(t):m(void 0),null}p(u((e,t)=>{!function r(o){o?e():f(g(),r,t)}(!1)}))})}class hr{constructor(e){this._writer=e,this._shuttingDown=!1,this._currentWrite=c(void 0)}_waitForWritesToFinish(){const e=this._currentWrite;return f(this._currentWrite,()=>e!==this._currentWrite?this._waitForWritesToFinish():void 0)}}class _r{constructor(e){this._state=e,this._promise=u((e,t)=>{this._resolvePromise=e,this._rejectPromise=t})}_chunkSteps(t){this._state._currentWrite=f(Yt(this._state._writer,t),void 0,e),this._resolvePromise(!1)}_closeSteps(){this._resolvePromise(!0)}_errorSteps(e){this._rejectPromise(e)}}class mr{constructor(e){this._state=e}_chunkSteps(t){this._state._currentWrite=f(Yt(this._state._writer,t),void 0,e)}_closeSteps(){}_errorSteps(e){}}function pr(e,t,r){"errored"===e._state?r(e._storedError):_(t,r)}class ReadableStreamDefaultController{constructor(){throw new TypeError("Illegal constructor")}get desiredSize(){if(!yr(this))throw Er("desiredSize");return Pr(this)}close(){if(!yr(this))throw Er("close");if(!Cr(this))throw new TypeError("The stream is not in a state that permits close");wr(this)}enqueue(e=void 0){if(!yr(this))throw Er("enqueue");if(!Cr(this))throw new TypeError("The stream is not in a state that permits enqueue");return Rr(this,e)}error(e=void 0){if(!yr(this))throw Er("error");Tr(this,e)}[T](e){qe(this);const t=this._cancelAlgorithm(e);return vr(this),t}[P](e){const t=this._controlledReadableStream;if(this._queue.length>0){const r=Pe(this);this._closeRequested&&0===this._queue.length?(vr(this),Yr(t)):Sr(this),e._chunkSteps(r)}else U(t,e),Sr(this)}[C](){return this._queue.length>0}[q](){}}function yr(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledReadableStream")&&e instanceof ReadableStreamDefaultController)}function Sr(e){if(!gr(e))return;if(e._pulling)return void(e._pullAgain=!0);e._pulling=!0;b(e._pullAlgorithm(),()=>(e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,Sr(e)),null),t=>(Tr(e,t),null))}function gr(e){const t=e._controlledReadableStream;if(!Cr(e))return!1;if(!e._started)return!1;if($r(t)&&X(t)>0)return!0;return Pr(e)>0}function vr(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function wr(e){if(!Cr(e))return;const t=e._controlledReadableStream;e._closeRequested=!0,0===e._queue.length&&(vr(e),Yr(t))}function Rr(e,t){if(!Cr(e))return;const r=e._controlledReadableStream;if($r(r)&&X(r)>0)G(r,t,!1);else{let r;try{r=e._strategySizeAlgorithm(t)}catch(t){throw Tr(e,t),t}try{Ce(e,t,r)}catch(t){throw Tr(e,t),t}}Sr(e)}function Tr(e,t){const r=e._controlledReadableStream;"readable"===r._state&&(qe(e),vr(e),Qr(r,t))}function Pr(e){const t=e._controlledReadableStream._state;return"errored"===t?null:"closed"===t?0:e._strategyHWM-e._queueTotalSize}function Cr(e){const t=e._controlledReadableStream._state;return!e._closeRequested&&"readable"===t}function qr(e,t,r,o,n,a,i){t._controlledReadableStream=e,t._queue=void 0,t._queueTotalSize=void 0,qe(t),t._started=!1,t._closeRequested=!1,t._pullAgain=!1,t._pulling=!1,t._strategySizeAlgorithm=i,t._strategyHWM=a,t._pullAlgorithm=o,t._cancelAlgorithm=n,e._readableStreamController=t;b(c(r()),()=>(t._started=!0,Sr(t),null),e=>(Tr(t,e),null))}function Er(e){return new TypeError(`ReadableStreamDefaultController.prototype.${e} can only be used on a ReadableStreamDefaultController`)}function Wr(e,t){return Be(e._readableStreamController)?function(e){let t,r,o,n,a,i=V(e),s=!1,l=!1,d=!1,f=!1,b=!1;const h=u(e=>{a=e});function m(e){_(e._closedPromise,t=>(e!==i||(Xe(o._readableStreamController,t),Xe(n._readableStreamController,t),f&&b||a(void 0)),null))}function p(){ft(i)&&(B(i),i=V(e),m(i));te(i,{_chunkSteps:t=>{y(()=>{l=!1,d=!1;const r=t;let i=t;if(!f&&!b)try{i=Te(t)}catch(t){return Xe(o._readableStreamController,t),Xe(n._readableStreamController,t),void a(Mr(e,t))}f||Ge(o._readableStreamController,r),b||Ge(n._readableStreamController,i),s=!1,l?g():d&&v()})},_closeSteps:()=>{s=!1,f||Ue(o._readableStreamController),b||Ue(n._readableStreamController),o._readableStreamController._pendingPullIntos.length>0&&et(o._readableStreamController,0),n._readableStreamController._pendingPullIntos.length>0&&et(n._readableStreamController,0),f&&b||a(void 0)},_errorSteps:()=>{s=!1}})}function S(t,r){ee(i)&&(B(i),i=it(e),m(i));const u=r?n:o,c=r?o:n;bt(i,t,1,{_chunkSteps:t=>{y(()=>{l=!1,d=!1;const o=r?b:f;if(r?f:b)o||tt(u._readableStreamController,t);else{let r;try{r=Te(t)}catch(t){return Xe(u._readableStreamController,t),Xe(c._readableStreamController,t),void a(Mr(e,t))}o||tt(u._readableStreamController,t),Ge(c._readableStreamController,r)}s=!1,l?g():d&&v()})},_closeSteps:e=>{s=!1;const t=r?b:f,o=r?f:b;t||Ue(u._readableStreamController),o||Ue(c._readableStreamController),void 0!==e&&(t||tt(u._readableStreamController,e),!o&&c._readableStreamController._pendingPullIntos.length>0&&et(c._readableStreamController,0)),t&&o||a(void 0)},_errorSteps:()=>{s=!1}})}function g(){if(s)return l=!0,c(void 0);s=!0;const e=Ke(o._readableStreamController);return null===e?p():S(e._view,!1),c(void 0)}function v(){if(s)return d=!0,c(void 0);s=!0;const e=Ke(n._readableStreamController);return null===e?p():S(e._view,!0),c(void 0)}function w(o){if(f=!0,t=o,b){const o=le([t,r]),n=Mr(e,o);a(n)}return h}function R(o){if(b=!0,r=o,f){const o=le([t,r]),n=Mr(e,o);a(n)}return h}function T(){}return o=Fr(T,g,w),n=Fr(T,v,R),m(i),[o,n]}(e):function(e){const t=V(e);let r,o,n,a,i,s=!1,l=!1,d=!1,f=!1;const b=u(e=>{i=e});function h(){if(s)return l=!0,c(void 0);s=!0;return te(t,{_chunkSteps:e=>{y(()=>{l=!1;const t=e,r=e;d||Rr(n._readableStreamController,t),f||Rr(a._readableStreamController,r),s=!1,l&&h()})},_closeSteps:()=>{s=!1,d||wr(n._readableStreamController),f||wr(a._readableStreamController),d&&f||i(void 0)},_errorSteps:()=>{s=!1}}),c(void 0)}function m(t){if(d=!0,r=t,f){const t=le([r,o]),n=Mr(e,t);i(n)}return b}function p(t){if(f=!0,o=t,d){const t=le([r,o]),n=Mr(e,t);i(n)}return b}function S(){}return n=Dr(S,h,m),a=Dr(S,h,p),_(t._closedPromise,e=>(Tr(n._readableStreamController,e),Tr(a._readableStreamController,e),d&&f||i(void 0),null)),[n,a]}(e)}function Br(r){return t(o=r)&&void 0!==o.getReader?function(r){let o;function n(){let e;try{e=r.read()}catch(e){return d(e)}return m(e,e=>{if(!t(e))throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");if(e.done)wr(o._readableStreamController);else{const t=e.value;Rr(o._readableStreamController,t)}})}function a(e){try{return c(r.cancel(e))}catch(e){return d(e)}}return o=Dr(e,n,a,0),o}(r.getReader()):function(r){let o;const n=me(r,"async");function a(){let e;try{e=pe(n)}catch(e){return d(e)}return m(c(e),e=>{if(!t(e))throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");if(e.done)wr(o._readableStreamController);else{const t=e.value;Rr(o._readableStreamController,t)}})}function i(e){const r=n.iterator;let o;try{o=be(r,"return")}catch(e){return d(e)}if(void 0===o)return c(void 0);return m(g(o,r,[e]),e=>{if(!t(e))throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object")})}return o=Dr(e,a,i,0),o}(r);var o}function Or(e,t,r){return I(e,r),r=>g(e,t,[r])}function jr(e,t,r){return I(e,r),r=>g(e,t,[r])}function kr(e,t,r){return I(e,r),r=>S(e,t,[r])}function Ar(e,t){if("bytes"!==(e=`${e}`))throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamType`);return e}function zr(e,t){L(e,t);const r=null==e?void 0:e.preventAbort,o=null==e?void 0:e.preventCancel,n=null==e?void 0:e.preventClose,a=null==e?void 0:e.signal;return void 0!==a&&function(e,t){if(!function(e){if("object"!=typeof e||null===e)return!1;try{return"boolean"==typeof e.aborted}catch(e){return!1}}(e))throw new TypeError(`${t} is not an AbortSignal.`)}(a,`${t} has member 'signal' that`),{preventAbort:Boolean(r),preventCancel:Boolean(o),preventClose:Boolean(n),signal:a}}Object.defineProperties(ReadableStreamDefaultController.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},desiredSize:{enumerable:!0}}),o(ReadableStreamDefaultController.prototype.close,"close"),o(ReadableStreamDefaultController.prototype.enqueue,"enqueue"),o(ReadableStreamDefaultController.prototype.error,"error"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableStreamDefaultController.prototype,Symbol.toStringTag,{value:"ReadableStreamDefaultController",configurable:!0});class ReadableStream{constructor(e={},t={}){void 0===e?e=null:$(e,"First parameter");const r=yt(t,"Second parameter"),o=function(e,t){L(e,t);const r=e,o=null==r?void 0:r.autoAllocateChunkSize,n=null==r?void 0:r.cancel,a=null==r?void 0:r.pull,i=null==r?void 0:r.start,s=null==r?void 0:r.type;return{autoAllocateChunkSize:void 0===o?void 0:N(o,`${t} has member 'autoAllocateChunkSize' that`),cancel:void 0===n?void 0:Or(n,r,`${t} has member 'cancel' that`),pull:void 0===a?void 0:jr(a,r,`${t} has member 'pull' that`),start:void 0===i?void 0:kr(i,r,`${t} has member 'start' that`),type:void 0===s?void 0:Ar(s,`${t} has member 'type' that`)}}(e,"First parameter");if(Lr(this),"bytes"===o.type){if(void 0!==r.size)throw new RangeError("The strategy for a byte stream cannot have a size function");!function(e,t,r){const o=Object.create(ReadableByteStreamController.prototype);let n,a,i;n=void 0!==t.start?()=>t.start(o):()=>{},a=void 0!==t.pull?()=>t.pull(o):()=>c(void 0),i=void 0!==t.cancel?e=>t.cancel(e):()=>c(void 0);const s=t.autoAllocateChunkSize;if(0===s)throw new TypeError("autoAllocateChunkSize must be greater than 0");rt(e,o,n,a,i,r,s)}(this,o,mt(r,0))}else{const e=pt(r);!function(e,t,r,o){const n=Object.create(ReadableStreamDefaultController.prototype);let a,i,s;a=void 0!==t.start?()=>t.start(n):()=>{},i=void 0!==t.pull?()=>t.pull(n):()=>c(void 0),s=void 0!==t.cancel?e=>t.cancel(e):()=>c(void 0),qr(e,n,a,i,s,r,o)}(this,o,mt(r,1),e)}}get locked(){if(!Ir(this))throw xr("locked");return $r(this)}cancel(e=void 0){return Ir(this)?$r(this)?d(new TypeError("Cannot cancel a stream that already has a reader")):Mr(this,e):d(xr("cancel"))}getReader(e=void 0){if(!Ir(this))throw xr("getReader");return void 0===function(e,t){L(e,t);const r=null==e?void 0:e.mode;return{mode:void 0===r?void 0:at(r,`${t} has member 'mode' that`)}}(e,"First parameter").mode?V(this):it(this)}pipeThrough(e,t={}){if(!Ir(this))throw xr("pipeThrough");M(e,1,"pipeThrough");const r=function(e,t){L(e,t);const r=null==e?void 0:e.readable;Y(r,"readable","ReadableWritablePair"),H(r,`${t} has member 'readable' that`);const o=null==e?void 0:e.writable;return Y(o,"writable","ReadableWritablePair"),Tt(o,`${t} has member 'writable' that`),{readable:r,writable:o}}(e,"First parameter"),o=zr(t,"Second parameter");if($r(this))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");if(Et(r.writable))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");return p(br(this,r.writable,o.preventClose,o.preventAbort,o.preventCancel,o.signal)),r.readable}pipeTo(e,t={}){if(!Ir(this))return d(xr("pipeTo"));if(void 0===e)return d("Parameter 1 is required in 'pipeTo'.");if(!qt(e))return d(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));let r;try{r=zr(t,"Second parameter")}catch(e){return d(e)}return $r(this)?d(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")):Et(e)?d(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")):br(this,e,r.preventClose,r.preventAbort,r.preventCancel,r.signal)}tee(){if(!Ir(this))throw xr("tee");return le(Wr(this))}values(e=void 0){if(!Ir(this))throw xr("values");return function(e,t){const r=V(e),o=new ye(r,t),n=Object.create(ge);return n._asyncIteratorImpl=o,n}(this,function(e,t){L(e,t);const r=null==e?void 0:e.preventCancel;return{preventCancel:Boolean(r)}}(e,"First parameter").preventCancel)}[_e](e){return this.values(e)}static from(e){return Br(e)}}function Dr(e,t,r,o=1,n=()=>1){const a=Object.create(ReadableStream.prototype);Lr(a);return qr(a,Object.create(ReadableStreamDefaultController.prototype),e,t,r,o,n),a}function Fr(e,t,r){const o=Object.create(ReadableStream.prototype);Lr(o);return rt(o,Object.create(ReadableByteStreamController.prototype),e,t,r,0,void 0),o}function Lr(e){e._state="readable",e._reader=void 0,e._storedError=void 0,e._disturbed=!1}function Ir(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readableStreamController")&&e instanceof ReadableStream)}function $r(e){return void 0!==e._reader}function Mr(t,r){if(t._disturbed=!0,"closed"===t._state)return c(void 0);if("errored"===t._state)return d(t._storedError);Yr(t);const o=t._reader;if(void 0!==o&&ft(o)){const e=o._readIntoRequests;o._readIntoRequests=new v,e.forEach(e=>{e._closeSteps(void 0)})}return m(t._readableStreamController[T](r),e)}function Yr(e){e._state="closed";const t=e._reader;if(void 0!==t&&(z(t),ee(t))){const e=t._readRequests;t._readRequests=new v,e.forEach(e=>{e._closeSteps()})}}function Qr(e,t){e._state="errored",e._storedError=t;const r=e._reader;void 0!==r&&(A(r,t),ee(r)?oe(r,t):ht(r,t))}function xr(e){return new TypeError(`ReadableStream.prototype.${e} can only be used on a ReadableStream`)}function Nr(e,t){L(e,t);const r=null==e?void 0:e.highWaterMark;return Y(r,"highWaterMark","QueuingStrategyInit"),{highWaterMark:Q(r)}}Object.defineProperties(ReadableStream,{from:{enumerable:!0}}),Object.defineProperties(ReadableStream.prototype,{cancel:{enumerable:!0},getReader:{enumerable:!0},pipeThrough:{enumerable:!0},pipeTo:{enumerable:!0},tee:{enumerable:!0},values:{enumerable:!0},locked:{enumerable:!0}}),o(ReadableStream.from,"from"),o(ReadableStream.prototype.cancel,"cancel"),o(ReadableStream.prototype.getReader,"getReader"),o(ReadableStream.prototype.pipeThrough,"pipeThrough"),o(ReadableStream.prototype.pipeTo,"pipeTo"),o(ReadableStream.prototype.tee,"tee"),o(ReadableStream.prototype.values,"values"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ReadableStream.prototype,Symbol.toStringTag,{value:"ReadableStream",configurable:!0}),Object.defineProperty(ReadableStream.prototype,_e,{value:ReadableStream.prototype.values,writable:!0,configurable:!0});const Hr=e=>e.byteLength;o(Hr,"size");class ByteLengthQueuingStrategy{constructor(e){M(e,1,"ByteLengthQueuingStrategy"),e=Nr(e,"First parameter"),this._byteLengthQueuingStrategyHighWaterMark=e.highWaterMark}get highWaterMark(){if(!Ur(this))throw Vr("highWaterMark");return this._byteLengthQueuingStrategyHighWaterMark}get size(){if(!Ur(this))throw Vr("size");return Hr}}function Vr(e){return new TypeError(`ByteLengthQueuingStrategy.prototype.${e} can only be used on a ByteLengthQueuingStrategy`)}function Ur(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_byteLengthQueuingStrategyHighWaterMark")&&e instanceof ByteLengthQueuingStrategy)}Object.defineProperties(ByteLengthQueuingStrategy.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(ByteLengthQueuingStrategy.prototype,Symbol.toStringTag,{value:"ByteLengthQueuingStrategy",configurable:!0});const Gr=()=>1;o(Gr,"size");class CountQueuingStrategy{constructor(e){M(e,1,"CountQueuingStrategy"),e=Nr(e,"First parameter"),this._countQueuingStrategyHighWaterMark=e.highWaterMark}get highWaterMark(){if(!Jr(this))throw Xr("highWaterMark");return this._countQueuingStrategyHighWaterMark}get size(){if(!Jr(this))throw Xr("size");return Gr}}function Xr(e){return new TypeError(`CountQueuingStrategy.prototype.${e} can only be used on a CountQueuingStrategy`)}function Jr(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_countQueuingStrategyHighWaterMark")&&e instanceof CountQueuingStrategy)}function Kr(e,t,r){return I(e,r),r=>g(e,t,[r])}function Zr(e,t,r){return I(e,r),r=>S(e,t,[r])}function eo(e,t,r){return I(e,r),(r,o)=>g(e,t,[r,o])}function to(e,t,r){return I(e,r),r=>g(e,t,[r])}Object.defineProperties(CountQueuingStrategy.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(CountQueuingStrategy.prototype,Symbol.toStringTag,{value:"CountQueuingStrategy",configurable:!0});class TransformStream{constructor(e={},t={},r={}){void 0===e&&(e=null);const o=yt(t,"Second parameter"),n=yt(r,"Third parameter"),a=function(e,t){L(e,t);const r=null==e?void 0:e.cancel,o=null==e?void 0:e.flush,n=null==e?void 0:e.readableType,a=null==e?void 0:e.start,i=null==e?void 0:e.transform,s=null==e?void 0:e.writableType;return{cancel:void 0===r?void 0:to(r,e,`${t} has member 'cancel' that`),flush:void 0===o?void 0:Kr(o,e,`${t} has member 'flush' that`),readableType:n,start:void 0===a?void 0:Zr(a,e,`${t} has member 'start' that`),transform:void 0===i?void 0:eo(i,e,`${t} has member 'transform' that`),writableType:s}}(e,"First parameter");if(void 0!==a.readableType)throw new RangeError("Invalid readableType specified");if(void 0!==a.writableType)throw new RangeError("Invalid writableType specified");const i=mt(n,0),s=pt(n),l=mt(o,1),f=pt(o);let h;!function(e,t,r,o,n,a){function i(){return t}function s(t){return function(e,t){const r=e._transformStreamController;if(e._backpressure){return m(e._backpressureChangePromise,()=>{const o=e._writable;if("erroring"===o._state)throw o._storedError;return co(r,t)})}return co(r,t)}(e,t)}function l(t){return function(e,t){const r=e._transformStreamController;if(void 0!==r._finishPromise)return r._finishPromise;const o=e._readable;r._finishPromise=u((e,t)=>{r._finishPromise_resolve=e,r._finishPromise_reject=t});const n=r._cancelAlgorithm(t);return lo(r),b(n,()=>("errored"===o._state?ho(r,o._storedError):(Tr(o._readableStreamController,t),bo(r)),null),e=>(Tr(o._readableStreamController,e),ho(r,e),null)),r._finishPromise}(e,t)}function c(){return function(e){const t=e._transformStreamController;if(void 0!==t._finishPromise)return t._finishPromise;const r=e._readable;t._finishPromise=u((e,r)=>{t._finishPromise_resolve=e,t._finishPromise_reject=r});const o=t._flushAlgorithm();return lo(t),b(o,()=>("errored"===r._state?ho(t,r._storedError):(wr(r._readableStreamController),bo(t)),null),e=>(Tr(r._readableStreamController,e),ho(t,e),null)),t._finishPromise}(e)}function d(){return function(e){return io(e,!1),e._backpressureChangePromise}(e)}function f(t){return function(e,t){const r=e._transformStreamController;if(void 0!==r._finishPromise)return r._finishPromise;const o=e._writable;r._finishPromise=u((e,t)=>{r._finishPromise_resolve=e,r._finishPromise_reject=t});const n=r._cancelAlgorithm(t);return lo(r),b(n,()=>("errored"===o._state?ho(r,o._storedError):(Gt(o._writableStreamController,t),ao(e),bo(r)),null),t=>(Gt(o._writableStreamController,t),ao(e),ho(r,t),null)),r._finishPromise}(e,t)}e._writable=function(e,t,r,o,n=1,a=()=>1){const i=Object.create(WritableStream.prototype);return Ct(i),Nt(i,Object.create(WritableStreamDefaultController.prototype),e,t,r,o,n,a),i}(i,s,c,l,r,o),e._readable=Dr(i,d,f,n,a),e._backpressure=void 0,e._backpressureChangePromise=void 0,e._backpressureChangePromise_resolve=void 0,io(e,!0),e._transformStreamController=void 0}(this,u(e=>{h=e}),l,f,i,s),function(e,t){const r=Object.create(TransformStreamDefaultController.prototype);let o,n,a;o=void 0!==t.transform?e=>t.transform(e,r):e=>{try{return uo(r,e),c(void 0)}catch(e){return d(e)}};n=void 0!==t.flush?()=>t.flush(r):()=>c(void 0);a=void 0!==t.cancel?e=>t.cancel(e):()=>c(void 0);!function(e,t,r,o,n){t._controlledTransformStream=e,e._transformStreamController=t,t._transformAlgorithm=r,t._flushAlgorithm=o,t._cancelAlgorithm=n,t._finishPromise=void 0,t._finishPromise_resolve=void 0,t._finishPromise_reject=void 0}(e,r,o,n,a)}(this,a),void 0!==a.start?h(a.start(this._transformStreamController)):h(void 0)}get readable(){if(!ro(this))throw _o("readable");return this._readable}get writable(){if(!ro(this))throw _o("writable");return this._writable}}function ro(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_transformStreamController")&&e instanceof TransformStream)}function oo(e,t){Tr(e._readable._readableStreamController,t),no(e,t)}function no(e,t){lo(e._transformStreamController),Gt(e._writable._writableStreamController,t),ao(e)}function ao(e){e._backpressure&&io(e,!1)}function io(e,t){void 0!==e._backpressureChangePromise&&e._backpressureChangePromise_resolve(),e._backpressureChangePromise=u(t=>{e._backpressureChangePromise_resolve=t}),e._backpressure=t}Object.defineProperties(TransformStream.prototype,{readable:{enumerable:!0},writable:{enumerable:!0}}),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(TransformStream.prototype,Symbol.toStringTag,{value:"TransformStream",configurable:!0});class TransformStreamDefaultController{constructor(){throw new TypeError("Illegal constructor")}get desiredSize(){if(!so(this))throw fo("desiredSize");return Pr(this._controlledTransformStream._readable._readableStreamController)}enqueue(e=void 0){if(!so(this))throw fo("enqueue");uo(this,e)}error(e=void 0){if(!so(this))throw fo("error");var t;t=e,oo(this._controlledTransformStream,t)}terminate(){if(!so(this))throw fo("terminate");!function(e){const t=e._controlledTransformStream;wr(t._readable._readableStreamController);const r=new TypeError("TransformStream terminated");no(t,r)}(this)}}function so(e){return!!t(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledTransformStream")&&e instanceof TransformStreamDefaultController)}function lo(e){e._transformAlgorithm=void 0,e._flushAlgorithm=void 0,e._cancelAlgorithm=void 0}function uo(e,t){const r=e._controlledTransformStream,o=r._readable._readableStreamController;if(!Cr(o))throw new TypeError("Readable side is not in a state that permits enqueue");try{Rr(o,t)}catch(e){throw no(r,e),r._readable._storedError}const n=function(e){return!gr(e)}(o);n!==r._backpressure&&io(r,!0)}function co(e,t){return m(e._transformAlgorithm(t),void 0,t=>{throw oo(e._controlledTransformStream,t),t})}function fo(e){return new TypeError(`TransformStreamDefaultController.prototype.${e} can only be used on a TransformStreamDefaultController`)}function bo(e){void 0!==e._finishPromise_resolve&&(e._finishPromise_resolve(),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}function ho(e,t){void 0!==e._finishPromise_reject&&(p(e._finishPromise),e._finishPromise_reject(t),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}function _o(e){return new TypeError(`TransformStream.prototype.${e} can only be used on a TransformStream`)}Object.defineProperties(TransformStreamDefaultController.prototype,{enqueue:{enumerable:!0},error:{enumerable:!0},terminate:{enumerable:!0},desiredSize:{enumerable:!0}}),o(TransformStreamDefaultController.prototype.enqueue,"enqueue"),o(TransformStreamDefaultController.prototype.error,"error"),o(TransformStreamDefaultController.prototype.terminate,"terminate"),"symbol"==typeof Symbol.toStringTag&&Object.defineProperty(TransformStreamDefaultController.prototype,Symbol.toStringTag,{value:"TransformStreamDefaultController",configurable:!0});const mo={ReadableStream:ReadableStream,ReadableStreamDefaultController:ReadableStreamDefaultController,ReadableByteStreamController:ReadableByteStreamController,ReadableStreamBYOBRequest:ReadableStreamBYOBRequest,ReadableStreamDefaultReader:ReadableStreamDefaultReader,ReadableStreamBYOBReader:ReadableStreamBYOBReader,WritableStream:WritableStream,WritableStreamDefaultController:WritableStreamDefaultController,WritableStreamDefaultWriter:WritableStreamDefaultWriter,ByteLengthQueuingStrategy:ByteLengthQueuingStrategy,CountQueuingStrategy:CountQueuingStrategy,TransformStream:TransformStream,TransformStreamDefaultController:TransformStreamDefaultController};for(const e in mo)Object.prototype.hasOwnProperty.call(mo,e)&&Object.defineProperty(dr,e,{value:mo[e],writable:!0,configurable:!0})}();

From 28aa78f5a0dc1aa44518f6c06024497fef3e7d56 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Mon, 7 Sep 2026 23:53:07 +0800
Subject: [PATCH 18/31] docs(runtime): document byte helpers and text encoding
 streams

---
 .../javascript-runtime-compatibility.md         | 17 +++++++++++++++++
 .../content/reference/javascript/request.mdx    |  1 +
 .../reference/javascript/textencoder.mdx        |  1 +
 .../content/reference/javascript/request.mdx    |  2 +-
 .../reference/javascript/textencoder.mdx        |  2 +-
 website/locales/zh-CN/manifest.json             |  8 ++++----
 6 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/docs/architecture/javascript-runtime-compatibility.md b/docs/architecture/javascript-runtime-compatibility.md
index 1334566..ecd2464 100644
--- a/docs/architecture/javascript-runtime-compatibility.md
+++ b/docs/architecture/javascript-runtime-compatibility.md
@@ -193,3 +193,20 @@ Ordinary Response construction accepts statuses 200–599 and rejects non-null
 bodies for 204, 205 and 304. Tysel's existing status-101 WebSocket upgrade remains
 available only after `tysel.acceptWebSocket()`, also with a null body. Null-body
 helpers remain repeatable and leave bodyUsed false.
+
+### Byte consumption and text encoding streams
+
+`Request.bytes()` and `Response.bytes()` return an independent `Uint8Array`
+with the same consumption rules as `arrayBuffer()`. They collect the entire
+body, requiring O(body size) memory.
+
+`TextEncoderStream` converts text chunks to UTF-8 for `pipeThrough()` and
+streaming responses. It retains at most one trailing high surrogate to join
+split pairs and replaces unmatched surrogates, including on close. Chunks use
+DOMString conversion, which rejects Symbols. The underlying TransformStream
+loads on construction and supplies backpressure, cancellation and error propagation.
+Output allocation scales with each input chunk, so applications should bound
+chunk sizes.
+
+These contracts follow the [Body bytes helper](https://fetch.spec.whatwg.org/#dom-body-bytes)
+and [TextEncoderStream algorithms](https://encoding.spec.whatwg.org/#interface-textencoderstream).
diff --git a/website/content/reference/javascript/request.mdx b/website/content/reference/javascript/request.mdx
index 8dd63e1..fa52989 100644
--- a/website/content/reference/javascript/request.mdx
+++ b/website/content/reference/javascript/request.mdx
@@ -24,6 +24,7 @@ Source of truth: `runtime-js/web-api/compatibility.json`
 - Response.redirect and Response.error with immutable headers and clone preservation
 - response status range and null-body status validation; status 101 only after tysel.acceptWebSocket
 - null-body helpers are repeatable and do not set bodyUsed
+- bytes() returns independent Uint8Array bytes with the same body consumption rules as arrayBuffer()
 
 ## Not supported
 
diff --git a/website/content/reference/javascript/textencoder.mdx b/website/content/reference/javascript/textencoder.mdx
index 82fb056..d794c93 100644
--- a/website/content/reference/javascript/textencoder.mdx
+++ b/website/content/reference/javascript/textencoder.mdx
@@ -16,6 +16,7 @@ Source of truth: `runtime-js/web-api/compatibility.json`
 - stateful UTF-8 decode with stream option and final flush
 - TextDecoderStream over TransformStream
 - TextEncoder.encodeInto with UTF-16 read counts, scalar replacement and bounded scratch storage
+- TextEncoderStream with cross-chunk surrogate pairs, final replacement, backpressure and cancellation
 
 ## Not supported
 
diff --git a/website/locales/zh-CN/content/reference/javascript/request.mdx b/website/locales/zh-CN/content/reference/javascript/request.mdx
index e32fd61..db022f5 100644
--- a/website/locales/zh-CN/content/reference/javascript/request.mdx
+++ b/website/locales/zh-CN/content/reference/javascript/request.mdx
@@ -20,10 +20,10 @@ description: "Tysel JavaScript 运行时支持的 Request and Response 契约。
 - Tysel 响应分块数组，对字符串、ArrayBuffer 和 ArrayBufferView 元素创建快照
 - 按需创建 ReadableStream body，并跟踪锁定与读取状态
 - Response 支持 Uint8Array 分块的 ReadableStream，以及原生背压和取消
-
 - Response.redirect 和 Response.error：响应头不可变，clone 保留该属性
 - 校验响应状态码范围及无响应体状态；仅在 tysel.acceptWebSocket 后允许状态码 101
 - 空响应体的辅助读取方法可重复调用，不设置 bodyUsed
+- bytes() 返回独立的 Uint8Array，遵循与 arrayBuffer() 相同的 Body 消费规则
 
 ## 不支持
 
diff --git a/website/locales/zh-CN/content/reference/javascript/textencoder.mdx b/website/locales/zh-CN/content/reference/javascript/textencoder.mdx
index 05ebcfa..63f6884 100644
--- a/website/locales/zh-CN/content/reference/javascript/textencoder.mdx
+++ b/website/locales/zh-CN/content/reference/javascript/textencoder.mdx
@@ -14,8 +14,8 @@ description: "Tysel JavaScript 运行时支持的 TextEncoder and TextDecoder 
 - UTF-8 编码和解码
 - 带 stream 选项和最终刷新功能的有状态 UTF-8 解码
 - 基于 TransformStream 的 TextDecoderStream
-
 - TextEncoder.encodeInto：按 UTF-16 码元计数、替换非法代理项，并限制临时存储大小
+- TextEncoderStream：跨块组合代理对、结束时替换孤立代理项，并支持背压与取消
 
 ## 不支持
 
diff --git a/website/locales/zh-CN/manifest.json b/website/locales/zh-CN/manifest.json
index 34c22ea..e1c7d46 100644
--- a/website/locales/zh-CN/manifest.json
+++ b/website/locales/zh-CN/manifest.json
@@ -2034,13 +2034,13 @@
       "status": "reviewed"
     },
     "reference/javascript/request.mdx": {
-      "sourceHash": "9c08f2bbac6b0529768554e520f66dc822071b2a00a8acfa8ae8cd1a9b8fa192",
-      "translationHash": "a11e0ded9a50af27d16a4d1b1b0bfd99c3281581b703fae83706369613c9360d",
+      "sourceHash": "ecb93693ae403a9035400c536e64cb00c8bba06fa11ec535e5d742ebbef84288",
+      "translationHash": "ef9de12b695c0313702962c18b79c386abc8a3a73823b1d05ad74cb6b792d629",
       "status": "reviewed"
     },
     "reference/javascript/textencoder.mdx": {
-      "sourceHash": "8118953d1bd5d17f12f780401959b49c7c08bd7ad2709d6a9d36b58a6c2ccaee",
-      "translationHash": "dd00f343f3416bc4c8f9d8338996e66ed052d8471b8069dd0af6e9cae8b82a2a",
+      "sourceHash": "0a0bf4bca3720fd06b52bba335448f5e373b52ca468fa2238c14da53453fae37",
+      "translationHash": "87dc88c9c70c778508a9cb13b25514732281770123b7ff7c38711db995638c2f",
       "status": "reviewed"
     },
     "reference/javascript/timers.mdx": {

From 0bc0185dba6105cab5330eaea77b45618f0f26f6 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Tue, 8 Sep 2026 14:41:59 +0800
Subject: [PATCH 19/31] fix(http): enforce request deadlines and drain
 connections on shutdown

Propagate deadlines and cancellation through worker queues and isolated IPC. Add a worker watchdog, avoid replaying uncertain HTTP writes, hide production exception details, and drain HTTP/1, HTTP/2 and WebSocket connections.

Include queue, cancellation, shutdown and packaged-service regressions with operational documentation. Validation: cargo check --locked for CLI, runtime, isolate and QuickJS, all targets.
---
 crates/tysel-cli/src/dev.rs             |  84 +++--
 crates/tysel-cli/tests/dev_check.rs     |   5 +-
 crates/tysel-engine-qjs/src/pool.rs     | 247 +++++++++++---
 crates/tysel-ipc/src/lib.rs             |   6 +
 crates/tysel-isolate/src/handler.rs     |  42 ++-
 crates/tysel-isolate/src/lib.rs         |   1 +
 crates/tysel-isolate/src/supervisor.rs  | 123 +++++--
 crates/tysel-isolate/src/watchdog.rs    | 116 +++++++
 crates/tysel-isolate/src/worker.rs      |  35 +-
 crates/tysel-isolate/tests/isolated.rs  | 113 ++++++-
 crates/tysel-runtime/src/http.rs        | 430 ++++++++++++++++++------
 crates/tysel-runtime/src/lib.rs         |   6 +-
 crates/tysel-runtime/src/service.rs     |  89 ++---
 crates/tysel-runtime/src/tests.rs       | 108 ++++++
 crates/tysel-runtime/tests/packaged.rs  |  93 ++++-
 docs/guides/concurrency-backpressure.md |  17 +-
 docs/operations/production.md           |   9 +
 docs/reference/errors-and-output.md     |  18 +-
 docs/reference/manifest/limits.md       |   2 +-
 19 files changed, 1271 insertions(+), 273 deletions(-)
 create mode 100644 crates/tysel-isolate/src/watchdog.rs

diff --git a/crates/tysel-cli/src/dev.rs b/crates/tysel-cli/src/dev.rs
index d7f05d5..bb3cd99 100644
--- a/crates/tysel-cli/src/dev.rs
+++ b/crates/tysel-cli/src/dev.rs
@@ -18,8 +18,8 @@ use tysel_package::SourceMap;
 #[cfg(unix)]
 use tysel_runtime::ModuleTaskService;
 use tysel_runtime::{
-    AppIsolate, DurablePlane, HttpLimits, RuntimeDiagnostic, SharedPool, handle_stream,
-    spawn_app_isolate,
+    AppIsolate, DurablePlane, HttpLimits, HttpShutdown, RuntimeDiagnostic, SharedPool,
+    handle_stream, spawn_app_isolate,
 };
 use tysel_task_rpc::TaskOutcome;
 
@@ -215,16 +215,22 @@ async fn serve(
     error_format: ErrorFormat,
 ) -> Result<()> {
     let loaded = load_for_serve(&manifest_path, entry.as_deref(), reload)?;
-    let pool = SharedPool::with_server_limits(
+    let shutdown = HttpShutdown::default();
+    let mut grace = loaded.isolate.request_timeout().saturating_add(Duration::from_secs(1));
+    let pool = SharedPool::with_http_limits(
         loaded.isolate,
-        loaded.max_request_bytes,
-        loaded.max_in_flight,
+        HttpLimits {
+            max_request_bytes: loaded.max_request_bytes,
+            max_response_bytes: loaded.max_response_bytes,
+            max_in_flight: loaded.max_in_flight,
+        },
         loaded.websocket,
         loaded.http1,
         loaded.http2,
-        Some(loaded.source_map),
-    );
-    if error_format == ErrorFormat::Json {
+        reload.then_some(loaded.source_map),
+    )
+    .with_shutdown(shutdown.clone());
+    if reload && error_format == ErrorFormat::Json {
         attach_runtime_diagnostics(&pool)?;
     }
     let listener =
@@ -238,17 +244,15 @@ async fn serve(
     }
     print!("{}", listen_announcement(bound));
     io::stdout().flush()?;
-    if reload {
+    let result = if reload {
         report_diagnostics_clear(error_format, 0);
         let mut changes = watch(manifest_path.parent().unwrap_or(Path::new(".")))?;
         let mut diagnostic_generation = 0u64;
         loop {
             tokio::select! {
-                _ = tokio::signal::ctrl_c() => break,
+                signal = shutdown_signal() => break signal.map_err(Into::into),
                 error = task_service_failure(task_service.as_ref()) => {
-                    shutdown_durable(durable.take()).await?;
-                    shutdown_task_service(task_service).await?;
-                    return Err(error);
+                    break Err(error);
                 }
                 _ = wait_change(&mut changes.rx) => {
                     diagnostic_generation = diagnostic_generation.saturating_add(1);
@@ -263,6 +267,7 @@ async fn serve(
                                         if error_format == ErrorFormat::Human {
                                             eprintln!("tysel reload");
                                         }
+                                        grace = grace.max(next.isolate.request_timeout().saturating_add(Duration::from_secs(1)));
                                         pool.replace_with_server_limits(
                                             next.isolate,
                                             HttpLimits {
@@ -289,32 +294,47 @@ async fn serve(
                     Err(err) => report_dev_error(error_format, diagnostic_generation, &err),
                 }},
                 accepted = listener.accept() => {
-                    let (stream, _) = accepted.context("accept")?;
+                    let (stream, _) = match accepted { Ok(value) => value, Err(error) => break Err(error.into()) };
                     handle_stream(stream, pool.clone());
                 }
             }
         }
-        shutdown_durable(durable.take()).await?;
-        shutdown_task_service(task_service).await?;
-        return Ok(());
-    }
-    loop {
-        tokio::select! {
-            _ = tokio::signal::ctrl_c() => break,
-            error = task_service_failure(task_service.as_ref()) => {
-                shutdown_durable(durable.take()).await?;
-                shutdown_task_service(task_service).await?;
-                return Err(error);
-            }
-            accepted = listener.accept() => {
-                let (stream, _) = accepted.context("accept")?;
-                handle_stream(stream, pool.clone());
+    } else {
+        loop {
+            tokio::select! {
+                signal = shutdown_signal() => break signal.map_err(Into::into),
+                    error = task_service_failure(task_service.as_ref()) => {
+                    break Err(error);
+                }
+                accepted = listener.accept() => {
+                    let (stream, _) = match accepted { Ok(value) => value, Err(error) => break Err(error.into()) };
+                    handle_stream(stream, pool.clone());
+                }
             }
         }
+    };
+    drop(listener);
+    shutdown.cancel();
+    shutdown.drain(grace).await;
+    let durable_result = shutdown_durable(durable.take()).await;
+    let task_result = shutdown_task_service(task_service).await;
+    result?;
+    durable_result?;
+    task_result
+}
+
+#[cfg(unix)]
+async fn shutdown_signal() -> io::Result<()> {
+    let mut terminate = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())?;
+    tokio::select! {
+        result = tokio::signal::ctrl_c() => result,
+        _ = terminate.recv() => Ok(()),
     }
-    shutdown_durable(durable.take()).await?;
-    shutdown_task_service(task_service).await?;
-    Ok(())
+}
+
+#[cfg(not(unix))]
+async fn shutdown_signal() -> io::Result<()> {
+    tokio::signal::ctrl_c().await
 }
 
 fn attach_runtime_diagnostics(pool: &SharedPool) -> Result<()> {
diff --git a/crates/tysel-cli/tests/dev_check.rs b/crates/tysel-cli/tests/dev_check.rs
index c52d984..8c538f3 100644
--- a/crates/tysel-cli/tests/dev_check.rs
+++ b/crates/tysel-cli/tests/dev_check.rs
@@ -1923,8 +1923,9 @@ export default {
     let error: serde_json::Value = serde_json::from_str(&body).unwrap();
     assert_eq!(error["error"]["code"], "RUNTIME_ERROR");
     let message = error["error"]["message"].as_str().unwrap();
-    assert!(message.contains("intentional failure"), "{message}");
-    assert!(message.contains("src/index.ts:5"), "{message}");
+    assert_eq!(message, "request execution failed");
+    assert!(!message.contains("intentional failure"), "{message}");
+    assert!(!message.contains("src/index.ts:5"), "{message}");
     assert!(!message.contains("app.js:"), "{message}");
     assert!(error["error"]["requestId"].as_str().is_some_and(|id| id.len() == 16));
 }
diff --git a/crates/tysel-engine-qjs/src/pool.rs b/crates/tysel-engine-qjs/src/pool.rs
index 08ef552..0b1d572 100644
--- a/crates/tysel-engine-qjs/src/pool.rs
+++ b/crates/tysel-engine-qjs/src/pool.rs
@@ -6,7 +6,7 @@ use std::time::{Duration, Instant};
 
 use rquickjs::{Context, Function, Runtime};
 use tokio::sync::{mpsc, oneshot};
-use tysel_engine::{EngineError, HttpHead, HttpRequest, IsolateConfig};
+use tysel_engine::{EngineError, HttpHead, HttpRequest, InterruptReason, IsolateConfig};
 
 use crate::cpu::CpuBudget;
 use crate::fetch;
@@ -40,11 +40,22 @@ impl From<HttpRequest> for IncomingHttp {
 }
 
 struct Job {
+    deadline: Instant,
+    cancel: IsolateCancel,
     request: IncomingHttp,
     response_tx: ResponseSender,
     _pending: PendingJob,
 }
 
+struct CancelPending(Option<IsolateCancel>);
+impl Drop for CancelPending {
+    fn drop(&mut self) {
+        if let Some(cancel) = &self.0 {
+            cancel.cancel();
+        }
+    }
+}
+
 struct ActiveJob {
     request: IncomingHttp,
     response_tx: ResponseSender,
@@ -78,11 +89,13 @@ pub enum OutgoingHttpBody {
 }
 
 struct Budgets {
+    cancel: IsolateCancel,
     cpu: Arc<CpuBudget>,
     request: Instant,
 }
 
 pub struct IsolatePool {
+    request_timeout: Duration,
     workers: Vec<WorkerSlot>,
     pending: Arc<[AtomicUsize]>,
     next: Arc<AtomicUsize>,
@@ -130,7 +143,13 @@ impl IsolatePool {
                 metadata = Some(worker_metadata);
             }
         }
-        let pool = Self { workers: senders, pending, next: Arc::new(AtomicUsize::new(0)), threads };
+        let pool = Self {
+            request_timeout: Duration::from_millis(config.request_timeout_ms.max(1)),
+            workers: senders,
+            pending,
+            next: Arc::new(AtomicUsize::new(0)),
+            threads,
+        };
         Ok((pool, metadata.expect("at least one isolate worker")))
     }
 
@@ -159,38 +178,67 @@ impl IsolatePool {
         &self,
         request: IncomingHttp,
     ) -> Result<(HttpHead, OutgoingHttpBody), EngineError> {
-        let (response_tx, response_rx) = oneshot::channel();
-        let mut request = Some(request);
-        let mut response_tx = Some(response_tx);
-        loop {
-            let (index, pending) = self
-                .reserve_worker()
-                .ok_or_else(|| EngineError::Isolate("all isolate workers stopped".into()))?;
-            let job = Job {
-                request: request.take().expect("request is retained until dispatch"),
-                response_tx: response_tx
-                    .take()
-                    .expect("response sender is retained until dispatch"),
-                _pending: pending,
-            };
-            match self.workers[index].jobs.send(job).await {
-                Ok(()) => break,
-                Err(error) => {
-                    let Job {
-                        request: returned_request,
-                        response_tx: returned_response_tx,
-                        _pending: _,
-                    } = error.0;
-                    request = Some(returned_request);
-                    response_tx = Some(returned_response_tx);
+        let deadline = Instant::now()
+            .checked_add(self.request_timeout)
+            .ok_or_else(|| EngineError::Isolate("request timeout is too large".into()))?;
+        self.dispatch_response_until(request, deadline).await
+    }
+
+    pub fn request_timeout(&self) -> Duration {
+        self.request_timeout
+    }
+
+    /// Preserve an ingress deadline through worker queueing and execution.
+    pub async fn dispatch_response_until(
+        &self,
+        request: IncomingHttp,
+        deadline: Instant,
+    ) -> Result<(HttpHead, OutgoingHttpBody), EngineError> {
+        if Instant::now() >= deadline {
+            return Err(EngineError::Interrupted(InterruptReason::Timeout));
+        }
+        let cancel = IsolateCancel::new();
+        let mut cancellation = CancelPending(Some(cancel.clone()));
+        let result = tokio::time::timeout_at(tokio::time::Instant::from_std(deadline), async {
+            let (response_tx, response_rx) = oneshot::channel();
+            let mut request = Some(request);
+            let mut response_tx = Some(response_tx);
+            loop {
+                let (index, pending) = self
+                    .reserve_worker()
+                    .ok_or_else(|| EngineError::Isolate("all isolate workers stopped".into()))?;
+                let job = Job {
+                    deadline,
+                    cancel: cancel.clone(),
+                    request: request.take().expect("request is retained until dispatch"),
+                    response_tx: response_tx
+                        .take()
+                        .expect("response sender is retained until dispatch"),
+                    _pending: pending,
+                };
+                match self.workers[index].jobs.send(job).await {
+                    Ok(()) => break,
+                    Err(error) => {
+                        let Job {
+                            request: returned_request,
+                            response_tx: returned_response_tx,
+                            ..
+                        } = error.0;
+                        request = Some(returned_request);
+                        response_tx = Some(returned_response_tx);
+                    }
                 }
             }
-        }
-        match response_rx.await {
-            Ok(Ok(PreparedHttpResponse { head, body })) => Ok((head, body)),
-            Ok(Err(err)) => Err(err),
-            Err(_) => Err(EngineError::Isolate("isolate dropped the response head".into())),
-        }
+            match response_rx.await {
+                Ok(Ok(PreparedHttpResponse { head, body })) => Ok((head, body)),
+                Ok(Err(err)) => Err(err),
+                Err(_) => Err(EngineError::Isolate("isolate dropped the response head".into())),
+            }
+        })
+        .await
+        .map_err(|_| EngineError::Interrupted(InterruptReason::Timeout))?;
+        cancellation.0.take();
+        result
     }
 
     fn reserve_worker(&self) -> Option<(usize, PendingJob)> {
@@ -211,8 +259,20 @@ impl IsolatePool {
     /// Run one request to completion on the process I/O runtime. Isolated
     /// workers use this from a blocking IPC thread.
     pub fn dispatch_sync(&self, request: HttpRequest) -> Result<(HttpHead, Vec<u8>), EngineError> {
+        let deadline = Instant::now()
+            .checked_add(self.request_timeout)
+            .ok_or_else(|| EngineError::Isolate("request timeout is too large".into()))?;
+        self.dispatch_sync_until(request, deadline)
+    }
+
+    pub fn dispatch_sync_until(
+        &self,
+        request: HttpRequest,
+        deadline: Instant,
+    ) -> Result<(HttpHead, Vec<u8>), EngineError> {
         crate::queue::io_handle().block_on(async {
-            let (head, response) = self.dispatch_response(IncomingHttp::from(request)).await?;
+            let (head, response) =
+                self.dispatch_response_until(IncomingHttp::from(request), deadline).await?;
             let mut body = Vec::new();
             let (mut chunks, completion) = match response {
                 OutgoingHttpBody::Buffered(bytes) => return Ok((head, bytes)),
@@ -268,6 +328,7 @@ fn run_worker(
     ready: &std::sync::mpsc::Sender<Result<ModuleMetadata, EngineError>>,
 ) -> Result<(), EngineError> {
     let budgets = Arc::new(Mutex::new(Budgets {
+        cancel: cancel.clone(),
         cpu: CpuBudget::new(Duration::from_secs(60)),
         request: Instant::now() + Duration::from_secs(60),
     }));
@@ -281,7 +342,9 @@ fn run_worker(
                 return true;
             }
             let budgets = budgets.lock().expect("budgets");
-            budgets.cpu.exhausted() || Instant::now() >= budgets.request
+            budgets.cancel.is_cancelled()
+                || budgets.cpu.exhausted()
+                || Instant::now() >= budgets.request
         })));
     }
 
@@ -312,17 +375,29 @@ fn run_worker(
     let _ = ready.send(Ok(metadata));
 
     while let Some(job) = jobs.blocking_recv() {
-        let Job { request, response_tx, _pending: pending } = job;
+        let Job {
+            request,
+            response_tx,
+            _pending: pending,
+            deadline: request_deadline,
+            cancel: request_cancel,
+        } = job;
+        if response_tx.is_closed() || request_cancel.is_cancelled() {
+            continue;
+        }
+        if Instant::now() >= request_deadline {
+            let _ = response_tx.send(Err(EngineError::Interrupted(InterruptReason::Timeout)));
+            continue;
+        }
         let request_id = request.request_id;
         let cpu = CpuBudget::new(Duration::from_millis(config.cpu_ms_per_turn.max(1)));
-        let request_deadline =
-            Instant::now() + Duration::from_millis(config.request_timeout_ms.max(1));
-        *budgets.lock().expect("budgets") = Budgets { cpu: cpu.clone(), request: request_deadline };
+        *budgets.lock().expect("budgets") =
+            Budgets { cancel: request_cancel.clone(), cpu: cpu.clone(), request: request_deadline };
         let job_result = handle_job(
             &runtime,
             &context,
             &reactor,
-            &cancel,
+            &request_cancel,
             ActiveJob { request, response_tx },
             request_deadline,
             &cpu,
@@ -517,9 +592,103 @@ fn handle_job(
 mod tests {
     use super::*;
 
+    fn request(path: &str) -> IncomingHttp {
+        HttpRequest {
+            method: "GET".into(),
+            url: format!("http://local{path}"),
+            ..Default::default()
+        }
+        .into()
+    }
+
+    #[tokio::test]
+    async fn queued_deadline_and_cancellation_skip_side_effects() {
+        let pool = Arc::new(
+            IsolatePool::spawn(
+                1,
+                r#"
+            let calls = 0;
+            export default {fetch(request) {
+                const path = new URL(request.url).pathname;
+                if (path === '/hold') return new Response(new ReadableStream({
+                    start(c) { c.enqueue(new Uint8Array([1])); },
+                    pull() { return new Promise(() => {}); }
+                }));
+                if (path === '/mutate') calls++;
+                return new Response(String(calls));
+            }};
+        "#,
+                IsolateConfig {
+                    request_timeout_ms: 2_000,
+                    cpu_ms_per_turn: 500,
+                    ..Default::default()
+                },
+            )
+            .unwrap(),
+        );
+        let (_, held) = pool.dispatch_response(request("/hold")).await.unwrap();
+        let result = pool
+            .dispatch_response_until(request("/mutate"), Instant::now() + Duration::from_millis(20))
+            .await;
+        assert!(matches!(result, Err(EngineError::Interrupted(InterruptReason::Timeout))));
+        let queued = tokio::spawn({
+            let pool = pool.clone();
+            async move { pool.dispatch_response(request("/mutate")).await }
+        });
+        while pool.pending_jobs()[0] < 3 {
+            tokio::task::yield_now().await;
+        }
+        queued.abort();
+        assert!(matches!(queued.await, Err(error) if error.is_cancelled()));
+        drop(held);
+        let (_, body) = pool.dispatch_response(request("/count")).await.unwrap();
+        assert!(matches!(body, OutgoingHttpBody::Buffered(bytes) if bytes == b"0"));
+    }
+
+    #[tokio::test]
+    async fn active_timeout_and_cancellation_do_not_poison_worker() {
+        let pool = Arc::new(
+            IsolatePool::spawn(
+                1,
+                r#"
+            export default {async fetch(request) {
+                if (new URL(request.url).pathname === '/hold') await new Promise(() => {});
+                return new Response('healthy');
+            }};
+        "#,
+                IsolateConfig {
+                    request_timeout_ms: 2_000,
+                    cpu_ms_per_turn: 500,
+                    ..Default::default()
+                },
+            )
+            .unwrap(),
+        );
+        let result = pool
+            .dispatch_response_until(request("/hold"), Instant::now() + Duration::from_millis(20))
+            .await;
+        assert!(matches!(result, Err(EngineError::Interrupted(InterruptReason::Timeout))));
+        let active = tokio::spawn({
+            let pool = pool.clone();
+            async move { pool.dispatch_response(request("/hold")).await }
+        });
+        tokio::time::sleep(Duration::from_millis(30)).await;
+        active.abort();
+        assert!(matches!(active.await, Err(error) if error.is_cancelled()));
+        let (_, body) = tokio::time::timeout(
+            Duration::from_millis(500),
+            pool.dispatch_response(request("/healthy")),
+        )
+        .await
+        .unwrap()
+        .unwrap();
+        assert!(matches!(body, OutgoingHttpBody::Buffered(bytes) if bytes == b"healthy"));
+    }
+
     fn test_pool(senders: Vec<mpsc::Sender<Job>>) -> IsolatePool {
         let pending = (0..senders.len()).map(|_| AtomicUsize::new(0)).collect::<Vec<_>>().into();
         IsolatePool {
+            request_timeout: Duration::from_secs(30),
             workers: senders.into_iter().map(|jobs| WorkerSlot { jobs }).collect(),
             pending,
             next: Arc::new(AtomicUsize::new(0)),
diff --git a/crates/tysel-ipc/src/lib.rs b/crates/tysel-ipc/src/lib.rs
index 8ea4df6..c6df803 100644
--- a/crates/tysel-ipc/src/lib.rs
+++ b/crates/tysel-ipc/src/lib.rs
@@ -87,6 +87,8 @@ pub enum Message {
         body: String,
         #[serde(default)]
         request_id: u64,
+        #[serde(default)]
+        timeout_ms: Option<u64>,
     },
     HttpOk {
         id: u64,
@@ -98,6 +100,8 @@ pub enum Message {
     HttpErr {
         id: u64,
         error: String,
+        #[serde(default)]
+        timed_out: bool,
     },
     CapCall {
         id: u64,
@@ -227,6 +231,7 @@ mod tests {
         write_message(
             &mut buf,
             &Message::Http {
+                timeout_ms: Some(250),
                 id: 3,
                 method: "GET".into(),
                 url: "http://tysel.local/".into(),
@@ -240,6 +245,7 @@ mod tests {
         assert_eq!(
             decoded,
             Message::Http {
+                timeout_ms: Some(250),
                 id: 3,
                 method: "GET".into(),
                 url: "http://tysel.local/".into(),
diff --git a/crates/tysel-isolate/src/handler.rs b/crates/tysel-isolate/src/handler.rs
index 498ff59..708ad09 100644
--- a/crates/tysel-isolate/src/handler.rs
+++ b/crates/tysel-isolate/src/handler.rs
@@ -1,6 +1,8 @@
 use std::collections::HashMap;
 use std::path::Path;
-use std::sync::Mutex;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
 
 use tysel_engine::{HttpHead, HttpRequest, IsolateConfig, Value};
 use tysel_engine_qjs::ModuleTaskDefinition;
@@ -15,6 +17,7 @@ fn spec_from_config(config: IsolateConfig) -> WorkerSpec {
 /// Fetch-handler pool that runs QuickJS in `tysel-worker`. The supervisor keeps
 /// the HTTP listener and secret values; the worker only sees secret names.
 pub struct IsolatedHttpPool {
+    request_timeout: Duration,
     inner: Mutex<Supervisor>,
 }
 
@@ -70,9 +73,10 @@ impl IsolatedHttpPool {
             .cloned()
             .map(|name| (name, String::new()))
             .collect::<HashMap<_, _>>();
+        let request_timeout = Duration::from_millis(spec.request_timeout_ms.max(1));
         let mut supervisor = Supervisor::spawn(worker_bin, spec, secrets)?;
         supervisor.load_handler(source, secret_names)?;
-        Ok(Self { inner: Mutex::new(supervisor) })
+        Ok(Self { inner: Mutex::new(supervisor), request_timeout })
     }
 
     pub fn spawn_from_config(
@@ -84,7 +88,39 @@ impl IsolatedHttpPool {
         Self::spawn(worker_bin, source, spec_from_config(config), secret_names)
     }
 
+    pub fn request_timeout(&self) -> Duration {
+        self.request_timeout
+    }
+
+    pub fn dispatch_sync_until(
+        &self,
+        request: HttpRequest,
+        deadline: Instant,
+    ) -> Result<(HttpHead, Vec<u8>), IsolateError> {
+        self.inner
+            .lock()
+            .map_err(|err| IsolateError::Worker(err.to_string()))?
+            .http_until(&request, deadline)
+    }
+
+    pub fn dispatch_sync_cancellable(
+        &self,
+        request: HttpRequest,
+        deadline: Instant,
+        cancelled: &Arc<AtomicBool>,
+    ) -> Result<(HttpHead, Vec<u8>), IsolateError> {
+        let mut supervisor =
+            self.inner.lock().map_err(|err| IsolateError::Worker(err.to_string()))?;
+        if cancelled.load(Ordering::Acquire) {
+            return Err(tysel_engine::EngineError::Interrupted(
+                tysel_engine::InterruptReason::Cancelled,
+            )
+            .into());
+        }
+        supervisor.http_cancellable(&request, deadline, Some(cancelled.clone()))
+    }
+
     pub fn dispatch_sync(&self, request: HttpRequest) -> Result<(HttpHead, Vec<u8>), IsolateError> {
-        self.inner.lock().map_err(|err| IsolateError::Worker(err.to_string()))?.http(&request)
+        self.dispatch_sync_until(request, Instant::now() + self.request_timeout)
     }
 }
diff --git a/crates/tysel-isolate/src/lib.rs b/crates/tysel-isolate/src/lib.rs
index dca44ea..4551f1d 100644
--- a/crates/tysel-isolate/src/lib.rs
+++ b/crates/tysel-isolate/src/lib.rs
@@ -10,6 +10,7 @@ mod landlock;
 mod rlimit;
 mod seccomp;
 mod supervisor;
+mod watchdog;
 mod worker;
 
 pub use handler::{IsolatedHttpPool, IsolatedTaskPool};
diff --git a/crates/tysel-isolate/src/supervisor.rs b/crates/tysel-isolate/src/supervisor.rs
index 03ad76c..cc2592f 100644
--- a/crates/tysel-isolate/src/supervisor.rs
+++ b/crates/tysel-isolate/src/supervisor.rs
@@ -1,7 +1,10 @@
+use crate::watchdog::Watchdog;
 use std::collections::HashMap;
 use std::io::{BufReader, Write};
 use std::path::{Path, PathBuf};
 use std::process::{Child, ChildStdin, ChildStdout, Command, Stdio};
+use std::sync::atomic::AtomicBool;
+use std::sync::{Arc, Mutex};
 
 use tysel_engine::{EngineError, HttpHead, HttpRequest, InterruptReason, IsolateConfig, Value};
 use tysel_engine_qjs::ModuleTaskDefinition;
@@ -103,7 +106,8 @@ pub struct Supervisor {
 }
 
 struct WorkerConn {
-    child: Child,
+    child: Arc<Mutex<Child>>,
+    watchdog: Watchdog,
     stdin: ChildStdin,
     stdout: BufReader<ChildStdout>,
 }
@@ -153,7 +157,7 @@ impl Supervisor {
         match read_message(&mut conn.stdout) {
             Ok(other) => Err(IsolateError::Worker(format!("worker survived overalloc: {other:?}"))),
             Err(_) => {
-                let _ = conn.child.wait();
+                let _ = conn.child.lock().unwrap().wait();
                 self.child = None;
                 self.cgroup = None;
                 Ok(())
@@ -162,16 +166,16 @@ impl Supervisor {
     }
 
     pub fn kill_worker(&mut self) -> Result<(), IsolateError> {
-        if let Some(mut conn) = self.child.take() {
-            let _ = conn.child.kill();
-            let _ = conn.child.wait();
+        if let Some(conn) = self.child.take() {
+            let _ = conn.child.lock().unwrap().kill();
+            let _ = conn.child.lock().unwrap().wait();
         }
         self.cgroup = None;
         Ok(())
     }
 
     pub fn worker_pid(&self) -> Option<u32> {
-        self.child.as_ref().map(|conn| conn.child.id())
+        self.child.as_ref().map(|conn| conn.child.lock().unwrap().id())
     }
 
     pub fn load_handler(
@@ -186,15 +190,47 @@ impl Supervisor {
     }
 
     pub fn http(&mut self, request: &HttpRequest) -> Result<(HttpHead, Vec<u8>), IsolateError> {
-        match self.http_inner(request) {
-            Ok(value) => Ok(value),
-            Err(err) if self.worker_connection_failed(&err) => {
-                self.restart_worker()?;
-                self.http_inner(request)
-                    .map_err(|retry| IsolateError::Worker(format!("{err}; retry: {retry}")))
-            }
-            Err(err) => Err(err),
+        self.http_until(
+            request,
+            std::time::Instant::now()
+                + std::time::Duration::from_millis(self.spec.request_timeout_ms.max(1)),
+        )
+    }
+
+    pub fn http_until(
+        &mut self,
+        request: &HttpRequest,
+        deadline: std::time::Instant,
+    ) -> Result<(HttpHead, Vec<u8>), IsolateError> {
+        self.http_cancellable(request, deadline, None)
+    }
+
+    pub fn http_cancellable(
+        &mut self,
+        request: &HttpRequest,
+        deadline: std::time::Instant,
+        cancelled: Option<Arc<AtomicBool>>,
+    ) -> Result<(HttpHead, Vec<u8>), IsolateError> {
+        if std::time::Instant::now() >= deadline {
+            return Err(EngineError::Interrupted(InterruptReason::Timeout).into());
         }
+        self.ensure_worker()?;
+        let operation = self.child.as_ref().expect("worker").watchdog.arm(deadline, cancelled);
+        // A disconnected worker may already have executed the request. Do not
+        // automatically replay HTTP writes after an uncertain outcome.
+        let result = self.http_inner(request, deadline);
+        if let Some(reason) = operation.finish() {
+            self.kill_worker()?;
+            return Err(EngineError::Interrupted(reason).into());
+        }
+        if result
+            .as_ref()
+            .err()
+            .is_some_and(|error| matches!(error, IsolateError::Io(_) | IsolateError::Ipc(_)))
+        {
+            self.kill_worker()?;
+        }
+        result
     }
 
     pub fn load_task_module(
@@ -298,11 +334,21 @@ impl Supervisor {
         }
     }
 
-    fn http_inner(&mut self, request: &HttpRequest) -> Result<(HttpHead, Vec<u8>), IsolateError> {
+    fn http_inner(
+        &mut self,
+        request: &HttpRequest,
+        deadline: std::time::Instant,
+    ) -> Result<(HttpHead, Vec<u8>), IsolateError> {
         if request.body.len() > MAX_ISOLATED_HTTP_BODY {
             return Err(IsolateError::Worker("isolated request body exceeds 32KiB IPC cap".into()));
         }
-        self.ensure_worker()?;
+        if std::time::Instant::now() >= deadline {
+            return Err(EngineError::Interrupted(InterruptReason::Timeout).into());
+        }
+        let remaining = deadline.saturating_duration_since(std::time::Instant::now());
+        if remaining.is_zero() {
+            return Err(EngineError::Interrupted(InterruptReason::Timeout).into());
+        }
         let id = self.next_id;
         self.next_id += 1;
         {
@@ -310,6 +356,7 @@ impl Supervisor {
             write_message(
                 &mut conn.stdin,
                 &Message::Http {
+                    timeout_ms: Some(remaining.as_millis().min(u128::from(u64::MAX)) as u64),
                     id,
                     method: request.method.clone(),
                     url: request.url.clone(),
@@ -348,7 +395,10 @@ impl Supervisor {
                     }
                     return Ok((HttpHead { status, headers, websocket: false }, body.into_bytes()));
                 }
-                Message::HttpErr { id: reply_id, error } if reply_id == id => {
+                Message::HttpErr { id: reply_id, error, timed_out } if reply_id == id => {
+                    if timed_out {
+                        return Err(EngineError::Interrupted(InterruptReason::Timeout).into());
+                    }
                     return Err(IsolateError::Worker(error));
                 }
                 other => return Err(IsolateError::Worker(format!("unexpected message {other:?}"))),
@@ -402,14 +452,28 @@ impl Supervisor {
             child.stdin.take().ok_or_else(|| IsolateError::Worker("missing stdin".into()))?;
         let stdout =
             child.stdout.take().ok_or_else(|| IsolateError::Worker("missing stdout".into()))?;
-        let mut conn = WorkerConn { child, stdin, stdout: BufReader::new(stdout) };
+        let child = Arc::new(Mutex::new(child));
+        let watchdog = match Watchdog::new(child.clone()) {
+            Ok(watchdog) => watchdog,
+            Err(error) => {
+                let mut child = child.lock().unwrap();
+                let _ = child.kill();
+                let _ = child.wait();
+                return Err(error.into());
+            }
+        };
+        let startup = watchdog.arm(
+            std::time::Instant::now()
+                + std::time::Duration::from_millis(self.spec.request_timeout_ms.max(1_000)),
+            None,
+        );
+        let mut conn = WorkerConn { child, watchdog, stdin, stdout: BufReader::new(stdout) };
         match read_message(&mut conn.stdout) {
             Ok(Message::WorkerReady) => {}
             Ok(other) => {
                 return Err(IsolateError::Worker(format!("expected ready, got {other:?}")));
             }
             Err(err) => {
-                let _ = conn.child.wait();
                 return Err(IsolateError::Worker(format!("worker failed to start: {err}")));
             }
         }
@@ -432,7 +496,7 @@ impl Supervisor {
             Err(err) => return Err(IsolateError::Worker(format!("start handshake failed: {err}"))),
         }
         let _ = conn.stdin.flush();
-        let pid = conn.child.id();
+        let pid = conn.child.lock().unwrap().id();
         self.cgroup = crate::cgroup::attach(pid, self.spec.rlimit_as_bytes);
         self.child = Some(conn);
         if self.handler_source.is_some() {
@@ -441,6 +505,10 @@ impl Supervisor {
         if self.task_source.is_some() {
             self.send_task_load()?;
         }
+        if let Some(reason) = startup.finish() {
+            self.kill_worker()?;
+            return Err(EngineError::Interrupted(reason).into());
+        }
         Ok(())
     }
 
@@ -448,7 +516,7 @@ impl Supervisor {
         let Some(conn) = self.child.as_mut() else {
             return true;
         };
-        match conn.child.try_wait() {
+        match conn.child.lock().unwrap().try_wait() {
             Ok(Some(_)) => true,
             Ok(None) => false,
             Err(_) => true,
@@ -475,12 +543,17 @@ fn task_error(error: String, kind: TaskErrorKind) -> IsolateError {
     IsolateError::Engine(engine)
 }
 
+impl Drop for WorkerConn {
+    fn drop(&mut self) {
+        // Killing before waiting also handles a stopped or unresponsive worker.
+        let mut child = self.child.lock().unwrap();
+        let _ = child.kill();
+        let _ = child.wait();
+    }
+}
+
 impl Drop for Supervisor {
     fn drop(&mut self) {
-        if let Some(conn) = self.child.as_mut() {
-            let _ = write_message(&mut conn.stdin, &Message::Shutdown);
-            let _ = conn.child.wait();
-        }
         self.child = None;
         self.cgroup = None;
     }
diff --git a/crates/tysel-isolate/src/watchdog.rs b/crates/tysel-isolate/src/watchdog.rs
new file mode 100644
index 0000000..5c4b5fd
--- /dev/null
+++ b/crates/tysel-isolate/src/watchdog.rs
@@ -0,0 +1,116 @@
+//! One sleeping watchdog per worker, independent of the blocking IPC reader.
+use std::process::Child;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Condvar, Mutex};
+use std::thread::JoinHandle;
+use std::time::{Duration, Instant};
+
+use tysel_engine::InterruptReason;
+
+type Shared = Arc<(Mutex<State>, Condvar)>;
+#[derive(Default)]
+struct State {
+    stop: bool,
+    deadline: Option<Instant>,
+    cancelled: Option<Arc<AtomicBool>>,
+    reason: Option<InterruptReason>,
+}
+
+pub(crate) struct Watchdog {
+    shared: Shared,
+    thread: Option<JoinHandle<()>>,
+    child: Arc<Mutex<Child>>,
+}
+
+pub(crate) struct Operation {
+    shared: Shared,
+    child: Arc<Mutex<Child>>,
+}
+
+fn interrupt(state: &mut State, child: &Mutex<Child>) {
+    let reason = if state.cancelled.as_ref().is_some_and(|c| c.load(Ordering::Acquire)) {
+        Some(InterruptReason::Cancelled)
+    } else if state.deadline.is_some_and(|d| Instant::now() >= d) {
+        Some(InterruptReason::Timeout)
+    } else {
+        None
+    };
+    if let Some(reason) = reason {
+        // Serialize disarming with killing: a late watchdog must never kill the
+        // next operation. The handle also prevents accidental PID reuse.
+        let _ = child.lock().unwrap().kill();
+        state.reason = Some(reason);
+        state.deadline = None;
+        state.cancelled = None;
+    }
+}
+
+impl Watchdog {
+    pub(crate) fn new(child: Arc<Mutex<Child>>) -> std::io::Result<Self> {
+        let shared: Shared = Arc::default();
+        let worker_state = shared.clone();
+        let worker_child = child.clone();
+        let thread =
+            std::thread::Builder::new().name("tysel-ipc-watchdog".into()).spawn(move || {
+                let (lock, wake) = &*worker_state;
+                let mut state = lock.lock().unwrap();
+                while !state.stop {
+                    interrupt(&mut state, &worker_child);
+                    state = match state.deadline {
+                        Some(deadline) => {
+                            let mut wait = deadline.saturating_duration_since(Instant::now());
+                            if state.cancelled.is_some() {
+                                wait = wait.min(Duration::from_millis(10));
+                            }
+                            wake.wait_timeout(state, wait).unwrap().0
+                        }
+                        None => wake.wait(state).unwrap(),
+                    };
+                }
+            })?;
+        Ok(Self { shared, thread: Some(thread), child })
+    }
+
+    pub(crate) fn arm(&self, deadline: Instant, cancelled: Option<Arc<AtomicBool>>) -> Operation {
+        let mut state = self.shared.0.lock().unwrap();
+        state.deadline = Some(deadline);
+        state.cancelled = cancelled;
+        state.reason = None;
+        interrupt(&mut state, &self.child);
+        self.shared.1.notify_one();
+        Operation { shared: self.shared.clone(), child: self.child.clone() }
+    }
+}
+
+impl Operation {
+    pub(crate) fn finish(self) -> Option<InterruptReason> {
+        let mut state = self.shared.0.lock().unwrap();
+        interrupt(&mut state, &self.child);
+        state.deadline = None;
+        state.cancelled = None;
+        state.reason
+    }
+}
+
+impl Drop for Operation {
+    fn drop(&mut self) {
+        let mut state = self.shared.0.lock().unwrap();
+        interrupt(&mut state, &self.child);
+        state.deadline = None;
+        state.cancelled = None;
+        self.shared.1.notify_one();
+    }
+}
+
+impl Drop for Watchdog {
+    fn drop(&mut self) {
+        {
+            let mut state = self.shared.0.lock().unwrap();
+            state.stop = true;
+            self.shared.1.notify_one();
+        }
+        if let Some(thread) = self.thread.take() {
+            let _ = thread.join();
+        }
+    }
+}
diff --git a/crates/tysel-isolate/src/worker.rs b/crates/tysel-isolate/src/worker.rs
index 747d425..162db56 100644
--- a/crates/tysel-isolate/src/worker.rs
+++ b/crates/tysel-isolate/src/worker.rs
@@ -4,7 +4,7 @@ use std::sync::{Arc, Mutex, mpsc};
 use std::thread;
 use std::time::{Duration, Instant};
 
-use tysel_engine::{HttpRequest, InterruptReason, IsolateConfig, Value};
+use tysel_engine::{EngineError, HttpRequest, InterruptReason, IsolateConfig, Value};
 use tysel_engine_qjs::{
     IoCompletion, IoRequest, IsolateCancel, IsolatePool, OpId, eval_with_reactor_deadline,
     inspect_task_module, invoke_task_module, open_bridge,
@@ -65,15 +65,17 @@ pub fn run() -> Result<(), IsolateError> {
                 };
                 write_locked(&stdout, &reply)?;
             }
-            Message::Http { id, method, url, headers, body, request_id } => {
+            Message::Http { id, method, url, headers, body, request_id, timeout_ms } => {
                 let reply = match handler.as_ref() {
-                    Some(pool) => match pool.dispatch_sync(HttpRequest {
-                        method,
-                        url,
-                        headers,
-                        body: body.into_bytes(),
-                        request_id,
-                    }) {
+                    Some(pool) => match pool.dispatch_sync_until(
+                        HttpRequest { method, url, headers, body: body.into_bytes(), request_id },
+                        Instant::now()
+                            + Duration::from_millis(
+                                timeout_ms
+                                    .unwrap_or(config.request_timeout_ms)
+                                    .min(config.request_timeout_ms),
+                            ),
+                    ) {
                         Ok((head, bytes)) => Message::HttpOk {
                             id,
                             status: head.status,
@@ -81,9 +83,20 @@ pub fn run() -> Result<(), IsolateError> {
                             body: String::from_utf8_lossy(&bytes).into_owned(),
                             websocket: head.websocket,
                         },
-                        Err(err) => Message::HttpErr { id, error: err.to_string() },
+                        Err(err) => Message::HttpErr {
+                            id,
+                            timed_out: matches!(
+                                err,
+                                EngineError::Interrupted(InterruptReason::Timeout)
+                            ),
+                            error: err.to_string(),
+                        },
+                    },
+                    None => Message::HttpErr {
+                        id,
+                        error: "handler not loaded".into(),
+                        timed_out: false,
                     },
-                    None => Message::HttpErr { id, error: "handler not loaded".into() },
                 };
                 write_locked(&stdout, &reply)?;
             }
diff --git a/crates/tysel-isolate/tests/isolated.rs b/crates/tysel-isolate/tests/isolated.rs
index 892229b..b60330f 100644
--- a/crates/tysel-isolate/tests/isolated.rs
+++ b/crates/tysel-isolate/tests/isolated.rs
@@ -129,7 +129,10 @@ fn kill_worker_recovers_on_next_http() {
             .expect("kill worker")
             .success()
     );
-    let (head, body) = supervisor.http(&request).expect("http after kill");
+    // If EOF races process exit detection, the first request has an uncertain
+    // outcome and must fail without transparent replay. A new request recovers.
+    let response = supervisor.http(&request);
+    let (head, body) = response.or_else(|_| supervisor.http(&request)).expect("http after kill");
     assert_eq!(head.status, 200);
     assert_eq!(body, b"ok");
 }
@@ -389,3 +392,111 @@ fn worker_exe() -> PathBuf {
     assert!(candidate.is_file(), "missing tysel-worker at {}", candidate.display());
     candidate
 }
+
+#[test]
+fn isolated_http_deadline_and_cancelled_queue_do_not_execute_late_work() {
+    use std::sync::atomic::AtomicBool;
+    use tysel_engine::{EngineError, InterruptReason};
+    use tysel_isolate::IsolateError;
+    let pool = IsolatedHttpPool::spawn(
+        worker_exe(),
+        r#"
+        let count = 0;
+        export default {async fetch(req) {
+            const path = new URL(req.url).pathname;
+            if (path === '/hang') await new Promise(() => {});
+            if (path === '/mutate') count++;
+            return new Response(String(count));
+        }};
+    "#,
+        spec(),
+        Vec::new(),
+    )
+    .unwrap();
+    let request = |path: &str| HttpRequest {
+        method: "GET".into(),
+        url: format!("http://local{path}"),
+        ..Default::default()
+    };
+    assert!(matches!(
+        pool.dispatch_sync_until(request("/mutate"), Instant::now()),
+        Err(IsolateError::Engine(EngineError::Interrupted(InterruptReason::Timeout)))
+    ));
+    let cancelled = std::sync::Arc::new(AtomicBool::new(true));
+    assert!(matches!(
+        pool.dispatch_sync_cancellable(
+            request("/mutate"),
+            Instant::now() + Duration::from_secs(1),
+            &cancelled
+        ),
+        Err(IsolateError::Engine(EngineError::Interrupted(InterruptReason::Cancelled)))
+    ));
+    assert!(matches!(
+        pool.dispatch_sync_until(request("/hang"), Instant::now() + Duration::from_millis(100)),
+        Err(IsolateError::Engine(EngineError::Interrupted(InterruptReason::Timeout)))
+    ));
+    assert_eq!(pool.dispatch_sync(request("/count")).unwrap().1, b"0");
+}
+
+#[cfg(unix)]
+#[test]
+fn stopped_worker_is_killed_at_deadline_and_replaced() {
+    use tysel_engine::{EngineError, InterruptReason};
+    use tysel_isolate::IsolateError;
+    let mut supervisor = Supervisor::spawn(worker_exe(), spec(), HashMap::new()).unwrap();
+    supervisor.load_handler("export default {fetch(){return new Response('ok')}}", vec![]).unwrap();
+    let pid = supervisor.worker_pid().unwrap();
+    assert!(
+        std::process::Command::new("kill")
+            .args(["-STOP", &pid.to_string()])
+            .status()
+            .unwrap()
+            .success()
+    );
+    let started = Instant::now();
+    let request = HttpRequest { url: "http://local/".into(), ..Default::default() };
+    assert!(matches!(
+        supervisor.http_until(&request, started + Duration::from_millis(100)),
+        Err(IsolateError::Engine(EngineError::Interrupted(InterruptReason::Timeout)))
+    ));
+    assert!(started.elapsed() < Duration::from_secs(1));
+    assert!(supervisor.worker_pid().is_none(), "timed-out worker must be reaped before returning");
+    assert_eq!(supervisor.http(&request).unwrap().1, b"ok");
+    assert_ne!(supervisor.worker_pid(), Some(pid));
+}
+
+#[cfg(unix)]
+#[test]
+fn active_cancellation_interrupts_blocking_ipc() {
+    use std::sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    };
+    use tysel_engine::{EngineError, InterruptReason};
+    use tysel_isolate::IsolateError;
+    let mut supervisor = Supervisor::spawn(worker_exe(), spec(), HashMap::new()).unwrap();
+    supervisor.load_handler("export default {fetch(){return new Response('ok')}}", vec![]).unwrap();
+    let pid = supervisor.worker_pid().unwrap();
+    assert!(
+        std::process::Command::new("kill")
+            .args(["-STOP", &pid.to_string()])
+            .status()
+            .unwrap()
+            .success()
+    );
+    let cancelled = Arc::new(AtomicBool::new(false));
+    let trigger = cancelled.clone();
+    let cancel = std::thread::spawn(move || {
+        std::thread::sleep(Duration::from_millis(50));
+        trigger.store(true, Ordering::Release);
+    });
+    let started = Instant::now();
+    let request = HttpRequest { url: "http://local/".into(), ..Default::default() };
+    assert!(matches!(
+        supervisor.http_cancellable(&request, started + Duration::from_secs(5), Some(cancelled)),
+        Err(IsolateError::Engine(EngineError::Interrupted(InterruptReason::Cancelled)))
+    ));
+    cancel.join().unwrap();
+    assert!(started.elapsed() < Duration::from_secs(1));
+    assert!(supervisor.worker_pid().is_none());
+}
diff --git a/crates/tysel-runtime/src/http.rs b/crates/tysel-runtime/src/http.rs
index a387097..9219a75 100644
--- a/crates/tysel-runtime/src/http.rs
+++ b/crates/tysel-runtime/src/http.rs
@@ -2,10 +2,10 @@ use std::convert::Infallible;
 use std::io;
 use std::net::SocketAddr;
 use std::pin::Pin;
-use std::sync::atomic::{AtomicU32, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU32, AtomicUsize, Ordering};
 use std::sync::{Arc, RwLock};
 use std::task::{Context, Poll};
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
 use bytes::Bytes;
 use futures_util::{SinkExt, StreamExt};
@@ -17,12 +17,12 @@ use hyper_util::rt::{TokioExecutor, TokioIo};
 use hyper_util::server::conn::auto;
 use std::future::Future;
 use tokio::net::TcpListener;
-use tokio::sync::{mpsc, oneshot};
+use tokio::sync::{Notify, mpsc, oneshot, watch};
 use tokio_tungstenite::WebSocketStream;
 use tokio_tungstenite::tungstenite::Message;
 use tokio_tungstenite::tungstenite::handshake::derive_accept_key;
 use tokio_tungstenite::tungstenite::protocol::Role;
-use tysel_engine::{EngineError, HttpHead, HttpRequest, IsolateConfig};
+use tysel_engine::{EngineError, HttpHead, HttpRequest, InterruptReason, IsolateConfig};
 use tysel_engine_qjs::{
     IncomingHttp, IsolatePool, ModuleMetadata, OutgoingHttpBody, STREAM_WINDOW,
 };
@@ -61,10 +61,23 @@ impl AppIsolate {
     async fn dispatch_incoming(
         &self,
         request: IncomingHttp,
+        deadline: Instant,
     ) -> Result<(tysel_engine::HttpHead, OutgoingHttpBody), EngineError> {
         match self {
-            Self::Trusted(pool) => pool.dispatch_response(request).await,
-            Self::Isolated(pool) => dispatch_isolated(pool.clone(), request).await,
+            Self::Trusted(pool) => pool.dispatch_response_until(request, deadline).await,
+            Self::Isolated(pool) => tokio::time::timeout_at(
+                tokio::time::Instant::from_std(deadline),
+                dispatch_isolated(pool.clone(), request, deadline),
+            )
+            .await
+            .map_err(|_| EngineError::Interrupted(InterruptReason::Timeout))?,
+        }
+    }
+
+    pub fn request_timeout(&self) -> Duration {
+        match self {
+            Self::Trusted(pool) => pool.request_timeout(),
+            Self::Isolated(pool) => pool.request_timeout(),
         }
     }
 }
@@ -102,6 +115,7 @@ pub fn spawn_app_isolate_with_metadata(
 async fn dispatch_isolated(
     pool: Arc<IsolatedHttpPool>,
     request: IncomingHttp,
+    deadline: Instant,
 ) -> Result<(HttpHead, OutgoingHttpBody), EngineError> {
     if request.ws_in.is_some() || request.ws_out.is_some() {
         return Err(EngineError::Isolate(
@@ -123,24 +137,117 @@ async fn dispatch_isolated(
             return Err(EngineError::BodyTooLarge);
         }
     }
+    struct CancelOnDrop(Arc<AtomicBool>);
+    impl Drop for CancelOnDrop {
+        fn drop(&mut self) {
+            self.0.store(true, Ordering::Release);
+        }
+    }
+    let cancelled = Arc::new(AtomicBool::new(false));
+    let _cancel_on_drop = CancelOnDrop(cancelled.clone());
     let result = tokio::task::spawn_blocking(move || {
-        pool.dispatch_sync(HttpRequest {
-            method: request.method,
-            url: request.url,
-            headers: request.headers,
-            body,
-            request_id: request.request_id,
-        })
+        pool.dispatch_sync_cancellable(
+            HttpRequest {
+                method: request.method,
+                url: request.url,
+                headers: request.headers,
+                body,
+                request_id: request.request_id,
+            },
+            deadline,
+            &cancelled,
+        )
     })
     .await
     .map_err(|err| EngineError::Isolate(err.to_string()))?;
-    let (head, bytes) = result.map_err(|err| EngineError::Isolate(err.to_string()))?;
+    let (head, bytes) = result.map_err(|err| match err {
+        tysel_isolate::IsolateError::Engine(error) => error,
+        other => EngineError::Isolate(other.to_string()),
+    })?;
     Ok((head, OutgoingHttpBody::Buffered(bytes)))
 }
 
 #[derive(Clone)]
 pub struct SharedPool {
     inner: Arc<RwLock<PoolState>>,
+    shutdown: Option<HttpShutdown>,
+}
+
+/// Cooperative connection draining. One watcher per connection, never per chunk.
+#[derive(Clone)]
+pub struct HttpShutdown(Arc<HttpShutdownState>);
+
+struct HttpShutdownState {
+    phase: watch::Sender<u8>,
+    active: AtomicUsize,
+    idle: Notify,
+}
+
+impl Default for HttpShutdown {
+    fn default() -> Self {
+        let (phase, _) = watch::channel(0);
+        Self(Arc::new(HttpShutdownState {
+            phase,
+            active: AtomicUsize::new(0),
+            idle: Notify::new(),
+        }))
+    }
+}
+
+impl HttpShutdown {
+    pub async fn drain(&self, grace: Duration) {
+        self.cancel();
+        if tokio::time::timeout(grace, self.idle()).await.is_err() {
+            self.0.phase.send_replace(2);
+            self.idle().await;
+        }
+    }
+
+    pub fn cancel(&self) {
+        self.0.phase.send_if_modified(|phase| {
+            if *phase == 0 {
+                *phase = 1;
+                true
+            } else {
+                false
+            }
+        });
+    }
+
+    async fn notified(&self, phase: u8) {
+        let mut rx = self.0.phase.subscribe();
+        while *rx.borrow_and_update() < phase {
+            if rx.changed().await.is_err() {
+                return;
+            }
+        }
+    }
+
+    fn track(&self) -> ConnectionGuard {
+        self.0.active.fetch_add(1, Ordering::AcqRel);
+        ConnectionGuard(self.clone())
+    }
+
+    async fn idle(&self) {
+        loop {
+            let notified = self.0.idle.notified();
+            tokio::pin!(notified);
+            notified.as_mut().enable();
+            if self.0.active.load(Ordering::Acquire) == 0 {
+                return;
+            }
+            notified.await;
+        }
+    }
+}
+
+struct ConnectionGuard(HttpShutdown);
+impl Drop for ConnectionGuard {
+    fn drop(&mut self) {
+        if self.0.0.active.fetch_sub(1, Ordering::AcqRel) == 1 {
+            self.0.0.idle.notify_waiters();
+        }
+    }
 }
 
 struct PoolState {
@@ -165,6 +272,7 @@ struct PoolSnapshot {
 }
 
 struct RuntimeDiagnostics {
+    shutdown: Option<HttpShutdown>,
     source_map: Option<Arc<SourceMap>>,
     sink: Option<RuntimeDiagnosticSink>,
 }
@@ -244,6 +352,11 @@ impl Drop for AdmissionPermit {
 }
 
 impl SharedPool {
+    pub fn with_shutdown(mut self, shutdown: HttpShutdown) -> Self {
+        self.shutdown = Some(shutdown);
+        self
+    }
+
     pub fn new(pool: impl Into<AppIsolate>, max_request_bytes: usize) -> Self {
         Self::with_websocket(pool, max_request_bytes, false)
     }
@@ -316,6 +429,7 @@ impl SharedPool {
         source_map: Option<Arc<SourceMap>>,
     ) -> Self {
         Self {
+            shutdown: None,
             inner: Arc::new(RwLock::new(PoolState {
                 isolate: pool.into(),
                 max_request_bytes: limits.max_request_bytes,
@@ -436,6 +550,7 @@ impl SharedPool {
             websocket: guard.websocket,
             admission: guard.admission.clone(),
             diagnostics: RuntimeDiagnostics {
+                shutdown: self.shutdown.clone(),
                 source_map: guard.source_map.clone(),
                 sink: guard.diagnostic_sink.clone(),
             },
@@ -544,12 +659,43 @@ pub async fn serve_with_http_limits(
     }
 }
 
+/// Serve until cancellation, then drain admitted responses and close idle sockets.
+/// The grace period is shared by every connection, including upgraded sockets.
+pub async fn serve_with_shutdown(
+    listener: TcpListener,
+    pool: SharedPool,
+    shutdown: HttpShutdown,
+    grace: Duration,
+) -> Result<(), HttpError> {
+    let (http1, http2) = pool.protocols();
+    if !http1 && !http2 {
+        return Err(HttpError::Hyper("at least one HTTP protocol must be enabled".into()));
+    }
+    let pool = pool.with_shutdown(shutdown.clone());
+    let result = loop {
+        tokio::select! {
+            biased;
+            () = shutdown.notified(1) => break Ok(()),
+            accepted = listener.accept() => match accepted {
+                Ok((stream, _)) => handle_stream(stream, pool.clone()),
+                Err(error) => break Err(HttpError::Io(error)),
+            }
+        }
+    };
+    drop(listener);
+    shutdown.drain(grace).await;
+    result
+}
+
 pub fn handle_stream(stream: tokio::net::TcpStream, pool: SharedPool) {
     // Small HTTP responses should not wait for Nagle/delayed-ACK interaction.
     // This applies to every accepted connection, independent of the handler or
     // workload, and mirrors the latency-oriented behavior of modern runtimes.
     let _ = stream.set_nodelay(true);
+    let shutdown = pool.shutdown.clone();
+    let guard = shutdown.as_ref().map(HttpShutdown::track);
     tokio::spawn(async move {
+        let _guard = guard;
         let (http1, http2) = pool.protocols();
         let io = TokioIo::new(stream);
         let service = service_fn(move |request| {
@@ -585,23 +731,37 @@ pub fn handle_stream(stream: tokio::net::TcpStream, pool: SharedPool) {
                 Ok::<_, Infallible>(response)
             }
         });
+        // Pin each protocol's native connection, retaining its existing fast path.
+        macro_rules! drive {
+            ($connection:expr) => {{
+                let connection = $connection;
+                tokio::pin!(connection);
+                if let Some(shutdown) = &shutdown {
+                    tokio::select! {
+                        result = &mut connection => { let _ = result; return; }
+                        () = shutdown.notified(1) => connection.as_mut().graceful_shutdown(),
+                    }
+                    tokio::select! {
+                        result = &mut connection => { let _ = result; }
+                        () = shutdown.notified(2) => {}
+                    }
+                } else {
+                    let _ = connection.await;
+                }
+            }};
+        }
         match (http1, http2) {
             (true, true) => {
-                let _ = auto::Builder::new(TokioExecutor::new())
-                    .serve_connection_with_upgrades(io, service)
-                    .await;
+                let builder = auto::Builder::new(TokioExecutor::new());
+                drive!(builder.serve_connection_with_upgrades(io, service));
             }
             (false, true) => {
-                let _ = hyper::server::conn::http2::Builder::new(TokioExecutor::new())
-                    .serve_connection(io, service)
-                    .await;
+                let builder = hyper::server::conn::http2::Builder::new(TokioExecutor::new());
+                drive!(builder.serve_connection(io, service));
             }
             (true, false) => {
-                let _ = hyper::server::conn::http1::Builder::new()
-                    .keep_alive(true)
-                    .serve_connection(io, service)
-                    .with_upgrades()
-                    .await;
+                let mut builder = hyper::server::conn::http1::Builder::new();
+                drive!(builder.keep_alive(true).serve_connection(io, service).with_upgrades());
             }
             (false, false) => {}
         }
@@ -644,53 +804,74 @@ async fn dispatch(
     permit: AdmissionPermit,
 ) -> Response<HttpBody> {
     let mut permit = Some(permit);
-    let mut response =
-        match dispatch_inner(pool, request, limits, websocket, request_id, &mut permit).await {
-            Ok(response) => response,
-            Err(HttpError::BodyTooLarge(limit)) => json_error_response(
-                StatusCode::PAYLOAD_TOO_LARGE,
-                "BODY_TOO_LARGE",
-                &format!("request body exceeds {limit} bytes"),
-                request_id,
-            ),
-            Err(HttpError::ResponseTooLarge(limit)) => json_error_response(
-                StatusCode::INTERNAL_SERVER_ERROR,
-                "RESPONSE_TOO_LARGE",
-                &format!("response body exceeds {limit} bytes"),
+    let mut response = match dispatch_inner(
+        pool,
+        request,
+        limits,
+        websocket,
+        request_id,
+        &mut permit,
+        diagnostics.shutdown.clone(),
+    )
+    .await
+    {
+        Ok(response) => response,
+        Err(HttpError::Engine(EngineError::Interrupted(InterruptReason::Timeout))) => {
+            json_error_response(
+                StatusCode::GATEWAY_TIMEOUT,
+                "REQUEST_TIMEOUT",
+                "request deadline exceeded",
                 request_id,
-            ),
-            Err(err) => {
-                let message = err.to_string();
-                let source = diagnostics
-                    .source_map
-                    .as_deref()
-                    .and_then(|source_map| source_map.first_original_position(&message))
-                    .map(|position| RuntimeDiagnosticSource {
-                        file: position.source,
-                        line: position.line,
-                        column: position.column,
-                    });
-                let message = diagnostics
-                    .source_map
-                    .as_deref()
-                    .map(|source_map| source_map.symbolicate_stack(&message))
-                    .unwrap_or(message);
-                if let Some(diagnostic_sink) = diagnostics.sink.as_ref() {
-                    diagnostic_sink(RuntimeDiagnostic {
-                        code: "RUNTIME_ERROR",
-                        message: message.clone(),
-                        request_id,
-                        source,
-                    });
-                }
-                json_error_response(
-                    StatusCode::INTERNAL_SERVER_ERROR,
-                    "RUNTIME_ERROR",
-                    &message,
+            )
+        }
+        Err(HttpError::BodyTooLarge(limit)) => json_error_response(
+            StatusCode::PAYLOAD_TOO_LARGE,
+            "BODY_TOO_LARGE",
+            &format!("request body exceeds {limit} bytes"),
+            request_id,
+        ),
+        Err(HttpError::ResponseTooLarge(limit)) => json_error_response(
+            StatusCode::INTERNAL_SERVER_ERROR,
+            "RESPONSE_TOO_LARGE",
+            &format!("response body exceeds {limit} bytes"),
+            request_id,
+        ),
+        Err(err) => {
+            // Source maps are supplied only by the explicit development
+            // diagnostics path. Packaged services must never echo an
+            // arbitrary application or host exception to their clients.
+            let expose_details = diagnostics.source_map.is_some();
+            let message = err.to_string();
+            let source = diagnostics
+                .source_map
+                .as_deref()
+                .and_then(|source_map| source_map.first_original_position(&message))
+                .map(|position| RuntimeDiagnosticSource {
+                    file: position.source,
+                    line: position.line,
+                    column: position.column,
+                });
+            let message = diagnostics
+                .source_map
+                .as_deref()
+                .map(|source_map| source_map.symbolicate_stack(&message))
+                .unwrap_or(message);
+            if let Some(diagnostic_sink) = diagnostics.sink.as_ref() {
+                diagnostic_sink(RuntimeDiagnostic {
+                    code: "RUNTIME_ERROR",
+                    message: message.clone(),
                     request_id,
-                )
+                    source,
+                });
             }
-        };
+            json_error_response(
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "RUNTIME_ERROR",
+                if expose_details { &message } else { "request execution failed" },
+                request_id,
+            )
+        }
+    };
     if let Some(permit) = permit {
         response.body_mut().hold_permit(permit);
     }
@@ -738,7 +919,11 @@ async fn dispatch_inner(
     websocket_enabled: bool,
     request_id: u64,
     permit: &mut Option<AdmissionPermit>,
+    shutdown: Option<HttpShutdown>,
 ) -> Result<Response<HttpBody>, HttpError> {
+    let deadline = Instant::now()
+        .checked_add(pool.request_timeout())
+        .ok_or_else(|| EngineError::Isolate("request timeout is too large".into()))?;
     if let Some(len) = request
         .headers()
         .get(hyper::header::CONTENT_LENGTH)
@@ -795,15 +980,18 @@ async fn dispatch_inner(
     };
 
     let (head, body) = match pool
-        .dispatch_incoming(IncomingHttp {
-            method,
-            url,
-            headers,
-            body: rx,
-            ws_in: ws_to_js_rx,
-            ws_out: ws_from_js_tx,
-            request_id,
-        })
+        .dispatch_incoming(
+            IncomingHttp {
+                method,
+                url,
+                headers,
+                body: rx,
+                ws_in: ws_to_js_rx,
+                ws_out: ws_from_js_tx,
+                request_id,
+            },
+            deadline,
+        )
         .await
     {
         Ok(pair) => pair,
@@ -819,10 +1007,22 @@ async fn dispatch_inner(
         && head.status == 101
     {
         let websocket_permit = permit.take();
+        let guard = shutdown.as_ref().map(HttpShutdown::track);
         tokio::spawn(async move {
+            let _guard = guard;
             let _permit = websocket_permit;
-            if let Ok(upgraded) = hyper::upgrade::on(request).await {
-                pump_websocket(upgraded, ws_to_js_tx, ws_from_js_rx).await;
+            let pump = async {
+                if let Ok(upgraded) = hyper::upgrade::on(request).await {
+                    pump_websocket(upgraded, ws_to_js_tx, ws_from_js_rx, shutdown.clone()).await;
+                }
+            };
+            if let Some(shutdown) = &shutdown {
+                tokio::select! {
+                    () = pump => {}
+                    () = shutdown.notified(2) => {}
+                }
+            } else {
+                pump.await;
             }
         });
         let accept = derive_accept_key(key.as_bytes());
@@ -885,43 +1085,67 @@ async fn pump_websocket(
     upgraded: hyper::upgrade::Upgraded,
     to_js: mpsc::Sender<Result<Vec<u8>, String>>,
     mut from_js: mpsc::Receiver<Vec<u8>>,
+    shutdown: Option<HttpShutdown>,
 ) {
     let mut ws = WebSocketStream::from_raw_socket(TokioIo::new(upgraded), Role::Server, None).await;
-    loop {
-        tokio::select! {
-            incoming = ws.next() => {
-                match incoming {
-                    Some(Ok(Message::Text(text))) => {
-                        if to_js.send(Ok(text.as_bytes().to_vec())).await.is_err() {
-                            break;
+    let draining = {
+        let pump = async {
+            loop {
+                tokio::select! {
+                    incoming = ws.next() => {
+                        match incoming {
+                            Some(Ok(Message::Text(text))) => {
+                                if to_js.send(Ok(text.as_bytes().to_vec())).await.is_err() {
+                                    break;
+                                }
+                            }
+                            Some(Ok(Message::Ping(_) | Message::Pong(_) | Message::Frame(_))) => {}
+                            Some(Ok(Message::Binary(_))) => {}
+                            Some(Ok(Message::Close(_))) | None | Some(Err(_)) => break,
                         }
                     }
-                    Some(Ok(Message::Ping(_) | Message::Pong(_) | Message::Frame(_))) => {}
-                    Some(Ok(Message::Binary(_))) => {}
-                    Some(Ok(Message::Close(_))) | None | Some(Err(_)) => break,
-                }
-            }
-            outgoing = from_js.recv() => {
-                match outgoing {
-                    Some(bytes) => {
-                        let text = String::from_utf8_lossy(&bytes).into_owned();
-                        if ws.send(Message::Text(text.into())).await.is_err() {
-                            break;
+                    outgoing = from_js.recv() => {
+                        match outgoing {
+                            Some(bytes) => {
+                                let text = String::from_utf8_lossy(&bytes).into_owned();
+                                if ws.send(Message::Text(text.into())).await.is_err() {
+                                    break;
+                                }
+                            }
+                            None => {
+                                let _ = ws.close(None).await;
+                                break;
+                            }
                         }
                     }
-                    None => {
-                        let _ = ws.close(None).await;
-                        break;
-                    }
                 }
             }
+        };
+        if let Some(shutdown) = &shutdown {
+            tokio::select! {
+                () = pump => false,
+                () = shutdown.notified(1) => true,
+            }
+        } else {
+            pump.await;
+            false
         }
+    };
+    if draining {
+        use tokio_tungstenite::tungstenite::protocol::{CloseFrame, frame::coding::CloseCode};
+        let _ = ws
+            .close(Some(CloseFrame { code: CloseCode::Away, reason: "server shutdown".into() }))
+            .await;
     }
 }
 
 async fn pump_request_body(mut body: Limited<Incoming>, tx: mpsc::Sender<Result<Vec<u8>, String>>) {
     loop {
-        match body.frame().await {
+        let frame = tokio::select! {
+            () = tx.closed() => return,
+            frame = body.frame() => frame,
+        };
+        match frame {
             Some(Ok(frame)) => {
                 if let Ok(data) = frame.into_data() {
                     if data.is_empty() {
diff --git a/crates/tysel-runtime/src/lib.rs b/crates/tysel-runtime/src/lib.rs
index 575b8d4..1619171 100644
--- a/crates/tysel-runtime/src/lib.rs
+++ b/crates/tysel-runtime/src/lib.rs
@@ -22,10 +22,10 @@ pub use durable_poll::{
     ProgramRegistryError,
 };
 pub use http::{
-    AppIsolate, HttpError, HttpLimits, RuntimeDiagnostic, RuntimeDiagnosticSink,
+    AppIsolate, HttpError, HttpLimits, HttpShutdown, RuntimeDiagnostic, RuntimeDiagnosticSink,
     RuntimeDiagnosticSource, SharedPool, bind, bind_with, bind_with_request_limit, handle_stream,
-    serve, serve_with_http_limits, serve_with_limits, serve_with_protocols, serve_with_websocket,
-    spawn_app_isolate, spawn_app_isolate_with_metadata,
+    serve, serve_with_http_limits, serve_with_limits, serve_with_protocols, serve_with_shutdown,
+    serve_with_websocket, spawn_app_isolate, spawn_app_isolate_with_metadata,
 };
 pub use service::{
     ComponentRuntimePolicy, StubError, configure_llm_from_env, invoke_component_tap,
diff --git a/crates/tysel-runtime/src/service.rs b/crates/tysel-runtime/src/service.rs
index 4f448ed..899f057 100644
--- a/crates/tysel-runtime/src/service.rs
+++ b/crates/tysel-runtime/src/service.rs
@@ -23,7 +23,8 @@ use tysel_engine_wasm::{
 use tysel_package::Tap;
 
 use crate::http::{
-    AppIsolate, HttpError, HttpLimits, serve_with_http_limits, spawn_app_isolate_with_metadata,
+    AppIsolate, HttpError, HttpLimits, HttpShutdown, serve_with_shutdown,
+    spawn_app_isolate_with_metadata,
 };
 use crate::{DurablePlane, DurablePlaneError};
 #[cfg(unix)]
@@ -296,52 +297,52 @@ pub async fn run_tap(tap: Tap) -> Result<(), StubError> {
         max_response_bytes: tap.manifest.max_response_bytes,
         max_in_flight: tap.manifest.max_in_flight,
     };
+    let shutdown = HttpShutdown::default();
+    let server = serve_with_shutdown(
+        listener,
+        crate::SharedPool::with_http_limits(
+            pool,
+            http_limits,
+            websocket,
+            tap.manifest.http1,
+            tap.manifest.http2,
+            None,
+        ),
+        shutdown.clone(),
+        Duration::from_millis(config.request_timeout_ms.saturating_add(1_000)),
+    );
+    tokio::pin!(server);
+    let mut server_finished = false;
     #[cfg(unix)]
-    if let Some(service) = task_service {
-        tokio::select! {
-            result = serve_with_http_limits(listener, pool, http_limits, websocket, tap.manifest.http1, tap.manifest.http2) => {
-                let durable_shutdown = shutdown_durable(durable.as_ref()).await;
-                service.shutdown().await?;
-                durable_shutdown?;
-                result?;
-            }
-            error = service.failed() => {
-                let durable_shutdown = shutdown_durable(durable.as_ref()).await;
-                service.shutdown().await?;
-                durable_shutdown?;
-                return Err(error.into());
-            }
-            signal = shutdown_signal() => {
-                let durable_shutdown = shutdown_durable(durable.as_ref()).await;
-                let shutdown = service.shutdown().await;
-                signal?;
-                durable_shutdown?;
-                shutdown?;
-            }
-        }
-    } else {
-        tokio::select! {
-            result = serve_with_http_limits(listener, pool, http_limits, websocket, tap.manifest.http1, tap.manifest.http2) => {
-                shutdown_durable(durable.as_ref()).await?;
-                result?;
+    let outcome: Result<(), StubError> = tokio::select! {
+        result = &mut server => { server_finished = true; result.map_err(Into::into) }
+        error = async {
+            match &task_service {
+                Some(service) => service.failed().await,
+                None => std::future::pending().await,
             }
-            signal = shutdown_signal() => {
-                shutdown_durable(durable.as_ref()).await?;
-                signal?;
-            }
-        }
-    }
+        } => Err(error.into()),
+        signal = shutdown_signal() => signal.map_err(Into::into),
+    };
     #[cfg(not(unix))]
-    tokio::select! {
-        result = serve_with_http_limits(listener, pool, http_limits, websocket, tap.manifest.http1, tap.manifest.http2) => {
-            shutdown_durable(durable.as_ref()).await?;
-            result?;
-        }
-        signal = shutdown_signal() => {
-            shutdown_durable(durable.as_ref()).await?;
-            signal?;
-        }
-    }
+    let outcome: Result<(), StubError> = tokio::select! {
+        result = &mut server => { server_finished = true; result.map_err(Into::into) }
+        signal = shutdown_signal() => signal.map_err(Into::into),
+    };
+    shutdown.cancel();
+    // Keep capability and durable hooks alive while admitted HTTP handlers finish.
+    let http_result = if server_finished { Ok(()) } else { server.await };
+    let durable_result = shutdown_durable(durable.as_ref()).await;
+    #[cfg(unix)]
+    let task_result = match task_service {
+        Some(service) => service.shutdown().await,
+        None => Ok(()),
+    };
+    outcome?;
+    http_result?;
+    durable_result?;
+    #[cfg(unix)]
+    task_result?;
     Ok(())
 }
 
diff --git a/crates/tysel-runtime/src/tests.rs b/crates/tysel-runtime/src/tests.rs
index cf04b30..4a8256f 100644
--- a/crates/tysel-runtime/src/tests.rs
+++ b/crates/tysel-runtime/src/tests.rs
@@ -760,3 +760,111 @@ async fn send(
     let bytes = response.into_body().collect().await.unwrap().to_bytes();
     (status, String::from_utf8_lossy(&bytes).into_owned())
 }
+
+#[tokio::test]
+async fn graceful_shutdown_drains_http2_and_force_closes_stalled_body() {
+    use crate::{HttpShutdown, serve_with_shutdown};
+    use std::time::{Duration, Instant};
+    for stalled in [false, true] {
+        let source = if stalled {
+            "export default {fetch(){return new Response(new ReadableStream({start(c){c.enqueue(new TextEncoder().encode('first'));}}));}}"
+        } else {
+            "export default {fetch(){return new Response(new ReadableStream({async start(c){c.enqueue(new TextEncoder().encode('first'));await new Promise(r=>setTimeout(r,100));c.enqueue(new TextEncoder().encode('last'));c.close();}}));}}"
+        };
+        let pool = Arc::new(IsolatePool::spawn(1, source, config()).unwrap());
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+        let shutdown = HttpShutdown::default();
+        let server = tokio::spawn(serve_with_shutdown(
+            listener,
+            SharedPool::with_http_limits(
+                pool.clone(),
+                HttpLimits {
+                    max_request_bytes: 16 * 1024 * 1024,
+                    max_response_bytes: 16 * 1024 * 1024,
+                    max_in_flight: 16,
+                },
+                false,
+                false,
+                true,
+                None,
+            ),
+            shutdown.clone(),
+            Duration::from_millis(300),
+        ));
+        let stream = TcpStream::connect(addr).await.unwrap();
+        let (mut sender, connection) = hyper::client::conn::http2::handshake::<_, _, Empty<Bytes>>(
+            TokioExecutor::new(),
+            TokioIo::new(stream),
+        )
+        .await
+        .unwrap();
+        tokio::spawn(async move {
+            let _ = connection.await;
+        });
+        let response = sender
+            .send_request(Request::builder().uri("http://localhost/").body(Empty::new()).unwrap())
+            .await
+            .unwrap();
+        let mut body = response.into_body();
+        assert_eq!(body.frame().await.unwrap().unwrap().into_data().unwrap(), "first");
+        let start = Instant::now();
+        shutdown.cancel();
+        if stalled {
+            assert!(
+                tokio::time::timeout(Duration::from_secs(1), body.collect())
+                    .await
+                    .unwrap()
+                    .is_err()
+            );
+            assert!(start.elapsed() >= Duration::from_millis(250));
+        } else {
+            assert_eq!(body.collect().await.unwrap().to_bytes(), "last");
+        }
+        tokio::time::timeout(Duration::from_secs(1), server).await.unwrap().unwrap().unwrap();
+        assert!(TcpStream::connect(addr).await.is_err());
+    }
+}
+
+#[tokio::test]
+async fn graceful_shutdown_sends_websocket_going_away() {
+    use crate::{HttpShutdown, serve_with_shutdown};
+    use futures_util::{SinkExt, StreamExt};
+    use std::time::Duration;
+    use tokio_tungstenite::tungstenite::{Message, protocol::frame::coding::CloseCode};
+    let pool = Arc::new(IsolatePool::spawn(1, WS_ECHO, config()).unwrap());
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let addr = listener.local_addr().unwrap();
+    let shutdown = HttpShutdown::default();
+    let server = tokio::spawn(serve_with_shutdown(
+        listener,
+        SharedPool::with_http_limits(
+            pool,
+            HttpLimits {
+                max_request_bytes: 16 * 1024 * 1024,
+                max_response_bytes: 16 * 1024 * 1024,
+                max_in_flight: 16,
+            },
+            true,
+            true,
+            false,
+            None,
+        ),
+        shutdown.clone(),
+        Duration::from_millis(500),
+    ));
+    let (mut socket, _) = tokio_tungstenite::connect_async(format!("ws://{addr}/")).await.unwrap();
+    socket.send(Message::Text("ready".into())).await.unwrap();
+    assert_eq!(socket.next().await.unwrap().unwrap().into_text().unwrap(), "ready");
+    shutdown.cancel();
+    match tokio::time::timeout(Duration::from_secs(1), socket.next())
+        .await
+        .unwrap()
+        .unwrap()
+        .unwrap()
+    {
+        Message::Close(Some(frame)) => assert_eq!(frame.code, CloseCode::Away),
+        other => panic!("expected shutdown close frame, got {other:?}"),
+    }
+    tokio::time::timeout(Duration::from_secs(1), server).await.unwrap().unwrap().unwrap();
+}
diff --git a/crates/tysel-runtime/tests/packaged.rs b/crates/tysel-runtime/tests/packaged.rs
index dcc9ee2..d084dbf 100644
--- a/crates/tysel-runtime/tests/packaged.rs
+++ b/crates/tysel-runtime/tests/packaged.rs
@@ -19,6 +19,7 @@ const HANDLER: &str = r#"
 export default {
   async fetch(request) {
     const path = new URL(request.url).pathname;
+    if (path === "/error") throw new Error("private-exception-sentinel");
     return Response.json({
       message: "Hello from Tysel",
       path,
@@ -69,6 +70,14 @@ async fn packaged_stub_serves_embedded_bundle() {
     assert!(body.contains("Hello from Tysel"));
     assert!(body.contains("\"path\":\"/hello\""));
     assert!(body.contains("\"packaged\":true"));
+    let (status, body) = request(addr, "/error").await;
+    assert_eq!(status, 500);
+    let error: serde_json::Value = serde_json::from_str(&body).unwrap();
+    assert_eq!(error["error"]["code"], "RUNTIME_ERROR");
+    assert_eq!(error["error"]["message"], "request execution failed");
+    assert!(!body.contains("private-exception-sentinel"));
+    assert!(!body.contains("app.js"));
+    assert!(error["error"]["requestId"].as_str().is_some_and(|id| id.len() == 16));
     child.kill().await.expect("stop packaged stub");
 }
 
@@ -100,6 +109,84 @@ async fn packaged_stub_exits_cleanly_on_sigterm() {
     assert!(status.success(), "status={status}; stderr={}", stderr_text(&stderr));
 }
 
+#[cfg(unix)]
+#[tokio::test]
+async fn sigterm_drains_streamed_response_and_closes_idle_keepalive() {
+    let _permit = PACKAGE_SEMAPHORE.acquire().await.unwrap();
+    let packaged = package_stub_with_source(
+        r#"
+        export default {fetch() {
+            return new Response(new ReadableStream({async start(c) {
+                c.enqueue(new TextEncoder().encode('first'));
+                await new Promise(resolve => setTimeout(resolve, 200));
+                c.enqueue(new TextEncoder().encode('last'));
+                c.close();
+            }}));
+        }};
+    "#,
+    );
+    let mut child = Command::new(packaged.path())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::null())
+        .kill_on_drop(true)
+        .spawn()
+        .unwrap();
+    let addr = read_listen(child.stdout.take().unwrap()).await.unwrap();
+    // Complete one response and keep its HTTP/1 connection idle during shutdown.
+    let idle = TcpStream::connect(addr).await.unwrap();
+    let (mut idle_client, idle_connection) =
+        hyper::client::conn::http1::handshake(TokioIo::new(idle)).await.unwrap();
+    let idle_driver = tokio::spawn(idle_connection);
+    idle_client
+        .send_request(
+            Request::builder()
+                .uri("/")
+                .header("host", "localhost")
+                .body(Empty::<Bytes>::new())
+                .unwrap(),
+        )
+        .await
+        .unwrap()
+        .into_body()
+        .collect()
+        .await
+        .unwrap();
+    let stream = TcpStream::connect(addr).await.unwrap();
+    let (mut client, connection) =
+        hyper::client::conn::http1::handshake(TokioIo::new(stream)).await.unwrap();
+    tokio::spawn(async move {
+        let _ = connection.await;
+    });
+    let response = client
+        .send_request(
+            Request::builder()
+                .uri("/")
+                .header("host", "localhost")
+                .body(Empty::<Bytes>::new())
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+    let mut body = response.into_body();
+    assert_eq!(
+        body.frame().await.unwrap().unwrap().into_data().unwrap(),
+        Bytes::from_static(b"first")
+    );
+    assert!(
+        Command::new("kill")
+            .args(["-TERM", &child.id().unwrap().to_string()])
+            .status()
+            .await
+            .unwrap()
+            .success()
+    );
+    let rest = body.collect().await.unwrap().to_bytes();
+    assert_eq!(rest, Bytes::from_static(b"last"));
+    let status = tokio::time::timeout(Duration::from_secs(4), child.wait()).await.unwrap().unwrap();
+    assert!(status.success());
+    tokio::time::timeout(Duration::from_secs(1), idle_driver).await.unwrap().unwrap().unwrap();
+}
+
 #[tokio::test]
 async fn packaged_stub_invokes_embedded_component_over_stdio() {
     let _permit = PACKAGE_SEMAPHORE.acquire().await.expect("package semaphore");
@@ -174,6 +261,10 @@ fn stub_exe() -> PathBuf {
 }
 
 fn package_stub() -> PackagedExecutable {
+    package_stub_with_source(HANDLER)
+}
+
+fn package_stub_with_source(source: &str) -> PackagedExecutable {
     let stub = std::fs::read(stub_exe()).expect("read stub");
     let map = identity_source_map("src/index.ts", TYPESCRIPT).expect("source map");
     let tap = Tap::new(
@@ -204,7 +295,7 @@ fn package_stub() -> PackagedExecutable {
             fs_write: Vec::new(),
             json_logs: true,
         },
-        HANDLER.as_bytes().to_vec(),
+        source.as_bytes().to_vec(),
         map,
     );
     let extracted_map = tap.parsed_source_map().expect("parse map");
diff --git a/docs/guides/concurrency-backpressure.md b/docs/guides/concurrency-backpressure.md
index 254b3d7..c00f267 100644
--- a/docs/guides/concurrency-backpressure.md
+++ b/docs/guides/concurrency-backpressure.md
@@ -40,6 +40,21 @@ before dispatching a request:
 Setting `max_in_flight = 0` deliberately sheds every request and can serve as a
 circuit breaker. It does not mean unlimited.
 
+## Request deadlines
+
+`request_timeout_ms` starts when a parsed HTTP request is admitted. It includes
+body consumption, waiting for a worker, and execution; dequeuing does not reset
+it. Expired or canceled queued requests are skipped before entering JavaScript.
+In the isolated profile, the remaining budget is forwarded to the worker, and
+canceled requests waiting for the supervisor are skipped before IPC dispatch.
+An already dispatched isolated request remains bounded by its remaining deadline.
+
+A timeout before response headers yields `504 REQUEST_TIMEOUT`. After headers,
+a streamed response ends with a body error. Request-header receipt and sending
+an already buffered response to a slow client are separate transport concerns;
+configure ingress timeouts as well. Cancellation does not roll back effects
+that already happened.
+
 ## Choose an initial value
 
 Use measured service time and a target throughput as a starting estimate:
@@ -101,7 +116,7 @@ provider concurrency limits, or deployment-level CPU and memory controls.
 | Immediate `503 OVERLOADED` | HTTP admission full | Reduce demand, shorten work, or raise the measured limit carefully. |
 | `413 BODY_TOO_LARGE` | Request-body limit | Reject or chunk earlier; raise only for a documented payload need. |
 | `500 RESPONSE_TOO_LARGE` | Response-body limit | Paginate, stream within the bound, or reduce output. |
-| Runtime timeout | Handler deadline | Bound upstream calls and keep the ingress deadline longer than Tysel's. |
+| `504 REQUEST_TIMEOUT`, or an aborted stream | Admission-to-execution deadline | Bound upstream calls and keep the ingress deadline longer than Tysel's. |
 | Memory grows after adding workers | Per-isolate budget multiplied | Reduce worker count or state; confirm external storage and cache strategy. |
 
 See [Application limits](../reference/manifest/limits.md),
diff --git a/docs/operations/production.md b/docs/operations/production.md
index 7d9326e..3938c00 100644
--- a/docs/operations/production.md
+++ b/docs/operations/production.md
@@ -104,6 +104,15 @@ Shutdown:
 3. Wait through the configured grace period.
 4. If the process remains, capture logs and process state before forcing it.
 
+On SIGTERM or Ctrl-C, packaged services and `tysel run` close the listener,
+drain HTTP/1 and HTTP/2 connections. Idle sockets
+close immediately. WebSockets receive close code 1001 (Going Away) when the
+transport can send it. Connections that remain after `request_timeout_ms +
+1000` milliseconds are closed forcibly. This HTTP grace is shared across
+connections; task-plane shutdown and telemetry flushing can add time, so keep
+the service-manager grace longer. Development servers use the same draining
+path, with enough grace for the largest timeout seen during reloads.
+
 Clean shutdown flushes OTLP providers and stops the service-owned task plane.
 
 ## Durable Postgres backup and restore
diff --git a/docs/reference/errors-and-output.md b/docs/reference/errors-and-output.md
index cedfbe0..d0dfd65 100644
--- a/docs/reference/errors-and-output.md
+++ b/docs/reference/errors-and-output.md
@@ -106,7 +106,7 @@ Unhandled runtime failures return HTTP `500` with JSON:
 {
   "error": {
     "code": "RUNTIME_ERROR",
-    "message": "...",
+    "message": "request execution failed",
     "requestId": "000000000000002a"
   }
 }
@@ -117,12 +117,16 @@ An oversized inbound body returns HTTP `413` with the same shape and code
 An internal serialization fallback can return only
 `{"error":{"code":"INTERNAL_ERROR"}}`.
 
-`tysel dev` uses the generated source map to symbolicate application stack
-information. Although the map is embedded during packaging, the packaged HTTP
-dispatcher does not currently apply it, so production messages can contain
-bundle locations. Treat all runtime messages as operator diagnostics: map
-errors to an application-owned response before exposing sensitive internals to
-public clients.
+Packaged services and `tysel run` return the fixed message `request execution
+failed` for unhandled failures. Arbitrary exception text, source paths, and
+stacks are not included in that public response. `tysel dev` retains mapped
+source diagnostics and detailed error messages for local debugging.
+
+A request whose deadline expires before response headers returns HTTP `504`
+with code `REQUEST_TIMEOUT` and message `request deadline exceeded`. The
+budget includes admitted queue time and handler execution. If headers have
+already been sent, a streaming timeout terminates the body with an error;
+it cannot replace the existing status with `504`.
 
 ## Application errors
 
diff --git a/docs/reference/manifest/limits.md b/docs/reference/manifest/limits.md
index 8a541f5..98c749f 100644
--- a/docs/reference/manifest/limits.md
+++ b/docs/reference/manifest/limits.md
@@ -7,7 +7,7 @@ are non-negative integers; omitted fields receive the values below.
 | --- | ---: | --- | --- |
 | `memory_mb` | `128` | MiB | QuickJS or isolated-worker memory budget. |
 | `cpu_ms_per_turn` | `50` | ms | CPU budget for one JavaScript turn. |
-| `request_timeout_ms` | `30000` | ms | Invocation deadline; also bounds configured LLM calls. |
+| `request_timeout_ms` | `30000` | ms | HTTP deadline includes admitted queue time and execution; also bounds configured LLM calls. |
 | `max_in_flight` | `1000` | requests | Maximum admitted HTTP requests, held through response-body completion. |
 | `max_response_mb` | `16` | MiB | Maximum cumulative HTTP response-body size. |
 | `max_request_mb` | `16` | MiB | Inbound request-body limit. |

From fdc224f28ee23f475ed588712addbe5cd274f7b8 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Tue, 8 Sep 2026 14:43:14 +0800
Subject: [PATCH 20/31] feat(durable): persist completion and supervise
 finalization recovery

Add SQLite and PostgreSQL completion records, active quota accounting, bounded retention cleanup and CLI result inspection. Retry retained outcomes without replaying handlers, release consumed history, preserve partial-batch notifications, and expose scheduler health to service owners.

Include lifecycle, recovery and administration regressions plus operational guidance. Active-crash recovery and cross-store admission remain open. Validation: cargo check --locked for CLI, runtime, durable and QuickJS, all targets.
---
 Cargo.lock                                    |   3 +
 crates/tysel-cli/Cargo.toml                   |   2 +
 crates/tysel-cli/src/dev.rs                   |  16 +
 crates/tysel-cli/src/durable_admin.rs         |  54 +++
 crates/tysel-cli/src/main.rs                  |  11 +
 crates/tysel-cli/tests/durable_admin.rs       |  48 +++
 crates/tysel-durable/src/lib.rs               | 140 +++++++-
 crates/tysel-durable/src/lifecycle.rs         | 329 ++++++++++++++++++
 crates/tysel-durable/src/postgres_store.rs    |  67 +++-
 .../src/postgres_store/lifecycle.rs           | 140 ++++++++
 crates/tysel-durable/tests/postgres_live.rs   | 115 ++++++
 crates/tysel-engine-qjs/src/durable.rs        | 146 +++++++-
 crates/tysel-engine-qjs/src/isolate.rs        |  21 +-
 crates/tysel-engine-qjs/src/lib.rs            |   2 +-
 crates/tysel-observability/src/lib.rs         |  30 ++
 crates/tysel-runtime/Cargo.toml               |   1 +
 crates/tysel-runtime/src/durable.rs           | 256 +++++++++++++-
 crates/tysel-runtime/src/durable_plane.rs     | 204 ++++++++++-
 crates/tysel-runtime/src/durable_poll.rs      | 211 ++++++++++-
 crates/tysel-runtime/src/lib.rs               |   4 +-
 crates/tysel-runtime/src/service.rs           |   9 +
 docs/operations/production.md                 |  48 ++-
 docs/reference/cli/index.md                   |   2 +-
 docs/reference/cli/tasks.md                   |  39 +++
 docs/reference/limits-and-defaults.md         |   8 +-
 docs/reference/runtime/durable.md             |   9 +-
 tests/p1/acceptance.py                        | 169 +++++++++
 tests/p1/review_regressions.py                | 269 ++++++++++++++
 28 files changed, 2288 insertions(+), 65 deletions(-)
 create mode 100644 crates/tysel-cli/src/durable_admin.rs
 create mode 100644 crates/tysel-cli/tests/durable_admin.rs
 create mode 100644 crates/tysel-durable/src/lifecycle.rs
 create mode 100644 crates/tysel-durable/src/postgres_store/lifecycle.rs
 create mode 100644 tests/p1/acceptance.py
 create mode 100644 tests/p1/review_regressions.py

diff --git a/Cargo.lock b/Cargo.lock
index fce4691..2cf1e93 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3799,12 +3799,14 @@ dependencies = [
  "tysel-cap-mcp",
  "tysel-capability",
  "tysel-distribution",
+ "tysel-durable",
  "tysel-engine",
  "tysel-engine-qjs",
  "tysel-manifest",
  "tysel-observability",
  "tysel-package",
  "tysel-runtime",
+ "tysel-task",
  "tysel-task-rpc",
  "tysel-testkit",
  "wat",
@@ -3988,6 +3990,7 @@ dependencies = [
  "http-body-util",
  "hyper",
  "hyper-util",
+ "rusqlite",
  "serde_json",
  "thiserror",
  "tokio",
diff --git a/crates/tysel-cli/Cargo.toml b/crates/tysel-cli/Cargo.toml
index ffcf009..ebabec5 100644
--- a/crates/tysel-cli/Cargo.toml
+++ b/crates/tysel-cli/Cargo.toml
@@ -31,6 +31,7 @@ tysel-observability.workspace = true
 tysel-capability.workspace = true
 tysel-cap-mcp.workspace = true
 tysel-task-rpc.workspace = true
+tysel-task.workspace = true
 tysel-package.workspace = true
 tysel-testkit = { path = "../tysel-testkit" }
 notify = "6"
@@ -42,4 +43,5 @@ libc.workspace = true
 reqwest = { version = "0.13", default-features = false, features = ["blocking", "native-tls"] }
 
 [dev-dependencies]
+tysel-durable = { path = "../tysel-durable" }
 wat = "1"
diff --git a/crates/tysel-cli/src/dev.rs b/crates/tysel-cli/src/dev.rs
index bb3cd99..fb4e1ed 100644
--- a/crates/tysel-cli/src/dev.rs
+++ b/crates/tysel-cli/src/dev.rs
@@ -251,6 +251,9 @@ async fn serve(
         loop {
             tokio::select! {
                 signal = shutdown_signal() => break signal.map_err(Into::into),
+                error = durable_service_failure(durable.as_ref()) => {
+                    break Err(error);
+                }
                 error = task_service_failure(task_service.as_ref()) => {
                     break Err(error);
                 }
@@ -303,6 +306,9 @@ async fn serve(
         loop {
             tokio::select! {
                 signal = shutdown_signal() => break signal.map_err(Into::into),
+                error = durable_service_failure(durable.as_ref()) => {
+                        break Err(error);
+                    }
                     error = task_service_failure(task_service.as_ref()) => {
                     break Err(error);
                 }
@@ -315,6 +321,9 @@ async fn serve(
     };
     drop(listener);
     shutdown.cancel();
+    if let Some(plane) = &durable {
+        plane.stop_claiming();
+    }
     shutdown.drain(grace).await;
     let durable_result = shutdown_durable(durable.take()).await;
     let task_result = shutdown_task_service(task_service).await;
@@ -665,6 +674,13 @@ async fn start_dev_durable(spec: Option<DurableSpec>) -> Result<Option<Arc<Durab
     Ok(Some(DurablePlane::start(store, spec.source, spec.config, owner)?))
 }
 
+async fn durable_service_failure(plane: Option<&Arc<DurablePlane>>) -> anyhow::Error {
+    match plane {
+        Some(plane) => plane.failed().await.into(),
+        None => std::future::pending().await,
+    }
+}
+
 async fn shutdown_durable(plane: Option<Arc<DurablePlane>>) -> Result<()> {
     if let Some(plane) = plane {
         plane.shutdown().await?;
diff --git a/crates/tysel-cli/src/durable_admin.rs b/crates/tysel-cli/src/durable_admin.rs
new file mode 100644
index 0000000..5a99ec6
--- /dev/null
+++ b/crates/tysel-cli/src/durable_admin.rs
@@ -0,0 +1,54 @@
+use anyhow::{Context, Result, bail};
+use clap::Subcommand;
+use serde_json::json;
+use tysel_runtime::DurablePlane;
+use tysel_task::TaskId;
+
+#[derive(Subcommand)]
+pub enum DurableCommand {
+    /// Read a retained completion without executing the application.
+    Result { task_id: String },
+    /// Delete a bounded batch of explicitly completed tasks and their retained history.
+    Prune {
+        /// Retain at least this many seconds of completed history.
+        #[arg(long, default_value_t = 604_800)]
+        older_than_secs: u64,
+        /// Maximum tasks in one batch (1..=100); active tasks are never removed.
+        #[arg(long, default_value_t = 32, value_parser = clap::value_parser!(u32).range(1..=100))]
+        limit: u32,
+    },
+}
+
+pub fn run(command: DurableCommand, project: &crate::project::ProjectContext) -> Result<()> {
+    let path = if project.manifest.durable.store == "sqlite" {
+        &project.manifest.durable.path
+    } else {
+        ""
+    };
+    if let Some(path) = DurablePlane::event_log_path(path, Some(&project.root))
+        && !path.is_file()
+    {
+        bail!("durable event store does not exist");
+    }
+    let store = DurablePlane::open_store(path, Some(&project.root))?
+        .context("durable event store is not configured")?;
+    let output = match command {
+        DurableCommand::Result { task_id } => {
+            let id = TaskId(u128::from_str_radix(&task_id, 16).context("invalid durable task ID")?);
+            let completion = store.completion(id)?;
+            json!({"taskId": id.to_string(), "completion": completion.map(|value| json!({
+                "status": "completed", "value": value.value, "completedAtMs": value.completed_at_ms,
+            }))})
+        }
+        DurableCommand::Prune { older_than_secs, limit } => {
+            let now_ms =
+                std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH)?.as_millis();
+            let retention_ms = u128::from(older_than_secs) * 1_000;
+            let before_ms = u64::try_from(now_ms.saturating_sub(retention_ms))?;
+            let deleted = store.prune_completed(before_ms, limit as usize)?;
+            json!({"deleted": deleted, "beforeMs": before_ms, "limit": limit})
+        }
+    };
+    println!("{}", serde_json::to_string_pretty(&output)?);
+    Ok(())
+}
diff --git a/crates/tysel-cli/src/main.rs b/crates/tysel-cli/src/main.rs
index 8c172da..b969750 100644
--- a/crates/tysel-cli/src/main.rs
+++ b/crates/tysel-cli/src/main.rs
@@ -19,6 +19,7 @@ mod compat;
 mod cross_target;
 mod dev;
 mod doctor;
+mod durable_admin;
 mod image;
 mod init;
 mod integrity;
@@ -120,6 +121,13 @@ enum ConfigCommand {
 
 #[derive(Subcommand)]
 enum Commands {
+    /// Inspect retained durable results and maintain completed history.
+    Durable {
+        #[command(subcommand)]
+        command: durable_admin::DurableCommand,
+        #[arg(long, global = true)]
+        manifest: Option<PathBuf>,
+    },
     /// Create a new Tysel application.
     Init {
         /// Project directory; omit it in a terminal to choose interactively.
@@ -444,6 +452,9 @@ fn run(cli: Cli) -> Result<ExitCode> {
         Ok(project)
     };
     let result = match cli.command {
+        Commands::Durable { command, manifest } => {
+            durable_admin::run(command, &context(manifest.as_deref())?)
+        }
         Commands::Inspect { manifest } => inspect(&context(manifest.as_deref())?),
         Commands::Check { manifest } => {
             let project = context(manifest.as_deref())?;
diff --git a/crates/tysel-cli/tests/durable_admin.rs b/crates/tysel-cli/tests/durable_admin.rs
new file mode 100644
index 0000000..87bbf16
--- /dev/null
+++ b/crates/tysel-cli/tests/durable_admin.rs
@@ -0,0 +1,48 @@
+use std::process::Command;
+use tysel_durable::SqliteStore;
+use tysel_task::TaskId;
+
+#[test]
+fn retained_results_and_bounded_pruning_do_not_load_application_or_delete_live_tasks() {
+    let root = std::env::temp_dir().join(format!(
+        "tysel-admin-{}-{}",
+        std::process::id(),
+        std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
+    ));
+    std::fs::create_dir_all(root.join("data")).unwrap();
+    std::fs::write(root.join("tysel.toml"), "[app]\nname = 'admin-fixture'\nentry = 'missing.js'\n[durable]\nstore = 'sqlite'\npath = './data/app.db'\n").unwrap();
+    let command = |args: &[&str]| {
+        Command::new(env!("CARGO_BIN_EXE_tysel"))
+            .arg("-C")
+            .arg(&root)
+            .args(args)
+            .env_remove("TYSEL_DURABLE_POSTGRES_URL")
+            .env_remove("TYSEL_DURABLE_SQLITE_PATH")
+            .output()
+            .unwrap()
+    };
+    assert!(!command(&["durable", "result", "1"]).status.success());
+    assert!(!root.join("data/durable-events.db").exists());
+    let store = SqliteStore::open(root.join("data/durable-events.db")).unwrap();
+    for id in [1, 2, 3] {
+        store.put_program(TaskId(id), "1", 0).unwrap();
+    }
+    for id in [1, 2] {
+        store.complete_task(TaskId(id), 0, &serde_json::json!({"answer":42}), 1).unwrap();
+    }
+    store.append_event_json_with_wakeup_at(TaskId(3), 0, "sleep".into(), "null", 0, 1).unwrap();
+    let result = command(&["durable", "result", "1"]);
+    assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stderr));
+    let result: serde_json::Value = serde_json::from_slice(&result.stdout).unwrap();
+    assert_eq!(result["completion"]["value"]["answer"], 42);
+    assert!(!command(&["durable", "prune", "--limit", "101"]).status.success());
+    let pruned = command(&["durable", "prune", "--older-than-secs", "0", "--limit", "1"]);
+    assert!(pruned.status.success(), "{}", String::from_utf8_lossy(&pruned.stderr));
+    assert_eq!(serde_json::from_slice::<serde_json::Value>(&pruned.stdout).unwrap()["deleted"], 1);
+    assert!(store.completion(TaskId(1)).unwrap().is_none());
+    assert!(store.completion(TaskId(2)).unwrap().is_some());
+    assert!(store.wakeup(TaskId(3)).unwrap().is_some());
+    assert_eq!(store.program_count().unwrap(), 1);
+    drop(store);
+    std::fs::remove_dir_all(root).unwrap();
+}
diff --git a/crates/tysel-durable/src/lib.rs b/crates/tysel-durable/src/lib.rs
index 8d1802a..c27da6b 100644
--- a/crates/tysel-durable/src/lib.rs
+++ b/crates/tysel-durable/src/lib.rs
@@ -21,7 +21,8 @@ const MAX_HISTORY_BYTES: usize = 16 * 1_048_576;
 const MAX_PENDING_SIGNALS: usize = 1_000;
 const MAX_LEASE_OWNER_BYTES: usize = 128;
 /// Durable SQLite schema and replay-log contract supported by this runtime.
-pub const DURABLE_LOG_VERSION: u32 = 1;
+pub const DURABLE_LOG_VERSION: u32 = 2;
+mod lifecycle;
 pub const MAX_DURABLE_PROGRAM_BYTES: usize = 1_048_576;
 pub const MAX_DURABLE_PROGRAM_TOTAL_BYTES: usize = 64 * 1_048_576;
 pub const MAX_DURABLE_PROGRAMS: usize = 10_000;
@@ -216,12 +217,39 @@ pub enum DurableProgramKind {
     Module,
 }
 
+/// Persisted successful termination. Retained history is audit state, not active work.
+#[derive(Debug, Clone, PartialEq)]
+pub struct TaskCompletion {
+    pub task_id: TaskId,
+    pub next_sequence: u64,
+    pub value: Value,
+    pub completed_at_ms: u64,
+}
+
 /// Storage contract consumed by the durable engine and scheduler.
 ///
 /// Implementations must preserve per-task event ordering and make composite
 /// event/wakeup and signal operations atomic. The synchronous surface is
 /// intentional: callers run durable storage work on blocking worker threads.
 pub trait DurableStore: Send + Sync {
+    fn completion(&self, task_id: TaskId) -> Result<Option<TaskCompletion>, DurableError>;
+    /// Persist completion for a registered program. Returns false for unregistered
+    /// low-level sessions, which retain the caller-managed lifecycle contract.
+    fn complete_task(
+        &self,
+        task_id: TaskId,
+        expected_sequence: u64,
+        value: &Value,
+        completed_at_ms: u64,
+    ) -> Result<bool, DurableError>;
+    /// Delete only explicitly completed tasks older than the cutoff, at most 100 per call.
+    fn prune_completed(&self, before_ms: u64, limit: usize) -> Result<usize, DurableError>;
+    fn load_due_programs_batch(
+        &self,
+        now_ms: u64,
+        kind: DurableProgramKind,
+        limit: usize,
+    ) -> Result<Vec<DurableProgram>, DurableError>;
     fn log_version(&self) -> Result<u32, DurableError>;
     fn put_program(
         &self,
@@ -393,6 +421,7 @@ impl SqliteStore {
         let digest: [u8; 32] = Sha256::digest(source.as_bytes()).into();
         let mut connection = self.lock()?;
         let transaction = connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        lifecycle::ensure_open(&transaction, task_id)?;
         if let Some(existing) = select_program(&transaction, task_id)? {
             if existing.kind != kind
                 || existing.source_sha256 != digest
@@ -404,8 +433,7 @@ impl SqliteStore {
             return Ok(Some(existing));
         }
         let (count, total_bytes): (i64, i64) = transaction.query_row(
-            "SELECT COUNT(*), COALESCE(SUM(length(CAST(source AS BLOB))), 0)
-             FROM durable_programs",
+            "SELECT active_count, active_bytes FROM durable_program_stats WHERE singleton = 1",
             [],
             |row| Ok((row.get(0)?, row.get(1)?)),
         )?;
@@ -426,6 +454,7 @@ impl SqliteStore {
              VALUES (?1, ?2, ?3, ?4, ?5)",
             params![id.as_slice(), kind.as_str(), source, digest.as_slice(), registered_at_ms],
         )?;
+        transaction.execute("UPDATE durable_program_stats SET active_count = active_count + 1, active_bytes = active_bytes + ?1 WHERE singleton = 1", params![source_bytes])?;
         transaction.commit()?;
         Ok(None)
     }
@@ -439,7 +468,7 @@ impl SqliteStore {
         let connection = self.lock()?;
         let mut statement = connection.prepare(
             "SELECT task_id, program_kind, source, source_sha256, registered_at_ms
-             FROM durable_programs ORDER BY task_id LIMIT ?1",
+             FROM durable_programs p WHERE NOT EXISTS (SELECT 1 FROM durable_completions c WHERE c.task_id = p.task_id) ORDER BY task_id LIMIT ?1",
         )?;
         let rows = statement.query_map(params![(MAX_DURABLE_PROGRAMS + 1) as i64], |row| {
             Ok((
@@ -464,6 +493,15 @@ impl SqliteStore {
         &self,
         now_ms: u64,
         kind: DurableProgramKind,
+    ) -> Result<Vec<DurableProgram>, DurableError> {
+        self.load_due_programs_batch(now_ms, kind, MAX_DURABLE_PROGRAMS)
+    }
+
+    pub fn load_due_programs_batch(
+        &self,
+        now_ms: u64,
+        kind: DurableProgramKind,
+        limit: usize,
     ) -> Result<Vec<DurableProgram>, DurableError> {
         let connection = self.lock()?;
         let now_ms = to_sql_integer(now_ms, "now_ms")?;
@@ -474,10 +512,11 @@ impl SqliteStore {
              WHERE w.wake_at_ms <= ?1
                AND (w.lease_until_ms IS NULL OR w.lease_until_ms <= ?1)
                AND p.program_kind = ?2
-             ORDER BY p.task_id LIMIT ?3",
+               AND NOT EXISTS (SELECT 1 FROM durable_completions c WHERE c.task_id = p.task_id)
+             ORDER BY w.wake_at_ms, p.task_id LIMIT ?3",
         )?;
         let rows = statement.query_map(
-            params![now_ms, kind.as_str(), (MAX_DURABLE_PROGRAMS + 1) as i64],
+            params![now_ms, kind.as_str(), limit.min(MAX_DURABLE_PROGRAMS) as i64],
             |row| {
                 Ok((
                     row.get::<_, Vec<u8>>(0)?,
@@ -495,8 +534,9 @@ impl SqliteStore {
         let id = task_id_bytes(task_id);
         let mut connection = self.lock()?;
         let transaction = connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        lifecycle::ensure_open(&transaction, task_id)?;
         let existing = select_program(&transaction, task_id)?;
-        if existing.is_some() {
+        if let Some(program) = &existing {
             let in_use = transaction.query_row(
                 "SELECT EXISTS(SELECT 1 FROM durable_events WHERE task_id = ?1)
                      OR EXISTS(SELECT 1 FROM durable_wakeups WHERE task_id = ?1)
@@ -508,6 +548,7 @@ impl SqliteStore {
             if in_use {
                 return Err(DurableError::ProgramInUse { task_id });
             }
+            transaction.execute("UPDATE durable_program_stats SET active_count = active_count - 1, active_bytes = active_bytes - ?1 WHERE singleton = 1", params![program.source.len() as i64])?;
             transaction.execute(
                 "DELETE FROM durable_programs WHERE task_id = ?1",
                 params![id.as_slice()],
@@ -519,8 +560,11 @@ impl SqliteStore {
 
     pub fn program_count(&self) -> Result<usize, DurableError> {
         let connection = self.lock()?;
-        let count: i64 =
-            connection.query_row("SELECT COUNT(*) FROM durable_programs", [], |row| row.get(0))?;
+        let count: i64 = connection.query_row(
+            "SELECT active_count FROM durable_program_stats WHERE singleton = 1",
+            [],
+            |row| row.get(0),
+        )?;
         usize::try_from(count).map_err(|_| DurableError::ProgramLimit)
     }
 
@@ -711,13 +755,16 @@ impl SqliteStore {
     }
 
     pub fn schedule_wakeup(&self, wakeup: Wakeup) -> Result<(), DurableError> {
-        let connection = self.lock()?;
+        let mut connection = self.lock()?;
+        let transaction = connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        lifecycle::ensure_open(&transaction, wakeup.task_id)?;
         upsert_wakeup(
-            &connection,
+            &transaction,
             wakeup.task_id,
             to_sql_integer(wakeup.sequence, "sequence")?,
             to_sql_integer(wakeup.wake_at_ms, "wake_at_ms")?,
         )?;
+        transaction.commit()?;
         Ok(())
     }
 
@@ -1027,6 +1074,7 @@ impl SqliteStore {
         let id = task_id_bytes(task_id);
         let mut connection = self.lock()?;
         let transaction = connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        lifecycle::ensure_open(&transaction, task_id)?;
         let (pending_count, pending_bytes) = transaction.query_row(
             "SELECT COUNT(*), COALESCE(SUM(
                  length(CAST(signal_name AS BLOB)) + length(CAST(payload AS BLOB))
@@ -1088,6 +1136,7 @@ impl SqliteStore {
         let id = task_id_bytes(task_id);
         let mut connection = self.lock()?;
         let transaction = connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        lifecycle::ensure_open(&transaction, task_id)?;
         let actual_sequence: i64 = transaction.query_row(
             "SELECT COALESCE(MAX(sequence) + 1, 0)
              FROM durable_events WHERE task_id = ?1",
@@ -1201,6 +1250,29 @@ impl SqliteStore {
 }
 
 impl DurableStore for SqliteStore {
+    fn completion(&self, task_id: TaskId) -> Result<Option<TaskCompletion>, DurableError> {
+        SqliteStore::completion(self, task_id)
+    }
+    fn complete_task(
+        &self,
+        task_id: TaskId,
+        expected_sequence: u64,
+        value: &Value,
+        completed_at_ms: u64,
+    ) -> Result<bool, DurableError> {
+        SqliteStore::complete_task(self, task_id, expected_sequence, value, completed_at_ms)
+    }
+    fn prune_completed(&self, before_ms: u64, limit: usize) -> Result<usize, DurableError> {
+        SqliteStore::prune_completed(self, before_ms, limit)
+    }
+    fn load_due_programs_batch(
+        &self,
+        now_ms: u64,
+        kind: DurableProgramKind,
+        limit: usize,
+    ) -> Result<Vec<DurableProgram>, DurableError> {
+        SqliteStore::load_due_programs_batch(self, now_ms, kind, limit)
+    }
     fn log_version(&self) -> Result<u32, DurableError> {
         SqliteStore::log_version(self)
     }
@@ -1366,6 +1438,10 @@ impl DurableStore for SqliteStore {
 
 #[derive(Debug, thiserror::Error)]
 pub enum DurableError {
+    #[error("durable task {task_id} is already completed")]
+    TaskCompleted { task_id: TaskId },
+    #[error("durable task {task_id} is still suspended or leased")]
+    TaskSuspended { task_id: TaskId },
     #[error(transparent)]
     Io(#[from] std::io::Error),
     #[error(transparent)]
@@ -1428,6 +1504,31 @@ pub enum DurableError {
     UnsupportedLogVersion { found: u32, supported: u32 },
 }
 
+impl DurableError {
+    /// Retry transport/availability failures, never corrupted history or identity.
+    pub fn is_retryable(&self) -> bool {
+        match self {
+            Self::Sqlite(rusqlite::Error::SqliteFailure(error, _)) => !matches!(
+                error.code,
+                rusqlite::ErrorCode::DatabaseCorrupt
+                    | rusqlite::ErrorCode::NotADatabase
+                    | rusqlite::ErrorCode::ConstraintViolation
+            ),
+            Self::Sqlite(rusqlite::Error::SqlInputError { .. }) => true,
+            Self::Io(_) | Self::PostgresPool(_) => true,
+            Self::Postgres(error) => {
+                error.is_closed()
+                    || error.code().is_some_and(|code| {
+                        ["08", "40", "53", "55", "57", "58"]
+                            .iter()
+                            .any(|prefix| code.code().starts_with(prefix))
+                    })
+            }
+            _ => false,
+        }
+    }
+}
+
 fn validate_program_source(source: &str) -> Result<(), DurableError> {
     if source.is_empty() || source.len() > MAX_DURABLE_PROGRAM_BYTES {
         return Err(DurableError::InvalidProgram);
@@ -1541,6 +1642,7 @@ fn insert_event(
     payload: &str,
     recorded_at_ms: i64,
 ) -> Result<i64, DurableError> {
+    lifecycle::ensure_open(transaction, task_id)?;
     let id = task_id_bytes(task_id);
     let event_bytes =
         event.key.len().checked_add(payload.len()).ok_or(DurableError::HistoryByteLimit)?;
@@ -1657,7 +1759,8 @@ fn register_signal_wait(
 
 fn initialize_schema(connection: &mut Connection) -> Result<(), DurableError> {
     let transaction = connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
-    if let Some(found) = read_log_version(&transaction)?
+    let previous_version = read_log_version(&transaction)?;
+    if let Some(found) = previous_version
         && found > DURABLE_LOG_VERSION
     {
         return Err(DurableError::UnsupportedLogVersion { found, supported: DURABLE_LOG_VERSION });
@@ -1709,6 +1812,7 @@ fn initialize_schema(connection: &mut Connection) -> Result<(), DurableError> {
              registered_at_ms INTEGER NOT NULL CHECK (registered_at_ms >= 0)
          );",
     )?;
+    lifecycle::initialize(&transaction)?;
     migrate_program_columns(&transaction)?;
     let sequence_added = migrate_wakeup_columns(&transaction)?;
     if sequence_added {
@@ -1721,8 +1825,9 @@ fn initialize_schema(connection: &mut Connection) -> Result<(), DurableError> {
              ), sequence);",
         )?;
     }
-    transaction.execute_batch(
-        "DROP INDEX IF EXISTS durable_wakeups_due;
+    if previous_version.unwrap_or(0) < 2 {
+        transaction.execute_batch(
+            "DROP INDEX IF EXISTS durable_wakeups_due;
          CREATE INDEX durable_wakeups_due
              ON durable_wakeups (wake_at_ms, lease_until_ms, task_id);
          CREATE INDEX IF NOT EXISTS durable_signal_inbox_task
@@ -1733,7 +1838,8 @@ fn initialize_schema(connection: &mut Connection) -> Result<(), DurableError> {
              length(CAST(payload AS BLOB)) + length(CAST(event_key AS BLOB))
          ), 0)
          FROM durable_events GROUP BY task_id;",
-    )?;
+        )?;
+    }
     transaction.execute(
         "INSERT INTO tysel_durable_metadata (key, value)
          VALUES ('schema_version', ?1)
@@ -2041,7 +2147,7 @@ mod tests {
                          key TEXT PRIMARY KEY,
                          value INTEGER NOT NULL
                      );
-                     INSERT INTO tysel_durable_metadata VALUES ('schema_version', 2);",
+                     INSERT INTO tysel_durable_metadata VALUES ('schema_version', 3);",
                 )
                 .unwrap();
         }
@@ -2052,7 +2158,7 @@ mod tests {
         };
         assert!(matches!(
             error,
-            DurableError::UnsupportedLogVersion { found: 2, supported: DURABLE_LOG_VERSION }
+            DurableError::UnsupportedLogVersion { found: 3, supported: DURABLE_LOG_VERSION }
         ));
         let connection = Connection::open(&path).unwrap();
         let events_table_exists: bool = connection
diff --git a/crates/tysel-durable/src/lifecycle.rs b/crates/tysel-durable/src/lifecycle.rs
new file mode 100644
index 0000000..96558cc
--- /dev/null
+++ b/crates/tysel-durable/src/lifecycle.rs
@@ -0,0 +1,329 @@
+use super::*;
+
+pub(super) fn initialize(tx: &Transaction<'_>) -> Result<(), DurableError> {
+    tx.execute_batch(
+        "CREATE TABLE IF NOT EXISTS durable_completions (
+            task_id BLOB PRIMARY KEY,
+            next_sequence INTEGER NOT NULL CHECK (next_sequence >= 0),
+            result_json TEXT NOT NULL,
+            completed_at_ms INTEGER NOT NULL CHECK (completed_at_ms >= 0)
+         );
+         CREATE INDEX IF NOT EXISTS durable_completions_retention
+             ON durable_completions (completed_at_ms, task_id);
+         CREATE TABLE IF NOT EXISTS durable_program_stats (
+            singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+            active_count INTEGER NOT NULL CHECK (active_count >= 0),
+            active_bytes INTEGER NOT NULL CHECK (active_bytes >= 0)
+         );",
+    )?;
+    if !tx.query_row(
+        "SELECT EXISTS(SELECT 1 FROM durable_program_stats WHERE singleton = 1)",
+        [],
+        |row| row.get::<_, bool>(0),
+    )? {
+        tx.execute("INSERT INTO durable_program_stats SELECT 1, COUNT(*), COALESCE(SUM(length(CAST(source AS BLOB))), 0) FROM durable_programs p WHERE NOT EXISTS (SELECT 1 FROM durable_completions c WHERE c.task_id = p.task_id)", [])?;
+    }
+    Ok(())
+}
+
+pub(super) fn ensure_open(connection: &Connection, task_id: TaskId) -> Result<(), DurableError> {
+    if connection.query_row(
+        "SELECT EXISTS(SELECT 1 FROM durable_completions WHERE task_id = ?1)",
+        params![task_id_bytes(task_id).as_slice()],
+        |row| row.get::<_, bool>(0),
+    )? {
+        return Err(DurableError::TaskCompleted { task_id });
+    }
+    Ok(())
+}
+
+impl SqliteStore {
+    pub fn completion(&self, task_id: TaskId) -> Result<Option<TaskCompletion>, DurableError> {
+        let connection = self.lock()?;
+        let row = connection.query_row(
+            "SELECT next_sequence, result_json, completed_at_ms FROM durable_completions WHERE task_id = ?1",
+            params![task_id_bytes(task_id).as_slice()],
+            |row| Ok((row.get::<_, i64>(0)?, row.get::<_, String>(1)?, row.get::<_, i64>(2)?)),
+        ).optional()?;
+        row.map(|(sequence, json, time)| {
+            Ok(TaskCompletion {
+                task_id,
+                next_sequence: from_sql_integer(sequence, "next_sequence")?,
+                value: serde_json::from_str(&json)?,
+                completed_at_ms: from_sql_integer(time, "completed_at_ms")?,
+            })
+        })
+        .transpose()
+    }
+
+    /// Commit completion only after every boundary is consumed and no suspension remains.
+    /// History and program identity remain available until explicit retention cleanup.
+    pub fn complete_task(
+        &self,
+        task_id: TaskId,
+        expected_sequence: u64,
+        value: &Value,
+        completed_at_ms: u64,
+    ) -> Result<bool, DurableError> {
+        let json = serde_json::to_string(value)?;
+        if json.len() > MAX_EVENT_PAYLOAD_BYTES {
+            return Err(DurableError::EventPayloadTooLarge);
+        }
+        let id = task_id_bytes(task_id);
+        let mut connection = self.lock()?;
+        let tx = connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        if let Some((sequence, stored)) = tx
+            .query_row(
+                "SELECT next_sequence, result_json FROM durable_completions WHERE task_id = ?1",
+                params![id.as_slice()],
+                |row| Ok((row.get::<_, i64>(0)?, row.get::<_, String>(1)?)),
+            )
+            .optional()?
+        {
+            if sequence != to_sql_integer(expected_sequence, "next_sequence")?
+                || serde_json::from_str::<Value>(&stored)? != *value
+            {
+                return Err(DurableError::TaskCompleted { task_id });
+            }
+            return Ok(true);
+        }
+        let Some(source_bytes) = tx
+            .query_row(
+                "SELECT length(CAST(source AS BLOB)) FROM durable_programs WHERE task_id = ?1",
+                params![id.as_slice()],
+                |row| row.get::<_, i64>(0),
+            )
+            .optional()?
+        else {
+            return Ok(false);
+        };
+        let actual: i64 = tx.query_row(
+            "SELECT COALESCE(MAX(sequence) + 1, 0) FROM durable_events WHERE task_id = ?1",
+            params![id.as_slice()],
+            |row| row.get(0),
+        )?;
+        if from_sql_integer(actual, "next_sequence")? != expected_sequence {
+            return Err(DurableError::HistoryConflict {
+                expected: expected_sequence,
+                actual: actual as u64,
+            });
+        }
+        let suspended: bool = tx.query_row(
+            "SELECT EXISTS(SELECT 1 FROM durable_wakeups WHERE task_id = ?1) OR EXISTS(SELECT 1 FROM durable_signal_waits WHERE task_id = ?1)",
+            params![id.as_slice()], |row| row.get(0),
+        )?;
+        if suspended {
+            return Err(DurableError::TaskSuspended { task_id });
+        }
+        tx.execute("INSERT INTO durable_completions (task_id, next_sequence, result_json, completed_at_ms) VALUES (?1, ?2, ?3, ?4)",
+            params![id.as_slice(), actual, json, to_sql_integer(completed_at_ms, "completed_at_ms")?])?;
+        tx.execute("UPDATE durable_program_stats SET active_count = active_count - 1, active_bytes = active_bytes - ?1 WHERE singleton = 1", params![source_bytes])?;
+        tx.commit()?;
+        Ok(true)
+    }
+
+    pub fn prune_completed(&self, before_ms: u64, limit: usize) -> Result<usize, DurableError> {
+        if limit == 0 {
+            return Ok(0);
+        }
+        let mut connection = self.lock()?;
+        let tx = connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        let candidates = {
+            let mut statement = tx.prepare(
+                "SELECT c.task_id, COALESCE(h.payload_bytes, 0) + COALESCE(length(CAST(p.source AS BLOB)), 0) + length(CAST(c.result_json AS BLOB))
+                   + COALESCE((SELECT SUM(length(CAST(s.signal_name AS BLOB)) + length(CAST(s.payload AS BLOB))) FROM durable_signal_inbox s WHERE s.task_id = c.task_id), 0)
+                 FROM durable_completions c
+                 LEFT JOIN durable_programs p ON p.task_id = c.task_id
+                 LEFT JOIN durable_history_stats h ON h.task_id = c.task_id
+                 WHERE c.completed_at_ms < ?1 ORDER BY c.completed_at_ms, c.task_id LIMIT ?2",
+            )?;
+            statement
+                .query_map(
+                    params![to_sql_integer(before_ms, "before_ms")?, limit.min(100) as i64],
+                    |row| Ok((row.get::<_, Vec<u8>>(0)?, row.get::<_, i64>(1)?)),
+                )?
+                .collect::<Result<Vec<_>, _>>()?
+        };
+        let mut deleted = 0;
+        let mut bytes = 0u64;
+        for (id, retained_bytes) in candidates {
+            if deleted > 0 && bytes + retained_bytes as u64 > MAX_HISTORY_BYTES as u64 {
+                break;
+            }
+            let live: bool = tx.query_row("SELECT EXISTS(SELECT 1 FROM durable_wakeups WHERE task_id = ?1) OR EXISTS(SELECT 1 FROM durable_signal_waits WHERE task_id = ?1)", params![&id], |row| row.get(0))?;
+            if live {
+                continue;
+            }
+            // Names are static SQL identifiers; no external input enters this SQL.
+            for table in [
+                "durable_programs",
+                "durable_events",
+                "durable_history_stats",
+                "durable_signal_inbox",
+                "durable_completions",
+            ] {
+                tx.execute(&format!("DELETE FROM {table} WHERE task_id = ?1"), params![&id])?;
+            }
+            bytes += retained_bytes as u64;
+            deleted += 1;
+        }
+        tx.commit()?;
+        Ok(deleted)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn completion_releases_quota_and_retention_preserves_live_history() {
+        let store = SqliteStore::in_memory().unwrap();
+        let done = TaskId(1);
+        let live = TaskId(2);
+        store.put_module(done, "export default async () => 1", 0).unwrap();
+        store.append_event_json_at(done, 0, EventKind::Step, "input".into(), "null", 0).unwrap();
+        assert!(matches!(
+            store.complete_task(done, 0, &Value::from(7), 10),
+            Err(DurableError::HistoryConflict { .. })
+        ));
+        store.schedule_wakeup(Wakeup { task_id: done, sequence: 0, wake_at_ms: 1 }).unwrap();
+        assert!(matches!(
+            store.complete_task(done, 1, &Value::from(7), 10),
+            Err(DurableError::TaskSuspended { .. })
+        ));
+        let claim = store.claim_wakeup(done, 1, "owner", 20).unwrap().unwrap();
+        assert!(store.complete_wakeup(done, 0, Some(&claim.lease_owner), 2).unwrap());
+        assert!(store.complete_task(done, 1, &Value::from(7), 10).unwrap());
+        assert!(store.complete_task(done, 1, &Value::from(7), 11).unwrap());
+        assert_eq!(store.program_count().unwrap(), 0);
+        assert!(store.load_programs().unwrap().is_empty());
+        assert_eq!(store.completion(done).unwrap().unwrap().value, Value::from(7));
+        assert_eq!(store.load_history(done).unwrap().events.len(), 1);
+        assert!(matches!(
+            store.send_signal(done, "late", &Value::Null, 12),
+            Err(DurableError::TaskCompleted { .. })
+        ));
+        assert!(matches!(
+            store.put_module(done, "export default async () => 1", 12),
+            Err(DurableError::TaskCompleted { .. })
+        ));
+        assert!(matches!(
+            store.append_event_json_at(done, 1, EventKind::Step, "late".into(), "null", 12),
+            Err(DurableError::TaskCompleted { .. })
+        ));
+        assert!(matches!(
+            store.poll_signal(done, 1, "late", 12, None),
+            Err(DurableError::TaskCompleted { .. })
+        ));
+        store.put_module(live, "export default async () => 2", 0).unwrap();
+        store.append_event_json_with_wakeup_at(live, 0, "sleep".into(), "null", 0, 1).unwrap();
+        assert_eq!(store.prune_completed(10, 100).unwrap(), 0);
+        assert_eq!(store.prune_completed(11, 0).unwrap(), 0);
+        assert_eq!(store.prune_completed(11, 1).unwrap(), 1);
+        assert!(store.completion(done).unwrap().is_none());
+        assert!(store.program(done).unwrap().is_none());
+        assert!(store.load_history(done).unwrap().events.is_empty());
+        assert_eq!(store.program_count().unwrap(), 1);
+        assert!(store.wakeup(live).unwrap().is_some());
+        assert_eq!(store.load_history(live).unwrap().events.len(), 1);
+    }
+
+    #[test]
+    fn completed_tasks_can_exceed_the_active_catalog_limit() {
+        let store = SqliteStore::in_memory().unwrap();
+        for n in 0..MAX_DURABLE_PROGRAMS + 1 {
+            let id = TaskId(n as u128);
+            store.put_program(id, "1", 0).unwrap();
+            store.complete_task(id, 0, &Value::Null, 1).unwrap();
+        }
+        assert_eq!(store.program_count().unwrap(), 0);
+        assert_eq!(store.prune_completed(2, usize::MAX).unwrap(), 100);
+        assert!(store.completion(TaskId(100)).unwrap().is_some());
+    }
+
+    #[test]
+    fn completion_and_wakeup_are_serial_across_sqlite_connections() {
+        use std::sync::{Arc, Barrier};
+        let path = std::env::temp_dir().join(format!(
+            "tysel-completion-race-{}-{}.db",
+            std::process::id(),
+            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
+        ));
+        let store = Arc::new(SqliteStore::open(&path).unwrap());
+        let other = Arc::new(SqliteStore::open(&path).unwrap());
+        for n in 0..16 {
+            let id = TaskId(n);
+            store.put_program(id, "1", 0).unwrap();
+            let barrier = Arc::new(Barrier::new(3));
+            let finish = {
+                let store = store.clone();
+                let barrier = barrier.clone();
+                std::thread::spawn(move || {
+                    barrier.wait();
+                    store.complete_task(id, 0, &Value::Null, 1)
+                })
+            };
+            let suspend = {
+                let other = other.clone();
+                let barrier = barrier.clone();
+                std::thread::spawn(move || {
+                    barrier.wait();
+                    other.schedule_wakeup(Wakeup { task_id: id, sequence: 0, wake_at_ms: 1 })
+                })
+            };
+            barrier.wait();
+            match (finish.join().unwrap(), suspend.join().unwrap()) {
+                (Ok(true), Err(DurableError::TaskCompleted { .. }))
+                | (Err(DurableError::TaskSuspended { .. }), Ok(())) => {}
+                other => panic!("non-serial completion and suspension: {other:?}"),
+            }
+        }
+        drop(other);
+        drop(store);
+        std::fs::remove_file(path).unwrap();
+    }
+
+    #[test]
+    fn retention_budget_counts_source_and_result_bytes() {
+        let store = SqliteStore::in_memory().unwrap();
+        let source = "x".repeat(MAX_DURABLE_PROGRAM_BYTES);
+        let value = Value::String("v".repeat(MAX_EVENT_PAYLOAD_BYTES - 2));
+        for n in 0..9 {
+            store.put_program(TaskId(n), &source, 0).unwrap();
+            store.complete_task(TaskId(n), 0, &value, 1).unwrap();
+        }
+        assert_eq!(store.prune_completed(2, 100).unwrap(), 8);
+        assert!(store.completion(TaskId(8)).unwrap().is_some());
+    }
+
+    #[test]
+    fn v1_migration_preserves_unclassified_tasks_and_accounting_on_reopen() {
+        let path = std::env::temp_dir().join(format!(
+            "tysel-lifecycle-{}-{}.db",
+            std::process::id(),
+            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
+        ));
+        {
+            let store = SqliteStore::open(&path).unwrap();
+            store.put_program(TaskId(1), "1", 0).unwrap();
+            let connection = store.lock().unwrap();
+            connection.execute_batch("DROP TABLE durable_completions; DROP TABLE durable_program_stats; UPDATE tysel_durable_metadata SET value = 1 WHERE key = 'schema_version';").unwrap();
+        }
+        {
+            let store = SqliteStore::open(&path).unwrap();
+            assert_eq!(store.log_version().unwrap(), 2);
+            assert_eq!(store.program_count().unwrap(), 1);
+            assert_eq!(store.prune_completed(u64::MAX / 2, 100).unwrap(), 0);
+            store.complete_task(TaskId(1), 0, &Value::from(1), 10).unwrap();
+        }
+        {
+            let store = SqliteStore::open(&path).unwrap();
+            assert_eq!(store.program_count().unwrap(), 0);
+            assert_eq!(store.completion(TaskId(1)).unwrap().unwrap().value, Value::from(1));
+            store.put_program(TaskId(2), "2", 11).unwrap();
+            assert_eq!(store.program_count().unwrap(), 1);
+        }
+        std::fs::remove_file(path).unwrap();
+    }
+}
diff --git a/crates/tysel-durable/src/postgres_store.rs b/crates/tysel-durable/src/postgres_store.rs
index 84c4885..a7a63d3 100644
--- a/crates/tysel-durable/src/postgres_store.rs
+++ b/crates/tysel-durable/src/postgres_store.rs
@@ -1,3 +1,4 @@
+mod lifecycle;
 use native_tls::TlsConnector;
 use postgres::{Client, GenericClient, NoTls, Transaction};
 use postgres_native_tls::MakeTlsConnector;
@@ -9,10 +10,10 @@ use tysel_task::TaskId;
 use super::{
     DURABLE_LOG_VERSION, DurableError, DurableProgram, DurableProgramKind, DurableStore, EventKind,
     History, MAX_DURABLE_PROGRAM_TOTAL_BYTES, MAX_DURABLE_PROGRAMS, MAX_EVENT_PAYLOAD_BYTES,
-    MAX_HISTORY_BYTES, MAX_HISTORY_EVENTS, MAX_PENDING_SIGNALS, NewEvent, SignalWait, TaskEvent,
-    Wakeup, WakeupClaim, from_sql_integer, raw_event, stored_event, task_id_bytes,
-    task_id_from_bytes, to_sql_integer, validate_lease_owner, validate_program_source,
-    validate_signal_name,
+    MAX_HISTORY_BYTES, MAX_HISTORY_EVENTS, MAX_PENDING_SIGNALS, NewEvent, SignalWait,
+    TaskCompletion, TaskEvent, Wakeup, WakeupClaim, from_sql_integer, raw_event, stored_event,
+    task_id_bytes, task_id_from_bytes, to_sql_integer, validate_lease_owner,
+    validate_program_source, validate_signal_name,
 };
 
 const MAX_WAKEUP_BATCH: usize = 10_000;
@@ -164,6 +165,7 @@ fn initialize_schema(client: &mut Client) -> Result<(), DurableError> {
             });
         }
     }
+    lifecycle::initialize(&mut tx)?;
     tx.execute(
         "INSERT INTO tysel_durable_metadata (key, value) VALUES ('schema_version', $1)
          ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value",
@@ -183,6 +185,15 @@ fn lock_task(tx: &mut Transaction<'_>, task_id: TaskId) -> Result<[u8; 16], Dura
         "SELECT task_id FROM durable_task_locks WHERE task_id = $1 FOR UPDATE",
         &[&&id[..]],
     )?;
+    if tx
+        .query_one(
+            "SELECT EXISTS(SELECT 1 FROM durable_completions WHERE task_id = $1)",
+            &[&&id[..]],
+        )?
+        .get::<_, bool>(0)
+    {
+        return Err(DurableError::TaskCompleted { task_id });
+    }
     Ok(id)
 }
 
@@ -315,13 +326,8 @@ impl PostgresStore {
                 tx.commit()?;
                 return Ok(Some(existing));
             }
-            tx.query_one(
-                "SELECT value FROM tysel_durable_metadata WHERE key = 'schema_version' FOR UPDATE",
-                &[],
-            )?;
             let row = tx.query_one(
-                "SELECT COUNT(*), COALESCE(SUM(octet_length(source)), 0) FROM durable_programs",
-                &[],
+                "SELECT active_count, active_bytes FROM durable_program_stats WHERE singleton = 1 FOR UPDATE", &[],
             )?;
             let count: i64 = row.get(0);
             let total_bytes: i64 = row.get(1);
@@ -342,6 +348,7 @@ impl PostgresStore {
                  VALUES ($1, $2, $3, $4, $5)",
                 &[&&id[..], &kind.as_str(), &source, &&digest[..], &registered_at_ms],
             )?;
+            tx.execute("UPDATE durable_program_stats SET active_count = active_count + 1, active_bytes = active_bytes + $1 WHERE singleton = 1", &[&source_bytes])?;
             tx.commit()?;
             Ok(None)
         })
@@ -377,6 +384,21 @@ impl PostgresStore {
 }
 
 impl DurableStore for PostgresStore {
+    fn completion(&self, task_id: TaskId) -> Result<Option<TaskCompletion>, DurableError> {
+        self.read_completion(task_id)
+    }
+    fn complete_task(
+        &self,
+        task_id: TaskId,
+        expected_sequence: u64,
+        value: &Value,
+        completed_at_ms: u64,
+    ) -> Result<bool, DurableError> {
+        self.finish_task(task_id, expected_sequence, value, completed_at_ms)
+    }
+    fn prune_completed(&self, before_ms: u64, limit: usize) -> Result<usize, DurableError> {
+        self.prune_finished(before_ms, limit)
+    }
     fn log_version(&self) -> Result<u32, DurableError> {
         self.with_client(|client| {
             let row = client
@@ -415,6 +437,15 @@ impl DurableStore for PostgresStore {
         &self,
         now_ms: u64,
         kind: DurableProgramKind,
+    ) -> Result<Vec<DurableProgram>, DurableError> {
+        self.load_due_programs_batch(now_ms, kind, MAX_DURABLE_PROGRAMS)
+    }
+
+    fn load_due_programs_batch(
+        &self,
+        now_ms: u64,
+        kind: DurableProgramKind,
+        limit: usize,
     ) -> Result<Vec<DurableProgram>, DurableError> {
         let now_ms = to_sql_integer(now_ms, "now_ms")?;
         self.with_client(|client| {
@@ -422,8 +453,10 @@ impl DurableStore for PostgresStore {
                 "SELECT p.task_id, p.program_kind, p.source, p.source_sha256, p.registered_at_ms
                  FROM durable_programs p JOIN durable_wakeups w ON w.task_id = p.task_id
                  WHERE w.wake_at_ms <= $1 AND (w.lease_until_ms IS NULL OR w.lease_until_ms <= $1)
-                   AND p.program_kind = $2 ORDER BY p.task_id LIMIT $3",
-                &[&now_ms, &kind.as_str(), &((MAX_DURABLE_PROGRAMS + 1) as i64)],
+                   AND p.program_kind = $2
+                   AND NOT EXISTS (SELECT 1 FROM durable_completions c WHERE c.task_id = p.task_id)
+                   ORDER BY w.wake_at_ms, p.task_id LIMIT $3",
+                &[&now_ms, &kind.as_str(), &(limit.min(MAX_DURABLE_PROGRAMS) as i64)],
             )?;
             if rows.len() > MAX_DURABLE_PROGRAMS {
                 return Err(DurableError::ProgramLimit);
@@ -449,7 +482,7 @@ impl DurableStore for PostgresStore {
             let mut tx = client.transaction()?;
             let id = lock_task(&mut tx, task_id)?;
             let existing = select_program(&mut tx, task_id)?;
-            if existing.is_some() {
+            if let Some(program) = &existing {
                 let row = tx.query_one(
                     "SELECT EXISTS(SELECT 1 FROM durable_events WHERE task_id = $1)
                        OR EXISTS(SELECT 1 FROM durable_wakeups WHERE task_id = $1)
@@ -460,6 +493,7 @@ impl DurableStore for PostgresStore {
                 if row.get::<_, bool>(0) {
                     return Err(DurableError::ProgramInUse { task_id });
                 }
+                tx.execute("UPDATE durable_program_stats SET active_count = active_count - 1, active_bytes = active_bytes - $1 WHERE singleton = 1", &[&(program.source.len() as i64)])?;
                 tx.execute("DELETE FROM durable_programs WHERE task_id = $1", &[&&id[..]])?;
             }
             tx.commit()?;
@@ -469,7 +503,12 @@ impl DurableStore for PostgresStore {
 
     fn program_count(&self) -> Result<usize, DurableError> {
         self.with_client(|client| {
-            let count: i64 = client.query_one("SELECT COUNT(*) FROM durable_programs", &[])?.get(0);
+            let count: i64 = client
+                .query_one(
+                    "SELECT active_count FROM durable_program_stats WHERE singleton = 1",
+                    &[],
+                )?
+                .get(0);
             usize::try_from(count).map_err(|_| DurableError::ProgramLimit)
         })
     }
diff --git a/crates/tysel-durable/src/postgres_store/lifecycle.rs b/crates/tysel-durable/src/postgres_store/lifecycle.rs
new file mode 100644
index 0000000..279fe23
--- /dev/null
+++ b/crates/tysel-durable/src/postgres_store/lifecycle.rs
@@ -0,0 +1,140 @@
+use super::*;
+
+pub(super) fn initialize(tx: &mut Transaction<'_>) -> Result<(), DurableError> {
+    tx.batch_execute(
+        "CREATE TABLE IF NOT EXISTS durable_completions (
+            task_id BYTEA PRIMARY KEY CHECK (octet_length(task_id) = 16),
+            next_sequence BIGINT NOT NULL CHECK (next_sequence >= 0),
+            result_json TEXT NOT NULL,
+            completed_at_ms BIGINT NOT NULL CHECK (completed_at_ms >= 0)
+         );
+         CREATE INDEX IF NOT EXISTS durable_completions_retention ON durable_completions (completed_at_ms, task_id);
+         CREATE TABLE IF NOT EXISTS durable_program_stats (
+            singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+            active_count BIGINT NOT NULL CHECK (active_count >= 0),
+            active_bytes BIGINT NOT NULL CHECK (active_bytes >= 0)
+         );",
+    )?;
+    if tx
+        .query_opt("SELECT singleton FROM durable_program_stats WHERE singleton = 1", &[])?
+        .is_none()
+    {
+        tx.execute(
+            "INSERT INTO durable_program_stats SELECT 1, COUNT(*), COALESCE(SUM(octet_length(source)), 0)
+             FROM durable_programs p WHERE NOT EXISTS (SELECT 1 FROM durable_completions c WHERE c.task_id = p.task_id)
+             ON CONFLICT (singleton) DO NOTHING", &[],
+        )?;
+    }
+    Ok(())
+}
+
+fn lock_for_completion(tx: &mut Transaction<'_>, id: &[u8]) -> Result<(), DurableError> {
+    tx.execute(
+        "INSERT INTO durable_task_locks (task_id) VALUES ($1) ON CONFLICT DO NOTHING",
+        &[&id],
+    )?;
+    tx.query_one("SELECT task_id FROM durable_task_locks WHERE task_id = $1 FOR UPDATE", &[&id])?;
+    Ok(())
+}
+
+impl PostgresStore {
+    pub(super) fn read_completion(
+        &self,
+        task_id: TaskId,
+    ) -> Result<Option<TaskCompletion>, DurableError> {
+        self.with_client(|client| {
+            let id = task_id_bytes(task_id);
+            client.query_opt("SELECT next_sequence, result_json, completed_at_ms FROM durable_completions WHERE task_id = $1", &[&&id[..]])?
+                .map(|row| Ok(TaskCompletion {
+                    task_id,
+                    next_sequence: from_sql_integer(row.get(0), "next_sequence")?,
+                    value: serde_json::from_str(row.get::<_, &str>(1))?,
+                    completed_at_ms: from_sql_integer(row.get(2), "completed_at_ms")?,
+                })).transpose()
+        })
+    }
+
+    pub(super) fn finish_task(
+        &self,
+        task_id: TaskId,
+        expected_sequence: u64,
+        value: &Value,
+        completed_at_ms: u64,
+    ) -> Result<bool, DurableError> {
+        let json = serde_json::to_string(value)?;
+        if json.len() > MAX_EVENT_PAYLOAD_BYTES {
+            return Err(DurableError::EventPayloadTooLarge);
+        }
+        self.with_client(|client| {
+            let mut tx = client.transaction()?;
+            let id = task_id_bytes(task_id);
+            lock_for_completion(&mut tx, &id)?;
+            if let Some(row) = tx.query_opt("SELECT next_sequence, result_json FROM durable_completions WHERE task_id = $1", &[&&id[..]])? {
+                if row.get::<_, i64>(0) != to_sql_integer(expected_sequence, "next_sequence")? || serde_json::from_str::<Value>(row.get::<_, &str>(1))? != *value {
+                    return Err(DurableError::TaskCompleted { task_id });
+                }
+                return Ok(true);
+            }
+            let Some(program) = tx.query_opt("SELECT octet_length(source) FROM durable_programs WHERE task_id = $1", &[&&id[..]])? else { return Ok(false); };
+            let source_bytes = i64::from(program.get::<_, i32>(0));
+            let actual: i64 = tx.query_one("SELECT COALESCE(MAX(sequence) + 1, 0) FROM durable_events WHERE task_id = $1", &[&&id[..]])?.get(0);
+            if from_sql_integer(actual, "next_sequence")? != expected_sequence {
+                return Err(DurableError::HistoryConflict { expected: expected_sequence, actual: actual as u64 });
+            }
+            let suspended: bool = tx.query_one("SELECT EXISTS(SELECT 1 FROM durable_wakeups WHERE task_id = $1) OR EXISTS(SELECT 1 FROM durable_signal_waits WHERE task_id = $1)", &[&&id[..]])?.get(0);
+            if suspended { return Err(DurableError::TaskSuspended { task_id }); }
+            tx.execute("INSERT INTO durable_completions (task_id, next_sequence, result_json, completed_at_ms) VALUES ($1, $2, $3, $4)",
+                &[&&id[..], &actual, &json, &to_sql_integer(completed_at_ms, "completed_at_ms")?])?;
+            tx.execute("UPDATE durable_program_stats SET active_count = active_count - 1, active_bytes = active_bytes - $1 WHERE singleton = 1", &[&source_bytes])?;
+            tx.commit()?;
+            Ok(true)
+        })
+    }
+
+    pub(super) fn prune_finished(
+        &self,
+        before_ms: u64,
+        limit: usize,
+    ) -> Result<usize, DurableError> {
+        if limit == 0 {
+            return Ok(0);
+        }
+        self.with_client(|client| {
+            let candidates = client.query(
+                "SELECT c.task_id, COALESCE(h.payload_bytes, 0) + COALESCE(octet_length(p.source), 0) + octet_length(c.result_json)
+                   + COALESCE((SELECT SUM(octet_length(s.signal_name) + octet_length(s.payload)) FROM durable_signal_inbox s WHERE s.task_id = c.task_id), 0)
+                 FROM durable_completions c
+                 LEFT JOIN durable_programs p ON p.task_id = c.task_id
+                 LEFT JOIN durable_history_stats h ON h.task_id = c.task_id
+                 WHERE completed_at_ms < $1 ORDER BY completed_at_ms, c.task_id LIMIT $2",
+                &[&to_sql_integer(before_ms, "before_ms")?, &(limit.min(100) as i64)],
+            )?;
+            let mut deleted = 0;
+            let mut bytes = 0u64;
+            for row in candidates {
+                let id: &[u8] = row.get(0);
+                let retained_bytes = row.get::<_, i64>(1) as u64;
+                if deleted > 0 && bytes + retained_bytes > MAX_HISTORY_BYTES as u64 { break; }
+                let mut tx = client.transaction()?;
+                // The same task-row lock order as writers avoids GC/finalization deadlocks.
+                lock_for_completion(&mut tx, id)?;
+                let eligible: bool = tx.query_one(
+                    "SELECT EXISTS(SELECT 1 FROM durable_completions WHERE task_id = $1 AND completed_at_ms < $2)
+                     AND NOT EXISTS(SELECT 1 FROM durable_wakeups WHERE task_id = $1)
+                     AND NOT EXISTS(SELECT 1 FROM durable_signal_waits WHERE task_id = $1)",
+                    &[&id, &to_sql_integer(before_ms, "before_ms")?],
+                )?.get(0);
+                if !eligible { continue; }
+                for table in ["durable_programs", "durable_events", "durable_history_stats", "durable_signal_inbox", "durable_completions"] {
+                    tx.execute(&format!("DELETE FROM {table} WHERE task_id = $1"), &[&id])?;
+                }
+                // Retain the small synchronization row: deleting a row that another
+                // transaction already waits on would break mutual exclusion.
+                tx.commit()?;
+                bytes += retained_bytes;
+                deleted += 1;
+            }
+            Ok(deleted)
+        })
+    }
+}
diff --git a/crates/tysel-durable/tests/postgres_live.rs b/crates/tysel-durable/tests/postgres_live.rs
index 2dbce61..e942a0f 100644
--- a/crates/tysel-durable/tests/postgres_live.rs
+++ b/crates/tysel-durable/tests/postgres_live.rs
@@ -82,3 +82,118 @@ fn postgres_preserves_replay_claim_signal_and_catalog_contracts() {
     assert!(store.wakeup(signaled).unwrap().is_none());
     assert!(store.signal_wait(signaled).unwrap().is_none());
 }
+
+#[test]
+fn postgres_completion_serializes_with_writers_and_prunes_only_terminal_tasks() {
+    let Some(store) = store() else {
+        return;
+    };
+    let initial = store.program_count().unwrap();
+    let live = task(100);
+    store.put_module(live, "export default async () => 1", 0).unwrap();
+    store.append_event_json_with_wakeup_at(live, 0, "sleep".into(), "null", 0, 1).unwrap();
+    assert!(matches!(
+        store.complete_task(live, 1, &json!(1), 10),
+        Err(DurableError::TaskSuspended { .. })
+    ));
+    let mut completed = Vec::new();
+    for offset in 101..113 {
+        let id = task(offset);
+        store.put_module(id, "export default async () => 1", 0).unwrap();
+        let barrier = Arc::new(Barrier::new(3));
+        let writer = {
+            let store = store.clone();
+            let barrier = barrier.clone();
+            std::thread::spawn(move || {
+                barrier.wait();
+                store.append_event_json_at(id, 0, EventKind::Step, "once".into(), "1", 1)
+            })
+        };
+        let finisher = {
+            let store = store.clone();
+            let barrier = barrier.clone();
+            std::thread::spawn(move || {
+                barrier.wait();
+                store.complete_task(id, 0, &json!(42), 10)
+            })
+        };
+        barrier.wait();
+        let written = writer.join().unwrap();
+        let finished = finisher.join().unwrap();
+        match (written, finished) {
+            (Ok(_), Err(DurableError::HistoryConflict { .. })) => {
+                store.complete_task(id, 1, &json!(42), 10).unwrap();
+            }
+            (Err(DurableError::TaskCompleted { .. }), Ok(true)) => {}
+            other => panic!("non-serial terminal mutation: {other:?}"),
+        }
+        assert!(matches!(
+            store.send_signal(id, "late", &json!(true), 11),
+            Err(DurableError::TaskCompleted { .. })
+        ));
+        assert!(matches!(store.remove_program(id), Err(DurableError::TaskCompleted { .. })));
+        assert_eq!(store.completion(id).unwrap().unwrap().value, json!(42));
+        completed.push(id);
+    }
+    assert_eq!(store.program_count().unwrap(), initial + 1);
+    assert_eq!(store.prune_completed(10, 100).unwrap(), 0);
+    // Concurrent collectors use the same task lock as completion and event writers.
+    let collectors: Vec<_> = (0..2)
+        .map(|_| {
+            let store = store.clone();
+            std::thread::spawn(move || store.prune_completed(11, 3).unwrap())
+        })
+        .collect();
+    let deleted: usize = collectors.into_iter().map(|thread| thread.join().unwrap()).sum();
+    assert!((3..=6).contains(&deleted));
+    let remaining = store.prune_completed(11, 100).unwrap();
+    assert_eq!(deleted + remaining, completed.len());
+    for id in completed {
+        assert!(store.program(id).unwrap().is_none());
+        assert!(store.completion(id).unwrap().is_none());
+    }
+    assert!(store.wakeup(live).unwrap().is_some());
+    assert_eq!(store.load_history(live).unwrap().events.len(), 1);
+    assert_eq!(store.program_count().unwrap(), initial + 1);
+}
+
+#[test]
+fn postgres_v1_migration_keeps_unclassified_work_and_reopens_completion_counters() {
+    let Ok(url) = std::env::var("TYSEL_POSTGRES_TEST_URL") else {
+        return;
+    };
+    let schema = format!("tysel_migration_{}", task(300).0);
+    let mut admin = postgres::Client::connect(&url, postgres::NoTls).unwrap();
+    admin.batch_execute(&format!("CREATE SCHEMA {schema}")).unwrap();
+    let scoped = if url.contains("://") {
+        format!(
+            "{url}{}options=-csearch_path%3D{schema}",
+            if url.contains('?') { "&" } else { "?" }
+        )
+    } else {
+        format!("{url} options='-c search_path={schema}'")
+    };
+    {
+        let store = PostgresStore::connect(&scoped).unwrap();
+        store.put_program(TaskId(1), "1", 0).unwrap();
+    }
+    {
+        let mut client = postgres::Client::connect(&scoped, postgres::NoTls).unwrap();
+        client.batch_execute("DROP TABLE durable_completions; DROP TABLE durable_program_stats; UPDATE tysel_durable_metadata SET value=1 WHERE key='schema_version'").unwrap();
+    }
+    {
+        let store = PostgresStore::connect(&scoped).unwrap();
+        assert_eq!(store.log_version().unwrap(), 2);
+        assert_eq!(store.program_count().unwrap(), 1);
+        assert_eq!(store.prune_completed(100, 100).unwrap(), 0);
+        store.complete_task(TaskId(1), 0, &json!(42), 1).unwrap();
+    }
+    {
+        let store = PostgresStore::connect(&scoped).unwrap();
+        assert_eq!(store.program_count().unwrap(), 0);
+        assert_eq!(store.completion(TaskId(1)).unwrap().unwrap().value, json!(42));
+        store.put_program(TaskId(2), "2", 2).unwrap();
+        assert_eq!(store.program_count().unwrap(), 1);
+    }
+    admin.batch_execute(&format!("DROP SCHEMA {schema} CASCADE")).unwrap();
+}
diff --git a/crates/tysel-engine-qjs/src/durable.rs b/crates/tysel-engine-qjs/src/durable.rs
index 6057d46..851d92c 100644
--- a/crates/tysel-engine-qjs/src/durable.rs
+++ b/crates/tysel-engine-qjs/src/durable.rs
@@ -1,7 +1,9 @@
 use std::sync::{Arc, Mutex};
 
 use serde_json::json;
-use tysel_durable::{DurableStore, EventKind, ReplayCursor, ReplayError, WakeupClaim};
+use tysel_durable::{
+    DurableError, DurableStore, EventKind, ReplayCursor, ReplayError, WakeupClaim,
+};
 use tysel_task::TaskId;
 
 #[derive(Clone)]
@@ -16,6 +18,8 @@ struct SessionInner {
     next_sequence: u64,
     active_wakeup: Option<WakeupToken>,
     suspended: bool,
+    lease_until_ms: Option<u64>,
+    result_json: Option<serde_json::Value>,
 }
 
 struct WakeupToken {
@@ -57,6 +61,9 @@ impl DurableSession {
     /// Start a task that has no pending wakeup. Suspended tasks must enter via
     /// `from_claim` so they cannot resume early or run under two schedulers.
     pub fn new(store: Arc<dyn DurableStore>, task_id: TaskId) -> Result<Self, String> {
+        if store.completion(task_id).map_err(|err| err.to_string())?.is_some() {
+            return Err("durable task is already completed".into());
+        }
         if let Some(wakeup) = store.wakeup(task_id).map_err(|err| err.to_string())? {
             return Err(format!(
                 "durable task is suspended until {} and must be resumed from a wakeup claim",
@@ -89,6 +96,7 @@ impl DurableSession {
         task_id: TaskId,
         active_claim: Option<WakeupClaim>,
     ) -> Result<Self, String> {
+        let lease_until_ms = active_claim.as_ref().map(|claim| claim.lease_until_ms);
         let history = store.load_history(task_id).map_err(|err| err.to_string())?;
         let next_sequence = history
             .events
@@ -125,6 +133,8 @@ impl DurableSession {
                 next_sequence,
                 active_wakeup,
                 suspended: false,
+                lease_until_ms,
+                result_json: None,
             })),
         })
     }
@@ -230,6 +240,7 @@ impl DurableSession {
             return Err("durable wakeup ownership was lost".into());
         }
         inner.active_wakeup = None;
+        inner.suspended = false;
         Ok(())
     }
 
@@ -251,6 +262,7 @@ impl DurableSession {
             }) {
                 inner.active_wakeup = None;
             }
+            inner.suspended = false;
             json!({ "found": true, "payload": event.payload })
         } else {
             inner.suspended = true;
@@ -259,6 +271,44 @@ impl DurableSession {
         serde_json::to_string(&response).map_err(|err| err.to_string())
     }
 
+    pub fn task_id(&self) -> TaskId {
+        self.inner.lock().expect("durable session lock").task_id
+    }
+
+    pub(crate) fn retain_result(&self, value: serde_json::Value) -> Result<(), String> {
+        self.inner.lock().map_err(|_| "durable session lock poisoned")?.result_json = Some(value);
+        Ok(())
+    }
+
+    /// Preserve the JSON number representation validated by the JavaScript engine.
+    pub fn take_result(&self) -> Option<serde_json::Value> {
+        self.inner.lock().ok()?.result_json.take()
+    }
+
+    /// Extract only the authority needed for terminal persistence. No replay
+    /// history or engine state is retained by this handle.
+    pub fn completion_handle(&self) -> Result<DurableCompletion, DurableError> {
+        let inner = self.inner.lock().map_err(|_| DurableError::LockPoisoned)?;
+        if inner.replay.ensure_consumed().is_err()
+            || inner.active_wakeup.is_some()
+            || inner.suspended
+        {
+            return Err(DurableError::TaskSuspended { task_id: inner.task_id });
+        }
+        Ok(DurableCompletion {
+            store: inner.store.clone(),
+            task_id: inner.task_id,
+            next_sequence: inner.next_sequence,
+            lease_until_ms: inner.lease_until_ms,
+        })
+    }
+
+    /// Persist successful termination after complete replay. Persistent suspension
+    /// checks run atomically inside the store's completion transaction.
+    pub fn complete(&self, value: &serde_json::Value) -> Result<bool, DurableError> {
+        self.completion_handle()?.complete(value)
+    }
+
     pub(crate) fn is_suspended(&self) -> Result<bool, String> {
         let inner = self.inner.lock().map_err(|_| "durable session lock poisoned")?;
         Ok(inner.suspended)
@@ -267,16 +317,45 @@ impl DurableSession {
     pub(crate) fn ensure_consumed(&self) -> Result<(), String> {
         let inner = self.inner.lock().map_err(|_| "durable session lock poisoned")?;
         inner.replay.ensure_consumed().map_err(replay_error)?;
-        let persisted_suspension =
-            inner.store.wakeup(inner.task_id).map_err(|err| err.to_string())?.is_some()
-                || inner.store.signal_wait(inner.task_id).map_err(|err| err.to_string())?.is_some();
-        if inner.active_wakeup.is_some() || persisted_suspension {
+        // Storage checks belong to terminal persistence, where availability
+        // errors can be retried with the computed result. Keep this check local.
+        if inner.active_wakeup.is_some() || inner.suspended {
             return Err("durable execution returned with a persisted suspension".into());
         }
         Ok(())
     }
 }
 
+/// Lightweight terminal write authority; deliberately contains no replay cursor.
+pub struct DurableCompletion {
+    store: Arc<dyn DurableStore>,
+    task_id: TaskId,
+    next_sequence: u64,
+    lease_until_ms: Option<u64>,
+}
+
+impl DurableCompletion {
+    pub fn task_id(&self) -> TaskId {
+        self.task_id
+    }
+
+    pub fn complete(&self, value: &serde_json::Value) -> Result<bool, DurableError> {
+        let now_ms = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map_err(std::io::Error::other)?
+            .as_millis() as u64;
+        if self.lease_until_ms.is_some_and(|until| now_ms >= until) {
+            if self.store.completion(self.task_id)?.is_some_and(|completion| {
+                completion.next_sequence == self.next_sequence && completion.value == *value
+            }) {
+                return Ok(true);
+            }
+            return Err(DurableError::TaskSuspended { task_id: self.task_id });
+        }
+        self.store.complete_task(self.task_id, self.next_sequence, value, now_ms)
+    }
+}
+
 fn parse_kind(raw: &str) -> Result<EventKind, String> {
     match raw {
         "step" => Ok(EventKind::Step),
@@ -300,3 +379,60 @@ fn unix_time_ms() -> Result<u64, String> {
         .map_err(|err| err.to_string())?;
     u64::try_from(duration.as_millis()).map_err(|_| "system time is too large".into())
 }
+
+#[cfg(test)]
+mod completion_tests {
+    use super::*;
+    use tysel_durable::SqliteStore;
+
+    #[test]
+    fn completion_handle_does_not_retain_consumed_history() {
+        let store = Arc::new(SqliteStore::in_memory().unwrap());
+        let id = TaskId(982);
+        store.put_program(id, "42", 0).unwrap();
+        store
+            .append_event_json_at(
+                id,
+                0,
+                EventKind::Step,
+                "large".into(),
+                &serde_json::to_string(&"x".repeat(1_000_000)).unwrap(),
+                0,
+            )
+            .unwrap();
+        let session = DurableSession::new(store.clone(), id).unwrap();
+        session.lookup_json("step", "large").unwrap();
+        let weak = Arc::downgrade(&session.inner);
+        let completion = session.completion_handle().unwrap();
+        drop(session);
+        assert!(weak.upgrade().is_none(), "finalization must release the replay owner");
+        assert!(completion.complete(&json!(42)).unwrap());
+    }
+
+    #[test]
+    fn completion_transaction_rejects_a_new_persisted_wait() {
+        let store = Arc::new(SqliteStore::in_memory().unwrap());
+        let id = TaskId(983);
+        store.put_program(id, "42", 0).unwrap();
+        let session = DurableSession::new(store.clone(), id).unwrap();
+        let completion = session.completion_handle().unwrap();
+        store.poll_signal(id, 0, "late", 0, None).unwrap();
+        assert!(matches!(completion.complete(&json!(42)), Err(DurableError::TaskSuspended { .. })));
+        assert!(store.completion(id).unwrap().is_none());
+    }
+
+    #[test]
+    fn expired_completion_can_only_acknowledge_an_identical_committed_outcome() {
+        let store = Arc::new(SqliteStore::in_memory().unwrap());
+        let task_id = TaskId(981);
+        store.put_program(task_id, "42", 0).unwrap();
+        let session = DurableSession::new(store.clone(), task_id).unwrap();
+        session.inner.lock().unwrap().lease_until_ms = Some(0);
+        assert!(matches!(session.complete(&json!(42)), Err(DurableError::TaskSuspended { .. })));
+        assert!(store.completion(task_id).unwrap().is_none());
+        store.complete_task(task_id, 0, &json!(42), 1).unwrap();
+        assert!(session.complete(&json!(42)).unwrap());
+        assert!(matches!(session.complete(&json!(43)), Err(DurableError::TaskSuspended { .. })));
+        assert_eq!(store.completion(task_id).unwrap().unwrap().value, json!(42));
+    }
+}
diff --git a/crates/tysel-engine-qjs/src/isolate.rs b/crates/tysel-engine-qjs/src/isolate.rs
index 2521389..6c3047b 100644
--- a/crates/tysel-engine-qjs/src/isolate.rs
+++ b/crates/tysel-engine-qjs/src/isolate.rs
@@ -254,7 +254,11 @@ fn run_with_reactor(
                     }
                     let value: serde_json::Value = serde_json::from_str(&json)
                         .map_err(|err| EngineError::Isolate(err.to_string()))?;
-                    Ok(from_json(value))
+                    let output = from_json_ref(&value);
+                    if let Some(session) = &durable {
+                        session.retain_result(value).map_err(EngineError::Isolate)?;
+                    }
+                    Ok(output)
                 })
             } else {
                 Ok(settled)
@@ -476,6 +480,21 @@ fn from_js(ctx: &Ctx<'_>, value: rquickjs::Value<'_>) -> Result<Value, EngineErr
     Err(EngineError::Isolate(format!("unsupported js type: {}", value.type_name())))
 }
 
+fn from_json_ref(value: &serde_json::Value) -> Value {
+    match value {
+        serde_json::Value::Null => Value::Null,
+        serde_json::Value::Bool(value) => Value::Bool(*value),
+        serde_json::Value::Number(value) => Value::Number(value.as_f64().unwrap_or(0.0)),
+        serde_json::Value::String(value) => Value::String(value.clone()),
+        serde_json::Value::Array(values) => {
+            Value::Array(values.iter().map(from_json_ref).collect())
+        }
+        serde_json::Value::Object(fields) => Value::Record(
+            fields.iter().map(|(key, value)| (key.clone(), from_json_ref(value))).collect(),
+        ),
+    }
+}
+
 pub(crate) fn from_json(value: serde_json::Value) -> Value {
     match value {
         serde_json::Value::Null => Value::Null,
diff --git a/crates/tysel-engine-qjs/src/lib.rs b/crates/tysel-engine-qjs/src/lib.rs
index 3818cb1..1072ba3 100644
--- a/crates/tysel-engine-qjs/src/lib.rs
+++ b/crates/tysel-engine-qjs/src/lib.rs
@@ -23,7 +23,7 @@ mod task_module;
 mod trust;
 
 pub use control::{DurableControl, configure as configure_durable_control};
-pub use durable::DurableSession;
+pub use durable::{DurableCompletion, DurableSession};
 pub use fetch_policy::configure as configure_fetch_hosts;
 pub use isolate::{
     IsolateCancel, encode_durable_export, eval, eval_cancellable, eval_durable,
diff --git a/crates/tysel-observability/src/lib.rs b/crates/tysel-observability/src/lib.rs
index a293932..a58197e 100644
--- a/crates/tysel-observability/src/lib.rs
+++ b/crates/tysel-observability/src/lib.rs
@@ -115,6 +115,36 @@ pub fn log_capability(
     }
 }
 
+/// Bounded scheduler diagnostics: never emit source, payloads, SQL or provider errors.
+pub fn log_durable(state: &str, task_id: Option<u128>, attempt: u32) {
+    let Some((app, json_logs)) = configured_log() else {
+        return;
+    };
+    let state = allowed_label(
+        state,
+        &[
+            "healthy",
+            "recovering",
+            "failed",
+            "completed",
+            "suspended",
+            "task_failed",
+            "completion_pending",
+        ],
+    );
+    if !json_logs {
+        let task = task_id.map(|id| format!(" task={id:032x}")).unwrap_or_default();
+        write_line(&format!("tysel durable {state}{task} attempt={attempt}"));
+        return;
+    }
+    let mut value =
+        serde_json::json!({"app": app, "event": "durable", "state": state, "attempt": attempt});
+    if let Some(id) = task_id {
+        value["taskId"] = format!("{id:032x}").into();
+    }
+    write_line(&value.to_string());
+}
+
 fn configured_log() -> Option<(String, bool)> {
     let guard = JSON_LOG.read().expect("json log lock");
     guard.as_ref().map(|config| (config.app.clone(), config.enabled))
diff --git a/crates/tysel-runtime/Cargo.toml b/crates/tysel-runtime/Cargo.toml
index 5b6cb37..ccf4c4b 100644
--- a/crates/tysel-runtime/Cargo.toml
+++ b/crates/tysel-runtime/Cargo.toml
@@ -45,6 +45,7 @@ name = "tysel-service"
 path = "src/bin/tysel-service.rs"
 
 [dev-dependencies]
+rusqlite = { version = "0.32", features = ["bundled"] }
 wat = "1"
 http-body-util.workspace = true
 hyper.workspace = true
diff --git a/crates/tysel-runtime/src/durable.rs b/crates/tysel-runtime/src/durable.rs
index d975579..16133bc 100644
--- a/crates/tysel-runtime/src/durable.rs
+++ b/crates/tysel-runtime/src/durable.rs
@@ -1,11 +1,13 @@
-use std::sync::Arc;
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{Arc, Mutex};
 use std::time::{SystemTime, UNIX_EPOCH};
 
 #[cfg(test)]
 use tysel_durable::SqliteStore;
 use tysel_durable::{DurableError, DurableStore, WakeupClaim};
 use tysel_engine::{EngineError, IsolateConfig, Value};
-use tysel_engine_qjs::{DurableSession, eval_durable, eval_durable_module};
+use tysel_engine_qjs::{DurableCompletion, DurableSession, eval_durable, eval_durable_module};
 use tysel_task::TaskId;
 
 const MAX_OWNER_BYTES: usize = 128;
@@ -15,6 +17,22 @@ pub struct DurableDispatcher {
     owner: String,
     lease_duration_ms: u64,
     isolate: IsolateConfig,
+    pending: Mutex<HashMap<TaskId, PendingCompletion>>,
+    slots: Arc<AtomicUsize>,
+}
+
+// Bound retained results and in-flight executions together, including HTTP starts.
+const MAX_FINALIZATIONS: usize = 32;
+pub(crate) struct CompletionSlot(Arc<AtomicUsize>);
+impl Drop for CompletionSlot {
+    fn drop(&mut self) {
+        self.0.fetch_sub(1, Ordering::AcqRel);
+    }
+}
+struct PendingCompletion {
+    completion: DurableCompletion,
+    json: String,
+    _slot: CompletionSlot,
 }
 
 impl DurableDispatcher {
@@ -34,7 +52,78 @@ impl DurableDispatcher {
                 request_timeout_ms: isolate.request_timeout_ms,
             });
         }
-        Ok(Self { store, owner, lease_duration_ms, isolate })
+        Ok(Self {
+            store,
+            owner,
+            lease_duration_ms,
+            isolate,
+            pending: Mutex::new(HashMap::new()),
+            slots: Arc::new(AtomicUsize::new(0)),
+        })
+    }
+
+    pub(crate) fn reserve(&self) -> Result<CompletionSlot, DurableRunError> {
+        self.slots
+            .fetch_update(Ordering::AcqRel, Ordering::Acquire, |n| {
+                (n < MAX_FINALIZATIONS).then_some(n + 1)
+            })
+            .map_err(|_| DurableRunError::FinalizationCapacity)?;
+        Ok(CompletionSlot(self.slots.clone()))
+    }
+
+    fn finish(
+        &self,
+        session: DurableSession,
+        value: Value,
+        slot: CompletionSlot,
+    ) -> Result<DurableRunStatus, DurableRunError> {
+        let json = session.take_result().unwrap_or_else(|| value_to_json(&value));
+        let completion = session.completion_handle()?;
+        drop(session);
+        match completion.complete(&json) {
+            Ok(_) => Ok(DurableRunStatus::Completed(value)),
+            Err(error) => {
+                // Retain the outcome, never rerun the handler to repair storage.
+                if !error.is_retryable() {
+                    return Err(DurableRunError::Store(error));
+                }
+                let json = serde_json::to_string(&json)
+                    .map_err(|error| DurableRunError::Session(error.to_string()))?;
+                let task_id = completion.task_id();
+                tysel_observability::log_durable("completion_pending", Some(task_id.0), 0);
+                self.pending
+                    .lock()
+                    .map_err(|_| DurableError::LockPoisoned)?
+                    .insert(task_id, PendingCompletion { completion, json, _slot: slot });
+                Err(DurableRunError::Store(error))
+            }
+        }
+    }
+
+    pub(crate) fn has_pending_completions(&self) -> bool {
+        self.pending.lock().map_or(true, |pending| !pending.is_empty())
+    }
+
+    pub(crate) fn retry_completions(&self) -> (Vec<DurableRun>, Option<DispatchError>) {
+        let mut pending = match self.pending.lock() {
+            Ok(pending) => pending,
+            Err(_) => return (Vec::new(), Some(DurableError::LockPoisoned.into())),
+        };
+        let ids: Vec<_> = pending.keys().copied().collect();
+        let mut runs = Vec::new();
+        for task_id in ids {
+            let entry = &pending[&task_id];
+            let json = serde_json::from_str(&entry.json).expect("validated completion JSON");
+            if let Err(error) = entry.completion.complete(&json) {
+                return (runs, Some(error.into()));
+            }
+            pending.remove(&task_id);
+            runs.push(DurableRun {
+                task_id,
+                result: Ok(DurableRunStatus::Completed(value_from_json(json))),
+            });
+        }
+        (runs, None)
     }
 
     pub(crate) fn store(&self) -> Arc<dyn DurableStore> {
@@ -42,6 +131,20 @@ impl DurableDispatcher {
     }
 
     pub fn start(&self, task_id: TaskId, script: &str) -> DurableRun {
+        if self.pending.lock().map_or(true, |pending| pending.contains_key(&task_id)) {
+            return DurableRun { task_id, result: Err(DurableRunError::FinalizationPending) };
+        }
+        match self.store.completion(task_id) {
+            Ok(Some(completion)) => {
+                return DurableRun {
+                    task_id,
+                    result: Ok(DurableRunStatus::Completed(value_from_json(completion.value))),
+                };
+            }
+            Err(error) => return DurableRun { task_id, result: Err(error.into()) },
+            Ok(None) => {}
+        }
+
         let result = DurableSession::new(self.store.clone(), task_id)
             .map_err(DurableRunError::Session)
             .and_then(|session| self.evaluate(script, session));
@@ -52,9 +155,37 @@ impl DurableDispatcher {
     /// `async (ctx, input) => value`. The input is recorded as the first
     /// durable boundary and is therefore not required when resuming.
     pub fn start_module(&self, task_id: TaskId, source: &str, input_json: &str) -> DurableRun {
+        let slot = match self.reserve() {
+            Ok(slot) => slot,
+            Err(error) => return DurableRun { task_id, result: Err(error) },
+        };
+        self.start_module_reserved(task_id, source, input_json, slot)
+    }
+
+    pub(crate) fn start_module_reserved(
+        &self,
+        task_id: TaskId,
+        source: &str,
+        input_json: &str,
+        slot: CompletionSlot,
+    ) -> DurableRun {
+        if self.pending.lock().map_or(true, |pending| pending.contains_key(&task_id)) {
+            return DurableRun { task_id, result: Err(DurableRunError::FinalizationPending) };
+        }
+        match self.store.completion(task_id) {
+            Ok(Some(completion)) => {
+                return DurableRun {
+                    task_id,
+                    result: Ok(DurableRunStatus::Completed(value_from_json(completion.value))),
+                };
+            }
+            Err(error) => return DurableRun { task_id, result: Err(error.into()) },
+            Ok(None) => {}
+        }
+
         let result = DurableSession::new(self.store.clone(), task_id)
             .map_err(DurableRunError::Session)
-            .and_then(|session| self.evaluate_module(source, input_json, session));
+            .and_then(|session| self.evaluate_module(source, input_json, session, slot));
         DurableRun { task_id, result }
     }
 
@@ -149,7 +280,7 @@ impl DurableDispatcher {
         let task_id = claim.task_id;
         let result = DurableSession::from_claim(self.store.clone(), claim)
             .map_err(DurableRunError::Session)
-            .and_then(|session| self.evaluate_module(source, "null", session));
+            .and_then(|session| self.evaluate_module(source, "null", session, self.reserve()?));
         DurableRun { task_id, result }
     }
 
@@ -158,8 +289,16 @@ impl DurableDispatcher {
         script: &str,
         session: DurableSession,
     ) -> Result<DurableRunStatus, DurableRunError> {
-        match eval_durable(script, self.isolate, session) {
-            Ok(value) => Ok(DurableRunStatus::Completed(value)),
+        let slot = self.reserve()?;
+        match eval_durable(script, self.isolate, session.clone()) {
+            Ok(value) => {
+                if matches!(&value, Value::Number(number) if !number.is_finite()) {
+                    return Err(DurableRunError::Engine(EngineError::Isolate(
+                        "durable result must be finite JSON".into(),
+                    )));
+                }
+                self.finish(session, value, slot)
+            }
             Err(EngineError::Suspended) => Ok(DurableRunStatus::Suspended),
             Err(error) => Err(DurableRunError::Engine(error)),
         }
@@ -170,15 +309,47 @@ impl DurableDispatcher {
         source: &str,
         input_json: &str,
         session: DurableSession,
+        slot: CompletionSlot,
     ) -> Result<DurableRunStatus, DurableRunError> {
-        match eval_durable_module(source, input_json, self.isolate, session) {
-            Ok(value) => Ok(DurableRunStatus::Completed(value)),
+        match eval_durable_module(source, input_json, self.isolate, session.clone()) {
+            Ok(value) => self.finish(session, value, slot),
             Err(EngineError::Suspended) => Ok(DurableRunStatus::Suspended),
             Err(error) => Err(DurableRunError::Engine(error)),
         }
     }
 }
 
+pub(crate) fn value_to_json(value: &Value) -> serde_json::Value {
+    use serde_json::Value as Json;
+    match value {
+        Value::Null => Json::Null,
+        Value::Bool(value) => Json::Bool(*value),
+        Value::Number(value) => {
+            serde_json::Number::from_f64(*value).map(Json::Number).unwrap_or(Json::Null)
+        }
+        Value::String(value) => Json::String(value.clone()),
+        Value::Bytes(value) => Json::Array(value.iter().copied().map(Json::from).collect()),
+        Value::Array(values) => Json::Array(values.iter().map(value_to_json).collect()),
+        Value::Record(values) => Json::Object(
+            values.iter().map(|(key, value)| (key.clone(), value_to_json(value))).collect(),
+        ),
+    }
+}
+
+fn value_from_json(value: serde_json::Value) -> Value {
+    use serde_json::Value as Json;
+    match value {
+        Json::Null => Value::Null,
+        Json::Bool(value) => Value::Bool(value),
+        Json::Number(value) => Value::Number(value.as_f64().unwrap_or_default()),
+        Json::String(value) => Value::String(value),
+        Json::Array(values) => Value::Array(values.into_iter().map(value_from_json).collect()),
+        Json::Object(values) => Value::Record(
+            values.into_iter().map(|(key, value)| (key, value_from_json(value))).collect(),
+        ),
+    }
+}
+
 #[derive(Debug)]
 pub struct DurableRun {
     pub task_id: TaskId,
@@ -193,6 +364,10 @@ pub enum DurableRunStatus {
 
 #[derive(Debug, thiserror::Error)]
 pub enum DurableRunError {
+    #[error("durable finalization capacity exhausted")]
+    FinalizationCapacity,
+    #[error("durable completion is pending persistence")]
+    FinalizationPending,
     #[error("durable session: {0}")]
     Session(String),
     #[error("durable engine: {0}")]
@@ -253,6 +428,69 @@ mod tests {
         DurableDispatcher::new(store, owner, 1_000, config()).unwrap()
     }
 
+    #[test]
+    fn non_finite_script_result_is_not_silently_persisted_as_null() {
+        let store = Arc::new(SqliteStore::in_memory().unwrap());
+        let id = TaskId(801);
+        store.put_program(id, "Infinity", 0).unwrap();
+        assert!(dispatcher(store.clone(), "runner").start(id, "Infinity").result.is_err());
+        assert!(store.completion(id).unwrap().is_none());
+    }
+
+    #[test]
+    fn integer_array_completion_keeps_the_validated_json_size() {
+        let store = Arc::new(SqliteStore::in_memory().unwrap());
+        let id = TaskId(802);
+        let source = "export default async () => Array(300000).fill(0)";
+        store.put_module(id, source, 0).unwrap();
+        let dispatcher = DurableDispatcher::new(
+            store.clone(),
+            "large-result",
+            15_000,
+            IsolateConfig {
+                memory_limit_bytes: 256 * 1024 * 1024,
+                cpu_ms_per_turn: 4_000,
+                request_timeout_ms: 10_000,
+            },
+        )
+        .unwrap();
+        let run = dispatcher.start_module(id, source, "null");
+        assert!(matches!(run.result, Ok(DurableRunStatus::Completed(_))), "{run:?}");
+        let json = serde_json::to_string(&store.completion(id).unwrap().unwrap().value).unwrap();
+        assert_eq!(json.len(), 600_001);
+        assert_eq!(dispatcher.slots.load(Ordering::Acquire), 0);
+    }
+
+    #[test]
+    fn finalization_slots_are_bounded_and_released() {
+        let store = Arc::new(SqliteStore::in_memory().unwrap());
+        let dispatcher = dispatcher(store.clone(), "bounded");
+        let slots: Vec<_> = (0..MAX_FINALIZATIONS).map(|_| dispatcher.reserve().unwrap()).collect();
+        assert!(matches!(dispatcher.reserve(), Err(DurableRunError::FinalizationCapacity)));
+        drop(slots);
+        assert!(dispatcher.reserve().is_ok());
+    }
+
+    #[test]
+    fn persisted_completion_returns_result_without_reexecuting() {
+        let store = Arc::new(SqliteStore::in_memory().unwrap());
+        let id = TaskId(800);
+        let source = "export default async (ctx, input) => ({answer: input.answer})";
+        store.put_module(id, source, 0).unwrap();
+        let dispatcher = dispatcher(store.clone(), "runner");
+        let first = dispatcher.start_module(id, source, r#"{"answer":42}"#);
+        assert!(matches!(first.result, Ok(DurableRunStatus::Completed(_))));
+        let cached = dispatcher.start_module(id, "throw new Error('must not execute')", "null");
+        match (first.result.unwrap(), cached.result.unwrap()) {
+            (DurableRunStatus::Completed(first), DurableRunStatus::Completed(cached)) => {
+                assert_eq!(first, cached)
+            }
+            _ => panic!("expected retained completion"),
+        }
+        assert_eq!(store.program_count().unwrap(), 0);
+        assert_eq!(store.load_history(id).unwrap().events.len(), 1);
+    }
+
     #[test]
     fn starts_suspends_and_resumes_a_signal_task() {
         let store = Arc::new(SqliteStore::in_memory().unwrap());
diff --git a/crates/tysel-runtime/src/durable_plane.rs b/crates/tysel-runtime/src/durable_plane.rs
index fe27aea..cfa6f6e 100644
--- a/crates/tysel-runtime/src/durable_plane.rs
+++ b/crates/tysel-runtime/src/durable_plane.rs
@@ -4,6 +4,7 @@ use std::sync::{Arc, Mutex, RwLock};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use serde_json::{Value as JsonValue, json};
+use tokio::sync::watch;
 use tokio::task::JoinHandle;
 use tysel_durable::{DurableError, DurableStore, POSTGRES_URL_ENV, PostgresStore, SqliteStore};
 use tysel_engine::{IsolateConfig, Value};
@@ -14,7 +15,7 @@ use tysel_task::TaskId;
 
 use crate::{
     DispatchError, DurableDispatcher, DurablePoller, DurableProgramCatalog, DurableRun,
-    DurableRunStatus, PollerError, PollerShutdown, ProgramRegistryError,
+    DurableRunStatus, PollerError, PollerHealth, PollerShutdown, ProgramRegistryError,
 };
 
 const POLL_INTERVAL: Duration = Duration::from_millis(200);
@@ -27,6 +28,7 @@ pub struct DurablePlane {
     source: RwLock<Arc<str>>,
     config: IsolateConfig,
     shutdown: PollerShutdown,
+    health: watch::Receiver<PollerHealth>,
     join: Mutex<Option<JoinHandle<Result<(), PollerError>>>>,
 }
 
@@ -44,6 +46,8 @@ pub enum DurablePlaneError {
     Engine(#[from] tysel_engine::EngineError),
     #[error("io: {0}")]
     Io(#[from] std::io::Error),
+    #[error("durable scheduler is unavailable; inspect scheduler health")]
+    Unavailable,
     #[error("durable control lock is poisoned")]
     Poisoned,
 }
@@ -139,9 +143,33 @@ impl DurablePlane {
         let poller =
             DurablePoller::new_persistent_modules(dispatcher.clone(), POLL_INTERVAL, POLL_BATCH)?;
         let shutdown = PollerShutdown::default();
+        let (health_tx, health) = watch::channel(PollerHealth::Healthy);
         let join = tokio::spawn({
             let shutdown = shutdown.clone();
-            async move { poller.run(shutdown, |_| {}).await }
+            async move {
+                poller
+                    .run_supervised(
+                        shutdown,
+                        |run| {
+                            let state = match run.result {
+                                Ok(DurableRunStatus::Completed(_)) => "completed",
+                                Ok(DurableRunStatus::Suspended) => "suspended",
+                                Err(_) => "task_failed",
+                            };
+                            tysel_observability::log_durable(state, Some(run.task_id.0), 0);
+                        },
+                        |health| {
+                            let (state, attempt) = match health {
+                                PollerHealth::Healthy => ("healthy", 0),
+                                PollerHealth::Recovering { attempt } => ("recovering", attempt),
+                                PollerHealth::Failed => ("failed", 0),
+                            };
+                            tysel_observability::log_durable(state, None, attempt);
+                            health_tx.send_replace(health);
+                        },
+                    )
+                    .await
+            }
         });
         let plane = Arc::new(Self {
             dispatcher,
@@ -149,6 +177,7 @@ impl DurablePlane {
             source: RwLock::new(Arc::from(source)),
             config,
             shutdown,
+            health,
             join: Mutex::new(Some(join)),
         });
         plane.install_hooks()?;
@@ -195,6 +224,9 @@ impl DurablePlane {
     }
 
     pub fn start_named(&self, name: &str, input_json: &str) -> Result<String, String> {
+        if self.health() != PollerHealth::Healthy {
+            return Err(DurablePlaneError::Unavailable.to_string());
+        }
         let name = name.trim();
         if name.is_empty() || name.len() > 128 {
             return Err("durable export name must be 1..=128 bytes".into());
@@ -207,9 +239,10 @@ impl DurablePlane {
             return Err(format!("durable export {name} is not registered"));
         }
         let wrapped = encode_durable_export(name, source.as_ref());
+        let slot = self.dispatcher.reserve().map_err(|error| error.to_string())?;
         let task_id = next_task_id();
         self.catalog.register_module(task_id, wrapped.clone()).map_err(|err| err.to_string())?;
-        encode_run(self.dispatcher.start_module(task_id, &wrapped, input_json))
+        encode_run(self.dispatcher.start_module_reserved(task_id, &wrapped, input_json, slot))
     }
 
     pub fn send_signal(&self, task_id: &str, name: &str, payload_json: &str) -> Result<(), String> {
@@ -224,6 +257,26 @@ impl DurablePlane {
             .map_err(|err| err.to_string())
     }
 
+    pub fn health(&self) -> PollerHealth {
+        *self.health.borrow()
+    }
+
+    pub async fn failed(&self) -> DurablePlaneError {
+        let mut health = self.health.clone();
+        loop {
+            if *health.borrow_and_update() == PollerHealth::Failed {
+                return DurablePlaneError::Unavailable;
+            }
+            if health.changed().await.is_err() {
+                return DurablePlaneError::Unavailable;
+            }
+        }
+    }
+
+    pub fn stop_claiming(&self) {
+        self.shutdown.cancel();
+    }
+
     pub async fn shutdown(&self) -> Result<(), DurablePlaneError> {
         configure_durable_control(None);
         self.shutdown.cancel();
@@ -231,6 +284,9 @@ impl DurablePlane {
         if let Some(join) = join {
             join.await.map_err(PollerError::Join)??;
         }
+        if self.dispatcher.has_pending_completions() {
+            return Err(DurablePlaneError::Unavailable);
+        }
         Ok(())
     }
 }
@@ -309,6 +365,148 @@ mod tests {
     use super::*;
     use std::time::Duration;
 
+    #[tokio::test]
+    async fn scheduler_recovers_after_store_error_without_restart() {
+        let path = std::env::temp_dir().join(format!(
+            "tysel-poller-recovery-{}-{}.db",
+            std::process::id(),
+            unix_time_ms().unwrap()
+        ));
+        let store = Arc::new(SqliteStore::open(&path).unwrap());
+        let connection = rusqlite::Connection::open(&path).unwrap();
+        connection
+            .execute_batch("ALTER TABLE durable_programs RENAME TO temporarily_unavailable")
+            .unwrap();
+        let plane = DurablePlane::start(store.clone(), r#"
+            export default {durable:{async work(ctx) { await ctx.sleep(1); return await ctx.step('resumed', () => 42); }}};
+        "#.into(), IsolateConfig { cpu_ms_per_turn: 500, request_timeout_ms: 1_000, ..Default::default() }, "recovery").unwrap();
+        tokio::time::timeout(Duration::from_secs(2), async {
+            while !matches!(plane.health(), PollerHealth::Recovering { .. }) {
+                tokio::time::sleep(Duration::from_millis(5)).await;
+            }
+        })
+        .await
+        .unwrap();
+        assert!(plane.start_named("work", "null").is_err());
+        connection
+            .execute_batch("ALTER TABLE temporarily_unavailable RENAME TO durable_programs")
+            .unwrap();
+        tokio::time::timeout(Duration::from_secs(2), async {
+            while plane.health() != PollerHealth::Healthy {
+                tokio::time::sleep(Duration::from_millis(5)).await;
+            }
+        })
+        .await
+        .unwrap();
+        let started: JsonValue =
+            serde_json::from_str(&plane.start_named("work", "null").unwrap()).unwrap();
+        let id = parse_task_id(started["taskId"].as_str().unwrap()).unwrap();
+        tokio::time::timeout(Duration::from_secs(2), async {
+            while store.completion(id).unwrap().is_none() {
+                tokio::time::sleep(Duration::from_millis(10)).await;
+            }
+        })
+        .await
+        .unwrap();
+        assert_eq!(store.completion(id).unwrap().unwrap().value.as_f64(), Some(42.0));
+        assert_eq!(store.program_count().unwrap(), 0);
+        plane.shutdown().await.unwrap();
+        drop(connection);
+        drop(plane);
+        drop(store);
+        std::fs::remove_file(path).unwrap();
+    }
+
+    #[tokio::test]
+    async fn completion_write_failure_is_retried_without_replaying_handler() {
+        let path = std::env::temp_dir().join(format!(
+            "tysel-finalize-{}-{}.db",
+            std::process::id(),
+            unix_time_ms().unwrap()
+        ));
+        let store = Arc::new(SqliteStore::open(&path).unwrap());
+        let connection = rusqlite::Connection::open(&path).unwrap();
+        connection.execute_batch("CREATE TRIGGER fail_completion BEFORE INSERT ON durable_completions BEGIN SELECT * FROM temporarily_missing; END").unwrap();
+        let plane = DurablePlane::start(
+            store.clone(),
+            r#"
+            export default {durable:{async work(ctx) { await ctx.sleep(1); return 42; }}};
+        "#
+            .into(),
+            IsolateConfig { cpu_ms_per_turn: 500, request_timeout_ms: 1_000, ..Default::default() },
+            "finalize",
+        )
+        .unwrap();
+        let started: JsonValue =
+            serde_json::from_str(&plane.start_named("work", "null").unwrap()).unwrap();
+        let id = parse_task_id(started["taskId"].as_str().unwrap()).unwrap();
+        tokio::time::timeout(Duration::from_secs(2), async {
+            while !matches!(plane.health(), PollerHealth::Recovering { .. }) {
+                tokio::time::sleep(Duration::from_millis(5)).await;
+            }
+        })
+        .await
+        .unwrap();
+        assert!(store.wakeup(id).unwrap().is_none());
+        assert!(store.completion(id).unwrap().is_none());
+        assert!(plane.start_named("work", "null").is_err());
+        // Replay would now fail. Only writing the retained outcome may succeed.
+        connection.execute_batch("UPDATE durable_programs SET source = 'throw new Error(\"forbidden replay\")'; DROP TRIGGER fail_completion;").unwrap();
+        tokio::time::timeout(Duration::from_secs(3), async {
+            while store.completion(id).unwrap().is_none() || plane.health() != PollerHealth::Healthy
+            {
+                tokio::time::sleep(Duration::from_millis(10)).await;
+            }
+        })
+        .await
+        .unwrap();
+        assert_eq!(store.completion(id).unwrap().unwrap().value, serde_json::json!(42));
+        assert_eq!(store.program_count().unwrap(), 0);
+        plane.shutdown().await.unwrap();
+        drop(connection);
+        drop(plane);
+        drop(store);
+        std::fs::remove_file(path).unwrap();
+    }
+
+    #[tokio::test]
+    async fn corrupted_program_is_reported_to_service_owner() {
+        let path = std::env::temp_dir().join(format!(
+            "tysel-poller-fatal-{}-{}.db",
+            std::process::id(),
+            unix_time_ms().unwrap()
+        ));
+        let store = Arc::new(SqliteStore::open(&path).unwrap());
+        store.put_module(TaskId(1), "export default async () => 1", 0).unwrap();
+        store
+            .schedule_wakeup(tysel_durable::Wakeup {
+                task_id: TaskId(1),
+                sequence: 0,
+                wake_at_ms: 0,
+            })
+            .unwrap();
+        let connection = rusqlite::Connection::open(&path).unwrap();
+        connection
+            .execute_batch("UPDATE durable_programs SET source_sha256 = zeroblob(32)")
+            .unwrap();
+        let plane = DurablePlane::start(
+            store.clone(),
+            "export default {};".into(),
+            IsolateConfig::default(),
+            "fatal",
+        )
+        .unwrap();
+        let error = tokio::time::timeout(Duration::from_secs(2), plane.failed()).await.unwrap();
+        assert!(matches!(error, DurablePlaneError::Unavailable));
+        assert_eq!(plane.health(), PollerHealth::Failed);
+        assert!(plane.shutdown().await.is_err());
+        assert!(store.wakeup(TaskId(1)).unwrap().is_some());
+        drop(connection);
+        drop(plane);
+        drop(store);
+        std::fs::remove_file(path).unwrap();
+    }
+
     #[tokio::test]
     async fn named_export_survives_store_reopen() {
         let dir = std::env::temp_dir().join(format!(
diff --git a/crates/tysel-runtime/src/durable_poll.rs b/crates/tysel-runtime/src/durable_poll.rs
index 2700ee5..5c8dab1 100644
--- a/crates/tysel-runtime/src/durable_poll.rs
+++ b/crates/tysel-runtime/src/durable_poll.rs
@@ -145,9 +145,10 @@ impl DurableProgramCatalog {
         &self,
         now_ms: u64,
         kind: DurableProgramKind,
+        limit: usize,
     ) -> Result<Vec<(TaskId, Arc<str>)>, ProgramRegistryError> {
         self.store
-            .load_due_programs_by_kind(now_ms, kind)?
+            .load_due_programs_batch(now_ms, kind, limit)?
             .into_iter()
             .map(|program| Ok((program.task_id, Arc::from(program.source))))
             .collect()
@@ -179,13 +180,14 @@ impl ProgramSource {
     async fn snapshot(
         &self,
         execution: ProgramExecution,
+        limit: usize,
     ) -> Result<Vec<(TaskId, Arc<str>)>, PollerError> {
         match self {
             Self::Memory(registry) => Ok(registry.snapshot()?),
             Self::Persistent(catalog) => {
                 let catalog = catalog.clone();
                 tokio::task::spawn_blocking(move || {
-                    catalog.due_snapshot(unix_time_ms()?, execution.kind())
+                    catalog.due_snapshot(unix_time_ms()?, execution.kind(), limit)
                 })
                 .await
                 .map_err(PollerError::Join)?
@@ -289,8 +291,24 @@ impl DurablePoller {
         F: FnMut(),
     {
         let dispatcher = self.dispatcher.clone();
+        let completed = if dispatcher.has_pending_completions() {
+            let finalize_dispatcher = dispatcher.clone();
+            let (runs, error) =
+                tokio::task::spawn_blocking(move || finalize_dispatcher.retry_completions())
+                    .await
+                    .map_err(PollerError::Join)?;
+            if let Some(error) = error {
+                return Err(PollerError::Dispatch(error).with_runs(runs));
+            }
+            runs
+        } else {
+            Vec::new()
+        };
         let execution = self.execution;
-        let mut programs = self.programs.snapshot(execution).await?;
+        let mut programs = match self.programs.snapshot(execution, self.batch_size).await {
+            Ok(programs) => programs,
+            Err(error) => return Err(error.with_runs(completed)),
+        };
         let batch_size = self.batch_size;
         if !programs.is_empty() {
             let start = self.cursor.fetch_add(batch_size, Ordering::Relaxed) % programs.len();
@@ -298,10 +316,12 @@ impl DurablePoller {
         }
         let mut programs = programs.into_iter();
         let mut pending = JoinSet::new();
-        let mut runs = Vec::with_capacity(batch_size.min(programs.len()));
+        let mut runs = completed;
+        let mut failure = None;
         loop {
             let cancelled = shutdown.is_some_and(PollerShutdown::is_cancelled);
             while !cancelled
+                && failure.is_none()
                 && pending.len() < MAX_POLL_CONCURRENCY
                 && runs.len() + pending.len() < batch_size
             {
@@ -319,11 +339,31 @@ impl DurablePoller {
             let Some(joined) = pending.join_next().await else {
                 break;
             };
-            if let Some(run) = joined.map_err(PollerError::Join)?.map_err(PollerError::Dispatch)? {
-                runs.push(run);
+            match joined
+                .map_err(PollerError::Join)
+                .and_then(|result| result.map_err(PollerError::Dispatch))
+            {
+                Ok(Some(run)) => {
+                    if let Err(crate::DurableRunError::Store(error)) = run.result {
+                        if failure.is_none() {
+                            failure = Some(PollerError::Dispatch(DispatchError::Store(error)));
+                        }
+                    } else {
+                        runs.push(run);
+                    }
+                }
+                Ok(None) => {}
+                Err(error) => {
+                    if failure.is_none() {
+                        failure = Some(error);
+                    }
+                }
             }
         }
-        Ok(runs)
+        match failure {
+            Some(error) => Err(error.with_runs(runs)),
+            None => Ok(runs),
+        }
     }
 
     /// Poll immediately, then at `interval` until shutdown. An in-flight batch
@@ -335,6 +375,60 @@ impl DurablePoller {
         self.run_inner(shutdown, &mut on_run, &mut || {}).await
     }
 
+    pub async fn run_supervised<F, G>(
+        &self,
+        shutdown: PollerShutdown,
+        mut on_run: F,
+        mut on_health: G,
+    ) -> Result<(), PollerError>
+    where
+        F: FnMut(DurableRun) + Send,
+        G: FnMut(PollerHealth) + Send,
+    {
+        let mut attempt = 0u32;
+        loop {
+            if shutdown.is_cancelled() {
+                return Ok(());
+            }
+            let batch = self
+                .poll_batch(Some(&shutdown), &mut || {})
+                .await
+                .map_err(|error| error.deliver_runs(&mut on_run));
+            let delay = match batch {
+                Ok(runs) => {
+                    if attempt > 0 {
+                        on_health(PollerHealth::Healthy);
+                    }
+                    attempt = 0;
+                    for run in runs {
+                        on_run(run);
+                    }
+                    self.interval
+                }
+                Err(error) if error.is_retryable() => {
+                    attempt = attempt.saturating_add(1);
+                    on_health(PollerHealth::Recovering { attempt });
+                    let base_ms =
+                        200u64.saturating_mul(1 << attempt.saturating_sub(1).min(5)).min(5_000);
+                    let jitter = SystemTime::now()
+                        .duration_since(UNIX_EPOCH)
+                        .unwrap_or_default()
+                        .subsec_nanos() as u64
+                        % (base_ms / 4 + 1);
+                    Duration::from_millis(base_ms + jitter)
+                }
+                Err(error) => {
+                    on_health(PollerHealth::Failed);
+                    return Err(error);
+                }
+            };
+            tokio::select! {
+                () = shutdown.cancelled() => return Ok(()),
+                () = tokio::time::sleep(delay) => {}
+            }
+        }
+    }
+
     async fn run_inner<F, G>(
         &self,
         shutdown: PollerShutdown,
@@ -349,7 +443,11 @@ impl DurablePoller {
             if shutdown.is_cancelled() {
                 return Ok(());
             }
-            for run in self.poll_batch(Some(&shutdown), on_dispatch).await? {
+            for run in self
+                .poll_batch(Some(&shutdown), on_dispatch)
+                .await
+                .map_err(|error| error.deliver_runs(on_run))?
+            {
                 on_run(run);
             }
             tokio::select! {
@@ -360,6 +458,13 @@ impl DurablePoller {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PollerHealth {
+    Healthy,
+    Recovering { attempt: u32 },
+    Failed,
+}
+
 #[derive(Clone)]
 pub struct PollerShutdown {
     sender: watch::Sender<bool>,
@@ -423,6 +528,14 @@ fn unix_time_ms() -> Result<u64, ProgramRegistryError> {
 
 #[derive(Debug, thiserror::Error)]
 pub enum PollerError {
+    /// A failed batch can still contain completed or suspended runs. Callers of
+    /// poll_once must consume these outcomes; supervised loops deliver them automatically.
+    #[error("{source}")]
+    PartialBatch {
+        runs: Vec<DurableRun>,
+        #[source]
+        source: Box<PollerError>,
+    },
     #[error("durable poll interval must be greater than zero")]
     InvalidInterval,
     #[error("durable poll batch must be 1..={MAX_POLL_BATCH}")]
@@ -435,6 +548,33 @@ pub enum PollerError {
     Join(tokio::task::JoinError),
 }
 
+impl PollerError {
+    fn with_runs(self, runs: Vec<DurableRun>) -> Self {
+        if runs.is_empty() { self } else { Self::PartialBatch { runs, source: Box::new(self) } }
+    }
+
+    fn deliver_runs(self, on_run: &mut impl FnMut(DurableRun)) -> Self {
+        match self {
+            Self::PartialBatch { runs, source } => {
+                for run in runs {
+                    on_run(run);
+                }
+                source.deliver_runs(on_run)
+            }
+            error => error,
+        }
+    }
+
+    fn is_retryable(&self) -> bool {
+        match self {
+            Self::PartialBatch { source, .. } => source.is_retryable(),
+            Self::Registry(ProgramRegistryError::Store(error))
+            | Self::Dispatch(DispatchError::Store(error)) => error.is_retryable(),
+            _ => false,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -502,6 +642,61 @@ mod tests {
             .unwrap();
     }
 
+    #[tokio::test]
+    async fn partial_batch_and_later_catalog_failure_preserve_completed_runs() {
+        let path = std::env::temp_dir().join(format!(
+            "tysel-partial-batch-{}-{}.db",
+            std::process::id(),
+            unix_time_ms()
+        ));
+        let store = Arc::new(SqliteStore::open(&path).unwrap());
+        let connection = rusqlite::Connection::open(&path).unwrap();
+        for (id, value) in [(TaskId(991), "a"), (TaskId(992), "b")] {
+            store
+                .put_program(
+                    id,
+                    &format!(
+                        "(async () => {{ await tysel.durable.sleep(1); return '{value}'; }})()"
+                    ),
+                    0,
+                )
+                .unwrap();
+            seed_due_sleep(&store, id);
+        }
+        connection
+            .execute_batch(
+                r#"CREATE TRIGGER fail_b BEFORE INSERT ON durable_completions
+            WHEN NEW.result_json = '"b"' BEGIN SELECT json('malformed'); END;"#,
+            )
+            .unwrap();
+        let dispatcher = dispatcher(store.clone(), "partial");
+        let poller =
+            DurablePoller::new_persistent(dispatcher.clone(), Duration::from_millis(10), 8)
+                .unwrap();
+        let error = poller.poll_once().await.unwrap_err();
+        let mut delivered = Vec::new();
+        assert!(error.deliver_runs(&mut |run| delivered.push(run.task_id)).is_retryable());
+        assert_eq!(delivered, vec![TaskId(991)]);
+        assert!(store.completion(TaskId(991)).unwrap().is_some());
+        assert!(store.completion(TaskId(992)).unwrap().is_none());
+        connection.execute_batch("DROP TRIGGER fail_b").unwrap();
+        // The retry succeeds, but discovery of a different due program fails.
+        // The retry's result must remain available in the error, exactly once.
+        store.put_program(TaskId(993), "42", 0).unwrap();
+        seed_due_sleep(&store, TaskId(993));
+        connection.execute_batch("UPDATE durable_programs SET source = 'bad hash' WHERE task_id = X'000000000000000000000000000003e1'").unwrap();
+        let error = poller.poll_once().await.unwrap_err();
+        assert!(!error.deliver_runs(&mut |run| delivered.push(run.task_id)).is_retryable());
+        assert_eq!(delivered, vec![TaskId(991), TaskId(992)]);
+        assert!(!dispatcher.has_pending_completions());
+        assert!(store.completion(TaskId(992)).unwrap().is_some());
+        drop(connection);
+        drop(poller);
+        drop(dispatcher);
+        drop(store);
+        std::fs::remove_file(path).unwrap();
+    }
+
     #[test]
     fn registry_updates_and_removes_bounded_programs() {
         let registry = DurableProgramRegistry::default();
diff --git a/crates/tysel-runtime/src/lib.rs b/crates/tysel-runtime/src/lib.rs
index 1619171..3e956f3 100644
--- a/crates/tysel-runtime/src/lib.rs
+++ b/crates/tysel-runtime/src/lib.rs
@@ -18,8 +18,8 @@ pub use durable::{
 };
 pub use durable_plane::{DurablePlane, DurablePlaneError};
 pub use durable_poll::{
-    DurablePoller, DurableProgramCatalog, DurableProgramRegistry, PollerError, PollerShutdown,
-    ProgramRegistryError,
+    DurablePoller, DurableProgramCatalog, DurableProgramRegistry, PollerError, PollerHealth,
+    PollerShutdown, ProgramRegistryError,
 };
 pub use http::{
     AppIsolate, HttpError, HttpLimits, HttpShutdown, RuntimeDiagnostic, RuntimeDiagnosticSink,
diff --git a/crates/tysel-runtime/src/service.rs b/crates/tysel-runtime/src/service.rs
index 899f057..ccef587 100644
--- a/crates/tysel-runtime/src/service.rs
+++ b/crates/tysel-runtime/src/service.rs
@@ -322,14 +322,23 @@ pub async fn run_tap(tap: Tap) -> Result<(), StubError> {
                 None => std::future::pending().await,
             }
         } => Err(error.into()),
+        error = async {
+            match &durable { Some(plane) => plane.failed().await, None => std::future::pending().await }
+        } => Err(error.into()),
         signal = shutdown_signal() => signal.map_err(Into::into),
     };
     #[cfg(not(unix))]
     let outcome: Result<(), StubError> = tokio::select! {
         result = &mut server => { server_finished = true; result.map_err(Into::into) }
+        error = async {
+            match &durable { Some(plane) => plane.failed().await, None => std::future::pending().await }
+        } => Err(error.into()),
         signal = shutdown_signal() => signal.map_err(Into::into),
     };
     shutdown.cancel();
+    if let Some(plane) = &durable {
+        plane.stop_claiming();
+    }
     // Keep capability and durable hooks alive while admitted HTTP handlers finish.
     let http_result = if server_finished { Ok(()) } else { server.await };
     let durable_result = shutdown_durable(durable.as_ref()).await;
diff --git a/docs/operations/production.md b/docs/operations/production.md
index 3938c00..9c03c92 100644
--- a/docs/operations/production.md
+++ b/docs/operations/production.md
@@ -105,7 +105,7 @@ Shutdown:
 4. If the process remains, capture logs and process state before forcing it.
 
 On SIGTERM or Ctrl-C, packaged services and `tysel run` close the listener,
-drain HTTP/1 and HTTP/2 connections. Idle sockets
+stop new durable claims, and drain HTTP/1 and HTTP/2 connections. Idle sockets
 close immediately. WebSockets receive close code 1001 (Going Away) when the
 transport can send it. Connections that remain after `request_timeout_ms +
 1000` milliseconds are closed forcibly. This HTTP grace is shared across
@@ -115,6 +115,50 @@ path, with enough grace for the largest timeout seen during reloads.
 
 Clean shutdown flushes OTLP providers and stops the service-owned task plane.
 
+Durable storage availability errors move the scheduler to `recovering`, with
+exponential retry from 200 ms to a 5-second base plus at most 25% jitter. New
+durable starts fail while recovery is pending. A successful poll restores
+`healthy`. Unrecoverable store/scheduler failures, such as a corrupt program
+digest, reach the service owner, which drains and exits unsuccessfully.
+Completion-write availability failures retain the JSON outcome in memory and retry
+persistence without rerunning the handler. At most 32 active executions and pending
+finalizations share reserved slots. Pending entries retain compact results and
+lease/sequence metadata, releasing consumed replay history. `completion_pending`
+logs the affected task ID. Completed outcomes are still reported when a different
+task in the same scheduling batch encounters a storage failure.
+Retries remain subject to the original lease; lease expiry or shutdown with pending
+outcomes reports failure and needs operator investigation. This does not provide
+recovery after process death: active task restart eligibility and atomic application
+admission/signal delivery remain release blockers (G1/G2).
+
+Per-task execution failures are logged as `task_failed`; they do not by
+themselves stop unrelated work. These states
+and task outcomes are bounded `durable` log events containing task IDs and
+attempt counts, without payloads, source, or database credentials. An HTTP-only
+health route may still succeed during recovery; use scheduler diagnostics for
+durable health.
+
+### Durable log v2 upgrade
+
+This release migrates durable log v1 to v2 transactionally on store open. The
+application manifest schema remains version 1. Before upgrading:
+
+1. Drain and stop **all** old writers and schedulers.
+2. Back up the complete durable store and verify that it can be restored.
+3. Start the new release or its admin command; verify replay and completion.
+4. Resume traffic only after those checks pass.
+
+Do not run old and new writers together. Old runtimes reject v2 on startup;
+rollback requires restoring the pre-upgrade snapshot and its matching release.
+Existing v1 programs remain active unless a new execution explicitly completes
+them. An absent wakeup is not proof of completion. Completion results and the
+active catalog counters persist across reopen. Retained data is removed only
+by [`tysel durable prune`](../reference/cli/tasks.md#tysel-durable).
+
+Failed executions and interrupted runs without an explicit completion are
+retained for investigation. This change does not add automatic replay of
+orphaned runs or an exactly-once external-effect guarantee.
+
 ## Durable Postgres backup and restore
 
 Use PostgreSQL for production durable state. SQLite is a local or single-writer
@@ -131,7 +175,7 @@ storage option, not a shared multi-replica durable backend.
 5. Resume writers only after durable backup completion.
 
 The backup must contain all Tysel durable tables, including metadata, programs,
-events, wakeups, signals, task locks, and statistics. Do not copy selected task
+events, wakeups, signals, completions, task locks, and statistics. Do not copy selected task
 rows or individual tables.
 
 ### Restore
diff --git a/docs/reference/cli/index.md b/docs/reference/cli/index.md
index f40bef6..2d66703 100644
--- a/docs/reference/cli/index.md
+++ b/docs/reference/cli/index.md
@@ -38,7 +38,7 @@ tysel run --manifest services/worker/tysel.toml
 | --- | --- |
 | Project setup | [`init`, `config`](project.md) |
 | Development | [`check`, `types`, `compat`, `test`, `dev`, `run`, `inspect`](development.md) |
-| Tasks and protocols | [`task`, `queue`, `mcp`](tasks.md) |
+| Tasks and protocols | [`task`, `queue`, `mcp`, `durable`](tasks.md) |
 | Delivery | [`build`, `image`](delivery.md) |
 | Installation | [`doctor`, `upgrade`](installation.md) |
 | Evidence | [`bench`, `release`](evidence.md) |
diff --git a/docs/reference/cli/tasks.md b/docs/reference/cli/tasks.md
index d7fe0ab..7b44573 100644
--- a/docs/reference/cli/tasks.md
+++ b/docs/reference/cli/tasks.md
@@ -55,3 +55,42 @@ from `kind: "mcp"` entries in the application's `tasks` export.
 
 See [Application module](../runtime/application.md) for queue and MCP handler
 types and [Limits and defaults](../limits-and-defaults.md) for protocol bounds.
+
+
+## `tysel durable`
+
+Inspect retained results or delete a bounded batch of completed history from
+the selected project's durable store. The application is not loaded or executed.
+
+```sh
+tysel -C services/worker durable result 00000000000000000000000000000001
+tysel -C services/worker durable prune --older-than-secs 604800 --limit 32
+```
+
+`--manifest FILE` is also accepted. Store selection follows the runtime:
+`TYSEL_DURABLE_POSTGRES_URL` takes precedence, then `TYSEL_DURABLE_SQLITE_PATH`,
+then the `durable-events.db` beside the manifest's SQLite capability path.
+An absent SQLite event store is an error; the command does not create it.
+
+`result` writes JSON with `taskId` and `completion`. A retained completion has
+`status: "completed"`, `value`, and `completedAtMs`. A null completion means no
+retained result is available; it does not distinguish an active, failed,
+unknown, or previously pruned task.
+
+`prune` defaults to retaining seven days and deleting at most 32 tasks. The
+limit must be 1–100. Only explicit completions strictly older than the cutoff
+are eligible; pending wakeups, leases, and signal waits prevent deletion. A
+batch also stops at 16 MiB of retained program, result, history, and inbox
+payload, allowing one larger task so cleanup can progress. The JSON report
+contains `deleted`, `beforeMs`, and `limit`. A batch may delete fewer than its
+limit; repeat it deliberately if more cleanup is needed.
+
+Pruning permanently removes the selected result, program, events, and inbox.
+It does not cancel active tasks or automatically compact database files.
+PostgreSQL retains a small per-task synchronization row to keep concurrent
+writers safe. Do not reuse pruned task IDs: completion deduplication is retained
+only until pruning. There is no automatic retention timer.
+
+Opening a store, including through these commands, migrates durable log v1 to
+v2. Follow the [upgrade procedure](../../operations/production.md#durable-log-v2-upgrade)
+before pointing this release at an existing store.
diff --git a/docs/reference/limits-and-defaults.md b/docs/reference/limits-and-defaults.md
index 886b1f3..b286d6e 100644
--- a/docs/reference/limits-and-defaults.md
+++ b/docs/reference/limits-and-defaults.md
@@ -82,9 +82,15 @@ request limit. The smaller applicable bound wins.
 | History | 10,000 events and 16 MiB |
 | Pending signal inbox | 1,000 signals and 16 MiB |
 | One durable program | 1 MiB |
-| Program catalog | 10,000 programs and 64 MiB total |
+| Active program catalog | 10,000 programs and 64 MiB total source |
+| Retained completion result | 1 MiB per task |
+| Retention cleanup | At most 100 tasks; 16 MiB of retained payload per batch, or one larger task |
 | Concurrent durable polling | 16 |
 
+Completed programs and history remain stored until explicit cleanup, but do
+not consume the active catalog quota. Legacy records without an explicit
+completion remain active. See [Durable administration](cli/tasks.md#tysel-durable).
+
 ## LLM bounds
 
 | Surface | Current implementation bound |
diff --git a/docs/reference/runtime/durable.md b/docs/reference/runtime/durable.md
index af3ab8e..271e00f 100644
--- a/docs/reference/runtime/durable.md
+++ b/docs/reference/runtime/durable.md
@@ -76,7 +76,14 @@ tysel.durable.sendSignal(status.taskId, "approval", { approved: true });
 ```
 
 `start` returns either a completed result or a suspended status.
-`sendSignal` appends a JSON signal for a waiting workflow.
+`sendSignal` appends a JSON signal for a waiting workflow. Once a registered
+workflow completes successfully, its JSON result is persisted and its active
+program quota is released. Its program and replay history remain retained.
+Later writes or signals to a retained completed task are rejected.
+
+Use [`tysel durable result` and `tysel durable prune`](../cli/tasks.md#tysel-durable)
+to read a retained result or remove an aged batch. Failed and legacy tasks are
+never inferred complete from the absence of a wakeup.
 
 Durable inputs and results are limited to 1 MiB, with additional history,
 signal, and program bounds listed under [Limits and defaults](../limits-and-defaults.md).
diff --git a/tests/p1/acceptance.py b/tests/p1/acceptance.py
new file mode 100644
index 0000000..12749d9
--- /dev/null
+++ b/tests/p1/acceptance.py
@@ -0,0 +1,169 @@
+"""Opt-in P1 fault acceptance using a disposable local fixture.
+
+Build the debug CLI and service first. Run directly for packaged mode, or set
+TYSEL_P1_USE_RUN=1 for the CLI server. The JSON result identifies the retained
+temporary fixture and logs. No existing application or database is modified.
+"""
+import concurrent.futures
+import http.client
+import json
+import os
+from pathlib import Path
+import signal
+import socket
+import sqlite3
+import subprocess
+import tempfile
+import time
+
+REPO = Path(__file__).resolve().parents[2]
+ROOT = Path(tempfile.mkdtemp(prefix='tysel-assessment-'))
+CLI = REPO / 'target/debug/tysel'
+STUB = REPO / 'target/debug/tysel-service'
+results = {'source_commit': '28aa78f + P1 working changes', 'fixture': str(ROOT)}
+source = '''export default {
+  durable: {
+    async done(ctx, input) { return {done: true}; },
+    async delayed(ctx, input) {
+      await ctx.sleep(50);
+      return await ctx.step("resumed", () => 1);
+    }
+  },
+  async fetch(request) {
+    const path = new URL(request.url).pathname;
+    if (path === "/error") throw new Error("ASSESSMENT_SENTINEL_PRIVATE_DETAILS");
+    if (path === "/slow") await new Promise(resolve => setTimeout(resolve, 350));
+    if (path === "/start") return Response.json(tysel.durable.start("done", {}));
+    if (path === "/schedule") return Response.json(tysel.durable.start("delayed", {}));
+    return new Response("ok");
+  }
+};'''
+(ROOT / 'index.js').write_text(source)
+with socket.socket() as sock:
+    sock.bind(('127.0.0.1', 0))
+    port = sock.getsockname()[1]
+(ROOT / 'tysel.toml').write_text(f'''schema_version = 1
+[app]
+name = "assessment"
+entry = "index.js"
+profile = "service"
+[server]
+listen = "127.0.0.1:{port}"
+workers = 1
+[limits]
+cpu_ms_per_turn = 500
+request_timeout_ms = 500
+max_in_flight = 10
+[durable]
+store = "sqlite"
+path = "./data/tysel.db"
+[observability]
+logs = "json"
+''')
+env = os.environ.copy()
+for key in list(env):
+    if key.startswith('TYSEL_DURABLE_') or key.startswith('OTEL_'):
+        del env[key]
+env['OTEL_SDK_DISABLED'] = 'true'
+build = subprocess.run([str(CLI), '-C', str(ROOT), 'build', '--stub', str(STUB), '--output', str(ROOT / 'app')], capture_output=True, text=True, env=env)
+results['build'] = {'returncode': build.returncode, 'stdout': build.stdout, 'stderr': build.stderr}
+if build.returncode:
+    print(json.dumps(results, indent=2))
+    raise SystemExit(1)
+
+def request(path):
+    started = time.monotonic()
+    conn = http.client.HTTPConnection('127.0.0.1', port, timeout=3)
+    try:
+        conn.request('GET', path)
+        response = conn.getresponse()
+        return {'status': response.status, 'body': response.read().decode(), 'elapsed_ms': round((time.monotonic()-started)*1000)}
+    except Exception as error:
+        return {'error': type(error).__name__ + ': ' + str(error), 'elapsed_ms': round((time.monotonic()-started)*1000)}
+    finally:
+        conn.close()
+
+log = open(ROOT / 'service.log', 'w')
+process = subprocess.Popen(([str(CLI), '-C', str(ROOT), 'run'] if os.environ.get('TYSEL_P1_USE_RUN') else [str(ROOT / 'app')]), cwd=ROOT, stdout=log, stderr=log, env=env)
+try:
+    for _ in range(100):
+        if request('/') .get('status') == 200:
+            break
+        if process.poll() is not None:
+            raise RuntimeError('service exited at startup')
+        time.sleep(.05)
+    results['error_response'] = request('/error')
+    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+        results['queued_requests'] = list(executor.map(request, ['/slow'] * 3))
+    results['completed_starts'] = [request('/start') for _ in range(3)]
+    db = sqlite3.connect(ROOT / 'data/durable-events.db', timeout=3)
+    results['retained_after_completion'] = {
+        'programs': db.execute('SELECT COUNT(*) FROM durable_programs').fetchone()[0],
+        'active_programs': db.execute('SELECT active_count FROM durable_program_stats').fetchone()[0],
+        'completions': db.execute('SELECT COUNT(*) FROM durable_completions').fetchone()[0],
+        'events': db.execute('SELECT COUNT(*) FROM durable_events').fetchone()[0],
+        'wakeups': db.execute('SELECT COUNT(*) FROM durable_wakeups').fetchone()[0]
+    }
+    # Fault injection affects only this disposable fixture's SQLite database.
+    db.execute('ALTER TABLE durable_programs RENAME TO assessment_programs_temporarily_unavailable')
+    db.commit()
+    time.sleep(.6)
+    db.execute('ALTER TABLE assessment_programs_temporarily_unavailable RENAME TO durable_programs')
+    db.commit()
+    for attempt in range(60):
+        resumed = request('/schedule')
+        if resumed.get('status') == 200:
+            break
+        time.sleep(.1)
+    results['start_after_store_recovery'] = resumed
+    time.sleep(.9)
+    results['after_store_recovery'] = {
+        'http': request('/'),
+        'pending_wakeups': db.execute('SELECT COUNT(*) FROM durable_wakeups').fetchone()[0],
+        'resumed_steps': db.execute("SELECT COUNT(*) FROM durable_events WHERE event_key = 'resumed'").fetchone()[0],
+        'process_alive': process.poll() is None
+    }
+    db.close()
+finally:
+    if process.poll() is None:
+        process.terminate()
+        try:
+            process.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait()
+    log.close()
+results['service_log'] = (ROOT / 'service.log').read_text()
+
+# Start a fresh instance so the shutdown observation is independent of the fault injection.
+log = open(ROOT / 'shutdown.log', 'w')
+process = subprocess.Popen(([str(CLI), '-C', str(ROOT), 'run'] if os.environ.get('TYSEL_P1_USE_RUN') else [str(ROOT / 'app')]), cwd=ROOT, stdout=log, stderr=log, env=env)
+try:
+    for _ in range(100):
+        if request('/').get('status') == 200:
+            break
+        time.sleep(.05)
+    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+        pending = executor.submit(request, '/slow')
+        time.sleep(.1)
+        process.send_signal(signal.SIGTERM)
+        results['inflight_request_at_sigterm'] = pending.result()
+finally:
+    if process.poll() is None:
+        process.terminate()
+        try:
+            process.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait()
+    log.close()
+assert results['error_response']['status'] == 500
+assert 'ASSESSMENT_SENTINEL' not in results['error_response']['body']
+assert sorted(r['status'] for r in results['queued_requests']) == [200,504,504]
+assert max(r['elapsed_ms'] for r in results['queued_requests']) < 750
+assert results['retained_after_completion']['active_programs'] == 0
+assert results['retained_after_completion']['completions'] == 3
+assert results['after_store_recovery']['resumed_steps'] == 1
+assert results['inflight_request_at_sigterm']['status'] == 200
+(ROOT / 'results.json').write_text(json.dumps(results, indent=2))
+print(json.dumps(results, indent=2))
diff --git a/tests/p1/review_regressions.py b/tests/p1/review_regressions.py
new file mode 100644
index 0000000..e2f1251
--- /dev/null
+++ b/tests/p1/review_regressions.py
@@ -0,0 +1,269 @@
+"""Opt-in loopback regression gates for the P1 review follow-up.
+
+Run from any directory after building tysel and tysel-worker. Uses disposable
+SQLite files and sends signals only to child workers of its own test service.
+Temporary fixtures and timing samples are retained for inspection.
+"""
+import http.client
+import json
+import os
+from pathlib import Path
+import signal
+import socket
+import sqlite3
+import subprocess
+import tempfile
+import time
+
+REPO = Path(__file__).resolve().parents[2]
+ROOT = Path(tempfile.mkdtemp(prefix="tysel-review-gates-"))
+
+
+class Service:
+    def __init__(self, name, source, settings):
+        self.root = ROOT / name
+        self.root.mkdir()
+        with socket.socket() as sock:
+            sock.bind(("127.0.0.1", 0))
+            self.port = sock.getsockname()[1]
+        (self.root / "index.js").write_text(source)
+        (self.root / "tysel.toml").write_text(
+            f'[app]\nname="{name}"\nentry="index.js"\n' + settings.format(port=self.port)
+        )
+        env = {k: v for k, v in os.environ.items()
+               if not k.startswith(("TYSEL_DURABLE_", "OTEL_"))}
+        env.update(OTEL_SDK_DISABLED="true", TYSEL_WORKER=str(REPO / "target/debug/tysel-worker"))
+        self.log = (self.root / "service.log").open("w")
+        self.process = subprocess.Popen(
+            [str(REPO / "target/debug/tysel"), "-C", str(self.root), "run"],
+            stdout=self.log, stderr=self.log, env=env,
+        )
+
+    def __enter__(self):
+        try:
+            deadline = time.monotonic() + 60
+            while time.monotonic() < deadline:
+                assert self.process.poll() is None, (self.root / "service.log").read_text()
+                try:
+                    if self.request("/")[0] == 200:
+                        return self
+                except OSError:
+                    pass
+                time.sleep(.05)
+            raise AssertionError("service did not become ready")
+        except BaseException:
+            self.__exit__(None, None, None)
+            raise
+
+    def request(self, path):
+        connection = http.client.HTTPConnection("127.0.0.1", self.port, timeout=15)
+        start = time.monotonic()
+        try:
+            connection.request("GET", path)
+            response = connection.getresponse()
+            body = response.read().decode()
+            return response.status, body, (time.monotonic() - start) * 1000
+        finally:
+            connection.close()
+
+    def workers(self):
+        children = subprocess.run(["pgrep", "-P", str(self.process.pid)],
+                                  capture_output=True, text=True).stdout.split()
+        return [int(pid) for pid in children if "tysel-worker" in subprocess.run(
+            ["ps", "-p", pid, "-o", "comm="], capture_output=True, text=True).stdout]
+
+    def __exit__(self, *_):
+        if self.process.poll() is None:
+            for pid in self.workers():
+                try:
+                    os.kill(pid, signal.SIGKILL)
+                except ProcessLookupError:
+                    pass
+            self.process.terminate()
+            try:
+                self.process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.process.kill()
+                self.process.wait()
+        self.log.close()
+
+
+def durable_gate():
+    settings = '''[server]
+listen="127.0.0.1:{port}"
+[limits]
+memory_mb=256
+cpu_ms_per_turn=4000
+request_timeout_ms=10000
+[durable]
+store="sqlite"
+path="./data/app.db"
+[observability]
+logs="json"
+'''
+    source = '''export default {
+      durable: {
+        async large(){return Array(300000).fill(0)},
+        async delayed(ctx){await ctx.sleep(100);return 42}
+      },
+      fetch(req){const name=new URL(req.url).pathname.slice(1);
+        return name ? Response.json(tysel.durable.start(name,null)) : new Response('ready');}
+    };'''
+    with Service("durable", source, settings) as service:
+        status, body, elapsed = service.request("/large")
+        assert status == 200, body
+        assert len(json.loads(body)["value"]) == 300000
+        with sqlite3.connect(service.root / "data/durable-events.db") as db:
+            db.execute("CREATE TRIGGER fail_completion BEFORE INSERT ON durable_completions "
+                       "BEGIN SELECT * FROM missing_test_table; END")
+            db.commit()
+            status, body, _ = service.request("/delayed")
+            assert status == 200, body
+            task = bytes.fromhex(json.loads(body)["taskId"])
+            deadline = time.monotonic() + 3
+            while '"state":"recovering"' not in (service.root / "service.log").read_text():
+                assert time.monotonic() < deadline, "scheduler did not report storage failure"
+                time.sleep(.01)
+            assert db.execute("SELECT count(*) FROM durable_completions WHERE task_id=?", (task,)).fetchone()[0] == 0
+            assert db.execute("SELECT count(*) FROM durable_wakeups WHERE task_id=?", (task,)).fetchone()[0] == 0
+            # Any attempt to reload this program would fail its source hash check.
+            db.execute("UPDATE durable_programs SET source='throw 42' WHERE task_id=?", (task,))
+            db.execute("DROP TRIGGER fail_completion")
+            db.commit()
+            deadline = time.monotonic() + 4
+            while db.execute("SELECT count(*) FROM durable_completions WHERE task_id=?", (task,)).fetchone()[0] != 1:
+                assert time.monotonic() < deadline, "completion never recovered"
+                time.sleep(.02)
+        return {"large_result_status": status, "large_result_ms": elapsed, "completion_recovered": True}
+
+
+def isolated_gate():
+    settings = '''profile="isolated"
+[server]
+listen="127.0.0.1:{port}"
+[limits]
+memory_mb=16
+cpu_ms_per_turn=200
+request_timeout_ms=300
+'''
+    source = "let n=0;export default {fetch(req){if(new URL(req.url).pathname==='/mutate')n++;return new Response(String(n));}}"
+    with Service("isolated", source, settings) as service:
+        pid, = service.workers()
+        samples = []
+        for _ in range(200):
+            status, _, elapsed = service.request("/count")
+            assert status == 200
+            samples.append(elapsed)
+        assert service.workers() == [pid], "normal requests should reuse their worker"
+        os.kill(pid, signal.SIGSTOP)
+        status, _, elapsed = service.request("/mutate")
+        assert status == 504 and elapsed < 1000, (status, elapsed)
+        time.sleep(.1)
+        assert pid not in service.workers(), "timed-out frozen worker is still alive"
+        assert service.request("/count")[:2] == (200, "0")
+        replacement, = service.workers()
+        os.kill(replacement, signal.SIGSTOP)
+        assert service.request("/mutate")[0] == 504
+        start = time.monotonic()
+        service.process.terminate()
+        service.process.wait(timeout=2)
+        samples.sort()
+        return {"timeout_ms": elapsed, "shutdown_ms": (time.monotonic() - start) * 1000,
+                "debug_loopback_p50_ms": samples[len(samples)//2],
+                "debug_loopback_p95_ms": samples[int(len(samples)*.95)],
+                "latency_samples_ms": samples, "worker_reaped": True}
+
+
+
+def finalization_read_gate():
+    settings = """[server]
+listen="127.0.0.1:{port}"
+[limits]
+memory_mb=32
+cpu_ms_per_turn=500
+request_timeout_ms=4000
+[durable]
+store="sqlite"
+path="./data/app.db"
+[observability]
+logs="json"
+"""
+    source = """export default {
+      durable:{async work(ctx){await ctx.sleep(100);await new Promise(r=>setTimeout(r,1200));return 42;}},
+      fetch(req){return new URL(req.url).pathname==='/'?new Response('ok'):Response.json(tysel.durable.start('work',null));}
+    };"""
+    with Service("finalization-read", source, settings) as service:
+        status, body, _ = service.request("/start")
+        assert status == 200, body
+        task = bytes.fromhex(json.loads(body)["taskId"])
+        with sqlite3.connect(service.root / "data/durable-events.db") as db:
+            deadline = time.monotonic() + 3
+            while db.execute("SELECT count(*) FROM durable_wakeups WHERE task_id=?", (task,)).fetchone()[0]:
+                assert time.monotonic() < deadline
+                time.sleep(.005)
+            db.execute("ALTER TABLE durable_signal_waits RENAME TO unavailable_waits")
+            db.commit()
+            deadline = time.monotonic() + 3
+            while '"state":"recovering"' not in (service.root / "service.log").read_text():
+                assert time.monotonic() < deadline, "finalization read fault was not supervised"
+                time.sleep(.01)
+            db.execute("ALTER TABLE unavailable_waits RENAME TO durable_signal_waits")
+            db.execute("UPDATE durable_programs SET source='throw 42' WHERE task_id=?", (task,))
+            db.commit()
+            deadline = time.monotonic() + 3
+            while db.execute("SELECT count(*) FROM durable_completions WHERE task_id=?", (task,)).fetchone()[0] != 1:
+                assert time.monotonic() < deadline, "result was lost after finalization read failure"
+                time.sleep(.01)
+        assert '"state":"completion_pending"' in (service.root / "service.log").read_text()
+        return {"recovered_without_replay": True}
+
+
+def partial_batch_gate():
+    settings = """[server]
+listen="127.0.0.1:{port}"
+[limits]
+memory_mb=32
+cpu_ms_per_turn=500
+request_timeout_ms=4000
+[durable]
+store="sqlite"
+path="./data/app.db"
+[observability]
+logs="json"
+"""
+    source = """export default {
+      durable:{async work(ctx,input){await ctx.sleep(500);return input;}},
+      fetch(req){let p=new URL(req.url).pathname;return p==='/'?new Response('ok'):Response.json(tysel.durable.start('work',p==='/a'?1:2));}
+    };"""
+    with Service("partial-batch", source, settings) as service:
+        with sqlite3.connect(service.root / "data/durable-events.db") as db:
+            db.execute("CREATE TRIGGER fail_second BEFORE INSERT ON durable_completions "
+                       "WHEN NEW.result_json='2' BEGIN SELECT json('malformed'); END")
+            db.commit()
+            task_ids = [json.loads(service.request(path)[1])["taskId"] for path in ("/a", "/b")]
+            deadline = time.monotonic() + 3
+            while '"state":"recovering"' not in (service.root / "service.log").read_text():
+                assert time.monotonic() < deadline
+                time.sleep(.01)
+            db.execute("DROP TRIGGER fail_second")
+            db.commit()
+            deadline = time.monotonic() + 3
+            while db.execute("SELECT count(*) FROM durable_completions").fetchone()[0] != 2:
+                assert time.monotonic() < deadline
+                time.sleep(.01)
+        # Allow the completion callback following the transaction to finish.
+        deadline = time.monotonic() + 1
+        while True:
+            events = [json.loads(line) for line in (service.root / "service.log").read_text().splitlines() if line.startswith("{")]
+            completed = [event["taskId"] for event in events if event.get("state") == "completed"]
+            if sorted(completed) == sorted(task_ids):
+                break
+            assert time.monotonic() < deadline, (task_ids, completed)
+            time.sleep(.01)
+        return {"completion_notifications": len(completed), "exactly_once_per_task": True}
+
+if __name__ == "__main__":
+    result = {"fixture": str(ROOT), "durable": durable_gate(), "isolated": isolated_gate(),
+              "finalization_read": finalization_read_gate(), "partial_batch": partial_batch_gate()}
+    (ROOT / "results.json").write_text(json.dumps(result, indent=2))
+    print(json.dumps(result, indent=2))

From e83a7cee2c12389965e10613f160bdddbbba9519 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Tue, 8 Sep 2026 14:45:09 +0800
Subject: [PATCH 21/31] fix(durable): validate completion leases inside storage
 transactions

Pass lease deadlines into SQLite and PostgreSQL completion transactions. Check fresh time after acquiring locks and before commit, rolling back result and quota changes on expiry while preserving identical committed-result acknowledgements.

Add SQLite session integration and PostgreSQL task/quota lock-wait regressions. Validation: all-target compile check; final source tree retains the previously validated 302 passing tests and Clippy results.
---
 crates/tysel-durable/src/lib.rs               | 19 +++++++
 crates/tysel-durable/src/lifecycle.rs         | 54 +++++++++++++++++++
 crates/tysel-durable/src/postgres_store.rs    | 11 +++-
 .../src/postgres_store/lifecycle.rs           |  8 ++-
 crates/tysel-durable/tests/postgres_live.rs   | 50 +++++++++++++++++
 crates/tysel-engine-qjs/src/durable.rs        | 13 ++---
 .../tysel-runtime/tests/lease_completion.rs   | 53 ++++++++++++++++++
 docs/operations/production.md                 |  5 +-
 8 files changed, 201 insertions(+), 12 deletions(-)
 create mode 100644 crates/tysel-runtime/tests/lease_completion.rs

diff --git a/crates/tysel-durable/src/lib.rs b/crates/tysel-durable/src/lib.rs
index c27da6b..ba0fb5f 100644
--- a/crates/tysel-durable/src/lib.rs
+++ b/crates/tysel-durable/src/lib.rs
@@ -242,6 +242,16 @@ pub trait DurableStore: Send + Sync {
         value: &Value,
         completed_at_ms: u64,
     ) -> Result<bool, DurableError>;
+    /// Complete under an absolute lease deadline. Implementations must validate a
+    /// fresh clock after acquiring transaction locks and before commit. Identical
+    /// already-committed outcomes may be acknowledged after expiry.
+    fn complete_task_before(
+        &self,
+        task_id: TaskId,
+        expected_sequence: u64,
+        value: &Value,
+        lease_until_ms: u64,
+    ) -> Result<bool, DurableError>;
     /// Delete only explicitly completed tasks older than the cutoff, at most 100 per call.
     fn prune_completed(&self, before_ms: u64, limit: usize) -> Result<usize, DurableError>;
     fn load_due_programs_batch(
@@ -1262,6 +1272,15 @@ impl DurableStore for SqliteStore {
     ) -> Result<bool, DurableError> {
         SqliteStore::complete_task(self, task_id, expected_sequence, value, completed_at_ms)
     }
+    fn complete_task_before(
+        &self,
+        task_id: TaskId,
+        expected_sequence: u64,
+        value: &Value,
+        lease_until_ms: u64,
+    ) -> Result<bool, DurableError> {
+        self.finish_task(task_id, expected_sequence, value, 0, Some(lease_until_ms))
+    }
     fn prune_completed(&self, before_ms: u64, limit: usize) -> Result<usize, DurableError> {
         SqliteStore::prune_completed(self, before_ms, limit)
     }
diff --git a/crates/tysel-durable/src/lifecycle.rs b/crates/tysel-durable/src/lifecycle.rs
index 96558cc..299d1be 100644
--- a/crates/tysel-durable/src/lifecycle.rs
+++ b/crates/tysel-durable/src/lifecycle.rs
@@ -37,6 +37,26 @@ pub(super) fn ensure_open(connection: &Connection, task_id: TaskId) -> Result<()
     Ok(())
 }
 
+/// Validate at the terminal transaction boundary, never with a caller's stale clock.
+/// The unleased low-level API preserves its explicit timestamp contract.
+pub(super) fn completion_time(
+    task_id: TaskId,
+    timestamp: u64,
+    lease_until_ms: Option<u64>,
+) -> Result<u64, DurableError> {
+    let Some(until) = lease_until_ms else {
+        return Ok(timestamp);
+    };
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_err(std::io::Error::other)?
+        .as_millis();
+    if now >= u128::from(until) {
+        return Err(DurableError::TaskSuspended { task_id });
+    }
+    Ok(now as u64)
+}
+
 impl SqliteStore {
     pub fn completion(&self, task_id: TaskId) -> Result<Option<TaskCompletion>, DurableError> {
         let connection = self.lock()?;
@@ -64,6 +84,17 @@ impl SqliteStore {
         expected_sequence: u64,
         value: &Value,
         completed_at_ms: u64,
+    ) -> Result<bool, DurableError> {
+        self.finish_task(task_id, expected_sequence, value, completed_at_ms, None)
+    }
+
+    pub(super) fn finish_task(
+        &self,
+        task_id: TaskId,
+        expected_sequence: u64,
+        value: &Value,
+        completed_at_ms: u64,
+        lease_until_ms: Option<u64>,
     ) -> Result<bool, DurableError> {
         let json = serde_json::to_string(value)?;
         if json.len() > MAX_EVENT_PAYLOAD_BYTES {
@@ -115,9 +146,11 @@ impl SqliteStore {
         if suspended {
             return Err(DurableError::TaskSuspended { task_id });
         }
+        let completed_at_ms = completion_time(task_id, completed_at_ms, lease_until_ms)?;
         tx.execute("INSERT INTO durable_completions (task_id, next_sequence, result_json, completed_at_ms) VALUES (?1, ?2, ?3, ?4)",
             params![id.as_slice(), actual, json, to_sql_integer(completed_at_ms, "completed_at_ms")?])?;
         tx.execute("UPDATE durable_program_stats SET active_count = active_count - 1, active_bytes = active_bytes - ?1 WHERE singleton = 1", params![source_bytes])?;
+        completion_time(task_id, completed_at_ms, lease_until_ms)?;
         tx.commit()?;
         Ok(true)
     }
@@ -176,6 +209,27 @@ impl SqliteStore {
 mod tests {
     use super::*;
 
+    #[test]
+    fn leased_completion_preserves_idempotence_and_uses_transaction_time() {
+        let store = SqliteStore::in_memory().unwrap();
+        let id = TaskId(801);
+        store.put_program(id, "42", 0).unwrap();
+        assert!(matches!(
+            store.complete_task_before(id, 0, &Value::from(42), 0),
+            Err(DurableError::TaskSuspended { .. })
+        ));
+        assert!(store.completion(id).unwrap().is_none());
+        let before = completion_time(id, 0, Some(u64::MAX)).unwrap();
+        assert!(store.complete_task_before(id, 0, &Value::from(42), u64::MAX).unwrap());
+        assert!(store.completion(id).unwrap().unwrap().completed_at_ms >= before);
+        assert!(store.complete_task_before(id, 0, &Value::from(42), 0).unwrap());
+        assert!(matches!(
+            store.complete_task_before(id, 0, &Value::from(43), 0),
+            Err(DurableError::TaskCompleted { .. })
+        ));
+        assert_eq!(store.program_count().unwrap(), 0);
+    }
+
     #[test]
     fn completion_releases_quota_and_retention_preserves_live_history() {
         let store = SqliteStore::in_memory().unwrap();
diff --git a/crates/tysel-durable/src/postgres_store.rs b/crates/tysel-durable/src/postgres_store.rs
index a7a63d3..346bfe0 100644
--- a/crates/tysel-durable/src/postgres_store.rs
+++ b/crates/tysel-durable/src/postgres_store.rs
@@ -394,7 +394,16 @@ impl DurableStore for PostgresStore {
         value: &Value,
         completed_at_ms: u64,
     ) -> Result<bool, DurableError> {
-        self.finish_task(task_id, expected_sequence, value, completed_at_ms)
+        self.finish_task(task_id, expected_sequence, value, completed_at_ms, None)
+    }
+    fn complete_task_before(
+        &self,
+        task_id: TaskId,
+        expected_sequence: u64,
+        value: &Value,
+        lease_until_ms: u64,
+    ) -> Result<bool, DurableError> {
+        self.finish_task(task_id, expected_sequence, value, 0, Some(lease_until_ms))
     }
     fn prune_completed(&self, before_ms: u64, limit: usize) -> Result<usize, DurableError> {
         self.prune_finished(before_ms, limit)
diff --git a/crates/tysel-durable/src/postgres_store/lifecycle.rs b/crates/tysel-durable/src/postgres_store/lifecycle.rs
index 279fe23..007ebfb 100644
--- a/crates/tysel-durable/src/postgres_store/lifecycle.rs
+++ b/crates/tysel-durable/src/postgres_store/lifecycle.rs
@@ -60,6 +60,7 @@ impl PostgresStore {
         expected_sequence: u64,
         value: &Value,
         completed_at_ms: u64,
+        lease_until_ms: Option<u64>,
     ) -> Result<bool, DurableError> {
         let json = serde_json::to_string(value)?;
         if json.len() > MAX_EVENT_PAYLOAD_BYTES {
@@ -83,9 +84,14 @@ impl PostgresStore {
             }
             let suspended: bool = tx.query_one("SELECT EXISTS(SELECT 1 FROM durable_wakeups WHERE task_id = $1) OR EXISTS(SELECT 1 FROM durable_signal_waits WHERE task_id = $1)", &[&&id[..]])?.get(0);
             if suspended { return Err(DurableError::TaskSuspended { task_id }); }
+            // Perform the existing quota update before checking time so its row
+            // lock cannot introduce an unchecked wait after the lease check.
+            // Expiry rolls this update back with the completion transaction.
+            tx.execute("UPDATE durable_program_stats SET active_count = active_count - 1, active_bytes = active_bytes - $1 WHERE singleton = 1", &[&source_bytes])?;
+            let completed_at_ms = crate::lifecycle::completion_time(task_id, completed_at_ms, lease_until_ms)?;
             tx.execute("INSERT INTO durable_completions (task_id, next_sequence, result_json, completed_at_ms) VALUES ($1, $2, $3, $4)",
                 &[&&id[..], &actual, &json, &to_sql_integer(completed_at_ms, "completed_at_ms")?])?;
-            tx.execute("UPDATE durable_program_stats SET active_count = active_count - 1, active_bytes = active_bytes - $1 WHERE singleton = 1", &[&source_bytes])?;
+            crate::lifecycle::completion_time(task_id, completed_at_ms, lease_until_ms)?;
             tx.commit()?;
             Ok(true)
         })
diff --git a/crates/tysel-durable/tests/postgres_live.rs b/crates/tysel-durable/tests/postgres_live.rs
index e942a0f..9c42924 100644
--- a/crates/tysel-durable/tests/postgres_live.rs
+++ b/crates/tysel-durable/tests/postgres_live.rs
@@ -197,3 +197,53 @@ fn postgres_v1_migration_keeps_unclassified_work_and_reopens_completion_counters
     }
     admin.batch_execute(&format!("DROP SCHEMA {schema} CASCADE")).unwrap();
 }
+
+#[test]
+fn postgres_completion_rechecks_lease_after_task_and_quota_lock_waits() {
+    let Some(store) = store() else {
+        return;
+    };
+    let url = std::env::var("TYSEL_POSTGRES_TEST_URL").unwrap();
+    let mut blocker = postgres::Client::connect(&url, postgres::NoTls).unwrap();
+    for quota in [false, true] {
+        let id = task(901 + u128::from(quota));
+        store.put_program(id, "42", 0).unwrap();
+        let active_before = store.program_count().unwrap();
+        let bytes = id.0.to_be_bytes();
+        let mut tx = blocker.transaction().unwrap();
+        if quota {
+            tx.query_one(
+                "SELECT singleton FROM durable_program_stats WHERE singleton = 1 FOR UPDATE",
+                &[],
+            )
+            .unwrap();
+        } else {
+            tx.query_one(
+                "SELECT task_id FROM durable_task_locks WHERE task_id = $1 FOR UPDATE",
+                &[&&bytes[..]],
+            )
+            .unwrap();
+        }
+        let now = || SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis() as u64;
+        let until = now() + 500;
+        let worker = {
+            let store = store.clone();
+            std::thread::spawn(move || store.complete_task_before(id, 0, &json!(42), until))
+        };
+        std::thread::sleep(std::time::Duration::from_millis(800));
+        assert!(!worker.is_finished(), "completion must wait for the held lock");
+        tx.rollback().unwrap();
+        assert!(matches!(worker.join().unwrap(), Err(DurableError::TaskSuspended { .. })));
+        assert!(store.completion(id).unwrap().is_none());
+        assert!(store.program(id).unwrap().is_some());
+        assert_eq!(store.program_count().unwrap(), active_before);
+        let before = now();
+        assert!(store.complete_task_before(id, 0, &json!(42), now() + 5_000).unwrap());
+        assert!(store.completion(id).unwrap().unwrap().completed_at_ms >= before);
+        assert!(store.complete_task_before(id, 0, &json!(42), 0).unwrap());
+        assert!(matches!(
+            store.complete_task_before(id, 0, &json!(43), 0),
+            Err(DurableError::TaskCompleted { .. })
+        ));
+    }
+}
diff --git a/crates/tysel-engine-qjs/src/durable.rs b/crates/tysel-engine-qjs/src/durable.rs
index 851d92c..cc64498 100644
--- a/crates/tysel-engine-qjs/src/durable.rs
+++ b/crates/tysel-engine-qjs/src/durable.rs
@@ -340,18 +340,13 @@ impl DurableCompletion {
     }
 
     pub fn complete(&self, value: &serde_json::Value) -> Result<bool, DurableError> {
+        if let Some(until) = self.lease_until_ms {
+            return self.store.complete_task_before(self.task_id, self.next_sequence, value, until);
+        }
         let now_ms = std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)
             .map_err(std::io::Error::other)?
             .as_millis() as u64;
-        if self.lease_until_ms.is_some_and(|until| now_ms >= until) {
-            if self.store.completion(self.task_id)?.is_some_and(|completion| {
-                completion.next_sequence == self.next_sequence && completion.value == *value
-            }) {
-                return Ok(true);
-            }
-            return Err(DurableError::TaskSuspended { task_id: self.task_id });
-        }
         self.store.complete_task(self.task_id, self.next_sequence, value, now_ms)
     }
 }
@@ -432,7 +427,7 @@ mod completion_tests {
         assert!(store.completion(task_id).unwrap().is_none());
         store.complete_task(task_id, 0, &json!(42), 1).unwrap();
         assert!(session.complete(&json!(42)).unwrap());
-        assert!(matches!(session.complete(&json!(43)), Err(DurableError::TaskSuspended { .. })));
+        assert!(matches!(session.complete(&json!(43)), Err(DurableError::TaskCompleted { .. })));
         assert_eq!(store.completion(task_id).unwrap().unwrap().value, json!(42));
     }
 }
diff --git a/crates/tysel-runtime/tests/lease_completion.rs b/crates/tysel-runtime/tests/lease_completion.rs
new file mode 100644
index 0000000..4192bc3
--- /dev/null
+++ b/crates/tysel-runtime/tests/lease_completion.rs
@@ -0,0 +1,53 @@
+use std::{
+    sync::Arc,
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
+use tysel_durable::SqliteStore;
+use tysel_engine::{EngineError, IsolateConfig};
+use tysel_engine_qjs::{DurableSession, eval_durable};
+use tysel_task::TaskId;
+fn now() -> u64 {
+    SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis() as u64
+}
+#[test]
+fn completion_rejects_lease_expiry_while_waiting_for_sqlite_writer() {
+    let path = std::env::temp_dir().join(format!("tysel-review-lease-{}.db", std::process::id()));
+    let store = Arc::new(SqliteStore::open(&path).unwrap());
+    let id = TaskId(701);
+    let script = "(async () => { await tysel.durable.sleep(1); return 42; })()";
+    store.put_program(id, script, now()).unwrap();
+    let config = IsolateConfig::default();
+    assert!(matches!(
+        eval_durable(script, config, DurableSession::new(store.clone(), id).unwrap()),
+        Err(EngineError::Suspended)
+    ));
+    std::thread::sleep(Duration::from_millis(5));
+    let claim = store.claim_wakeup(id, now(), "review", 500).unwrap().unwrap();
+    let until = claim.lease_until_ms;
+    let session = DurableSession::from_claim(store.clone(), claim).unwrap();
+    eval_durable(script, config, session.clone()).unwrap();
+    let completion = session.completion_handle().unwrap();
+    let blocker = rusqlite::Connection::open(&path).unwrap();
+    blocker.execute_batch("BEGIN IMMEDIATE").unwrap();
+    let started = now();
+    assert!(started < until);
+    let thread = std::thread::spawn(move || completion.complete(&serde_json::json!(42)));
+    std::thread::sleep(Duration::from_millis(800));
+    assert!(!thread.is_finished(), "completion must wait for the held writer lock");
+    blocker.execute_batch("ROLLBACK").unwrap();
+    let result = thread.join().unwrap();
+    let persisted = store.completion(id).unwrap();
+    println!(
+        "started_before_expiry_ms={} finished_after_expiry_ms={} result={result:?} persisted={}",
+        until - started,
+        now() - until,
+        persisted.is_some()
+    );
+    assert!(matches!(result, Err(tysel_durable::DurableError::TaskSuspended { .. })));
+    assert!(persisted.is_none());
+    assert_eq!(store.program_count().unwrap(), 1);
+    drop(blocker);
+    drop(session);
+    drop(store);
+    std::fs::remove_file(path).unwrap();
+}
diff --git a/docs/operations/production.md b/docs/operations/production.md
index 9c03c92..d36d471 100644
--- a/docs/operations/production.md
+++ b/docs/operations/production.md
@@ -126,7 +126,10 @@ finalizations share reserved slots. Pending entries retain compact results and
 lease/sequence metadata, releasing consumed replay history. `completion_pending`
 logs the affected task ID. Completed outcomes are still reported when a different
 task in the same scheduling batch encounters a storage failure.
-Retries remain subject to the original lease; lease expiry or shutdown with pending
+Retries remain subject to the original lease. Completion transactions check fresh
+time after acquiring their locks and again before commit; expiry rolls back both
+the result and quota changes. An identical already-committed outcome can still be
+acknowledged after expiry. Lease expiry or shutdown with pending
 outcomes reports failure and needs operator investigation. This does not provide
 recovery after process death: active task restart eligibility and atomic application
 admission/signal delivery remain release blockers (G1/G2).

From b61b46fe2c1f02fb2bd49b41bb17d37e51856781 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Tue, 8 Sep 2026 22:01:31 +0800
Subject: [PATCH 22/31] feat(durable): persist fenced execution and idempotent
 delivery identities

---
 Cargo.lock                                    |   1 +
 crates/tysel-durable/Cargo.toml               |   1 +
 crates/tysel-durable/src/execution.rs         | 332 ++++++++++++++++++
 crates/tysel-durable/src/lib.rs               | 169 ++++++++-
 crates/tysel-durable/src/lifecycle.rs         |   8 +-
 crates/tysel-durable/src/postgres_store.rs    | 212 ++++++++---
 .../src/postgres_store/execution.rs           | 124 +++++++
 .../src/postgres_store/lifecycle.rs           |   6 +-
 crates/tysel-durable/tests/execution.rs       |  94 +++++
 crates/tysel-durable/tests/postgres_live.rs   |  38 +-
 10 files changed, 911 insertions(+), 74 deletions(-)
 create mode 100644 crates/tysel-durable/src/execution.rs
 create mode 100644 crates/tysel-durable/src/postgres_store/execution.rs
 create mode 100644 crates/tysel-durable/tests/execution.rs

diff --git a/Cargo.lock b/Cargo.lock
index 2cf1e93..2480240 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3834,6 +3834,7 @@ dependencies = [
 name = "tysel-durable"
 version = "0.2.0"
 dependencies = [
+ "getrandom 0.4.3",
  "native-tls",
  "postgres",
  "postgres-native-tls",
diff --git a/crates/tysel-durable/Cargo.toml b/crates/tysel-durable/Cargo.toml
index 161a2f4..5f4ef4b 100644
--- a/crates/tysel-durable/Cargo.toml
+++ b/crates/tysel-durable/Cargo.toml
@@ -12,6 +12,7 @@ description = "Durable task history, replay, and wakeup store."
 workspace = true
 
 [dependencies]
+getrandom = "0.4"
 native-tls.workspace = true
 postgres = "0.19"
 postgres-native-tls = "0.5"
diff --git a/crates/tysel-durable/src/execution.rs b/crates/tysel-durable/src/execution.rs
new file mode 100644
index 0000000..d99ed4b
--- /dev/null
+++ b/crates/tysel-durable/src/execution.rs
@@ -0,0 +1,332 @@
+use super::*;
+
+/// Fences one execution independently of its currently suspended boundary.
+#[derive(Debug, Clone)]
+pub struct ExecutionClaim {
+    pub task_id: TaskId,
+    pub owner: String,
+    pub generation: u64,
+    pub lease_until_ms: u64,
+    pub wakeup: Option<WakeupClaim>,
+}
+
+/// Store-wide identity. Applications should namespace keys by tenant and operation.
+pub fn admission_task_id(key: &str) -> Result<TaskId, DurableError> {
+    validate_key(key)?;
+    let mut hash = Sha256::new();
+    hash.update(b"tysel:admission:v1:");
+    hash.update(key.as_bytes());
+    let digest = hash.finalize();
+    Ok(TaskId(u128::from_be_bytes(digest[..16].try_into().expect("digest prefix"))))
+}
+
+pub(super) fn owner_token(owner: &str) -> Result<String, DurableError> {
+    validate_lease_owner(owner)?;
+    let mut entropy = [0u8; 32];
+    getrandom::fill(&mut entropy).map_err(std::io::Error::other)?;
+    let mut hash = Sha256::new();
+    hash.update(owner.as_bytes());
+    hash.update(entropy);
+    Ok(format!("{:x}", hash.finalize()))
+}
+
+pub(super) fn now() -> Result<u64, DurableError> {
+    let ms = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_err(std::io::Error::other)?
+        .as_millis();
+    u64::try_from(ms).map_err(|_| DurableError::IntegerRange { field: "time" })
+}
+pub(super) fn validate_key(key: &str) -> Result<(), DurableError> {
+    if key.is_empty() || key.len() > 256 {
+        return Err(DurableError::InvalidIdempotencyKey);
+    }
+    Ok(())
+}
+pub(super) fn fingerprint(source: &str, input: &str) -> Result<(String, String), DurableError> {
+    validate_program_source(source)?;
+    if input.len() > MAX_EVENT_PAYLOAD_BYTES {
+        return Err(DurableError::EventPayloadTooLarge);
+    }
+    let input = serde_json::to_string(&serde_json::from_str::<Value>(input)?)?;
+    let mut hash = Sha256::new();
+    hash.update(source.as_bytes());
+    hash.update([0]);
+    hash.update(input.as_bytes());
+    Ok((format!("{:x}", hash.finalize()), input))
+}
+
+pub(super) fn initialize(tx: &Transaction<'_>) -> Result<(), DurableError> {
+    tx.execute_batch("CREATE TABLE IF NOT EXISTS durable_executions (
+        task_id BLOB PRIMARY KEY,
+        state TEXT NOT NULL CHECK (state IN ('ready','running','suspended','failed','completed')),
+        generation INTEGER NOT NULL DEFAULT 0,
+        owner TEXT, lease_until_ms INTEGER,
+        admission_key TEXT, request_hash TEXT
+    );
+    CREATE INDEX IF NOT EXISTS durable_executions_due ON durable_executions(state, lease_until_ms, task_id);
+    CREATE TABLE IF NOT EXISTS durable_signal_receipts (
+        task_id BLOB NOT NULL, request_key TEXT NOT NULL, signal_name TEXT NOT NULL,
+        payload TEXT NOT NULL, signal_id INTEGER NOT NULL, PRIMARY KEY(task_id, request_key)
+    );")?;
+    Ok(())
+}
+
+impl SqliteStore {
+    pub(super) fn guard_execution(
+        &self,
+        tx: &Connection,
+        task: TaskId,
+    ) -> Result<(), DurableError> {
+        let Some(claim) = &self.execution else {
+            return Ok(());
+        };
+        let valid: bool = tx.query_row("SELECT EXISTS(SELECT 1 FROM durable_executions WHERE task_id=?1 AND state='running' AND owner=?2 AND generation=?3 AND lease_until_ms > ?4)",
+            params![task_id_bytes(task).as_slice(), claim.owner, to_sql_integer(claim.generation,"generation")?, to_sql_integer(now()?,"time")?], |r|r.get(0))?;
+        if task != claim.task_id || !valid {
+            return Err(DurableError::ExecutionLeaseLost);
+        }
+        Ok(())
+    }
+
+    pub(super) fn admit(
+        &self,
+        task: TaskId,
+        key: &str,
+        source: &str,
+        input: &str,
+        time: u64,
+    ) -> Result<(), DurableError> {
+        validate_key(key)?;
+        let (hash, input) = fingerprint(source, input)?;
+        let id = task_id_bytes(task);
+        let mut conn = self.lock()?;
+        let tx = conn.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        if let Some((old_key, old_hash)) = tx
+            .query_row(
+                "SELECT admission_key, request_hash FROM durable_executions WHERE task_id=?1",
+                params![id.as_slice()],
+                |r| Ok((r.get::<_, Option<String>>(0)?, r.get::<_, Option<String>>(1)?)),
+            )
+            .optional()?
+        {
+            if old_key.as_deref() != Some(key) || old_hash.as_deref() != Some(&hash) {
+                return Err(DurableError::AdmissionConflict);
+            }
+            return Ok(());
+        }
+        if select_program(&tx, task)?.is_some() {
+            return Err(DurableError::AdmissionConflict);
+        }
+        let (count, bytes): (i64, i64) = tx.query_row(
+            "SELECT active_count, active_bytes FROM durable_program_stats WHERE singleton=1",
+            [],
+            |r| Ok((r.get(0)?, r.get(1)?)),
+        )?;
+        if count >= MAX_DURABLE_PROGRAMS as i64 {
+            return Err(DurableError::ProgramLimit);
+        }
+        if bytes + source.len() as i64 > MAX_DURABLE_PROGRAM_TOTAL_BYTES as i64 {
+            return Err(DurableError::ProgramByteLimit);
+        }
+        let digest: [u8; 32] = Sha256::digest(source.as_bytes()).into();
+        tx.execute("INSERT INTO durable_programs(task_id,program_kind,source,source_sha256,registered_at_ms) VALUES (?1,'module',?2,?3,?4)",params![id.as_slice(),source,digest.as_slice(),to_sql_integer(time,"time")?])?;
+        tx.execute("UPDATE durable_program_stats SET active_count=active_count+1, active_bytes=active_bytes+?1 WHERE singleton=1",params![source.len() as i64])?;
+        let event = raw_event(EventKind::Step, "$tysel:task-input".into(), &input, time)?;
+        insert_event(&tx, task, Some(0), &event, &input, to_sql_integer(time, "time")?)?;
+        tx.execute("INSERT INTO durable_executions(task_id,state,admission_key,request_hash) VALUES (?1,'ready',?2,?3)",params![id.as_slice(),key,hash])?;
+        tx.commit()?;
+        Ok(())
+    }
+
+    pub(super) fn claim_run(
+        &self,
+        task: TaskId,
+        owner: &str,
+        duration: u64,
+    ) -> Result<Option<ExecutionClaim>, DurableError> {
+        let token = owner_token(owner)?;
+        let owner = token.as_str();
+        let id = task_id_bytes(task);
+        let mut conn = self.lock()?;
+        let tx = conn.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        if tx.query_row(
+            "SELECT EXISTS(SELECT 1 FROM durable_completions WHERE task_id=?1)",
+            params![id.as_slice()],
+            |r| r.get::<_, bool>(0),
+        )? {
+            return Ok(None);
+        }
+        if !tx.query_row(
+            "SELECT EXISTS(SELECT 1 FROM durable_programs WHERE task_id=?1)",
+            params![id.as_slice()],
+            |r| r.get::<_, bool>(0),
+        )? {
+            return Ok(None);
+        }
+        let time = now()?;
+        let until = time
+            .checked_add(duration)
+            .filter(|u| *u > time)
+            .ok_or(DurableError::ExecutionLeaseLost)?;
+        let row = tx
+            .query_row(
+                "SELECT state,generation,lease_until_ms FROM durable_executions WHERE task_id=?1",
+                params![id.as_slice()],
+                |r| Ok((r.get::<_, String>(0)?, r.get::<_, i64>(1)?, r.get::<_, Option<i64>>(2)?)),
+            )
+            .optional()?;
+        if let Some((state, _, lease)) = &row
+            && (state == "completed" || state == "failed" || lease.is_some_and(|u| u > time as i64))
+        {
+            return Ok(None);
+        }
+        let wake = tx
+            .query_row(
+                "SELECT sequence,wake_at_ms,lease_until_ms FROM durable_wakeups WHERE task_id=?1",
+                params![id.as_slice()],
+                |r| Ok((r.get::<_, i64>(0)?, r.get::<_, i64>(1)?, r.get::<_, Option<i64>>(2)?)),
+            )
+            .optional()?;
+        if wake.as_ref().is_some_and(|(_, at, lease)| {
+            *at > time as i64 || lease.is_some_and(|u| u > time as i64)
+        }) {
+            return Ok(None);
+        }
+        if wake.is_none()
+            && tx.query_row(
+                "SELECT EXISTS(SELECT 1 FROM durable_signal_waits WHERE task_id=?1)",
+                params![id.as_slice()],
+                |r| r.get::<_, bool>(0),
+            )?
+        {
+            return Ok(None);
+        }
+        let generation = row
+            .map_or(Ok(1), |(_, g, _)| g.checked_add(1).ok_or(DurableError::ExecutionLeaseLost))?;
+        tx.execute("INSERT INTO durable_executions(task_id,state,generation,owner,lease_until_ms) VALUES (?1,'running',?2,?3,?4) ON CONFLICT(task_id) DO UPDATE SET state='running',generation=excluded.generation,owner=excluded.owner,lease_until_ms=excluded.lease_until_ms",params![id.as_slice(),generation,owner,to_sql_integer(until,"lease")?])?;
+        let wakeup = if let Some((seq, at, _)) = wake {
+            tx.execute(
+                "UPDATE durable_wakeups SET lease_owner=?2,lease_until_ms=?3 WHERE task_id=?1",
+                params![id.as_slice(), owner, to_sql_integer(until, "lease")?],
+            )?;
+            Some(WakeupClaim {
+                task_id: task,
+                sequence: seq as u64,
+                wake_at_ms: at as u64,
+                lease_owner: owner.into(),
+                lease_until_ms: until,
+            })
+        } else {
+            None
+        };
+        if now()? >= until {
+            return Ok(None);
+        }
+        tx.commit()?;
+        Ok(Some(ExecutionClaim {
+            task_id: task,
+            owner: owner.into(),
+            generation: generation as u64,
+            lease_until_ms: until,
+            wakeup,
+        }))
+    }
+
+    pub(super) fn release_run(
+        &self,
+        claim: &ExecutionClaim,
+        failed: bool,
+    ) -> Result<(), DurableError> {
+        let scoped = Self { connection: self.connection.clone(), execution: Some(claim.clone()) };
+        let mut conn = self.lock()?;
+        let tx = conn.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        scoped.guard_execution(&tx, claim.task_id)?;
+        let id = task_id_bytes(claim.task_id);
+        tx.execute(
+            "UPDATE durable_wakeups SET lease_owner=NULL,lease_until_ms=NULL WHERE task_id=?1",
+            params![id.as_slice()],
+        )?;
+        scoped.guard_execution(&tx, claim.task_id)?;
+        tx.execute("UPDATE durable_executions SET state=?2,owner=NULL,lease_until_ms=NULL WHERE task_id=?1",params![id.as_slice(),if failed {"failed"}else{"suspended"}])?;
+        tx.commit()?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn failed_admission_rolls_back_program_input_and_quota() {
+        let store = SqliteStore::in_memory().unwrap();
+        store.lock().unwrap().execute_batch("CREATE TRIGGER fail_input BEFORE INSERT ON durable_events BEGIN SELECT json('malformed'); END;").unwrap();
+        let id = admission_task_id("rollback").unwrap();
+        assert!(
+            store
+                .admit_module(
+                    id,
+                    "rollback",
+                    "export default async () => 42",
+                    "null",
+                    now().unwrap()
+                )
+                .is_err()
+        );
+        assert_eq!(store.program_count().unwrap(), 0);
+        assert!(store.program(id).unwrap().is_none());
+        assert!(store.load_history(id).unwrap().events.is_empty());
+        store.lock().unwrap().execute_batch("DROP TRIGGER fail_input").unwrap();
+        store
+            .admit_module(id, "rollback", "export default async () => 42", "null", now().unwrap())
+            .unwrap();
+        assert_eq!(store.program_count().unwrap(), 1);
+    }
+    #[test]
+    fn concurrent_admission_has_one_input_and_execution() {
+        let store = Arc::new(SqliteStore::in_memory().unwrap());
+        let id = admission_task_id("concurrent").unwrap();
+        let mut workers = Vec::new();
+        for _ in 0..8 {
+            let store = store.clone();
+            workers.push(std::thread::spawn(move || {
+                store.admit_module(
+                    id,
+                    "concurrent",
+                    "export default async () => 42",
+                    "null",
+                    now().unwrap(),
+                )
+            }));
+        }
+        for w in workers {
+            w.join().unwrap().unwrap();
+        }
+        assert_eq!(store.program_count().unwrap(), 1);
+        assert_eq!(store.load_history(id).unwrap().events.len(), 1);
+        let claim = store.claim_execution(id, "owner", 10_000).unwrap().unwrap();
+        assert!(store.claim_execution(id, "owner", 10_000).unwrap().is_none());
+        let scoped = store.execution_store(&claim);
+        scoped.complete_task_before(id, 1, &Value::Null, claim.lease_until_ms).unwrap();
+        store.prune_completed(u64::MAX / 2, 100).unwrap();
+        store
+            .admit_module(id, "concurrent", "export default async () => 42", "null", now().unwrap())
+            .unwrap();
+        let replacement = store.claim_execution(id, "owner", 10_000).unwrap().unwrap();
+        assert_ne!(
+            claim.owner, replacement.owner,
+            "new incarnation must not reuse fencing authority"
+        );
+        assert!(matches!(
+            scoped.append_event_json_at(
+                id,
+                1,
+                EventKind::Effect,
+                "late".into(),
+                "null",
+                now().unwrap()
+            ),
+            Err(DurableError::ExecutionLeaseLost)
+        ));
+    }
+}
diff --git a/crates/tysel-durable/src/lib.rs b/crates/tysel-durable/src/lib.rs
index ba0fb5f..f91dc09 100644
--- a/crates/tysel-durable/src/lib.rs
+++ b/crates/tysel-durable/src/lib.rs
@@ -5,7 +5,7 @@ mod postgres_store;
 pub use postgres_store::{POSTGRES_URL_ENV, PostgresStore};
 
 use std::path::Path;
-use std::sync::{Mutex, MutexGuard};
+use std::sync::{Arc, Mutex, MutexGuard};
 use std::time::Duration;
 
 use rusqlite::{Connection, OptionalExtension, Transaction, TransactionBehavior, params};
@@ -21,8 +21,10 @@ const MAX_HISTORY_BYTES: usize = 16 * 1_048_576;
 const MAX_PENDING_SIGNALS: usize = 1_000;
 const MAX_LEASE_OWNER_BYTES: usize = 128;
 /// Durable SQLite schema and replay-log contract supported by this runtime.
-pub const DURABLE_LOG_VERSION: u32 = 2;
+pub const DURABLE_LOG_VERSION: u32 = 3;
+mod execution;
 mod lifecycle;
+pub use execution::{ExecutionClaim, admission_task_id};
 pub const MAX_DURABLE_PROGRAM_BYTES: usize = 1_048_576;
 pub const MAX_DURABLE_PROGRAM_TOTAL_BYTES: usize = 64 * 1_048_576;
 pub const MAX_DURABLE_PROGRAMS: usize = 10_000;
@@ -232,6 +234,32 @@ pub struct TaskCompletion {
 /// event/wakeup and signal operations atomic. The synchronous surface is
 /// intentional: callers run durable storage work on blocking worker threads.
 pub trait DurableStore: Send + Sync {
+    /// Persist immutable admission, input and restart eligibility atomically.
+    fn admit_module(
+        &self,
+        task_id: TaskId,
+        key: &str,
+        source: &str,
+        input: &str,
+        now_ms: u64,
+    ) -> Result<(), DurableError>;
+    fn claim_execution(
+        &self,
+        task_id: TaskId,
+        owner: &str,
+        duration_ms: u64,
+    ) -> Result<Option<ExecutionClaim>, DurableError>;
+    fn execution_failed(&self, task_id: TaskId) -> Result<bool, DurableError>;
+    fn execution_store(&self, claim: &ExecutionClaim) -> Arc<dyn DurableStore>;
+    fn finish_execution(&self, claim: &ExecutionClaim, failed: bool) -> Result<(), DurableError>;
+    fn send_signal_once(
+        &self,
+        task_id: TaskId,
+        name: &str,
+        payload: &Value,
+        key: &str,
+        now_ms: u64,
+    ) -> Result<u64, DurableError>;
     fn completion(&self, task_id: TaskId) -> Result<Option<TaskCompletion>, DurableError>;
     /// Persist completion for a registered program. Returns false for unregistered
     /// low-level sessions, which retain the caller-managed lifecycle contract.
@@ -366,7 +394,8 @@ impl DurableProgramKind {
 }
 
 pub struct SqliteStore {
-    connection: Mutex<Connection>,
+    connection: Arc<Mutex<Connection>>,
+    execution: Option<ExecutionClaim>,
 }
 
 impl SqliteStore {
@@ -388,7 +417,7 @@ impl SqliteStore {
         connection.busy_timeout(Duration::from_secs(5))?;
         connection.execute_batch("PRAGMA foreign_keys = ON;")?;
         initialize_schema(&mut connection)?;
-        Ok(Self { connection: Mutex::new(connection) })
+        Ok(Self { connection: Arc::new(Mutex::new(connection)), execution: None })
     }
 
     /// Return the durable log contract version recorded in this store.
@@ -516,14 +545,24 @@ impl SqliteStore {
         let connection = self.lock()?;
         let now_ms = to_sql_integer(now_ms, "now_ms")?;
         let mut statement = connection.prepare(
-            "SELECT p.task_id, p.program_kind, p.source, p.source_sha256, p.registered_at_ms
-             FROM durable_programs AS p
-             INNER JOIN durable_wakeups AS w ON w.task_id = p.task_id
-             WHERE w.wake_at_ms <= ?1
-               AND (w.lease_until_ms IS NULL OR w.lease_until_ms <= ?1)
-               AND p.program_kind = ?2
-               AND NOT EXISTS (SELECT 1 FROM durable_completions c WHERE c.task_id = p.task_id)
-             ORDER BY w.wake_at_ms, p.task_id LIMIT ?3",
+            "WITH due AS (
+                SELECT w.task_id, w.wake_at_ms AS due_at
+                FROM durable_wakeups w LEFT JOIN durable_executions r ON r.task_id=w.task_id
+                WHERE w.wake_at_ms <= ?1 AND (w.lease_until_ms IS NULL OR w.lease_until_ms <= ?1)
+                  AND (r.state IS NULL OR r.state IN ('ready','running','suspended'))
+                  AND (r.lease_until_ms IS NULL OR r.lease_until_ms <= ?1)
+                UNION ALL
+                SELECT r.task_id, COALESCE(r.lease_until_ms, 0) AS due_at
+                FROM durable_executions r
+                WHERE r.state IN ('ready','running') AND (r.lease_until_ms IS NULL OR r.lease_until_ms <= ?1)
+                  AND NOT EXISTS(SELECT 1 FROM durable_wakeups w WHERE w.task_id=r.task_id)
+                  AND NOT EXISTS(SELECT 1 FROM durable_signal_waits s WHERE s.task_id=r.task_id)
+             )
+             SELECT p.task_id, p.program_kind, p.source, p.source_sha256, p.registered_at_ms
+             FROM due d JOIN durable_programs p ON p.task_id=d.task_id
+             WHERE p.program_kind=?2
+               AND NOT EXISTS(SELECT 1 FROM durable_completions c WHERE c.task_id=p.task_id)
+             ORDER BY d.due_at, p.task_id LIMIT ?3",
         )?;
         let rows = statement.query_map(
             params![now_ms, kind.as_str(), limit.min(MAX_DURABLE_PROGRAMS) as i64],
@@ -612,6 +651,7 @@ impl SqliteStore {
         let recorded_at_ms = to_sql_integer(recorded_at_ms, "recorded_at_ms")?;
         let mut connection = self.lock()?;
         let transaction = connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        self.guard_execution(&transaction, task_id)?;
         let sequence = insert_event(
             &transaction,
             task_id,
@@ -620,6 +660,7 @@ impl SqliteStore {
             payload_json,
             recorded_at_ms,
         )?;
+        self.guard_execution(&transaction, task_id)?;
         transaction.commit()?;
         stored_event(task_id, sequence, event, payload_json.into())
     }
@@ -633,6 +674,7 @@ impl SqliteStore {
         let (payload, recorded_at_ms) = validate_event(&event)?;
         let mut connection = self.lock()?;
         let transaction = connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        self.guard_execution(&transaction, task_id)?;
         let sequence = insert_event(
             &transaction,
             task_id,
@@ -641,6 +683,7 @@ impl SqliteStore {
             &payload,
             recorded_at_ms,
         )?;
+        self.guard_execution(&transaction, task_id)?;
         transaction.commit()?;
         stored_event(task_id, sequence, event, payload)
     }
@@ -681,6 +724,7 @@ impl SqliteStore {
         let wake_at_ms = to_sql_integer(wake_at_ms, "wake_at_ms")?;
         let mut connection = self.lock()?;
         let transaction = connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        self.guard_execution(&transaction, task_id)?;
         let sequence = insert_event(
             &transaction,
             task_id,
@@ -690,6 +734,7 @@ impl SqliteStore {
             recorded_at_ms,
         )?;
         upsert_wakeup(&transaction, task_id, sequence, wake_at_ms)?;
+        self.guard_execution(&transaction, task_id)?;
         transaction.commit()?;
         stored_event(task_id, sequence, event, payload_json.into())
     }
@@ -705,6 +750,7 @@ impl SqliteStore {
         let wake_at_ms_sql = to_sql_integer(wake_at_ms, "wake_at_ms")?;
         let mut connection = self.lock()?;
         let transaction = connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        self.guard_execution(&transaction, task_id)?;
         let sequence = insert_event(
             &transaction,
             task_id,
@@ -714,6 +760,7 @@ impl SqliteStore {
             recorded_at_ms,
         )?;
         upsert_wakeup(&transaction, task_id, sequence, wake_at_ms_sql)?;
+        self.guard_execution(&transaction, task_id)?;
         transaction.commit()?;
         stored_event(task_id, sequence, event, payload)
     }
@@ -921,7 +968,9 @@ impl SqliteStore {
         lease_owner: Option<&str>,
         now_ms: u64,
     ) -> Result<bool, DurableError> {
-        let connection = self.lock()?;
+        let mut guard = self.lock()?;
+        let connection = guard.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        self.guard_execution(&connection, task_id)?;
         let id = task_id_bytes(task_id);
         let sequence = to_sql_integer(sequence, "sequence")?;
         let now_ms = to_sql_integer(now_ms, "now_ms")?;
@@ -941,6 +990,8 @@ impl SqliteStore {
                 params![id.as_slice(), sequence],
             )?,
         };
+        self.guard_execution(&connection, task_id)?;
+        connection.commit()?;
         Ok(changed == 1)
     }
 
@@ -1074,6 +1125,17 @@ impl SqliteStore {
         signal_name: &str,
         payload: &Value,
         sent_at_ms: u64,
+    ) -> Result<u64, DurableError> {
+        self.send_signal_inner(task_id, signal_name, payload, sent_at_ms, None)
+    }
+
+    fn send_signal_inner(
+        &self,
+        task_id: TaskId,
+        signal_name: &str,
+        payload: &Value,
+        sent_at_ms: u64,
+        key: Option<&str>,
     ) -> Result<u64, DurableError> {
         validate_signal_name(signal_name)?;
         let payload = serde_json::to_string(payload)?;
@@ -1084,6 +1146,29 @@ impl SqliteStore {
         let id = task_id_bytes(task_id);
         let mut connection = self.lock()?;
         let transaction = connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        if let Some(key) = key {
+            execution::validate_key(key)?;
+            let hash = format!("{:x}", Sha256::digest(payload.as_bytes()));
+            if let Some((name, prior, id)) = transaction.query_row("SELECT signal_name,payload,signal_id FROM durable_signal_receipts WHERE task_id=?1 AND request_key=?2",params![id.as_slice(),key],|r|Ok((r.get::<_,String>(0)?,r.get::<_,String>(1)?,r.get::<_,i64>(2)?))).optional()? {
+                if name != signal_name || prior != hash {return Err(DurableError::AdmissionConflict);}
+                return from_sql_integer(id,"signal_id");
+            }
+            let count: i64 = transaction.query_row(
+                "SELECT COUNT(*) FROM durable_signal_receipts WHERE task_id=?1",
+                params![id.as_slice()],
+                |r| r.get(0),
+            )?;
+            if count >= MAX_HISTORY_EVENTS as i64 {
+                return Err(DurableError::SignalInboxLimit);
+            }
+            if !transaction.query_row(
+                "SELECT EXISTS(SELECT 1 FROM durable_programs WHERE task_id=?1)",
+                params![id.as_slice()],
+                |row| row.get::<_, bool>(0),
+            )? {
+                return Err(DurableError::AdmissionConflict);
+            }
+        }
         lifecycle::ensure_open(&transaction, task_id)?;
         let (pending_count, pending_bytes) = transaction.query_row(
             "SELECT COUNT(*), COALESCE(SUM(
@@ -1127,6 +1212,9 @@ impl SqliteStore {
                 params![id.as_slice(), sequence, sent_at_ms],
             )?;
         }
+        if let Some(key) = key {
+            transaction.execute("INSERT INTO durable_signal_receipts(task_id,request_key,signal_name,payload,signal_id) VALUES (?1,?2,?3,?4,?5)",params![id.as_slice(),key,signal_name,format!("{:x}",Sha256::digest(payload.as_bytes())),signal_id])?;
+        }
         transaction.commit()?;
         from_sql_integer(signal_id, "signal_id")
     }
@@ -1146,6 +1234,7 @@ impl SqliteStore {
         let id = task_id_bytes(task_id);
         let mut connection = self.lock()?;
         let transaction = connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        self.guard_execution(&transaction, task_id)?;
         lifecycle::ensure_open(&transaction, task_id)?;
         let actual_sequence: i64 = transaction.query_row(
             "SELECT COALESCE(MAX(sequence) + 1, 0)
@@ -1183,6 +1272,7 @@ impl SqliteStore {
             .optional()?;
         let Some((signal_id, payload_json, sent_at_ms)) = queued else {
             register_signal_wait(&transaction, task_id, expected_sequence, signal_name)?;
+            self.guard_execution(&transaction, task_id)?;
             transaction.commit()?;
             return Ok(None);
         };
@@ -1250,6 +1340,7 @@ impl SqliteStore {
              WHERE task_id = ?1 AND sequence = ?2 AND signal_name = ?3",
             params![id.as_slice(), sequence, signal_name],
         )?;
+        self.guard_execution(&transaction, task_id)?;
         transaction.commit()?;
         stored_event(task_id, sequence, event, payload_json).map(Some)
     }
@@ -1260,6 +1351,46 @@ impl SqliteStore {
 }
 
 impl DurableStore for SqliteStore {
+    fn admit_module(
+        &self,
+        id: TaskId,
+        key: &str,
+        source: &str,
+        input: &str,
+        now: u64,
+    ) -> Result<(), DurableError> {
+        self.admit(id, key, source, input, now)
+    }
+    fn claim_execution(
+        &self,
+        id: TaskId,
+        owner: &str,
+        duration: u64,
+    ) -> Result<Option<ExecutionClaim>, DurableError> {
+        self.claim_run(id, owner, duration)
+    }
+    fn execution_failed(&self, task_id: TaskId) -> Result<bool, DurableError> {
+        self.lock()?.query_row(
+            "SELECT EXISTS(SELECT 1 FROM durable_executions WHERE task_id=?1 AND state='failed')",
+            params![task_id_bytes(task_id).as_slice()], |row| row.get(0)
+        ).map_err(Into::into)
+    }
+    fn execution_store(&self, claim: &ExecutionClaim) -> Arc<dyn DurableStore> {
+        Arc::new(Self { connection: self.connection.clone(), execution: Some(claim.clone()) })
+    }
+    fn finish_execution(&self, claim: &ExecutionClaim, failed: bool) -> Result<(), DurableError> {
+        self.release_run(claim, failed)
+    }
+    fn send_signal_once(
+        &self,
+        id: TaskId,
+        name: &str,
+        payload: &Value,
+        key: &str,
+        now: u64,
+    ) -> Result<u64, DurableError> {
+        self.send_signal_inner(id, name, payload, now, Some(key))
+    }
     fn completion(&self, task_id: TaskId) -> Result<Option<TaskCompletion>, DurableError> {
         SqliteStore::completion(self, task_id)
     }
@@ -1457,6 +1588,13 @@ impl DurableStore for SqliteStore {
 
 #[derive(Debug, thiserror::Error)]
 pub enum DurableError {
+    #[error("durable execution lease is missing, expired or superseded")]
+    ExecutionLeaseLost,
+    #[error("durable idempotency key conflicts with an existing request")]
+    AdmissionConflict,
+    #[error("durable idempotency key must be 1..=256 bytes")]
+    InvalidIdempotencyKey,
+
     #[error("durable task {task_id} is already completed")]
     TaskCompleted { task_id: TaskId },
     #[error("durable task {task_id} is still suspended or leased")]
@@ -1832,6 +1970,7 @@ fn initialize_schema(connection: &mut Connection) -> Result<(), DurableError> {
          );",
     )?;
     lifecycle::initialize(&transaction)?;
+    execution::initialize(&transaction)?;
     migrate_program_columns(&transaction)?;
     let sequence_added = migrate_wakeup_columns(&transaction)?;
     if sequence_added {
@@ -2166,7 +2305,7 @@ mod tests {
                          key TEXT PRIMARY KEY,
                          value INTEGER NOT NULL
                      );
-                     INSERT INTO tysel_durable_metadata VALUES ('schema_version', 3);",
+                     INSERT INTO tysel_durable_metadata VALUES ('schema_version', 4);",
                 )
                 .unwrap();
         }
@@ -2177,7 +2316,7 @@ mod tests {
         };
         assert!(matches!(
             error,
-            DurableError::UnsupportedLogVersion { found: 3, supported: DURABLE_LOG_VERSION }
+            DurableError::UnsupportedLogVersion { found: 4, supported: DURABLE_LOG_VERSION }
         ));
         let connection = Connection::open(&path).unwrap();
         let events_table_exists: bool = connection
diff --git a/crates/tysel-durable/src/lifecycle.rs b/crates/tysel-durable/src/lifecycle.rs
index 299d1be..445d10d 100644
--- a/crates/tysel-durable/src/lifecycle.rs
+++ b/crates/tysel-durable/src/lifecycle.rs
@@ -118,6 +118,7 @@ impl SqliteStore {
             }
             return Ok(true);
         }
+        self.guard_execution(&tx, task_id)?;
         let Some(source_bytes) = tx
             .query_row(
                 "SELECT length(CAST(source AS BLOB)) FROM durable_programs WHERE task_id = ?1",
@@ -151,6 +152,8 @@ impl SqliteStore {
             params![id.as_slice(), actual, json, to_sql_integer(completed_at_ms, "completed_at_ms")?])?;
         tx.execute("UPDATE durable_program_stats SET active_count = active_count - 1, active_bytes = active_bytes - ?1 WHERE singleton = 1", params![source_bytes])?;
         completion_time(task_id, completed_at_ms, lease_until_ms)?;
+        self.guard_execution(&tx, task_id)?;
+        tx.execute("UPDATE durable_executions SET state='completed',owner=NULL,lease_until_ms=NULL WHERE task_id=?1", params![id.as_slice()])?;
         tx.commit()?;
         Ok(true)
     }
@@ -165,6 +168,7 @@ impl SqliteStore {
             let mut statement = tx.prepare(
                 "SELECT c.task_id, COALESCE(h.payload_bytes, 0) + COALESCE(length(CAST(p.source AS BLOB)), 0) + length(CAST(c.result_json AS BLOB))
                    + COALESCE((SELECT SUM(length(CAST(s.signal_name AS BLOB)) + length(CAST(s.payload AS BLOB))) FROM durable_signal_inbox s WHERE s.task_id = c.task_id), 0)
+                   + COALESCE((SELECT SUM(length(CAST(r.request_key AS BLOB)) + length(CAST(r.signal_name AS BLOB)) + length(CAST(r.payload AS BLOB))) FROM durable_signal_receipts r WHERE r.task_id = c.task_id), 0)
                  FROM durable_completions c
                  LEFT JOIN durable_programs p ON p.task_id = c.task_id
                  LEFT JOIN durable_history_stats h ON h.task_id = c.task_id
@@ -194,6 +198,8 @@ impl SqliteStore {
                 "durable_history_stats",
                 "durable_signal_inbox",
                 "durable_completions",
+                "durable_executions",
+                "durable_signal_receipts",
             ] {
                 tx.execute(&format!("DELETE FROM {table} WHERE task_id = ?1"), params![&id])?;
             }
@@ -366,7 +372,7 @@ mod tests {
         }
         {
             let store = SqliteStore::open(&path).unwrap();
-            assert_eq!(store.log_version().unwrap(), 2);
+            assert_eq!(store.log_version().unwrap(), DURABLE_LOG_VERSION);
             assert_eq!(store.program_count().unwrap(), 1);
             assert_eq!(store.prune_completed(u64::MAX / 2, 100).unwrap(), 0);
             store.complete_task(TaskId(1), 0, &Value::from(1), 10).unwrap();
diff --git a/crates/tysel-durable/src/postgres_store.rs b/crates/tysel-durable/src/postgres_store.rs
index 346bfe0..e126741 100644
--- a/crates/tysel-durable/src/postgres_store.rs
+++ b/crates/tysel-durable/src/postgres_store.rs
@@ -1,10 +1,13 @@
+mod execution;
 mod lifecycle;
+use super::ExecutionClaim;
 use native_tls::TlsConnector;
 use postgres::{Client, GenericClient, NoTls, Transaction};
 use postgres_native_tls::MakeTlsConnector;
 use r2d2_postgres::PostgresConnectionManager;
 use serde_json::Value;
 use sha2::{Digest, Sha256};
+use std::sync::Arc;
 use tysel_task::TaskId;
 
 use super::{
@@ -21,6 +24,7 @@ const DEFAULT_POOL_SIZE: u32 = 16;
 const MAX_POOL_SIZE: u32 = 128;
 pub const POSTGRES_URL_ENV: &str = "TYSEL_DURABLE_POSTGRES_URL";
 
+#[derive(Clone)]
 enum Pool {
     Plain(r2d2::Pool<PostgresConnectionManager<NoTls>>),
     Tls(r2d2::Pool<PostgresConnectionManager<MakeTlsConnector>>),
@@ -34,6 +38,7 @@ enum Pool {
 /// share one store.
 pub struct PostgresStore {
     pool: Pool,
+    execution: Option<ExecutionClaim>,
 }
 
 impl PostgresStore {
@@ -72,11 +77,84 @@ impl PostgresStore {
                 r2d2::Pool::builder().max_size(pool_size).build(manager).map_err(pool_error)?,
             )
         };
-        let store = Self { pool };
+        let store = Self { pool, execution: None };
         store.with_client(initialize_schema)?;
         Ok(store)
     }
 
+    fn send_signal_inner(
+        &self,
+        task_id: TaskId,
+        signal_name: &str,
+        payload: &Value,
+        sent_at_ms: u64,
+        key: Option<&str>,
+    ) -> Result<u64, DurableError> {
+        validate_signal_name(signal_name)?;
+        let payload = serde_json::to_string(payload)?;
+        if payload.len() > MAX_EVENT_PAYLOAD_BYTES {
+            return Err(DurableError::EventPayloadTooLarge);
+        }
+        let sent_at_ms = to_sql_integer(sent_at_ms, "sent_at_ms")?;
+        self.with_client(|client| {
+            let mut tx = client.transaction()?;
+            let id = task_id_bytes(task_id);
+            tx.execute("INSERT INTO durable_task_locks(task_id) VALUES ($1) ON CONFLICT DO NOTHING", &[&&id[..]])?;
+            tx.query_one("SELECT task_id FROM durable_task_locks WHERE task_id=$1 FOR UPDATE", &[&&id[..]])?;
+            if let Some(key) = key {
+                crate::execution::validate_key(key)?;
+                let hash = format!("{:x}",Sha256::digest(payload.as_bytes()));
+                if let Some(row) = tx.query_opt("SELECT signal_name,payload,signal_id FROM durable_signal_receipts WHERE task_id=$1 AND request_key=$2",&[&&id[..],&key])? {
+                    if row.get::<_,&str>(0)!=signal_name || row.get::<_,&str>(1)!=hash {return Err(DurableError::AdmissionConflict);}
+                    return from_sql_integer(row.get(2),"signal_id");
+                }
+                let count:i64=tx.query_one("SELECT COUNT(*) FROM durable_signal_receipts WHERE task_id=$1",&[&&id[..]])?.get(0);
+                if count>=MAX_HISTORY_EVENTS as i64 {return Err(DurableError::SignalInboxLimit);}
+                if !tx.query_one("SELECT EXISTS(SELECT 1 FROM durable_programs WHERE task_id=$1)",&[&&id[..]])?.get::<_,bool>(0) {return Err(DurableError::AdmissionConflict);}
+            }
+            lock_task(&mut tx, task_id)?;
+            let row = tx.query_one(
+                "SELECT COUNT(*), COALESCE(SUM(octet_length(signal_name) + octet_length(payload)), 0)
+                 FROM durable_signal_inbox WHERE task_id = $1",
+                &[&&id[..]],
+            )?;
+            let count: i64 = row.get(0);
+            let bytes: i64 = row.get(1);
+            let signal_bytes = signal_name.len().checked_add(payload.len()).ok_or(DurableError::SignalInboxLimit)?;
+            if count >= MAX_PENDING_SIGNALS as i64
+                || bytes
+                    .checked_add(i64::try_from(signal_bytes).map_err(|_| DurableError::SignalInboxLimit)?)
+                    .is_none_or(|value| value > MAX_HISTORY_BYTES as i64)
+            {
+                return Err(DurableError::SignalInboxLimit);
+            }
+            let signal_id: i64 = tx
+                .query_one(
+                    "INSERT INTO durable_signal_inbox (task_id, signal_name, payload, sent_at_ms)
+                     VALUES ($1, $2, $3, $4) RETURNING id",
+                    &[&&id[..], &signal_name, &payload, &sent_at_ms],
+                )?
+                .get(0);
+            if let Some(row) = tx.query_opt(
+                "SELECT sequence FROM durable_signal_waits WHERE task_id = $1 AND signal_name = $2",
+                &[&&id[..], &signal_name],
+            )? {
+                let sequence: i64 = row.get(0);
+                tx.execute(
+                    "INSERT INTO durable_wakeups
+                     (task_id, sequence, wake_at_ms, lease_owner, lease_until_ms)
+                     VALUES ($1, $2, $3, NULL, NULL) ON CONFLICT (task_id) DO NOTHING",
+                    &[&&id[..], &sequence, &sent_at_ms],
+                )?;
+            }
+            if let Some(key) = key {
+                tx.execute("INSERT INTO durable_signal_receipts(task_id,request_key,signal_name,payload,signal_id) VALUES ($1,$2,$3,$4,$5)",&[&&id[..],&key,&signal_name,&format!("{:x}",Sha256::digest(payload.as_bytes())),&signal_id])?;
+            }
+            tx.commit()?;
+            from_sql_integer(signal_id, "signal_id")
+        })
+    }
+
     fn with_client<T>(
         &self,
         operation: impl FnOnce(&mut Client) -> Result<T, DurableError>,
@@ -100,6 +178,9 @@ fn pool_error(error: impl std::fmt::Display) -> DurableError {
 
 fn initialize_schema(client: &mut Client) -> Result<(), DurableError> {
     let mut tx = client.transaction()?;
+    // Serialize bootstrap and migrations before touching even the metadata table.
+    // Transaction-scoped, so failed initialization cannot strand the lock.
+    tx.query_one("SELECT pg_advisory_xact_lock($1)", &[&0x747973656c64626di64])?;
     tx.batch_execute(
         "CREATE TABLE IF NOT EXISTS tysel_durable_metadata (
              key TEXT PRIMARY KEY,
@@ -166,6 +247,7 @@ fn initialize_schema(client: &mut Client) -> Result<(), DurableError> {
         }
     }
     lifecycle::initialize(&mut tx)?;
+    execution::initialize(&mut tx)?;
     tx.execute(
         "INSERT INTO tysel_durable_metadata (key, value) VALUES ('schema_version', $1)
          ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value",
@@ -366,6 +448,7 @@ impl PostgresStore {
         let wake_sql = wake_at_ms.map(|value| to_sql_integer(value, "wake_at_ms")).transpose()?;
         self.with_client(|client| {
             let mut tx = client.transaction()?;
+            self.guard_execution(&mut tx, task_id)?;
             let sequence = insert_event(
                 &mut tx,
                 task_id,
@@ -377,6 +460,7 @@ impl PostgresStore {
             if let Some(wake_at_ms) = wake_sql {
                 upsert_wakeup(&mut tx, task_id, sequence, wake_at_ms)?;
             }
+            self.guard_execution(&mut tx, task_id)?;
             tx.commit()?;
             stored_event(task_id, sequence, event, payload_json.into())
         })
@@ -384,6 +468,48 @@ impl PostgresStore {
 }
 
 impl DurableStore for PostgresStore {
+    fn admit_module(
+        &self,
+        id: TaskId,
+        key: &str,
+        source: &str,
+        input: &str,
+        now: u64,
+    ) -> Result<(), DurableError> {
+        self.admit(id, key, source, input, now)
+    }
+    fn claim_execution(
+        &self,
+        id: TaskId,
+        owner: &str,
+        duration: u64,
+    ) -> Result<Option<ExecutionClaim>, DurableError> {
+        self.claim_run(id, owner, duration)
+    }
+    fn execution_failed(&self, task_id: TaskId) -> Result<bool, DurableError> {
+        self.with_client(|client| {
+            Ok(client.query_one(
+            "SELECT EXISTS(SELECT 1 FROM durable_executions WHERE task_id=$1 AND state='failed')",
+            &[&&task_id_bytes(task_id)[..]]
+        )?.get(0))
+        })
+    }
+    fn execution_store(&self, claim: &ExecutionClaim) -> Arc<dyn DurableStore> {
+        Arc::new(Self { pool: self.pool.clone(), execution: Some(claim.clone()) })
+    }
+    fn finish_execution(&self, claim: &ExecutionClaim, failed: bool) -> Result<(), DurableError> {
+        self.release_run(claim, failed)
+    }
+    fn send_signal_once(
+        &self,
+        id: TaskId,
+        name: &str,
+        payload: &Value,
+        key: &str,
+        now: u64,
+    ) -> Result<u64, DurableError> {
+        self.send_signal_inner(id, name, payload, now, Some(key))
+    }
     fn completion(&self, task_id: TaskId) -> Result<Option<TaskCompletion>, DurableError> {
         self.read_completion(task_id)
     }
@@ -459,12 +585,24 @@ impl DurableStore for PostgresStore {
         let now_ms = to_sql_integer(now_ms, "now_ms")?;
         self.with_client(|client| {
             let rows = client.query(
-                "SELECT p.task_id, p.program_kind, p.source, p.source_sha256, p.registered_at_ms
-                 FROM durable_programs p JOIN durable_wakeups w ON w.task_id = p.task_id
-                 WHERE w.wake_at_ms <= $1 AND (w.lease_until_ms IS NULL OR w.lease_until_ms <= $1)
-                   AND p.program_kind = $2
-                   AND NOT EXISTS (SELECT 1 FROM durable_completions c WHERE c.task_id = p.task_id)
-                   ORDER BY w.wake_at_ms, p.task_id LIMIT $3",
+                "WITH due AS (
+                SELECT w.task_id, w.wake_at_ms AS due_at
+                FROM durable_wakeups w LEFT JOIN durable_executions r ON r.task_id=w.task_id
+                WHERE w.wake_at_ms <= $1 AND (w.lease_until_ms IS NULL OR w.lease_until_ms <= $1)
+                  AND (r.state IS NULL OR r.state IN ('ready','running','suspended'))
+                  AND (r.lease_until_ms IS NULL OR r.lease_until_ms <= $1)
+                UNION ALL
+                SELECT r.task_id, COALESCE(r.lease_until_ms, 0) AS due_at
+                FROM durable_executions r
+                WHERE r.state IN ('ready','running') AND (r.lease_until_ms IS NULL OR r.lease_until_ms <= $1)
+                  AND NOT EXISTS(SELECT 1 FROM durable_wakeups w WHERE w.task_id=r.task_id)
+                  AND NOT EXISTS(SELECT 1 FROM durable_signal_waits s WHERE s.task_id=r.task_id)
+             )
+             SELECT p.task_id, p.program_kind, p.source, p.source_sha256, p.registered_at_ms
+             FROM due d JOIN durable_programs p ON p.task_id=d.task_id
+             WHERE p.program_kind=$2
+               AND NOT EXISTS(SELECT 1 FROM durable_completions c WHERE c.task_id=p.task_id)
+             ORDER BY d.due_at, p.task_id LIMIT $3",
                 &[&now_ms, &kind.as_str(), &(limit.min(MAX_DURABLE_PROGRAMS) as i64)],
             )?;
             if rows.len() > MAX_DURABLE_PROGRAMS {
@@ -677,20 +815,24 @@ impl DurableStore for PostgresStore {
         let sequence = to_sql_integer(sequence, "sequence")?;
         let now_ms = to_sql_integer(now_ms, "now_ms")?;
         self.with_client(|client| {
+            let mut tx = client.transaction()?;
+            self.guard_execution(&mut tx, task_id)?;
             let changed = if let Some(owner) = lease_owner {
                 validate_lease_owner(owner)?;
-                client.execute(
+                tx.execute(
                     "DELETE FROM durable_wakeups WHERE task_id = $1 AND sequence = $2
                      AND lease_owner = $3 AND lease_until_ms > $4",
                     &[&&id[..], &sequence, &owner, &now_ms],
                 )?
             } else {
-                client.execute(
+                tx.execute(
                     "DELETE FROM durable_wakeups WHERE task_id = $1 AND sequence = $2
                      AND lease_owner IS NULL",
                     &[&&id[..], &sequence],
                 )?
             };
+            self.guard_execution(&mut tx, task_id)?;
+            tx.commit()?;
             Ok(changed == 1)
         })
     }
@@ -816,52 +958,7 @@ impl DurableStore for PostgresStore {
         payload: &Value,
         sent_at_ms: u64,
     ) -> Result<u64, DurableError> {
-        validate_signal_name(signal_name)?;
-        let payload = serde_json::to_string(payload)?;
-        if payload.len() > MAX_EVENT_PAYLOAD_BYTES {
-            return Err(DurableError::EventPayloadTooLarge);
-        }
-        let sent_at_ms = to_sql_integer(sent_at_ms, "sent_at_ms")?;
-        self.with_client(|client| {
-            let mut tx = client.transaction()?;
-            let id = lock_task(&mut tx, task_id)?;
-            let row = tx.query_one(
-                "SELECT COUNT(*), COALESCE(SUM(octet_length(signal_name) + octet_length(payload)), 0)
-                 FROM durable_signal_inbox WHERE task_id = $1",
-                &[&&id[..]],
-            )?;
-            let count: i64 = row.get(0);
-            let bytes: i64 = row.get(1);
-            let signal_bytes = signal_name.len().checked_add(payload.len()).ok_or(DurableError::SignalInboxLimit)?;
-            if count >= MAX_PENDING_SIGNALS as i64
-                || bytes
-                    .checked_add(i64::try_from(signal_bytes).map_err(|_| DurableError::SignalInboxLimit)?)
-                    .is_none_or(|value| value > MAX_HISTORY_BYTES as i64)
-            {
-                return Err(DurableError::SignalInboxLimit);
-            }
-            let signal_id: i64 = tx
-                .query_one(
-                    "INSERT INTO durable_signal_inbox (task_id, signal_name, payload, sent_at_ms)
-                     VALUES ($1, $2, $3, $4) RETURNING id",
-                    &[&&id[..], &signal_name, &payload, &sent_at_ms],
-                )?
-                .get(0);
-            if let Some(row) = tx.query_opt(
-                "SELECT sequence FROM durable_signal_waits WHERE task_id = $1 AND signal_name = $2",
-                &[&&id[..], &signal_name],
-            )? {
-                let sequence: i64 = row.get(0);
-                tx.execute(
-                    "INSERT INTO durable_wakeups
-                     (task_id, sequence, wake_at_ms, lease_owner, lease_until_ms)
-                     VALUES ($1, $2, $3, NULL, NULL) ON CONFLICT (task_id) DO NOTHING",
-                    &[&&id[..], &sequence, &sent_at_ms],
-                )?;
-            }
-            tx.commit()?;
-            from_sql_integer(signal_id, "signal_id")
-        })
+        self.send_signal_inner(task_id, signal_name, payload, sent_at_ms, None)
     }
 
     fn poll_signal(
@@ -876,6 +973,7 @@ impl DurableStore for PostgresStore {
         let now_sql = to_sql_integer(now_ms, "now_ms")?;
         self.with_client(|client| {
             let mut tx = client.transaction()?;
+            self.guard_execution(&mut tx, task_id)?;
             let id = lock_task(&mut tx, task_id)?;
             let actual: i64 = tx
                 .query_one(
@@ -918,7 +1016,8 @@ impl DurableStore for PostgresStore {
                 {
                     return Err(DurableError::SignalWaitConflict);
                 }
-                tx.commit()?;
+                self.guard_execution(&mut tx, task_id)?;
+            tx.commit()?;
                 return Ok(None);
             };
 
@@ -970,6 +1069,7 @@ impl DurableStore for PostgresStore {
                 "DELETE FROM durable_signal_waits WHERE task_id = $1 AND sequence = $2 AND signal_name = $3",
                 &[&&id[..], &sequence, &signal_name],
             )?;
+            self.guard_execution(&mut tx, task_id)?;
             tx.commit()?;
             stored_event(task_id, sequence, event, payload_json).map(Some)
         })
diff --git a/crates/tysel-durable/src/postgres_store/execution.rs b/crates/tysel-durable/src/postgres_store/execution.rs
new file mode 100644
index 0000000..f9db129
--- /dev/null
+++ b/crates/tysel-durable/src/postgres_store/execution.rs
@@ -0,0 +1,124 @@
+use super::*;
+use crate::execution::{fingerprint, now, validate_key};
+
+pub(super) fn initialize(tx: &mut Transaction<'_>) -> Result<(), DurableError> {
+    tx.batch_execute("CREATE TABLE IF NOT EXISTS durable_executions (
+        task_id BYTEA PRIMARY KEY,
+        state TEXT NOT NULL CHECK (state IN ('ready','running','suspended','failed','completed')),
+        generation BIGINT NOT NULL DEFAULT 0,
+        owner TEXT, lease_until_ms BIGINT,
+        admission_key TEXT, request_hash TEXT
+    );
+    CREATE INDEX IF NOT EXISTS durable_executions_due ON durable_executions(state, lease_until_ms, task_id);
+    CREATE TABLE IF NOT EXISTS durable_signal_receipts (
+        task_id BYTEA NOT NULL, request_key TEXT NOT NULL, signal_name TEXT NOT NULL,
+        payload TEXT NOT NULL, signal_id BIGINT NOT NULL, PRIMARY KEY(task_id, request_key)
+    );")?;
+    Ok(())
+}
+impl PostgresStore {
+    pub(super) fn guard_execution(
+        &self,
+        tx: &mut Transaction<'_>,
+        task: TaskId,
+    ) -> Result<(), DurableError> {
+        let Some(claim) = &self.execution else {
+            return Ok(());
+        };
+        // Share the task lock with admission, claims, completion and all event writes.
+        let id = task_id_bytes(task);
+        tx.query_one(
+            "SELECT task_id FROM durable_task_locks WHERE task_id=$1 FOR UPDATE",
+            &[&&id[..]],
+        )?;
+        let valid:bool = tx.query_one("SELECT EXISTS(SELECT 1 FROM durable_executions WHERE task_id=$1 AND state='running' AND owner=$2 AND generation=$3 AND lease_until_ms > $4)",
+            &[&&id[..],&claim.owner,&to_sql_integer(claim.generation,"generation")?,&to_sql_integer(now()?,"time")?])?.get(0);
+        if task != claim.task_id || !valid {
+            return Err(DurableError::ExecutionLeaseLost);
+        }
+        Ok(())
+    }
+    pub(super) fn admit(
+        &self,
+        task: TaskId,
+        key: &str,
+        source: &str,
+        input: &str,
+        time: u64,
+    ) -> Result<(), DurableError> {
+        validate_key(key)?;
+        let (hash, input) = fingerprint(source, input)?;
+        self.with_client(|client| {
+            let mut tx=client.transaction()?;
+            let id=task_id_bytes(task);
+            tx.execute("INSERT INTO durable_task_locks(task_id) VALUES ($1) ON CONFLICT DO NOTHING", &[&&id[..]])?;
+            tx.query_one("SELECT task_id FROM durable_task_locks WHERE task_id=$1 FOR UPDATE", &[&&id[..]])?;
+            if let Some(row)=tx.query_opt("SELECT admission_key,request_hash FROM durable_executions WHERE task_id=$1", &[&&id[..]])? {
+                if row.get::<_,Option<&str>>(0)!=Some(key) || row.get::<_,Option<&str>>(1)!=Some(hash.as_str()) {return Err(DurableError::AdmissionConflict);}
+                return Ok(());
+            }
+            if select_program(&mut tx,task)?.is_some() {return Err(DurableError::AdmissionConflict);}
+            let row=tx.query_one("SELECT active_count,active_bytes FROM durable_program_stats WHERE singleton=1 FOR UPDATE",&[])?;
+            if row.get::<_,i64>(0)>=MAX_DURABLE_PROGRAMS as i64 {return Err(DurableError::ProgramLimit);}
+            if row.get::<_,i64>(1)+source.len() as i64 > MAX_DURABLE_PROGRAM_TOTAL_BYTES as i64 {return Err(DurableError::ProgramByteLimit);}
+            let digest:[u8;32]=Sha256::digest(source.as_bytes()).into();
+            tx.execute("INSERT INTO durable_programs(task_id,program_kind,source,source_sha256,registered_at_ms) VALUES ($1,'module',$2,$3,$4)",&[&&id[..],&source,&&digest[..],&to_sql_integer(time,"time")?])?;
+            tx.execute("UPDATE durable_program_stats SET active_count=active_count+1,active_bytes=active_bytes+$1 WHERE singleton=1",&[&(source.len() as i64)])?;
+            let event=raw_event(EventKind::Step,"$tysel:task-input".into(),&input,time)?;
+            insert_event(&mut tx,task,0,&event,&input,to_sql_integer(time,"time")?)?;
+            tx.execute("INSERT INTO durable_executions(task_id,state,admission_key,request_hash) VALUES ($1,'ready',$2,$3)",&[&&id[..],&key,&hash])?;
+            tx.commit()?; Ok(())
+        })
+    }
+    pub(super) fn claim_run(
+        &self,
+        task: TaskId,
+        owner: &str,
+        duration: u64,
+    ) -> Result<Option<ExecutionClaim>, DurableError> {
+        let token = crate::execution::owner_token(owner)?;
+        let owner = token.as_str();
+        self.with_client(|client| {
+            let mut tx=client.transaction()?;
+            let id=task_id_bytes(task);
+            tx.execute("INSERT INTO durable_task_locks(task_id) VALUES ($1) ON CONFLICT DO NOTHING", &[&&id[..]])?;
+            // Skip a busy task instead of serializing the scheduler behind it.
+            if tx.query_opt("SELECT task_id FROM durable_task_locks WHERE task_id=$1 FOR UPDATE SKIP LOCKED", &[&&id[..]])?.is_none() {return Ok(None);}
+            if tx.query_one("SELECT EXISTS(SELECT 1 FROM durable_completions WHERE task_id=$1)",&[&&id[..]])?.get::<_,bool>(0) {return Ok(None);}
+            if !tx.query_one("SELECT EXISTS(SELECT 1 FROM durable_programs WHERE task_id=$1)",&[&&id[..]])?.get::<_,bool>(0) {return Ok(None);}
+            let time=now()?;
+            let until=time.checked_add(duration).filter(|u|*u>time).ok_or(DurableError::ExecutionLeaseLost)?;
+            let row=tx.query_opt("SELECT state,generation,lease_until_ms FROM durable_executions WHERE task_id=$1",&[&&id[..]])?;
+            if let Some(row)=&row
+                && (matches!(row.get::<_,&str>(0),"completed"|"failed") || row.get::<_,Option<i64>>(2).is_some_and(|u|u>time as i64)) {return Ok(None);}
+            let wake=tx.query_opt("SELECT sequence,wake_at_ms,lease_until_ms FROM durable_wakeups WHERE task_id=$1 FOR UPDATE",&[&&id[..]])?;
+            if wake.as_ref().is_some_and(|w|w.get::<_,i64>(1)>time as i64 || w.get::<_,Option<i64>>(2).is_some_and(|u|u>time as i64)) {return Ok(None);}
+            if wake.is_none() && tx.query_one("SELECT EXISTS(SELECT 1 FROM durable_signal_waits WHERE task_id=$1)",&[&&id[..]])?.get::<_,bool>(0) {return Ok(None);}
+            let generation=row.map_or(Ok(1),|r|r.get::<_,i64>(1).checked_add(1).ok_or(DurableError::ExecutionLeaseLost))?;
+            tx.execute("INSERT INTO durable_executions(task_id,state,generation,owner,lease_until_ms) VALUES ($1,'running',$2,$3,$4) ON CONFLICT(task_id) DO UPDATE SET state='running',generation=excluded.generation,owner=excluded.owner,lease_until_ms=excluded.lease_until_ms",&[&&id[..],&generation,&owner,&to_sql_integer(until,"lease")?])?;
+            let wakeup=if let Some(w)=wake {
+                tx.execute("UPDATE durable_wakeups SET lease_owner=$2,lease_until_ms=$3 WHERE task_id=$1",&[&&id[..],&owner,&to_sql_integer(until,"lease")?])?;
+                Some(WakeupClaim{task_id:task,sequence:w.get::<_,i64>(0) as u64,wake_at_ms:w.get::<_,i64>(1) as u64,lease_owner:owner.into(),lease_until_ms:until})
+            }else{None};
+            if now()? >= until {return Ok(None);}
+            tx.commit()?;
+            Ok(Some(ExecutionClaim{task_id:task,owner:owner.into(),generation:generation as u64,lease_until_ms:until,wakeup}))
+        })
+    }
+    pub(super) fn release_run(
+        &self,
+        claim: &ExecutionClaim,
+        failed: bool,
+    ) -> Result<(), DurableError> {
+        let scoped = Self { pool: self.pool.clone(), execution: Some(claim.clone()) };
+        self.with_client(|client| {
+            let mut tx=client.transaction()?;
+            scoped.guard_execution(&mut tx,claim.task_id)?;
+            let id=task_id_bytes(claim.task_id);
+            tx.execute("UPDATE durable_wakeups SET lease_owner=NULL,lease_until_ms=NULL WHERE task_id=$1",&[&&id[..]])?;
+            scoped.guard_execution(&mut tx,claim.task_id)?;
+            tx.execute("UPDATE durable_executions SET state=$2,owner=NULL,lease_until_ms=NULL WHERE task_id=$1",&[&&id[..],&if failed{"failed"}else{"suspended"}])?;
+            tx.commit()?;Ok(())
+        })
+    }
+}
diff --git a/crates/tysel-durable/src/postgres_store/lifecycle.rs b/crates/tysel-durable/src/postgres_store/lifecycle.rs
index 007ebfb..b682951 100644
--- a/crates/tysel-durable/src/postgres_store/lifecycle.rs
+++ b/crates/tysel-durable/src/postgres_store/lifecycle.rs
@@ -76,6 +76,7 @@ impl PostgresStore {
                 }
                 return Ok(true);
             }
+            self.guard_execution(&mut tx, task_id)?;
             let Some(program) = tx.query_opt("SELECT octet_length(source) FROM durable_programs WHERE task_id = $1", &[&&id[..]])? else { return Ok(false); };
             let source_bytes = i64::from(program.get::<_, i32>(0));
             let actual: i64 = tx.query_one("SELECT COALESCE(MAX(sequence) + 1, 0) FROM durable_events WHERE task_id = $1", &[&&id[..]])?.get(0);
@@ -92,6 +93,8 @@ impl PostgresStore {
             tx.execute("INSERT INTO durable_completions (task_id, next_sequence, result_json, completed_at_ms) VALUES ($1, $2, $3, $4)",
                 &[&&id[..], &actual, &json, &to_sql_integer(completed_at_ms, "completed_at_ms")?])?;
             crate::lifecycle::completion_time(task_id, completed_at_ms, lease_until_ms)?;
+            self.guard_execution(&mut tx, task_id)?;
+            tx.execute("UPDATE durable_executions SET state='completed',owner=NULL,lease_until_ms=NULL WHERE task_id=$1", &[&&id[..]])?;
             tx.commit()?;
             Ok(true)
         })
@@ -109,6 +112,7 @@ impl PostgresStore {
             let candidates = client.query(
                 "SELECT c.task_id, COALESCE(h.payload_bytes, 0) + COALESCE(octet_length(p.source), 0) + octet_length(c.result_json)
                    + COALESCE((SELECT SUM(octet_length(s.signal_name) + octet_length(s.payload)) FROM durable_signal_inbox s WHERE s.task_id = c.task_id), 0)
+                   + COALESCE((SELECT SUM(octet_length(r.request_key) + octet_length(r.signal_name) + octet_length(r.payload)) FROM durable_signal_receipts r WHERE r.task_id = c.task_id), 0)
                  FROM durable_completions c
                  LEFT JOIN durable_programs p ON p.task_id = c.task_id
                  LEFT JOIN durable_history_stats h ON h.task_id = c.task_id
@@ -131,7 +135,7 @@ impl PostgresStore {
                     &[&id, &to_sql_integer(before_ms, "before_ms")?],
                 )?.get(0);
                 if !eligible { continue; }
-                for table in ["durable_programs", "durable_events", "durable_history_stats", "durable_signal_inbox", "durable_completions"] {
+                for table in ["durable_programs", "durable_events", "durable_history_stats", "durable_signal_inbox", "durable_completions", "durable_executions", "durable_signal_receipts"] {
                     tx.execute(&format!("DELETE FROM {table} WHERE task_id = $1"), &[&id])?;
                 }
                 // Retain the small synchronization row: deleting a row that another
diff --git a/crates/tysel-durable/tests/execution.rs b/crates/tysel-durable/tests/execution.rs
new file mode 100644
index 0000000..da88fc9
--- /dev/null
+++ b/crates/tysel-durable/tests/execution.rs
@@ -0,0 +1,94 @@
+use serde_json::json;
+use std::sync::Arc;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use tysel_durable::{
+    DurableError, DurableProgramKind, DurableStore, EventKind, PostgresStore, SqliteStore,
+    admission_task_id,
+};
+fn now() -> u64 {
+    SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis() as u64
+}
+fn contract(store: Arc<dyn DurableStore>) {
+    let key = format!(
+        "execution-test-{}-{}",
+        std::process::id(),
+        SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos()
+    );
+    let id = admission_task_id(&key).unwrap();
+    let source = "export default async () => 42";
+    store.admit_module(id, &key, source, "{\"n\":1}", now()).unwrap();
+    store.admit_module(id, &key, source, "{ \"n\": 1 }", now()).unwrap();
+    assert!(matches!(
+        store.admit_module(id, &key, source, "2", now()),
+        Err(DurableError::AdmissionConflict)
+    ));
+    assert_eq!(store.load_history(id).unwrap().events.len(), 1);
+    assert!(
+        store
+            .load_due_programs_batch(now(), DurableProgramKind::Module, 100)
+            .unwrap()
+            .iter()
+            .any(|p| p.task_id == id)
+    );
+    let first = store.claim_execution(id, "same-owner", 150).unwrap().unwrap();
+    assert!(store.claim_execution(id, "same-owner", 150).unwrap().is_none());
+    let stale = store.execution_store(&first);
+    // An active task remains eligible after process death even without a wakeup.
+    std::thread::sleep(Duration::from_millis(180));
+    let second = store.claim_execution(id, "same-owner", 5_000).unwrap().unwrap();
+    assert!(second.generation > first.generation);
+    assert!(matches!(store.finish_execution(&first, false), Err(DurableError::ExecutionLeaseLost)));
+    assert!(matches!(
+        stale.append_event_json_at(id, 1, EventKind::Effect, "write".into(), "42", now()),
+        Err(DurableError::ExecutionLeaseLost)
+    ));
+    assert!(matches!(
+        stale.complete_task_before(id, 1, &json!(42), u64::MAX),
+        Err(DurableError::ExecutionLeaseLost)
+    ));
+    let scoped = store.execution_store(&second);
+    scoped.append_event_json_at(id, 1, EventKind::Effect, "write".into(), "42", now()).unwrap();
+    let signal = store.send_signal_once(id, "approval", &json!(true), "decision-1", now()).unwrap();
+    assert_eq!(
+        store.send_signal_once(id, "approval", &json!(true), "decision-1", now()).unwrap(),
+        signal
+    );
+    assert!(matches!(
+        store.send_signal_once(id, "approval", &json!(false), "decision-1", now()),
+        Err(DurableError::AdmissionConflict)
+    ));
+    assert!(scoped.poll_signal(id, 2, "approval", now(), None).unwrap().is_some());
+    assert_eq!(
+        store.send_signal_once(id, "approval", &json!(true), "decision-1", now()).unwrap(),
+        signal
+    );
+    assert_eq!(store.load_history(id).unwrap().events.len(), 3);
+    assert!(scoped.complete_task_before(id, 3, &json!(42), second.lease_until_ms).unwrap());
+    store.admit_module(id, &key, source, "{\"n\":1}", now()).unwrap();
+    assert_eq!(
+        store.send_signal_once(id, "approval", &json!(true), "decision-1", now()).unwrap(),
+        signal
+    );
+    assert!(store.claim_execution(id, "third", 5_000).unwrap().is_none());
+    assert!(scoped.complete_task_before(id, 3, &json!(42), 0).unwrap());
+    let failed_key = format!("{key}-failed");
+    let failed_id = admission_task_id(&failed_key).unwrap();
+    store.admit_module(failed_id, &failed_key, source, "null", now()).unwrap();
+    assert!(!store.execution_failed(failed_id).unwrap());
+    let claim = store.claim_execution(failed_id, "failed-owner", 5000).unwrap().unwrap();
+    store.finish_execution(&claim, true).unwrap();
+    assert!(store.execution_failed(failed_id).unwrap());
+    store.admit_module(failed_id, &failed_key, source, "null", now()).unwrap();
+    assert!(store.execution_failed(failed_id).unwrap());
+}
+#[test]
+fn sqlite_execution_and_idempotency_contract() {
+    contract(Arc::new(SqliteStore::in_memory().unwrap()));
+}
+#[test]
+fn postgres_execution_and_idempotency_contract() {
+    let Ok(url) = std::env::var("TYSEL_POSTGRES_TEST_URL") else {
+        return;
+    };
+    contract(Arc::new(PostgresStore::connect(&url).unwrap()));
+}
diff --git a/crates/tysel-durable/tests/postgres_live.rs b/crates/tysel-durable/tests/postgres_live.rs
index 9c42924..178ad33 100644
--- a/crates/tysel-durable/tests/postgres_live.rs
+++ b/crates/tysel-durable/tests/postgres_live.rs
@@ -183,7 +183,7 @@ fn postgres_v1_migration_keeps_unclassified_work_and_reopens_completion_counters
     }
     {
         let store = PostgresStore::connect(&scoped).unwrap();
-        assert_eq!(store.log_version().unwrap(), 2);
+        assert_eq!(store.log_version().unwrap(), DURABLE_LOG_VERSION);
         assert_eq!(store.program_count().unwrap(), 1);
         assert_eq!(store.prune_completed(100, 100).unwrap(), 0);
         store.complete_task(TaskId(1), 0, &json!(42), 1).unwrap();
@@ -247,3 +247,39 @@ fn postgres_completion_rechecks_lease_after_task_and_quota_lock_waits() {
         ));
     }
 }
+
+#[test]
+fn postgres_concurrent_empty_schema_initialization_is_serialized() {
+    let Ok(url) = std::env::var("TYSEL_POSTGRES_TEST_URL") else {
+        return;
+    };
+    let schema = format!(
+        "init_{}_{}",
+        std::process::id(),
+        SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos()
+    );
+    let mut admin = postgres::Client::connect(&url, postgres::NoTls).unwrap();
+    admin.batch_execute(&format!("CREATE SCHEMA {schema}")).unwrap();
+    let scoped_url = format!(
+        "{url}{}options=-csearch_path%3D{schema}",
+        if url.contains('?') { "&" } else { "?" }
+    );
+    let barrier = Arc::new(Barrier::new(8));
+    let workers: Vec<_> = (0..8)
+        .map(|_| {
+            let url = scoped_url.clone();
+            let barrier = barrier.clone();
+            std::thread::spawn(move || {
+                barrier.wait();
+                let store = PostgresStore::connect_with_pool_size(&url, 1)?;
+                assert_eq!(store.log_version()?, DURABLE_LOG_VERSION);
+                Ok::<_, DurableError>(())
+            })
+        })
+        .collect();
+    let results: Vec<_> = workers.into_iter().map(|w| w.join()).collect();
+    admin.batch_execute(&format!("DROP SCHEMA {schema} CASCADE")).unwrap();
+    for result in results {
+        result.unwrap().unwrap();
+    }
+}

From 526ed898852f6a549aaaf35c27d34697f6593e08 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Tue, 8 Sep 2026 22:01:54 +0800
Subject: [PATCH 23/31] fix(runtime): recover active tasks and preserve durable
 control across reloads

---
 crates/tysel-cli/src/dev.rs                   |  43 +--
 crates/tysel-engine-qjs/src/control.rs        |  27 +-
 crates/tysel-engine-qjs/src/durable.rs        |  97 +++++-
 crates/tysel-engine-qjs/src/host.rs           |  22 +-
 crates/tysel-engine-qjs/src/lib.rs            |   5 +-
 crates/tysel-runtime/src/durable.rs           | 279 ++++++++++++++++--
 crates/tysel-runtime/src/durable_plane.rs     | 148 ++++++++--
 crates/tysel-runtime/src/service.rs           |  38 ++-
 .../tysel-runtime/tests/lease_completion.rs   |   2 +-
 packages/tysel-types/src/index.ts             |  13 +
 packages/tysel-types/test/consumer/index.ts   |  11 +
 runtime-js/capability-client/index.ts         |   4 +-
 runtime-js/durable/control.js                 |  15 +-
 tests/p1/reload_recovery.py                   |  38 +++
 14 files changed, 633 insertions(+), 109 deletions(-)
 create mode 100644 tests/p1/reload_recovery.py

diff --git a/crates/tysel-cli/src/dev.rs b/crates/tysel-cli/src/dev.rs
index fb4e1ed..457dc9d 100644
--- a/crates/tysel-cli/src/dev.rs
+++ b/crates/tysel-cli/src/dev.rs
@@ -655,23 +655,27 @@ async fn shutdown_task_service(_service: Option<()>) -> Result<()> {
 }
 
 async fn start_dev_durable(spec: Option<DurableSpec>) -> Result<Option<Arc<DurablePlane>>> {
-    let Some(spec) = spec else {
-        return Ok(None);
-    };
-    if spec.execution_profile.eq_ignore_ascii_case("isolated") {
-        return Ok(None);
-    }
-    if !DurablePlane::requested(&spec.sqlite_path, Some(&spec.root), &spec.source, spec.config)? {
-        return Ok(None);
-    }
-    let Some(store) = DurablePlane::open_store(&spec.sqlite_path, Some(&spec.root))? else {
-        return Ok(None);
-    };
-    if !DurablePlane::should_start(store.as_ref(), &spec.source, spec.config)? {
-        return Ok(None);
-    }
-    let owner = format!("tysel-dev-{}", std::process::id());
-    Ok(Some(DurablePlane::start(store, spec.source, spec.config, owner)?))
+    tokio::task::spawn_blocking(move || {
+        let Some(spec) = spec else {
+            return Ok(None);
+        };
+        if spec.execution_profile.eq_ignore_ascii_case("isolated") {
+            return Ok(None);
+        }
+        if !DurablePlane::requested(&spec.sqlite_path, Some(&spec.root), &spec.source, spec.config)?
+        {
+            return Ok(None);
+        }
+        let Some(store) = DurablePlane::open_store(&spec.sqlite_path, Some(&spec.root))? else {
+            return Ok(None);
+        };
+        if !DurablePlane::should_start(store.as_ref(), &spec.source, spec.config)? {
+            return Ok(None);
+        }
+        let owner = format!("tysel-dev-{}", std::process::id());
+        Ok(Some(DurablePlane::start(store, spec.source, spec.config, owner)?))
+    })
+    .await?
 }
 
 async fn durable_service_failure(plane: Option<&Arc<DurablePlane>>) -> anyhow::Error {
@@ -683,7 +687,10 @@ async fn durable_service_failure(plane: Option<&Arc<DurablePlane>>) -> anyhow::E
 
 async fn shutdown_durable(plane: Option<Arc<DurablePlane>>) -> Result<()> {
     if let Some(plane) = plane {
-        plane.shutdown().await?;
+        let result = plane.shutdown().await;
+        // The synchronous PostgreSQL client also drives its runtime on drop.
+        tokio::task::spawn_blocking(move || drop(plane)).await?;
+        result?;
     }
     Ok(())
 }
diff --git a/crates/tysel-engine-qjs/src/control.rs b/crates/tysel-engine-qjs/src/control.rs
index 701e249..0a95129 100644
--- a/crates/tysel-engine-qjs/src/control.rs
+++ b/crates/tysel-engine-qjs/src/control.rs
@@ -1,7 +1,7 @@
-use std::sync::{Arc, OnceLock, RwLock};
+use std::sync::{Arc, OnceLock, RwLock, Weak};
 
-type StartFn = Box<dyn Fn(&str, &str) -> Result<String, String> + Send + Sync>;
-type SignalFn = Box<dyn Fn(&str, &str, &str) -> Result<(), String> + Send + Sync>;
+type StartFn = Box<dyn Fn(&str, &str, Option<&str>) -> Result<String, String> + Send + Sync>;
+type SignalFn = Box<dyn Fn(&str, &str, &str, Option<&str>) -> Result<(), String> + Send + Sync>;
 
 /// Process-wide hooks so a fetch handler can start and signal durable tasks
 /// owned by the embedding service. Unconfigured processes fail closed.
@@ -19,18 +19,31 @@ pub fn configure(control: Option<Arc<DurableControl>>) {
     *slot().write().expect("durable control lock") = control;
 }
 
-pub fn start_named(name: &str, input_json: &str) -> Result<String, String> {
+/// Retiring a scheduler must not unregister a newer scheduler's hooks.
+pub fn clear_if_current(owner: &Weak<DurableControl>) {
+    let mut guard = slot().write().expect("durable control lock");
+    if guard.as_ref().is_some_and(|current| owner.ptr_eq(&Arc::downgrade(current))) {
+        *guard = None;
+    }
+}
+
+pub fn start_named(name: &str, input_json: &str, key: Option<&str>) -> Result<String, String> {
     let guard = slot().read().map_err(|_| "durable control lock poisoned".to_string())?;
     let Some(control) = guard.as_ref() else {
         return Err("durable scheduler is not configured".into());
     };
-    (control.start)(name, input_json)
+    (control.start)(name, input_json, key)
 }
 
-pub fn send_signal(task_id: &str, name: &str, payload_json: &str) -> Result<(), String> {
+pub fn send_signal(
+    task_id: &str,
+    name: &str,
+    payload_json: &str,
+    key: Option<&str>,
+) -> Result<(), String> {
     let guard = slot().read().map_err(|_| "durable control lock poisoned".to_string())?;
     let Some(control) = guard.as_ref() else {
         return Err("durable scheduler is not configured".into());
     };
-    (control.send_signal)(task_id, name, payload_json)
+    (control.send_signal)(task_id, name, payload_json, key)
 }
diff --git a/crates/tysel-engine-qjs/src/durable.rs b/crates/tysel-engine-qjs/src/durable.rs
index cc64498..bf28a96 100644
--- a/crates/tysel-engine-qjs/src/durable.rs
+++ b/crates/tysel-engine-qjs/src/durable.rs
@@ -2,7 +2,7 @@ use std::sync::{Arc, Mutex};
 
 use serde_json::json;
 use tysel_durable::{
-    DurableError, DurableStore, EventKind, ReplayCursor, ReplayError, WakeupClaim,
+    DurableError, DurableStore, EventKind, ExecutionClaim, ReplayCursor, ReplayError, WakeupClaim,
 };
 use tysel_task::TaskId;
 
@@ -20,6 +20,25 @@ struct SessionInner {
     suspended: bool,
     lease_until_ms: Option<u64>,
     result_json: Option<serde_json::Value>,
+    replayed_sleep: Option<u64>,
+    storage_error: Option<DurableError>,
+}
+
+impl SessionInner {
+    fn check_storage(&self) -> Result<(), String> {
+        match &self.storage_error {
+            Some(error) => Err(error.to_string()),
+            None => Ok(()),
+        }
+    }
+
+    fn capture_storage(&mut self, error: DurableError) -> String {
+        let message = error.to_string();
+        if self.storage_error.is_none() {
+            self.storage_error = Some(error);
+        }
+        message
+    }
 }
 
 struct WakeupToken {
@@ -38,6 +57,7 @@ impl DurableSession {
     pub(crate) fn record_input_json(&self, input_json: &str) -> Result<String, String> {
         const INPUT_KEY: &str = "$tysel:task-input";
         let mut inner = self.inner.lock().map_err(|_| "durable session lock poisoned")?;
+        inner.check_storage()?;
         if let Some(event) =
             inner.replay.consume_event(EventKind::Step, INPUT_KEY).map_err(replay_error)?
         {
@@ -53,7 +73,7 @@ impl DurableSession {
                 input_json,
                 unix_time_ms()?,
             )
-            .map_err(|err| err.to_string())?;
+            .map_err(|err| inner.capture_storage(err))?;
         inner.next_sequence = stored.sequence.saturating_add(1);
         Ok(stored.payload_json().into())
     }
@@ -91,6 +111,21 @@ impl DurableSession {
         Self::load(store, task_id, Some(claim))
     }
 
+    pub fn from_execution(
+        store: Arc<dyn DurableStore>,
+        claim: &ExecutionClaim,
+    ) -> Result<Self, String> {
+        let scoped = store.execution_store(claim);
+        let session = if let Some(wakeup) = &claim.wakeup {
+            Self::from_claim(scoped, wakeup.clone())?
+        } else {
+            Self::load(scoped, claim.task_id, None)?
+        };
+        session.inner.lock().map_err(|_| "durable session lock")?.lease_until_ms =
+            Some(claim.lease_until_ms);
+        Ok(session)
+    }
+
     fn load(
         store: Arc<dyn DurableStore>,
         task_id: TaskId,
@@ -135,6 +170,8 @@ impl DurableSession {
                 suspended: false,
                 lease_until_ms,
                 result_json: None,
+                replayed_sleep: None,
+                storage_error: None,
             })),
         })
     }
@@ -142,7 +179,13 @@ impl DurableSession {
     pub(crate) fn lookup_json(&self, kind: &str, key: &str) -> Result<String, String> {
         let kind = parse_kind(kind)?;
         let mut inner = self.inner.lock().map_err(|_| "durable session lock poisoned")?;
+        inner.check_storage()?;
         let event = inner.replay.consume_event(kind, key).map_err(replay_error)?.cloned();
+        inner.replayed_sleep = if kind == EventKind::Sleep {
+            event.as_ref().map(|event| event.sequence)
+        } else {
+            None
+        };
         Ok(match event {
             Some(event) => format!(
                 r#"{{"found":true,"payload":{},"sequence":{},"recordedAtMs":{}}}"#,
@@ -156,6 +199,7 @@ impl DurableSession {
 
     pub(crate) fn find_retry_outcome_json(&self, key: &str) -> Result<String, String> {
         let mut inner = self.inner.lock().map_err(|_| "durable session lock poisoned")?;
+        inner.check_storage()?;
         let event = inner.replay.consume_through(EventKind::Retry, key).cloned();
         Ok(match event {
             Some(event) => format!(
@@ -177,6 +221,7 @@ impl DurableSession {
     ) -> Result<(), String> {
         let kind = parse_kind(kind)?;
         let mut inner = self.inner.lock().map_err(|_| "durable session lock poisoned")?;
+        inner.check_storage()?;
         let stored = inner
             .store
             .append_event_json_at(
@@ -187,7 +232,7 @@ impl DurableSession {
                 payload_json,
                 recorded_at_ms,
             )
-            .map_err(|err| err.to_string())?;
+            .map_err(|err| inner.capture_storage(err))?;
         inner.next_sequence = stored.sequence.saturating_add(1);
         Ok(())
     }
@@ -200,6 +245,7 @@ impl DurableSession {
         wake_at_ms: u64,
     ) -> Result<(), String> {
         let mut inner = self.inner.lock().map_err(|_| "durable session lock poisoned")?;
+        inner.check_storage()?;
         let stored = inner
             .store
             .append_event_json_with_wakeup_at(
@@ -210,7 +256,7 @@ impl DurableSession {
                 recorded_at_ms,
                 wake_at_ms,
             )
-            .map_err(|err| err.to_string())?;
+            .map_err(|err| inner.capture_storage(err))?;
         inner.next_sequence = stored.sequence.saturating_add(1);
         inner.active_wakeup =
             Some(WakeupToken { sequence: stored.sequence, kind: WakeupKind::Sleep, claim: None });
@@ -220,6 +266,16 @@ impl DurableSession {
 
     pub(crate) fn complete_sleep(&self) -> Result<(), String> {
         let mut inner = self.inner.lock().map_err(|_| "durable session lock poisoned")?;
+        inner.check_storage()?;
+        if let Some(sequence) = inner.replayed_sleep.take()
+            && !inner
+                .active_wakeup
+                .as_ref()
+                .is_some_and(|token| token.kind == WakeupKind::Sleep && token.sequence == sequence)
+        {
+            return Ok(());
+        }
+
         let token = inner
             .active_wakeup
             .as_ref()
@@ -235,7 +291,7 @@ impl DurableSession {
                 token.claim.as_ref().map(|claim| claim.lease_owner.as_str()),
                 unix_time_ms()?,
             )
-            .map_err(|err| err.to_string())?;
+            .map_err(|err| inner.capture_storage(err))?;
         if !completed {
             return Err("durable wakeup ownership was lost".into());
         }
@@ -246,6 +302,7 @@ impl DurableSession {
 
     pub(crate) fn poll_signal_json(&self, signal_name: &str) -> Result<String, String> {
         let mut inner = self.inner.lock().map_err(|_| "durable session lock poisoned")?;
+        inner.check_storage()?;
         let claim = inner
             .active_wakeup
             .as_ref()
@@ -254,7 +311,7 @@ impl DurableSession {
         let event = inner
             .store
             .poll_signal(inner.task_id, inner.next_sequence, signal_name, unix_time_ms()?, claim)
-            .map_err(|err| err.to_string())?;
+            .map_err(|err| inner.capture_storage(err))?;
         let response = if let Some(event) = event {
             inner.next_sequence = event.sequence.saturating_add(1);
             if inner.active_wakeup.as_ref().is_some_and(|token| {
@@ -271,6 +328,15 @@ impl DurableSession {
         serde_json::to_string(&response).map_err(|err| err.to_string())
     }
 
+    /// Preserve host storage failures across the JavaScript exception boundary.
+    /// The dispatcher checks this even when user code catches the exception.
+    pub fn take_storage_error(&self) -> Option<DurableError> {
+        match self.inner.lock() {
+            Ok(mut inner) => inner.storage_error.take(),
+            Err(_) => Some(DurableError::LockPoisoned),
+        }
+    }
+
     pub fn task_id(&self) -> TaskId {
         self.inner.lock().expect("durable session lock").task_id
     }
@@ -289,7 +355,8 @@ impl DurableSession {
     /// history or engine state is retained by this handle.
     pub fn completion_handle(&self) -> Result<DurableCompletion, DurableError> {
         let inner = self.inner.lock().map_err(|_| DurableError::LockPoisoned)?;
-        if inner.replay.ensure_consumed().is_err()
+        if inner.storage_error.is_some()
+            || inner.replay.ensure_consumed().is_err()
             || inner.active_wakeup.is_some()
             || inner.suspended
         {
@@ -316,6 +383,7 @@ impl DurableSession {
 
     pub(crate) fn ensure_consumed(&self) -> Result<(), String> {
         let inner = self.inner.lock().map_err(|_| "durable session lock poisoned")?;
+        inner.check_storage()?;
         inner.replay.ensure_consumed().map_err(replay_error)?;
         // Storage checks belong to terminal persistence, where availability
         // errors can be retried with the computed result. Keep this check local.
@@ -341,7 +409,18 @@ impl DurableCompletion {
 
     pub fn complete(&self, value: &serde_json::Value) -> Result<bool, DurableError> {
         if let Some(until) = self.lease_until_ms {
-            return self.store.complete_task_before(self.task_id, self.next_sequence, value, until);
+            let result =
+                self.store.complete_task_before(self.task_id, self.next_sequence, value, until);
+            // A deadline can expire inside the completion transaction after its
+            // initial fencing check. Normalize that case to lost authority too.
+            if matches!(&result, Err(DurableError::TaskSuspended { .. }))
+                && std::time::SystemTime::now()
+                    .duration_since(std::time::UNIX_EPOCH)
+                    .is_ok_and(|now| now.as_millis() >= u128::from(until))
+            {
+                return Err(DurableError::ExecutionLeaseLost);
+            }
+            return result;
         }
         let now_ms = std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)
@@ -423,7 +502,7 @@ mod completion_tests {
         store.put_program(task_id, "42", 0).unwrap();
         let session = DurableSession::new(store.clone(), task_id).unwrap();
         session.inner.lock().unwrap().lease_until_ms = Some(0);
-        assert!(matches!(session.complete(&json!(42)), Err(DurableError::TaskSuspended { .. })));
+        assert!(matches!(session.complete(&json!(42)), Err(DurableError::ExecutionLeaseLost)));
         assert!(store.completion(task_id).unwrap().is_none());
         store.complete_task(task_id, 0, &json!(42), 1).unwrap();
         assert!(session.complete(&json!(42)).unwrap());
diff --git a/crates/tysel-engine-qjs/src/host.rs b/crates/tysel-engine-qjs/src/host.rs
index 3782027..5c8b194 100644
--- a/crates/tysel-engine-qjs/src/host.rs
+++ b/crates/tysel-engine-qjs/src/host.rs
@@ -216,17 +216,23 @@ fn install_inner(
     )?;
     tysel.set(
         "_durableStart",
-        Function::new(ctx.clone(), |ctx, name: String, input_json: String| {
-            crate::control::start_named(&name, &input_json)
-                .map_err(|err| Exception::throw_type(&ctx, &err))
-        })?,
+        Function::new(
+            ctx.clone(),
+            |ctx, name: String, input_json: String, key: Option<String>| {
+                crate::control::start_named(&name, &input_json, key.as_deref())
+                    .map_err(|err| Exception::throw_type(&ctx, &err))
+            },
+        )?,
     )?;
     tysel.set(
         "_durableSendSignal",
-        Function::new(ctx.clone(), |ctx, task_id: String, name: String, payload_json: String| {
-            crate::control::send_signal(&task_id, &name, &payload_json)
-                .map_err(|err| Exception::throw_type(&ctx, &err))
-        })?,
+        Function::new(
+            ctx.clone(),
+            |ctx, task_id: String, name: String, payload_json: String, key: Option<String>| {
+                crate::control::send_signal(&task_id, &name, &payload_json, key.as_deref())
+                    .map_err(|err| Exception::throw_type(&ctx, &err))
+            },
+        )?,
     )?;
     tysel.set(
         "_wsRead",
diff --git a/crates/tysel-engine-qjs/src/lib.rs b/crates/tysel-engine-qjs/src/lib.rs
index 1072ba3..2bd3a9f 100644
--- a/crates/tysel-engine-qjs/src/lib.rs
+++ b/crates/tysel-engine-qjs/src/lib.rs
@@ -22,7 +22,10 @@ mod secrets;
 mod task_module;
 mod trust;
 
-pub use control::{DurableControl, configure as configure_durable_control};
+pub use control::{
+    DurableControl, clear_if_current as clear_durable_control_if_current,
+    configure as configure_durable_control,
+};
 pub use durable::{DurableCompletion, DurableSession};
 pub use fetch_policy::configure as configure_fetch_hosts;
 pub use isolate::{
diff --git a/crates/tysel-runtime/src/durable.rs b/crates/tysel-runtime/src/durable.rs
index 16133bc..04f318a 100644
--- a/crates/tysel-runtime/src/durable.rs
+++ b/crates/tysel-runtime/src/durable.rs
@@ -5,7 +5,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 #[cfg(test)]
 use tysel_durable::SqliteStore;
-use tysel_durable::{DurableError, DurableStore, WakeupClaim};
+use tysel_durable::{DurableError, DurableStore, ExecutionClaim, WakeupClaim};
 use tysel_engine::{EngineError, IsolateConfig, Value};
 use tysel_engine_qjs::{DurableCompletion, DurableSession, eval_durable, eval_durable_module};
 use tysel_task::TaskId;
@@ -83,9 +83,9 @@ impl DurableDispatcher {
         match completion.complete(&json) {
             Ok(_) => Ok(DurableRunStatus::Completed(value)),
             Err(error) => {
-                // Retain the outcome, never rerun the handler to repair storage.
+                // Retry the retained outcome while this completion authority is valid.
                 if !error.is_retryable() {
-                    return Err(DurableRunError::Store(error));
+                    return Err(DurableRunError::boundary(error));
                 }
                 let json = serde_json::to_string(&json)
                     .map_err(|error| DurableRunError::Session(error.to_string()))?;
@@ -114,8 +114,16 @@ impl DurableDispatcher {
         for task_id in ids {
             let entry = &pending[&task_id];
             let json = serde_json::from_str(&entry.json).expect("validated completion JSON");
-            if let Err(error) = entry.completion.complete(&json) {
-                return (runs, Some(error.into()));
+            match entry.completion.complete(&json) {
+                Ok(_) => {}
+                Err(DurableError::ExecutionLeaseLost) => {
+                    // This result no longer has write authority. Release its slot;
+                    // persisted execution eligibility lets the scheduler reclaim
+                    // the original task and replay its recorded boundaries.
+                    pending.remove(&task_id);
+                    continue;
+                }
+                Err(error) => return (runs, Some(error.into())),
             }
             pending.remove(&task_id);
             runs.push(DurableRun {
@@ -189,22 +197,101 @@ impl DurableDispatcher {
         DurableRun { task_id, result }
     }
 
+    pub(crate) fn start_admitted(
+        &self,
+        task_id: TaskId,
+        source: &str,
+        slot: CompletionSlot,
+    ) -> Result<Option<DurableRun>, DispatchError> {
+        if let Some(completion) = self.store.completion(task_id)? {
+            return Ok(Some(DurableRun {
+                task_id,
+                result: Ok(DurableRunStatus::Completed(value_from_json(completion.value))),
+            }));
+        }
+        let Some(claim) =
+            self.store.claim_execution(task_id, &self.owner, self.lease_duration_ms)?
+        else {
+            if self.store.execution_failed(task_id)? {
+                return Ok(Some(DurableRun { task_id, result: Err(DurableRunError::TaskFailed) }));
+            }
+            return Ok(None);
+        };
+        Ok(Some(self.execute_managed(claim, source, true, slot)))
+    }
+
+    fn execute_managed(
+        &self,
+        claim: ExecutionClaim,
+        source: &str,
+        module: bool,
+        slot: CompletionSlot,
+    ) -> DurableRun {
+        let task_id = claim.task_id;
+        let result = DurableSession::from_execution(self.store.clone(), &claim)
+            .map_err(DurableRunError::Session)
+            .and_then(|session| {
+                if module {
+                    self.evaluate_module(source, "null", session, slot)
+                } else {
+                    let result = eval_durable(source, self.isolate, session.clone());
+                    if let Some(error) = session.take_storage_error() {
+                        return Err(DurableRunError::boundary(error));
+                    }
+                    match result {
+                        Ok(value) => self.finish(session, value, slot),
+                        Err(EngineError::Suspended) => Ok(DurableRunStatus::Suspended),
+                        Err(error) => Err(DurableRunError::Engine(error)),
+                    }
+                }
+            });
+        let transition = match &result {
+            Ok(DurableRunStatus::Suspended) => self.store.finish_execution(&claim, false),
+            Err(
+                DurableRunError::Store(_)
+                | DurableRunError::Session(_)
+                | DurableRunError::LeaseLost,
+            ) => Ok(()), // retained completion retries retain this lease
+            Err(_) => self.store.finish_execution(&claim, true),
+            _ => Ok(()),
+        };
+        DurableRun {
+            task_id,
+            result: match transition {
+                Ok(()) => result,
+                Err(error) => Err(DurableRunError::boundary(error)),
+            },
+        }
+    }
+
     /// Claim and execute one exact registered task if its wakeup is due.
     pub fn dispatch_task(
         &self,
         task_id: TaskId,
         script: &str,
     ) -> Result<Option<DurableRun>, DispatchError> {
-        let Some(claim) = self.store.claim_wakeup(
-            task_id,
-            unix_time_ms()?,
-            &self.owner,
-            self.lease_duration_ms,
-        )?
+        // Caller-owned in-memory registries retain their low-level wakeup contract.
+        if self.store.program(task_id)?.is_none() {
+            let Some(claim) = self.store.claim_wakeup(
+                task_id,
+                unix_time_ms()?,
+                &self.owner,
+                self.lease_duration_ms,
+            )?
+            else {
+                return Ok(None);
+            };
+            return Ok(Some(self.execute_claim(claim, script)));
+        }
+        let Ok(slot) = self.reserve() else {
+            return Ok(None);
+        };
+        let Some(claim) =
+            self.store.claim_execution(task_id, &self.owner, self.lease_duration_ms)?
         else {
             return Ok(None);
         };
-        Ok(Some(self.execute_claim(claim, script)))
+        Ok(Some(self.execute_managed(claim, script, false, slot)))
     }
 
     pub fn dispatch_module_task(
@@ -212,16 +299,15 @@ impl DurableDispatcher {
         task_id: TaskId,
         source: &str,
     ) -> Result<Option<DurableRun>, DispatchError> {
-        let Some(claim) = self.store.claim_wakeup(
-            task_id,
-            unix_time_ms()?,
-            &self.owner,
-            self.lease_duration_ms,
-        )?
+        let Ok(slot) = self.reserve() else {
+            return Ok(None);
+        };
+        let Some(claim) =
+            self.store.claim_execution(task_id, &self.owner, self.lease_duration_ms)?
         else {
             return Ok(None);
         };
-        Ok(Some(self.execute_module_claim(claim, source)))
+        Ok(Some(self.execute_managed(claim, source, true, slot)))
     }
 
     /// Claim and execute up to `limit` due tasks. The resolver supplies the
@@ -276,21 +362,17 @@ impl DurableDispatcher {
         DurableRun { task_id, result }
     }
 
-    fn execute_module_claim(&self, claim: WakeupClaim, source: &str) -> DurableRun {
-        let task_id = claim.task_id;
-        let result = DurableSession::from_claim(self.store.clone(), claim)
-            .map_err(DurableRunError::Session)
-            .and_then(|session| self.evaluate_module(source, "null", session, self.reserve()?));
-        DurableRun { task_id, result }
-    }
-
     fn evaluate(
         &self,
         script: &str,
         session: DurableSession,
     ) -> Result<DurableRunStatus, DurableRunError> {
         let slot = self.reserve()?;
-        match eval_durable(script, self.isolate, session.clone()) {
+        let result = eval_durable(script, self.isolate, session.clone());
+        if let Some(error) = session.take_storage_error() {
+            return Err(DurableRunError::boundary(error));
+        }
+        match result {
             Ok(value) => {
                 if matches!(&value, Value::Number(number) if !number.is_finite()) {
                     return Err(DurableRunError::Engine(EngineError::Isolate(
@@ -311,7 +393,11 @@ impl DurableDispatcher {
         session: DurableSession,
         slot: CompletionSlot,
     ) -> Result<DurableRunStatus, DurableRunError> {
-        match eval_durable_module(source, input_json, self.isolate, session.clone()) {
+        let result = eval_durable_module(source, input_json, self.isolate, session.clone());
+        if let Some(error) = session.take_storage_error() {
+            return Err(DurableRunError::boundary(error));
+        }
+        match result {
             Ok(value) => self.finish(session, value, slot),
             Err(EngineError::Suspended) => Ok(DurableRunStatus::Suspended),
             Err(error) => Err(DurableRunError::Engine(error)),
@@ -364,6 +450,10 @@ pub enum DurableRunStatus {
 
 #[derive(Debug, thiserror::Error)]
 pub enum DurableRunError {
+    #[error("durable task has already failed; the same admission will not be executed again")]
+    TaskFailed,
+    #[error("durable task boundary: {0}")]
+    Boundary(#[source] DurableError),
     #[error("durable finalization capacity exhausted")]
     FinalizationCapacity,
     #[error("durable completion is pending persistence")]
@@ -380,6 +470,25 @@ pub enum DurableRunError {
     LeaseLost,
 }
 
+impl DurableRunError {
+    fn boundary(error: DurableError) -> Self {
+        match error {
+            DurableError::ExecutionLeaseLost => Self::LeaseLost,
+            DurableError::EventKeyTooLarge
+            | DurableError::EventPayloadTooLarge
+            | DurableError::HistoryEventLimit
+            | DurableError::HistoryByteLimit
+            | DurableError::InvalidSignalName
+            | DurableError::SignalWaitConflict
+            | DurableError::SignalInboxLimit
+            | DurableError::InvalidEventKind(_)
+            | DurableError::IntegerRange { .. }
+            | DurableError::Json(_) => Self::Boundary(error),
+            _ => Self::Store(error),
+        }
+    }
+}
+
 #[derive(Debug, thiserror::Error)]
 pub enum DispatchError {
     #[error("dispatcher owner must be 1..={MAX_OWNER_BYTES} bytes")]
@@ -428,6 +537,118 @@ mod tests {
         DurableDispatcher::new(store, owner, 1_000, config()).unwrap()
     }
 
+    #[test]
+    fn expired_pending_completion_releases_slot_and_recovers_original_history() {
+        let path =
+            std::env::temp_dir().join(format!("tysel-pending-expiry-{}.db", std::process::id()));
+        let store = Arc::new(SqliteStore::open(&path).unwrap());
+        let db = rusqlite::Connection::open(&path).unwrap();
+        let source = "export default async ctx => await ctx.effect('write',async()=>42)";
+        let id = TaskId(910);
+        store.admit_module(id, "pending-expiry", source, "null", 0).unwrap();
+        db.execute_batch("CREATE TRIGGER fail_completion BEFORE INSERT ON durable_completions BEGIN SELECT * FROM missing_completion_table; END;").unwrap();
+        let dispatcher = dispatcher(store.clone(), "pending-expiry");
+        let run =
+            dispatcher.start_admitted(id, source, dispatcher.reserve().unwrap()).unwrap().unwrap();
+        assert!(matches!(run.result, Err(DurableRunError::Store(_))));
+        assert!(dispatcher.has_pending_completions());
+        assert_eq!(store.load_history(id).unwrap().events.len(), 2);
+        std::thread::sleep(Duration::from_millis(1100));
+        let (runs, error) = dispatcher.retry_completions();
+        assert!(error.is_none(), "{error:?}");
+        assert!(runs.is_empty(), "an expired result must not notify completion");
+        assert!(!dispatcher.has_pending_completions(), "expired handle must release its slot");
+        assert!(store.completion(id).unwrap().is_none());
+        db.execute_batch("DROP TRIGGER fail_completion").unwrap();
+        let run = dispatcher.dispatch_module_task(id, source).unwrap().unwrap();
+        assert!(matches!(run.result, Ok(DurableRunStatus::Completed(Value::Number(42.0)))));
+        assert_eq!(store.load_history(id).unwrap().events.len(), 2);
+        assert_eq!(store.completion(id).unwrap().unwrap().value, serde_json::json!(42));
+        drop(dispatcher);
+        drop(db);
+        drop(store);
+        std::fs::remove_file(path).unwrap();
+    }
+
+    #[test]
+    fn managed_storage_failure_recovers_even_when_javascript_catches_it() {
+        for caught in [false, true] {
+            let path = std::env::temp_dir()
+                .join(format!("tysel-storage-fault-{}-{caught}.db", std::process::id()));
+            let store = Arc::new(SqliteStore::open(&path).unwrap());
+            let db = rusqlite::Connection::open(&path).unwrap();
+            let source = if caught {
+                "export default async ctx => {try {return await ctx.effect('write',async()=>42)} catch {return 99}}"
+            } else {
+                "export default async ctx => await ctx.effect('write',async()=>42)"
+            };
+            let id = TaskId(900);
+            store.admit_module(id, "fault", source, "null", 0).unwrap();
+            db.execute_batch("CREATE TRIGGER fail_effect BEFORE INSERT ON durable_events WHEN NEW.sequence=1 BEGIN SELECT RAISE(FAIL, 'temporary storage fault'); END;").unwrap();
+            let dispatcher = dispatcher(store.clone(), "fault-test");
+            let run = dispatcher
+                .start_admitted(id, source, dispatcher.reserve().unwrap())
+                .unwrap()
+                .unwrap();
+            assert!(matches!(run.result, Err(DurableRunError::Store(_))), "{run:?}");
+            assert!(
+                store.completion(id).unwrap().is_none(),
+                "caught error must not commit fallback"
+            );
+            assert_eq!(
+                db.query_row("SELECT state FROM durable_executions", [], |r| r.get::<_, String>(0))
+                    .unwrap(),
+                "running"
+            );
+            db.execute_batch("DROP TRIGGER fail_effect").unwrap();
+            std::thread::sleep(Duration::from_millis(1100));
+            let due = store
+                .load_due_programs_batch(
+                    unix_time_ms().unwrap(),
+                    tysel_durable::DurableProgramKind::Module,
+                    32,
+                )
+                .unwrap();
+            assert_eq!(due.len(), 1);
+            let run = dispatcher.dispatch_module_task(id, source).unwrap().unwrap();
+            assert!(
+                matches!(run.result, Ok(DurableRunStatus::Completed(Value::Number(42.0)))),
+                "{run:?}"
+            );
+            assert_eq!(store.completion(id).unwrap().unwrap().value, serde_json::json!(42));
+            drop(dispatcher);
+            drop(db);
+            drop(store);
+            std::fs::remove_file(path).unwrap();
+        }
+    }
+
+    #[test]
+    fn managed_business_exception_remains_failed() {
+        let store = Arc::new(SqliteStore::in_memory().unwrap());
+        let source = "export default async () => {throw new Error('business failure')}";
+        let id = TaskId(901);
+        store.admit_module(id, "business", source, "null", 0).unwrap();
+        let dispatcher = dispatcher(store.clone(), "business-test");
+        let run =
+            dispatcher.start_admitted(id, source, dispatcher.reserve().unwrap()).unwrap().unwrap();
+        assert!(matches!(run.result, Err(DurableRunError::Engine(_))));
+        assert!(store.claim_execution(id, "other", 1000).unwrap().is_none());
+        let retry =
+            dispatcher.start_admitted(id, source, dispatcher.reserve().unwrap()).unwrap().unwrap();
+        assert!(matches!(retry.result, Err(DurableRunError::TaskFailed)));
+        assert!(
+            store
+                .load_due_programs_batch(
+                    unix_time_ms().unwrap() + 2000,
+                    tysel_durable::DurableProgramKind::Module,
+                    32
+                )
+                .unwrap()
+                .is_empty()
+        );
+    }
+
     #[test]
     fn non_finite_script_result_is_not_silently_persisted_as_null() {
         let store = Arc::new(SqliteStore::in_memory().unwrap());
diff --git a/crates/tysel-runtime/src/durable_plane.rs b/crates/tysel-runtime/src/durable_plane.rs
index cfa6f6e..7498f74 100644
--- a/crates/tysel-runtime/src/durable_plane.rs
+++ b/crates/tysel-runtime/src/durable_plane.rs
@@ -9,13 +9,14 @@ use tokio::task::JoinHandle;
 use tysel_durable::{DurableError, DurableStore, POSTGRES_URL_ENV, PostgresStore, SqliteStore};
 use tysel_engine::{IsolateConfig, Value};
 use tysel_engine_qjs::{
-    DurableControl, configure_durable_control, encode_durable_export, inspect_durable_exports,
+    DurableControl, clear_durable_control_if_current, configure_durable_control,
+    encode_durable_export, inspect_durable_exports,
 };
 use tysel_task::TaskId;
 
 use crate::{
-    DispatchError, DurableDispatcher, DurablePoller, DurableProgramCatalog, DurableRun,
-    DurableRunStatus, PollerError, PollerHealth, PollerShutdown, ProgramRegistryError,
+    DispatchError, DurableDispatcher, DurablePoller, DurableRun, DurableRunStatus, PollerError,
+    PollerHealth, PollerShutdown, ProgramRegistryError,
 };
 
 const POLL_INTERVAL: Duration = Duration::from_millis(200);
@@ -24,12 +25,12 @@ const SQLITE_PATH_ENV: &str = "TYSEL_DURABLE_SQLITE_PATH";
 
 pub struct DurablePlane {
     dispatcher: Arc<DurableDispatcher>,
-    catalog: DurableProgramCatalog,
     source: RwLock<Arc<str>>,
     config: IsolateConfig,
     shutdown: PollerShutdown,
     health: watch::Receiver<PollerHealth>,
     join: Mutex<Option<JoinHandle<Result<(), PollerError>>>>,
+    hooks: Mutex<std::sync::Weak<DurableControl>>,
 }
 
 #[derive(Debug, thiserror::Error)]
@@ -139,7 +140,6 @@ impl DurablePlane {
         let lease_duration_ms = config.request_timeout_ms.saturating_add(5_000).max(1_000);
         let dispatcher =
             Arc::new(DurableDispatcher::new(store.clone(), owner, lease_duration_ms, config)?);
-        let catalog = DurableProgramCatalog::new(store);
         let poller =
             DurablePoller::new_persistent_modules(dispatcher.clone(), POLL_INTERVAL, POLL_BATCH)?;
         let shutdown = PollerShutdown::default();
@@ -173,12 +173,12 @@ impl DurablePlane {
         });
         let plane = Arc::new(Self {
             dispatcher,
-            catalog,
             source: RwLock::new(Arc::from(source)),
             config,
             shutdown,
             health,
             join: Mutex::new(Some(join)),
+            hooks: Mutex::new(std::sync::Weak::new()),
         });
         plane.install_hooks()?;
         Ok(plane)
@@ -213,17 +213,30 @@ impl DurablePlane {
 
     fn install_hooks(self: &Arc<Self>) -> Result<(), DurablePlaneError> {
         let plane = self.clone();
-        configure_durable_control(Some(Arc::new(DurableControl {
-            start: Box::new(move |name, input| plane.start_named(name, input)),
+        let hooks = Arc::new(DurableControl {
+            start: Box::new(move |name, input, key| plane.start_named_with_key(name, input, key)),
             send_signal: {
                 let plane = self.clone();
-                Box::new(move |task_id, name, payload| plane.send_signal(task_id, name, payload))
+                Box::new(move |task_id, name, payload, key| {
+                    plane.send_signal_with_key(task_id, name, payload, key)
+                })
             },
-        })));
+        });
+        *self.hooks.lock().map_err(|_| DurablePlaneError::Poisoned)? = Arc::downgrade(&hooks);
+        configure_durable_control(Some(hooks));
         Ok(())
     }
 
     pub fn start_named(&self, name: &str, input_json: &str) -> Result<String, String> {
+        self.start_named_with_key(name, input_json, None)
+    }
+
+    pub fn start_named_with_key(
+        &self,
+        name: &str,
+        input_json: &str,
+        key: Option<&str>,
+    ) -> Result<String, String> {
         if self.health() != PollerHealth::Healthy {
             return Err(DurablePlaneError::Unavailable.to_string());
         }
@@ -240,21 +253,51 @@ impl DurablePlane {
         }
         let wrapped = encode_durable_export(name, source.as_ref());
         let slot = self.dispatcher.reserve().map_err(|error| error.to_string())?;
-        let task_id = next_task_id();
-        self.catalog.register_module(task_id, wrapped.clone()).map_err(|err| err.to_string())?;
-        encode_run(self.dispatcher.start_module_reserved(task_id, &wrapped, input_json, slot))
+        let generated = next_task_id().to_string();
+        let key = key.unwrap_or(&generated);
+        let task_id = tysel_durable::admission_task_id(key).map_err(|error| error.to_string())?;
+        self.dispatcher
+            .store()
+            .admit_module(
+                task_id,
+                key,
+                &wrapped,
+                input_json,
+                unix_time_ms().map_err(|e| e.to_string())?,
+            )
+            .map_err(|error| error.to_string())?;
+        match self
+            .dispatcher
+            .start_admitted(task_id, &wrapped, slot)
+            .map_err(|error| error.to_string())?
+        {
+            Some(run) => encode_run(run),
+            None => Ok(json!({"status":"accepted","taskId":task_id.to_string()}).to_string()),
+        }
     }
 
     pub fn send_signal(&self, task_id: &str, name: &str, payload_json: &str) -> Result<(), String> {
+        self.send_signal_with_key(task_id, name, payload_json, None)
+    }
+
+    pub fn send_signal_with_key(
+        &self,
+        task_id: &str,
+        name: &str,
+        payload_json: &str,
+        key: Option<&str>,
+    ) -> Result<(), String> {
         let task_id = parse_task_id(task_id)?;
         let payload: JsonValue = serde_json::from_str(payload_json)
             .map_err(|err| format!("durable signal payload must be JSON: {err}"))?;
         let now_ms = unix_time_ms().map_err(|err| err.to_string())?;
-        self.dispatcher
-            .store()
-            .send_signal(task_id, name, &payload, now_ms)
-            .map(|_| ())
-            .map_err(|err| err.to_string())
+        let store = self.dispatcher.store();
+        match key {
+            Some(key) => store.send_signal_once(task_id, name, &payload, key, now_ms),
+            None => store.send_signal(task_id, name, &payload, now_ms),
+        }
+        .map(|_| ())
+        .map_err(|err| err.to_string())
     }
 
     pub fn health(&self) -> PollerHealth {
@@ -278,7 +321,9 @@ impl DurablePlane {
     }
 
     pub async fn shutdown(&self) -> Result<(), DurablePlaneError> {
-        configure_durable_control(None);
+        clear_durable_control_if_current(
+            &*self.hooks.lock().map_err(|_| DurablePlaneError::Poisoned)?,
+        );
         self.shutdown.cancel();
         let join = self.join.lock().map_err(|_| DurablePlaneError::Poisoned)?.take();
         if let Some(join) = join {
@@ -365,6 +410,71 @@ mod tests {
     use super::*;
     use std::time::Duration;
 
+    #[tokio::test]
+    async fn task_boundary_error_does_not_stop_scheduler_or_accept_failed_retry() {
+        let store = Arc::new(SqliteStore::in_memory().unwrap());
+        let plane = DurablePlane::start(store.clone(), r#"
+          export default {durable: {
+            async bad(ctx) {await ctx.sleep(1);return await ctx.effect('x'.repeat(257),async()=>42)},
+            async good() {return 42}
+          }};
+        "#.into(), IsolateConfig {request_timeout_ms:1000,..Default::default()}, "boundary-test").unwrap();
+        let first: JsonValue = serde_json::from_str(
+            &plane.start_named_with_key("bad", "null", Some("bad-key")).unwrap(),
+        )
+        .unwrap();
+        let id = parse_task_id(first["taskId"].as_str().unwrap()).unwrap();
+        tokio::time::timeout(Duration::from_secs(3), async {
+            while !store.execution_failed(id).unwrap() {
+                tokio::time::sleep(Duration::from_millis(10)).await;
+            }
+        })
+        .await
+        .unwrap();
+        assert_eq!(plane.health(), PollerHealth::Healthy);
+        let error = plane.start_named_with_key("bad", "null", Some("bad-key")).unwrap_err();
+        assert!(error.contains("already failed"), "{error}");
+        let good: JsonValue = serde_json::from_str(
+            &plane.start_named_with_key("good", "null", Some("good-key")).unwrap(),
+        )
+        .unwrap();
+        assert_eq!(good["value"].as_f64(), Some(42.0));
+        plane.shutdown().await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn retry_sleep_then_rejected_approval_replays_to_completion() {
+        let store = Arc::new(SqliteStore::in_memory().unwrap());
+        let plane=DurablePlane::start(store.clone(),r#"
+          export default {durable:{async job(ctx) {
+            await ctx.retry({maxAttempts:2,delay:1},async attempt=>{if(attempt===1)throw new Error('retry');return true;});
+            return await ctx.waitForSignal('approval');
+          }}};
+        "#.into(),IsolateConfig{request_timeout_ms:1_000,cpu_ms_per_turn:500,..Default::default()},"retry-approval").unwrap();
+        let result: JsonValue = serde_json::from_str(
+            &plane.start_named_with_key("job", "null", Some("retry-approval")).unwrap(),
+        )
+        .unwrap();
+        let id = parse_task_id(result["taskId"].as_str().unwrap()).unwrap();
+        tokio::time::timeout(Duration::from_secs(3), async {
+            while store.signal_wait(id).unwrap().is_none() {
+                tokio::time::sleep(Duration::from_millis(10)).await;
+            }
+        })
+        .await
+        .unwrap();
+        plane.send_signal_with_key(&id.to_string(), "approval", "false", Some("reject-1")).unwrap();
+        tokio::time::timeout(Duration::from_secs(3), async {
+            while store.completion(id).unwrap().is_none() {
+                tokio::time::sleep(Duration::from_millis(10)).await;
+            }
+        })
+        .await
+        .unwrap();
+        assert_eq!(store.completion(id).unwrap().unwrap().value, json!(false));
+        plane.shutdown().await.unwrap();
+    }
+
     #[tokio::test]
     async fn scheduler_recovers_after_store_error_without_restart() {
         let path = std::env::temp_dir().join(format!(
diff --git a/crates/tysel-runtime/src/service.rs b/crates/tysel-runtime/src/service.rs
index ccef587..ceb861e 100644
--- a/crates/tysel-runtime/src/service.rs
+++ b/crates/tysel-runtime/src/service.rs
@@ -279,14 +279,25 @@ pub async fn run_tap(tap: Tap) -> Result<(), StubError> {
             Some(service)
         }
     };
-    let durable = start_durable_plane(
-        &tap.manifest.execution_profile,
-        &tap.manifest.sqlite_path,
-        None,
-        &bundle,
-        config,
-        metadata.as_ref().map(|metadata| !metadata.durable_exports.is_empty()),
-    )?;
+    let durable = {
+        let execution_profile = tap.manifest.execution_profile.clone();
+        let sqlite_path = tap.manifest.sqlite_path.clone();
+        let source = bundle.clone();
+        let has_durable_exports =
+            metadata.as_ref().map(|metadata| !metadata.durable_exports.is_empty());
+        tokio::task::spawn_blocking(move || {
+            start_durable_plane(
+                &execution_profile,
+                &sqlite_path,
+                None,
+                &source,
+                config,
+                has_durable_exports,
+            )
+        })
+        .await
+        .map_err(|error| io::Error::other(error.to_string()))??
+    };
     if durable.is_some() {
         println!("tysel durable on");
     }
@@ -341,7 +352,7 @@ pub async fn run_tap(tap: Tap) -> Result<(), StubError> {
     }
     // Keep capability and durable hooks alive while admitted HTTP handlers finish.
     let http_result = if server_finished { Ok(()) } else { server.await };
-    let durable_result = shutdown_durable(durable.as_ref()).await;
+    let durable_result = shutdown_durable(durable).await;
     #[cfg(unix)]
     let task_result = match task_service {
         Some(service) => service.shutdown().await,
@@ -400,9 +411,14 @@ fn start_durable_plane(
     Ok(Some(DurablePlane::start(store, bundle.to_owned(), config, owner)?))
 }
 
-async fn shutdown_durable(plane: Option<&std::sync::Arc<DurablePlane>>) -> Result<(), StubError> {
+async fn shutdown_durable(plane: Option<std::sync::Arc<DurablePlane>>) -> Result<(), StubError> {
     if let Some(plane) = plane {
-        plane.shutdown().await?;
+        let result = plane.shutdown().await;
+        // PostgreSQL pool destruction must not block an async runtime thread.
+        tokio::task::spawn_blocking(move || drop(plane))
+            .await
+            .map_err(|error| io::Error::other(error.to_string()))?;
+        result?;
     }
     Ok(())
 }
diff --git a/crates/tysel-runtime/tests/lease_completion.rs b/crates/tysel-runtime/tests/lease_completion.rs
index 4192bc3..7b5446d 100644
--- a/crates/tysel-runtime/tests/lease_completion.rs
+++ b/crates/tysel-runtime/tests/lease_completion.rs
@@ -43,7 +43,7 @@ fn completion_rejects_lease_expiry_while_waiting_for_sqlite_writer() {
         now() - until,
         persisted.is_some()
     );
-    assert!(matches!(result, Err(tysel_durable::DurableError::TaskSuspended { .. })));
+    assert!(matches!(result, Err(tysel_durable::DurableError::ExecutionLeaseLost)));
     assert!(persisted.is_none());
     assert_eq!(store.program_count().unwrap(), 1);
     drop(blocker);
diff --git a/packages/tysel-types/src/index.ts b/packages/tysel-types/src/index.ts
index 0a1837c..ad4f066 100644
--- a/packages/tysel-types/src/index.ts
+++ b/packages/tysel-types/src/index.ts
@@ -203,6 +203,16 @@ export interface LlmClient {
   ): Promise<LlmResponse<Output>>;
 }
 
+export interface DurableRequestOptions {
+  /** Store-wide key bound to this exact request until explicit retention cleanup. */
+  readonly idempotencyKey: string;
+}
+
+export interface DurableAcceptedResult {
+  readonly status: "accepted";
+  readonly taskId: string;
+}
+
 export interface DurableSuspendedResult {
   readonly status: "suspended";
   readonly taskId: string;
@@ -215,6 +225,7 @@ export interface DurableCompletedResult<Output = JsonValue> {
 }
 
 export type DurableStartResult<Output = JsonValue> =
+  | DurableAcceptedResult
   | DurableSuspendedResult
   | DurableCompletedResult<Output>;
 
@@ -222,11 +233,13 @@ export interface DurableControlClient {
   start<Output = JsonValue, Input = JsonValue>(
     name: string,
     input?: Input,
+    options?: DurableRequestOptions,
   ): DurableStartResult<Output>;
   sendSignal<Payload = JsonValue>(
     taskId: string,
     name: string,
     payload?: Payload,
+    options?: DurableRequestOptions,
   ): void;
 }
 
diff --git a/packages/tysel-types/test/consumer/index.ts b/packages/tysel-types/test/consumer/index.ts
index 263622f..b5c1ffe 100644
--- a/packages/tysel-types/test/consumer/index.ts
+++ b/packages/tysel-types/test/consumer/index.ts
@@ -142,3 +142,14 @@ await socket.opened;
 tysel._sqliteExec("SELECT 1", "[]");
 // @ts-expect-error model is required by the public LLM contract
 await tysel.llm.generate({ input: "hello" });
+
+const durableRun = tysel.durable.start<{ approved: boolean }>("approvalFlow", null, {
+  idempotencyKey: "tenant:approval:request-1",
+});
+if (durableRun.status === "completed") durableRun.value.approved.valueOf();
+if (durableRun.status === "accepted") durableRun.taskId.toUpperCase();
+tysel.durable.sendSignal(durableRun.taskId, "approval", false, {
+  idempotencyKey: "decision-1",
+});
+// @ts-expect-error idempotency keys must be strings
+tysel.durable.start("approvalFlow", null, { idempotencyKey: 1 });
diff --git a/runtime-js/capability-client/index.ts b/runtime-js/capability-client/index.ts
index 4d57f1c..9b82099 100644
--- a/runtime-js/capability-client/index.ts
+++ b/runtime-js/capability-client/index.ts
@@ -87,8 +87,8 @@ export interface DurableStartResult {
 }
 
 export interface DurableControlClient {
-  start(name: string, input?: unknown): DurableStartResult;
-  sendSignal(taskId: string, name: string, payload?: unknown): void;
+  start(name: string, input?: unknown, options?: { idempotencyKey: string }): DurableStartResult;
+  sendSignal(taskId: string, name: string, payload?: unknown, options?: { idempotencyKey: string }): void;
 }
 
 /** Public JavaScript surface installed by the capability-client layer. */
diff --git a/runtime-js/durable/control.js b/runtime-js/durable/control.js
index 3fd9f0f..ad02fdb 100644
--- a/runtime-js/durable/control.js
+++ b/runtime-js/durable/control.js
@@ -1,7 +1,14 @@
 if (!globalThis.tysel.durable) globalThis.tysel.durable = {};
-globalThis.tysel.durable.start = function(name, input) {
-  return JSON.parse(tysel._durableStart(String(name), JSON.stringify(input === undefined ? null : input)));
+function durableRequestKey(options) {
+  if (options === undefined) return undefined;
+  if (!options || typeof options.idempotencyKey !== "string" || !options.idempotencyKey) {
+    throw new TypeError("durable options require a nonempty idempotencyKey");
+  }
+  return options.idempotencyKey;
+}
+globalThis.tysel.durable.start = function(name, input, options) {
+  return JSON.parse(tysel._durableStart(String(name), JSON.stringify(input === undefined ? null : input), durableRequestKey(options)));
 };
-globalThis.tysel.durable.sendSignal = function(taskId, name, payload) {
-  tysel._durableSendSignal(String(taskId), String(name), JSON.stringify(payload === undefined ? null : payload));
+globalThis.tysel.durable.sendSignal = function(taskId, name, payload, options) {
+  tysel._durableSendSignal(String(taskId), String(name), JSON.stringify(payload === undefined ? null : payload), durableRequestKey(options));
 };
diff --git a/tests/p1/reload_recovery.py b/tests/p1/reload_recovery.py
new file mode 100644
index 0000000..53ae12b
--- /dev/null
+++ b/tests/p1/reload_recovery.py
@@ -0,0 +1,38 @@
+import tempfile,pathlib,socket,subprocess,http.client,time,json,os
+root=pathlib.Path(tempfile.mkdtemp(prefix='tysel-reassess-reload-'))
+with socket.socket() as s:s.bind(('127.0.0.1',0));port=s.getsockname()[1]
+(root/'tysel.toml').write_text(f'''[app]\nname="reload-probe"\nentry="index.js"\nprofile="service"\n[server]\nlisten="127.0.0.1:{port}"\n[durable]\nstore="sqlite"\npath="./data/durable.db"\n''')
+source='''export default { durable: {async job(ctx,input){ return await ctx.waitForSignal("go"); }}, fetch(request){ if(new URL(request.url).pathname==='/signal'){tysel.durable.sendSignal(new URL(request.url).searchParams.get('id'),'go',{ok:true});return new Response('ok');}if(new URL(request.url).pathname==='/start') {try{return Response.json(tysel.durable.start('job',{ok:true}));}catch(e){return new Response(String(e),{status:500});}}return new Response('VERSION');}};'''
+(root/'index.js').write_text(source.replace('VERSION','one'))
+env={k:v for k,v in os.environ.items() if not k.startswith('TYSEL_DURABLE_')}
+log=(root/'service.log').open('w');p=subprocess.Popen([os.environ.get('TYSEL_BIN',str(pathlib.Path(__file__).resolve().parents[2]/'target/debug/tysel')),'-C',str(root),'dev'],env=env,stdout=log,stderr=log)
+def get(path):
+ c=http.client.HTTPConnection('127.0.0.1',port,timeout=2);c.request('GET',path);r=c.getresponse();v=(r.status,r.read().decode());c.close();return v
+def wait(body):
+ for _ in range(200):
+  try:
+   if get('/')[1]==body:return
+  except OSError:pass
+  time.sleep(.05)
+ raise RuntimeError('timeout '+str(root))
+try:
+ wait('one');time.sleep(1);before=get('/start');assert before[0]==200,before
+ first=json.loads(before[1])['taskId']
+ (root/'index.js').write_text(source.replace('VERSION','two'));time.sleep(2);wait('two')
+ after=get('/start');assert after[0]==200,after
+ second=json.loads(after[1])['taskId']
+ assert get('/signal?id='+first)[0]==200
+ assert get('/signal?id='+second)[0]==200
+ import sqlite3
+ db=sqlite3.connect('file:'+str(root/'data/durable-events.db')+'?mode=ro',uri=True)
+ for _ in range(100):
+  completed=db.execute('SELECT result_json FROM durable_completions').fetchall()
+  if len(completed)==2:break
+  time.sleep(.05)
+ assert len(completed)==2,completed
+ assert all(json.loads(row[0])=={'ok':True} for row in completed)
+ db.close()
+ print(json.dumps({'fixture':str(root),'before':before,'after':after,'completed':2}))
+
+finally:
+ p.terminate();p.wait(timeout=10);log.close();assert p.returncode==0,p.returncode;assert "panicked at" not in (root/"service.log").read_text()

From 6af9bb0066d8351c4a4237ef71b869a8755759ac Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Tue, 8 Sep 2026 22:02:32 +0800
Subject: [PATCH 24/31] test(durable): add deployment crash gates and document
 recovery limits

---
 docs/concepts/durable-execution.md    |   5 +-
 docs/operations/production.md         |  66 ++++++--
 docs/reference/limits-and-defaults.md |   2 +
 docs/reference/runtime/durable.md     |  73 +++++++-
 tests/p1/completion_recovery.py       |  88 ++++++++++
 tests/p1/crash_recovery.py            | 234 ++++++++++++++++++++++++++
 tests/p1/error_isolation.py           |  29 ++++
 tests/p1/release_capacity.py          |  99 +++++++++++
 tests/p1/review_regressions.py        |   5 +-
 tests/p1/storage_recovery.py          |  44 +++++
 10 files changed, 619 insertions(+), 26 deletions(-)
 create mode 100644 tests/p1/completion_recovery.py
 create mode 100644 tests/p1/crash_recovery.py
 create mode 100644 tests/p1/error_isolation.py
 create mode 100644 tests/p1/release_capacity.py
 create mode 100644 tests/p1/storage_recovery.py

diff --git a/docs/concepts/durable-execution.md b/docs/concepts/durable-execution.md
index 7106166..d6904f6 100644
--- a/docs/concepts/durable-execution.md
+++ b/docs/concepts/durable-execution.md
@@ -37,8 +37,9 @@ export default {
 Typed projects created by `tysel init` already contain `tysel-env.d.ts`. Run
 `tysel types` after changing the durable store or other manifest capabilities.
 
-`tysel.durable.start` returns a task ID and either a completed or suspended
-status. Send an external event with
+`tysel.durable.start` returns a task ID and a completed, suspended, or accepted
+status. Use a stable `idempotencyKey` option to repair lost acknowledgements; see
+the [control contract](../reference/runtime/durable.md#control-api). Send an external event with
 `tysel.durable.sendSignal(taskId, "approval", payload)`.
 
 ## Durable boundaries
diff --git a/docs/operations/production.md b/docs/operations/production.md
index d36d471..ac7fa6a 100644
--- a/docs/operations/production.md
+++ b/docs/operations/production.md
@@ -121,7 +121,11 @@ durable starts fail while recovery is pending. A successful poll restores
 `healthy`. Unrecoverable store/scheduler failures, such as a corrupt program
 digest, reach the service owner, which drains and exits unsuccessfully.
 Completion-write availability failures retain the JSON outcome in memory and retry
-persistence without rerunning the handler. At most 32 active executions and pending
+persistence without rerunning the handler while the execution lease is valid.
+If that authority expires or is superseded, the pending handle and its slot are
+released without reporting completion. The scheduler can reclaim the original
+managed task and replay its history; recorded effects do not execute again.
+At most 32 active executions and pending
 finalizations share reserved slots. Pending entries retain compact results and
 lease/sequence metadata, releasing consumed replay history. `completion_pending`
 logs the affected task ID. Completed outcomes are still reported when a different
@@ -129,10 +133,18 @@ task in the same scheduling batch encounters a storage failure.
 Retries remain subject to the original lease. Completion transactions check fresh
 time after acquiring their locks and again before commit; expiry rolls back both
 the result and quota changes. An identical already-committed outcome can still be
-acknowledged after expiry. Lease expiry or shutdown with pending
-outcomes reports failure and needs operator investigation. This does not provide
-recovery after process death: active task restart eligibility and atomic application
-admission/signal delivery remain release blockers (G1/G2).
+acknowledged after expiry. Lease expiry or shutdown with pending outcomes reports
+failure. Persisted execution eligibility survives process death; a new scheduler
+can reclaim the same task after expiry. Every execution has a unique token and
+generation, and stale history/suspension/completion writes are rejected. Interrupted
+unrecorded effects are re-entered: reconcile external outcomes or use provider
+idempotency before repeating writes. Automatic replay does not imply exactly-once
+external effects.
+
+For admission and signal acknowledgement gaps, use the optional stable
+`idempotencyKey` and an application outbox. The runtime atomically records each
+keyed request in its own database; it cannot atomically commit the application's
+separate database. See the [control contract](../reference/runtime/durable.md#control-api).
 
 Per-task execution failures are logged as `task_failed`; they do not by
 themselves stop unrelated work. These states
@@ -141,9 +153,9 @@ attempt counts, without payloads, source, or database credentials. An HTTP-only
 health route may still succeed during recovery; use scheduler diagnostics for
 durable health.
 
-### Durable log v2 upgrade
+### Durable log v3 upgrade
 
-This release migrates durable log v1 to v2 transactionally on store open. The
+This release migrates durable log v1/v2 to v3 transactionally on store open. The
 application manifest schema remains version 1. Before upgrading:
 
 1. Drain and stop **all** old writers and schedulers.
@@ -151,16 +163,18 @@ application manifest schema remains version 1. Before upgrading:
 3. Start the new release or its admin command; verify replay and completion.
 4. Resume traffic only after those checks pass.
 
-Do not run old and new writers together. Old runtimes reject v2 on startup;
+Do not run old and new writers together. Old runtimes reject v3 on startup;
 rollback requires restoring the pre-upgrade snapshot and its matching release.
-Existing v1 programs remain active unless a new execution explicitly completes
+Existing v1/v2 programs remain active unless a new execution explicitly completes
 them. An absent wakeup is not proof of completion. Completion results and the
 active catalog counters persist across reopen. Retained data is removed only
 by [`tysel durable prune`](../reference/cli/tasks.md#tysel-durable).
 
-Failed executions and interrupted runs without an explicit completion are
-retained for investigation. This change does not add automatic replay of
-orphaned runs or an exactly-once external-effect guarantee.
+Failed executions are retained for investigation. Legacy interrupted runs without
+a wakeup or a v3 execution record remain unclassified and are not automatically
+replayed. Do not infer a safe replacement write from absent runtime history.
+Completion pruning also removes admission identities and signal receipts; keep
+retention longer than the application outbox retry horizon.
 
 ## Durable Postgres backup and restore
 
@@ -178,7 +192,8 @@ storage option, not a shared multi-replica durable backend.
 5. Resume writers only after durable backup completion.
 
 The backup must contain all Tysel durable tables, including metadata, programs,
-events, wakeups, signals, completions, task locks, and statistics. Do not copy selected task
+events, wakeups, signals, completions, execution leases, idempotency receipts,
+task locks, and statistics. Do not copy selected task
 rows or individual tables.
 
 ### Restore
@@ -273,3 +288,28 @@ logs.
 
 After recovery, rerun release admission and one durable restart/replay test
 before closing the incident. See [Debugging](../guides/debugging.md).
+
+### Active-crash and acknowledgement gates
+
+From a checked-out runtime source tree, build the local binaries and run:
+
+```sh
+cargo build --locked -p tysel-cli -p tysel-runtime -p tysel-isolate --bins
+python3 tests/p1/crash_recovery.py
+```
+
+The gate uses only loopback services and disposable databases. It covers six
+SIGKILL windows in both `tysel run` and standalone mode with an empty PATH:
+initial unacknowledged admission, before the external write, external commit
+before response, response before effect recording, after effect recording, and
+projection update before signal-wait registration. It also retries a persisted
+signal after its HTTP acknowledgement is lost. Passing requires the same task
+to complete with the reconciled result, a single external create, and a single
+consumed approval event. The fake provider reconciles by stable operation ID;
+the runtime does not make arbitrary provider writes exactly-once.
+
+Run `cargo test --locked -p tysel-durable --test execution` with a disposable
+`TYSEL_POSTGRES_TEST_URL` to also exercise PostgreSQL execution fencing and
+idempotency. The SIGKILL gate above uses SQLite; PostgreSQL deployment crash and
+capacity checks, and an application's own outbox integration, remain separate
+release verification work.
diff --git a/docs/reference/limits-and-defaults.md b/docs/reference/limits-and-defaults.md
index b286d6e..9151836 100644
--- a/docs/reference/limits-and-defaults.md
+++ b/docs/reference/limits-and-defaults.md
@@ -86,6 +86,8 @@ request limit. The smaller applicable bound wins.
 | Retained completion result | 1 MiB per task |
 | Retention cleanup | At most 100 tasks; 16 MiB of retained payload per batch, or one larger task |
 | Concurrent durable polling | 16 |
+| Idempotency key | 1–256 UTF-8 bytes |
+| Retained keyed signal receipts | 10,000 per task; removed with completed-task cleanup |
 
 Completed programs and history remain stored until explicit cleanup, but do
 not consume the active catalog quota. Legacy records without an explicit
diff --git a/docs/reference/runtime/durable.md b/docs/reference/runtime/durable.md
index 271e00f..25c4657 100644
--- a/docs/reference/runtime/durable.md
+++ b/docs/reference/runtime/durable.md
@@ -1,7 +1,8 @@
 # Durable API
 
-Durable handlers record effect boundaries so interrupted work can resume
-without repeating already committed external actions.
+Durable handlers record effect outcomes so interrupted work can replay recorded
+boundaries. An external commit without a recorded outcome still requires provider
+idempotency or reconciliation when the callback is entered again.
 
 ```ts
 interface DurableContext {
@@ -71,15 +72,69 @@ their results are not wrapped by a recorded boundary.
 ## Control API
 
 ```ts
-const status = tysel.durable.start("provision", input);
-tysel.durable.sendSignal(status.taskId, "approval", { approved: true });
+const status = tysel.durable.start("provision", input, {
+  idempotencyKey: "tenant-42:provision:request-123",
+});
+tysel.durable.sendSignal(status.taskId, "approval", { approved: true }, {
+  idempotencyKey: "approval-decision-456",
+});
 ```
 
-`start` returns either a completed result or a suspended status.
-`sendSignal` appends a JSON signal for a waiting workflow. Once a registered
-workflow completes successfully, its JSON result is persisted and its active
-program quota is released. Its program and replay history remain retained.
-Later writes or signals to a retained completed task are rejected.
+`start` atomically persists the task, immutable input and restart eligibility
+before executing the handler. It returns `completed`, `suspended`, or `accepted`
+when another execution owns the task or it is already queued/waiting. `accepted`
+is not a suspension acknowledgement or a terminal result.
+
+The optional start key is scoped to the entire durable store: namespace it by
+tenant and operation. Repeating it with the same bundled handler and canonical
+JSON input returns the same task ID without starting a replacement. Changing the
+handler or input under the same key is a conflict. A failed task returns an
+explicit error on same-key admission retry; it is not acknowledged as `accepted`. Without a key, every call is a
+new admission; a lost acknowledgement cannot be safely repaired by another start.
+
+Signal keys are scoped to a task. Receipt and inbox insertion share one transaction.
+Repeating the same name, payload and key is acknowledged even after consumption or
+completion, without adding another signal. Conflicting reuse is rejected. Unkeyed
+signals retain FIFO semantics and each call enqueues a new signal. New signals to
+completed tasks are rejected. Up to 10,000 keyed signal receipts are retained per
+task, independently of the pending inbox bound.
+
+Applications using a separate database should persist an outbox intent and stable
+key in their own transaction, retry the exact request after uncertain delivery,
+and mark it delivered after acknowledgement. This provides a repairable protocol,
+**not a transaction across the application and runtime databases**. Tysel does not
+run or drain the application's outbox. Both admission and signal deduplication
+last until explicit `prune` removes the completed task; retain tasks longer than
+the application's retry horizon, and do not reuse keys after cleanup.
+
+## Active crash recovery
+
+The service scheduler persists an execution lease independently of wakeups.
+After process death, an eligible task is claimed after lease expiry and resumes
+against its original source and history. Recorded effects return their recorded
+result; an effect interrupted before recording its outcome is entered again.
+Use the same provider operation key or reconcile its outcome before another write.
+Execution generations and unique ownership tokens fence history, suspension and
+completion writes from stale executors. They cannot fence an external provider's
+in-flight request. The lease is the request timeout plus the scheduler margin;
+recovery is not instantaneous. Pending completion retries also respect that
+lease: a stale completion handle is discarded without stopping the service, and
+the original managed task becomes eligible for normal fenced recovery.
+
+A storage failure at a durable boundary invalidates the current execution attempt,
+even if handler code catches the JavaScript exception. The runtime preserves the
+storage error and restart eligibility rather than committing a fallback result.
+After storage recovers and the lease expires, the original history is replayed.
+Ordinary handler exceptions and task boundary validation/limit errors fail only
+the task; they do not stop the scheduler. Lost execution authority abandons the
+stale attempt without stopping other tasks.
+
+Completion releases active quota while retaining program, history and receipts.
+Legacy v1/v2 tasks with persisted wakeups can enter the managed lifecycle when
+resumed. Legacy orphan tasks with neither a wakeup nor an execution record are
+not guessed runnable; investigate them before initiating further external writes.
+Low-level caller-owned Rust sessions and in-memory registries retain their
+caller-managed lifecycle contract.
 
 Use [`tysel durable result` and `tysel durable prune`](../cli/tasks.md#tysel-durable)
 to read a retained result or remove an aged batch. Failed and legacy tasks are
diff --git a/tests/p1/completion_recovery.py b/tests/p1/completion_recovery.py
new file mode 100644
index 0000000..fe2531c
--- /dev/null
+++ b/tests/p1/completion_recovery.py
@@ -0,0 +1,88 @@
+"""Completion storage outage longer than a lease must not stop the service.
+
+Run after building the runtime binaries. Uses disposable SQLite and loopback only.
+"""
+import http.server
+import json
+import sqlite3
+import threading
+import time
+from review_regressions import Service
+
+class Provider(http.server.BaseHTTPRequestHandler):
+    calls = 0
+
+    def do_GET(self):
+        Provider.calls += 1
+        body = b'42'
+        self.send_response(200)
+        self.send_header('Content-Length', str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def log_message(self, *_):
+        pass
+
+provider = http.server.HTTPServer(('127.0.0.1', 0), Provider)
+thread = threading.Thread(target=provider.serve_forever, daemon=True)
+thread.start()
+settings = '''[server]
+listen="127.0.0.1:{port}"
+[limits]
+request_timeout_ms=1000
+[permissions]
+fetch=["127.0.0.1"]
+[durable]
+store="sqlite"
+path="./data/app.db"
+[observability]
+logs="json"
+'''
+source = '''export default {
+ durable: {async job(ctx) {
+   return await ctx.effect('external', async () => {
+     const response = await fetch('ORIGIN'); return await response.json();
+   });
+ }},
+ fetch(req) {
+   return new URL(req.url).pathname === '/' ? new Response('ok') :
+     Response.json(tysel.durable.start('job', null, {idempotencyKey:'completion'}));
+ }
+};'''.replace('ORIGIN', 'http://127.0.0.1:' + str(provider.server_port))
+try:
+    with Service('completion-expiry-recovery', source, settings) as service:
+        with sqlite3.connect(service.root / 'data/durable-events.db') as db:
+            db.execute('CREATE TRIGGER fail_completion BEFORE INSERT ON durable_completions '
+                       'BEGIN SELECT * FROM missing_completion_table; END')
+            db.commit()
+            assert service.request('/start')[0] == 500
+            assert Provider.calls == 1
+            # Exceed the 1 second request timeout plus 5 second lease margin.
+            time.sleep(8)
+            assert service.process.poll() is None, 'lease expiry stopped the service'
+            assert service.request('/')[0] == 200
+            assert db.execute('SELECT count(*) FROM durable_completions').fetchone()[0] == 0
+            db.execute('DROP TRIGGER fail_completion')
+            db.commit()
+            start = time.monotonic()
+            while db.execute('SELECT count(*) FROM durable_completions').fetchone()[0] == 0:
+                assert service.process.poll() is None
+                assert time.monotonic() - start < 10, 'completion did not recover'
+                time.sleep(.02)
+            assert Provider.calls == 1, 'recorded effect ran again'
+            assert db.execute('SELECT count(*) FROM durable_events').fetchone()[0] == 2
+            assert db.execute('SELECT generation FROM durable_executions').fetchone()[0] >= 2
+            status, body, _ = service.request('/start')
+            assert status == 200
+            assert json.loads(body)['status'] == 'completed'
+            assert json.loads(body)['value'] == 42
+            result = {'fixture': str(service.root), 'outage_seconds': 8,
+                      'service_survived': True, 'recovered': True,
+                      'provider_calls': Provider.calls,
+                      'recovery_after_fault_removed_seconds': time.monotonic() - start}
+            (service.root / 'results.json').write_text(json.dumps(result, indent=2))
+            print(json.dumps(result))
+finally:
+    provider.shutdown()
+    provider.server_close()
+    thread.join(timeout=2)
diff --git a/tests/p1/crash_recovery.py b/tests/p1/crash_recovery.py
new file mode 100644
index 0000000..15f9efc
--- /dev/null
+++ b/tests/p1/crash_recovery.py
@@ -0,0 +1,234 @@
+"""G1/G2 SIGKILL gates. Build CLI and service binaries first.
+
+All traffic is loopback. Fake provider survives the child runtime crash and
+reconciles a committed operation using its stable identity. Database inspection
+is read-only; both CLI and standalone run against the same files after restart.
+"""
+import concurrent.futures
+import http.client
+import http.server
+import json
+import os
+from pathlib import Path
+import signal
+import socket
+import sqlite3
+import subprocess
+import tempfile
+import threading
+import time
+
+REPO = Path(__file__).resolve().parents[2]
+BIN = Path(os.environ.get('TYSEL_GATE_BIN_DIR', str(REPO / 'target/debug'))).resolve()
+PG_URL = os.environ.get('TYSEL_GATE_POSTGRES_URL')
+PG_CONTAINER = os.environ.get('TYSEL_GATE_POSTGRES_CONTAINER')
+INSTANCES = int(os.environ.get('TYSEL_GATE_INSTANCES', '1'))
+assert INSTANCES in (1, 2)
+
+def pg_query(sql):
+    assert PG_CONTAINER, 'dedicated PostgreSQL fixture container required'
+    result = subprocess.run(['podman', 'exec', PG_CONTAINER, 'psql', '-U', 'postgres', '-d', 'tysel_validation', '-qAt', '-v', 'ON_ERROR_STOP=1', '-c', sql], check=True, capture_output=True, text=True)
+    return result.stdout.strip()
+
+ROOT = Path(tempfile.mkdtemp(prefix='tysel-g12-crash-'))
+print('FIXTURE='+str(ROOT), flush=True)
+
+def wait_for(fn, seconds=15):
+    until=time.monotonic()+seconds
+    while time.monotonic()<until:
+        value=fn()
+        if value:return value
+        time.sleep(.02)
+    raise AssertionError('condition timed out')
+
+class Provider(http.server.ThreadingHTTPServer):
+    daemon_threads=True
+    def __init__(self,mode):
+        self.mode=mode; self.calls={}; self.creates=0; self.result=None
+        self.blocked=threading.Event();self.release=threading.Event();self.lock=threading.Lock()
+        super().__init__(('127.0.0.1',0),Handler)
+class Handler(http.server.BaseHTTPRequestHandler):
+    def log_message(self,*args):pass
+    def do_GET(self):self.respond()
+    def do_POST(self):self.respond()
+    def respond(self):
+        server=self.server
+        with server.lock:
+            server.calls[self.path]=server.calls.get(self.path,0)+1
+            first=server.calls[self.path]==1
+            if self.path=='/create':
+                server.creates+=1
+                server.result={'operationId':'stable-operation'}
+            value={'found':server.result is not None,'result':server.result} if self.path=='/lookup' else server.result or {}
+        gate={'before_effect':'/before','initial_admission':'/before','after_commit':'/create','after_return':'/after-return','after_record':'/after','projection_wait':'/projection'}[server.mode]
+        if self.path==gate and first:
+            server.blocked.set();server.release.wait(20)
+        data=json.dumps(value).encode()
+        try:
+            self.send_response(200);self.send_header('content-length',str(len(data)));self.end_headers();self.wfile.write(data)
+        except (BrokenPipeError,ConnectionResetError):pass
+
+def run(mode,standalone):
+    root=ROOT/(('standalone-' if standalone else 'run-')+mode+'-'+str(time.time_ns()));root.mkdir()
+    provider=Provider(mode);thread=threading.Thread(target=provider.serve_forever,daemon=True);thread.start()
+    origin='http://127.0.0.1:'+str(provider.server_port)
+    with socket.socket() as sock:sock.bind(('127.0.0.1',0));port=sock.getsockname()[1]
+    source='''const origin=ORIGIN;
+export default {
+ durable: {async job(ctx,input) {
+   if(input.mode==='projection_wait') await fetch(origin+'/projection');
+   if(input.mode!=='initial_admission') await ctx.waitForSignal('go');
+   const result=await ctx.effect('create',async()=>{
+     const prior=await (await fetch(origin+'/lookup')).json();
+     if(prior.found) return prior.result;
+     if(input.mode==='before_effect'||input.mode==='initial_admission') await fetch(origin+'/before');
+     const created=await (await fetch(origin+'/create',{method:'POST'})).json();
+     if(input.mode==='after_return') await fetch(origin+'/after-return');
+     return created;
+   });
+   if(input.mode==='after_record') await fetch(origin+'/after');
+   return result;
+ }},
+ async fetch(request) {
+   const path=new URL(request.url).pathname;
+   if(path==='/start') return Response.json(tysel.durable.start('job',{mode:MODE},{idempotencyKey:'bound-run'}));
+   if(path==='/signal'||path==='/signal-lost') {
+     const data=await request.json();
+     tysel.durable.sendSignal(data.taskId,'go',{approved:true},{idempotencyKey:'decision-1'});
+     if(path==='/signal-lost') await new Promise(()=>{});
+     return new Response('ok');
+   }
+   return new Response('healthy');
+ }
+};'''.replace('ORIGIN',json.dumps(origin)).replace('MODE',json.dumps(mode))
+    (root/'index.js').write_text(source)
+    (root/'tysel.toml').write_text(f'''[app]
+name="crash-gate"
+entry="index.js"
+profile="service"
+[server]
+listen="127.0.0.1:{port}"
+workers=2
+[permissions]
+fetch=["127.0.0.1"]
+[limits]
+request_timeout_ms=1000
+cpu_ms_per_turn=500
+[durable]
+store="sqlite"
+path="./data/app.db"
+[observability]
+logs="json"
+''')
+    env={k:v for k,v in os.environ.items() if not k.startswith(('TYSEL_DURABLE_','OTEL_'))}
+    env['OTEL_SDK_DISABLED']='true'
+    schema = 'gate_' + str(time.time_ns())
+    if PG_URL:
+        pg_query('CREATE SCHEMA ' + schema)
+        env['TYSEL_DURABLE_POSTGRES_URL'] = PG_URL + ('&' if '?' in PG_URL else '?') + 'options=-csearch_path%3D' + schema
+
+    if standalone:
+        subprocess.run([str(BIN/'tysel'),'-C',str(root),'build','--stub',str(BIN/'tysel-service'),'--output',str(root/'app')],env=env,check=True,capture_output=True)
+        env['PATH']='';command=[str(root/'app')]
+    else:command=[str(BIN/'tysel'),'-C',str(root),'run']
+    def request(path,data=None):
+        conn=http.client.HTTPConnection('127.0.0.1',port,timeout=3)
+        try:
+            conn.request('POST' if data is not None else 'GET',path,None if data is None else json.dumps(data),{'content-type':'application/json'})
+            response=conn.getresponse();body=response.read().decode()
+            assert response.status==200,(response.status,body)
+            return body
+        finally:conn.close()
+    def healthy():
+        try:return request('/')=='healthy'
+        except (OSError,AssertionError):return False
+    log=(root/'service.log').open('w');process=None;peer=None;peer_log=None
+    executor=concurrent.futures.ThreadPoolExecutor(1)
+    try:
+        process=subprocess.Popen(command,cwd=root,env=env,stdout=log,stderr=log);wait_for(healthy)
+        # Prepare the peer artifact before holding a one-second effect open.
+        if INSTANCES == 2:
+            assert PG_URL, 'multi-instance gate requires shared PostgreSQL'
+            peer_root=root/'peer';peer_root.mkdir()
+            with socket.socket() as sock:sock.bind(('127.0.0.1',0));peer_port=sock.getsockname()[1]
+            (peer_root/'index.js').write_text(source)
+            (peer_root/'tysel.toml').write_text((root/'tysel.toml').read_text().replace(str(port),str(peer_port)))
+            peer_command=[str(BIN/'tysel'),'-C',str(peer_root),'run']
+            if standalone:
+                subprocess.run([str(BIN/'tysel'),'-C',str(peer_root),'build','--stub',str(BIN/'tysel-service'),'--output',str(peer_root/'app')],env={**env,'PATH':os.environ.get('PATH','')},check=True,capture_output=True)
+                peer_command=[str(peer_root/'app')]
+        # The initial request is deliberately left unacknowledged in two cases.
+        pending=executor.submit(request,'/start')
+        db_path=root/'data/durable-events.db'
+        def rows(sql):
+            if PG_URL:
+                sql = sql.replace('lower(hex(task_id))', "encode(task_id,'hex')")
+                data = json.loads(pg_query("SET search_path TO "+schema+"; SET default_transaction_read_only=on; SELECT COALESCE(json_agg(row_to_json(t)),'[]'::json) FROM ("+sql+") t"))
+                return [list(row.values()) for row in data]
+            if not db_path.exists():return []
+            with sqlite3.connect('file:'+str(db_path)+'?mode=ro',uri=True) as db:return db.execute(sql).fetchall()
+        task=wait_for(lambda:rows('SELECT lower(hex(task_id)) FROM durable_programs'))[0][0]
+        if mode not in ('initial_admission','projection_wait'):
+            pending.result()
+            if mode=='after_commit':pending=executor.submit(request,'/signal-lost',{'taskId':task})
+            else:request('/signal',{'taskId':task})
+        assert provider.blocked.wait(8),(mode,provider.calls)
+        if mode=='after_record':assert rows("SELECT count(*) FROM durable_events WHERE kind='effect'")[0][0]==1
+        if INSTANCES == 2:
+            peer_log=(peer_root/'service.log').open('w')
+            peer=subprocess.Popen(peer_command,cwd=peer_root,env=env,stdout=peer_log,stderr=peer_log)
+            def peer_ready():
+                try:
+                    conn=http.client.HTTPConnection('127.0.0.1',peer_port,timeout=1)
+                    conn.request('GET','/');response=conn.getresponse();body=response.read();conn.close()
+                    return response.status==200 and body==b'healthy'
+                except OSError:return False
+            wait_for(peer_ready)
+        process.send_signal(signal.SIGKILL);process.wait(timeout=5)
+        provider.release.set()
+        try:pending.result(timeout=3)
+        except (OSError,http.client.HTTPException,AssertionError):pass
+        process=subprocess.Popen(command,cwd=root,env=env,stdout=log,stderr=log);wait_for(healthy)
+        # Repeated admission binds to the original task and cannot run a replacement.
+        repeated=json.loads(request('/start'));assert repeated['taskId']==task,repeated
+        if mode in ('projection_wait','after_commit'):request('/signal',{'taskId':task})
+        started=time.monotonic()
+        completed=wait_for(lambda:rows('SELECT result_json FROM durable_completions'),15)
+        assert json.loads(completed[0][0])=={'operationId':'stable-operation'},completed
+        if mode!='initial_admission':
+            request('/signal',{'taskId':task}) # duplicate after consumption and completion
+            assert rows("SELECT count(*) FROM durable_events WHERE kind='signal'")[0][0]==1
+            assert rows('SELECT count(*) FROM durable_signal_inbox')[0][0]==0
+        assert rows('SELECT count(*) FROM durable_programs')[0][0]==1
+        assert rows('SELECT active_count FROM durable_program_stats')[0][0]==0
+        assert provider.creates==1,provider.calls
+        result={'backend':'postgres' if PG_URL else 'sqlite','instances':INSTANCES,'mode':mode,'standalone':standalone,'task_id':task,'completed':True,'create_requests':provider.creates,'provider_calls':dict(provider.calls),'recovery_seconds':round(time.monotonic()-started,3)}
+        print(json.dumps(result),flush=True);return result
+    finally:
+        provider.release.set()
+        if process is not None and process.poll() is None:
+            process.terminate()
+            try:process.wait(timeout=5)
+            except subprocess.TimeoutExpired:process.kill();process.wait()
+        if peer is not None and peer.poll() is None:
+            peer.terminate()
+            try:peer.wait(timeout=5)
+            except subprocess.TimeoutExpired:peer.kill();peer.wait()
+        if peer_log:peer_log.close()
+        executor.shutdown(wait=True);log.close();provider.shutdown();provider.server_close();thread.join()
+        if 'result' in locals():
+            for service in (process,peer):
+                if service is not None:
+                    assert service.returncode==0, f'Unclean shutdown: {service.returncode}'
+        for service_log in [root/'service.log', root/'peer'/'service.log']:
+            if service_log.exists():
+                content=service_log.read_text()
+                assert 'panicked at' not in content, f'Runtime panic: {service_log}'
+
+if __name__=='__main__':
+    results=[]
+    for standalone in ((True,) if os.environ.get('TYSEL_GATE_STANDALONE_ONLY') else (False,True)):
+        for mode in ('initial_admission','before_effect','after_commit','after_return','after_record','projection_wait'):
+            results.append(run(mode,standalone))
+            (ROOT/'results.json').write_text(json.dumps(results,indent=2))
+    print('RESULT_PATH='+str(ROOT/'results.json'),flush=True)
diff --git a/tests/p1/error_isolation.py b/tests/p1/error_isolation.py
new file mode 100644
index 0000000..3ad7b09
--- /dev/null
+++ b/tests/p1/error_isolation.py
@@ -0,0 +1,29 @@
+"""Regression gate: task errors must not stop the service or acknowledge failed retries."""
+import sys,time,json
+from review_regressions import Service
+settings='''[server]
+listen="127.0.0.1:{port}"
+[limits]
+request_timeout_ms=1000
+[durable]
+store="sqlite"
+path="./data/app.db"
+[observability]
+logs="json"
+'''
+source='''export default {durable:{async bad(ctx){await ctx.sleep(1);return await ctx.effect('x'.repeat(257),async()=>42)},async business(){throw new Error('business')},async good(){return 42}},fetch(req){const name=new URL(req.url).pathname.slice(1);return name?Response.json(tysel.durable.start(name,null,{idempotencyKey:name})):new Response('ok')}}'''
+with Service('final-review',source,settings) as s:
+ result={'fixture':str(s.root),'business_first':s.request('/business'),'business_retry':s.request('/business'),'good_before':s.request('/good'),'bad':s.request('/bad')}
+ time.sleep(1)
+ try: result['good_after']=s.request('/good')
+ except OSError as e: result['good_after']={'error':str(e)}
+ result['process_exit']=s.process.poll()
+ result['log']=(s.root/'service.log').read_text()
+ assert result['business_first'][0] == 500
+ assert result['business_retry'][0] == 500
+ assert result['bad'][0] == 200
+ assert result['process_exit'] is None
+ assert result['good_after'][0] == 200
+ assert json.loads(result['good_after'][1])['value'] == 42
+ print(json.dumps(result))
+ (s.root/'results.json').write_text(json.dumps(result,indent=2))
diff --git a/tests/p1/release_capacity.py b/tests/p1/release_capacity.py
new file mode 100644
index 0000000..b8aa5e8
--- /dev/null
+++ b/tests/p1/release_capacity.py
@@ -0,0 +1,99 @@
+"""Closed-loop capacity probe; not an SLO or open-loop saturation certification."""
+import concurrent.futures
+import http.client
+import json
+import os
+import statistics
+import sqlite3
+import subprocess
+import threading
+import time
+from review_regressions import Service, BIN_DIR
+
+assert BIN_DIR.name == 'release', 'set TYSEL_GATE_BIN_DIR to optimized binaries'
+SETTINGS = '''[server]
+listen="127.0.0.1:{port}"
+workers=8
+[limits]
+request_timeout_ms=5000
+cpu_ms_per_turn=1000
+memory_mb=128
+[durable]
+store="sqlite"
+path="./data/app.db"
+[observability]
+logs="json"
+'''
+SOURCE = '''export default {
+ durable: {
+  async one(ctx) {return await ctx.effect('one',async()=>42)},
+  async ten(ctx) {let n=0;for(let i=0;i<10;i++)n+=await ctx.effect('e'+i,async()=>1);return n},
+  async payload(ctx) {return await ctx.effect('payload',async()=>'x'.repeat(65536))}
+ },
+ fetch(req) {const path=new URL(req.url).pathname.slice(1);
+  if(!path) return new Response('ready');
+  if(path==='http') return Response.json({ok:true});
+  return Response.json(tysel.durable.start(path,null));
+ }
+};'''
+
+def phase(service, workload, clients, seconds):
+    barrier=threading.Barrier(clients+1)
+    def client():
+        conn=http.client.HTTPConnection('127.0.0.1',service.port,timeout=12)
+        samples=[];statuses={};barrier.wait();deadline=time.monotonic()+seconds
+        while time.monotonic()<deadline:
+            start=time.monotonic()
+            try:
+                conn.request('GET','/'+workload)
+                response=conn.getresponse();body=response.read()
+                status=str(response.status)
+                if response.status==200:
+                    data=json.loads(body)
+                    if workload!='http':
+                        if data.get('status')=='accepted' and data.get('taskId'):status='accepted'
+                        elif data.get('status')!='completed' or data.get('value')!=({'one':42,'ten':10,'payload':'x'*65536}[workload]):status='invalid_result'
+            except Exception as error:
+                status=type(error).__name__;conn.close();conn=http.client.HTTPConnection('127.0.0.1',service.port,timeout=12)
+            statuses[status]=statuses.get(status,0)+1;samples.append((time.monotonic()-start)*1000)
+        conn.close();return samples,statuses
+    with concurrent.futures.ThreadPoolExecutor(clients) as pool:
+        futures=[pool.submit(client) for _ in range(clients)]
+        start=time.monotonic();barrier.wait();rss=[]
+        while not all(f.done() for f in futures):
+            sample=subprocess.run(['ps','-p',str(service.process.pid),'-o','rss=,%cpu='],capture_output=True,text=True).stdout.split()
+            if len(sample)==2:rss.append({'seconds':round(time.monotonic()-start,2),'rss_kib':int(sample[0]),'ps_cpu_percent':float(sample[1])})
+            time.sleep(.5)
+        elapsed=time.monotonic()-start;samples=[];statuses={}
+        for future in futures:
+            values,counts=future.result();samples+=values
+            for status,count in counts.items():statuses[status]=statuses.get(status,0)+count
+    samples.sort()
+    completed = None
+    if workload != 'http':
+        with sqlite3.connect('file:'+str(service.root/'data/durable-events.db')+'?mode=ro',uri=True) as db:
+            deadline=time.monotonic()+10
+            while db.execute('SELECT active_count FROM durable_program_stats').fetchone()[0]:
+                assert time.monotonic()<deadline, 'admitted tasks did not drain'
+                time.sleep(.02)
+            total=db.execute('SELECT count(*) FROM durable_completions').fetchone()[0]
+            completed=total-getattr(service,'completed_count',0)
+            service.completed_count=total
+            assert completed==statuses.get('200',0)+statuses.get('accepted',0), 'admission/completion mismatch'
+    return {'completed_tasks':completed,'workload':workload,'clients':clients,'seconds':elapsed,'requests':len(samples),'rps':len(samples)/elapsed,'status_counts':statuses,'p50_ms':statistics.median(samples),'p95_ms':samples[int(len(samples)*.95)],'p99_ms':samples[int(len(samples)*.99)],'rss_samples':rss}
+
+results=[]
+for workload in ['http','one','ten','payload']:
+    with Service('capacity-'+workload,SOURCE,SETTINGS) as service:
+        for clients in [1,4,16,32]:
+            result=phase(service,workload,clients,int(os.environ.get('TYSEL_PHASE_SECONDS','5')))
+            result['fixture']=str(service.root);results.append(result)
+            print(json.dumps({k:v for k,v in result.items() if k!='rss_samples'}),flush=True)
+            (service.root/'results.json').write_text(json.dumps(results,indent=2))
+        if workload=='one':
+            result=phase(service,workload,4,int(os.environ.get('TYSEL_SOAK_SECONDS','60')))
+            result['fixture']=str(service.root);result['soak']=True;results.append(result)
+            print(json.dumps({k:v for k,v in result.items() if k!='rss_samples'}),flush=True)
+output=os.environ.get('TYSEL_CAPACITY_OUTPUT','/tmp/tysel-release-capacity.json')
+with open(output,'w') as f:json.dump(results,f,indent=2)
+print('RESULT_PATH='+output,flush=True)
diff --git a/tests/p1/review_regressions.py b/tests/p1/review_regressions.py
index e2f1251..cb4b938 100644
--- a/tests/p1/review_regressions.py
+++ b/tests/p1/review_regressions.py
@@ -16,6 +16,7 @@
 import time
 
 REPO = Path(__file__).resolve().parents[2]
+BIN_DIR = Path(os.environ.get("TYSEL_GATE_BIN_DIR", str(REPO / "target/debug"))).resolve()
 ROOT = Path(tempfile.mkdtemp(prefix="tysel-review-gates-"))
 
 
@@ -32,10 +33,10 @@ def __init__(self, name, source, settings):
         )
         env = {k: v for k, v in os.environ.items()
                if not k.startswith(("TYSEL_DURABLE_", "OTEL_"))}
-        env.update(OTEL_SDK_DISABLED="true", TYSEL_WORKER=str(REPO / "target/debug/tysel-worker"))
+        env.update(OTEL_SDK_DISABLED="true", TYSEL_WORKER=str(BIN_DIR / "tysel-worker"))
         self.log = (self.root / "service.log").open("w")
         self.process = subprocess.Popen(
-            [str(REPO / "target/debug/tysel"), "-C", str(self.root), "run"],
+            [str(BIN_DIR / "tysel"), "-C", str(self.root), "run"],
             stdout=self.log, stderr=self.log, env=env,
         )
 
diff --git a/tests/p1/storage_recovery.py b/tests/p1/storage_recovery.py
new file mode 100644
index 0000000..6b2f5d1
--- /dev/null
+++ b/tests/p1/storage_recovery.py
@@ -0,0 +1,44 @@
+"""Loopback regression for an effect recording failure; uses disposable SQLite only.
+Run after building tysel: python3 tests/p1/storage_recovery.py
+"""
+import json
+import sqlite3
+import time
+from review_regressions import Service
+
+SETTINGS = '[server]\nlisten="127.0.0.1:{port}"\n[limits]\nrequest_timeout_ms=1000\n[durable]\nstore="sqlite"\npath="./data/app.db"\n[observability]\nlogs="json"\n'
+SOURCE = """export default {
+  durable: {async job(ctx) {
+    try {return await ctx.effect('write', async () => 42)}
+    catch {return 99}
+  }},
+  fetch(req) {
+    return new URL(req.url).pathname === '/' ? new Response('ok') :
+      Response.json(tysel.durable.start('job', null, {idempotencyKey: 'review'}));
+  }
+};"""
+
+with Service('effect-storage-recovery', SOURCE, SETTINGS) as service:
+    with sqlite3.connect(service.root / 'data/durable-events.db') as db:
+        db.execute("CREATE TRIGGER fail_effect BEFORE INSERT ON durable_events "
+                   "WHEN NEW.sequence=1 BEGIN SELECT RAISE(FAIL, 'temporary storage fault'); END")
+        db.commit()
+        assert service.request('/start')[0] == 500
+        assert db.execute('SELECT state FROM durable_executions').fetchone()[0] == 'running'
+        assert db.execute('SELECT count(*) FROM durable_completions').fetchone()[0] == 0
+        db.execute('DROP TRIGGER fail_effect')
+        db.commit()
+        start = time.monotonic()
+        while db.execute('SELECT count(*) FROM durable_completions').fetchone()[0] == 0:
+            assert time.monotonic() - start < 10, 'task did not recover'
+            time.sleep(.02)
+        elapsed = time.monotonic() - start
+        assert json.loads(db.execute('SELECT result_json FROM durable_completions').fetchone()[0]) == 42
+        status, body, _ = service.request('/start')
+        assert status == 200
+        assert json.loads(body)['status'] == 'completed'
+        assert json.loads(body)['value'] == 42
+        result = {'fixture': str(service.root), 'recovered': True,
+                  'caught_fallback_not_committed': True, 'recovery_seconds': elapsed}
+        (service.root / 'results.json').write_text(json.dumps(result, indent=2))
+        print(json.dumps(result))

From 32482a2bf572385c708abb2e1beaae4e884805d9 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Wed, 9 Sep 2026 14:34:53 +0800
Subject: [PATCH 25/31] perf(runtime): cache durable exports per source
 revision

---
 crates/tysel-runtime/src/durable_plane.rs | 61 ++++++++++++++++++++---
 1 file changed, 54 insertions(+), 7 deletions(-)

diff --git a/crates/tysel-runtime/src/durable_plane.rs b/crates/tysel-runtime/src/durable_plane.rs
index 7498f74..e876021 100644
--- a/crates/tysel-runtime/src/durable_plane.rs
+++ b/crates/tysel-runtime/src/durable_plane.rs
@@ -25,7 +25,7 @@ const SQLITE_PATH_ENV: &str = "TYSEL_DURABLE_SQLITE_PATH";
 
 pub struct DurablePlane {
     dispatcher: Arc<DurableDispatcher>,
-    source: RwLock<Arc<str>>,
+    source: RwLock<Arc<RegisteredSource>>,
     config: IsolateConfig,
     shutdown: PollerShutdown,
     health: watch::Receiver<PollerHealth>,
@@ -33,6 +33,19 @@ pub struct DurablePlane {
     hooks: Mutex<std::sync::Weak<DurableControl>>,
 }
 
+// Publish source and its inspected exports together so reloads cannot mix generations.
+struct RegisteredSource {
+    text: String,
+    exports: Vec<String>,
+}
+
+impl RegisteredSource {
+    fn new(text: String, config: IsolateConfig) -> Result<Self, DurablePlaneError> {
+        let exports = inspect_durable_exports(&text, config)?;
+        Ok(Self { text, exports })
+    }
+}
+
 #[derive(Debug, thiserror::Error)]
 pub enum DurablePlaneError {
     #[error(transparent)]
@@ -137,6 +150,7 @@ impl DurablePlane {
         config: IsolateConfig,
         owner: impl Into<String>,
     ) -> Result<Arc<Self>, DurablePlaneError> {
+        let source = Arc::new(RegisteredSource::new(source, config)?);
         let lease_duration_ms = config.request_timeout_ms.saturating_add(5_000).max(1_000);
         let dispatcher =
             Arc::new(DurableDispatcher::new(store.clone(), owner, lease_duration_ms, config)?);
@@ -173,7 +187,7 @@ impl DurablePlane {
         });
         let plane = Arc::new(Self {
             dispatcher,
-            source: RwLock::new(Arc::from(source)),
+            source: RwLock::new(source),
             config,
             shutdown,
             health,
@@ -185,7 +199,8 @@ impl DurablePlane {
     }
 
     pub fn replace_source(&self, source: String) -> Result<(), DurablePlaneError> {
-        *self.source.write().map_err(|_| DurablePlaneError::Poisoned)? = Arc::from(source);
+        let source = Arc::new(RegisteredSource::new(source, self.config)?);
+        *self.source.write().map_err(|_| DurablePlaneError::Poisoned)? = source;
         Ok(())
     }
 
@@ -246,12 +261,10 @@ impl DurablePlane {
         }
         let source =
             { self.source.read().map_err(|_| "durable source lock poisoned".to_string())?.clone() };
-        let available =
-            inspect_durable_exports(source.as_ref(), self.config).map_err(|err| err.to_string())?;
-        if !available.iter().any(|export| export == name) {
+        if !source.exports.iter().any(|export| export == name) {
             return Err(format!("durable export {name} is not registered"));
         }
-        let wrapped = encode_durable_export(name, source.as_ref());
+        let wrapped = encode_durable_export(name, &source.text);
         let slot = self.dispatcher.reserve().map_err(|error| error.to_string())?;
         let generated = next_task_id().to_string();
         let key = key.unwrap_or(&generated);
@@ -410,6 +423,40 @@ mod tests {
     use super::*;
     use std::time::Duration;
 
+    #[tokio::test]
+    async fn source_replacement_updates_exports_atomically_and_preserves_replay() {
+        let store = Arc::new(SqliteStore::in_memory().unwrap());
+        let config = IsolateConfig { cpu_ms_per_turn: 500, ..Default::default() };
+        let plane = DurablePlane::start(
+            store.clone(),
+            "export default {durable:{async old(ctx){await ctx.waitForSignal('go');return 1}}};"
+                .into(),
+            config,
+            "source-cache",
+        )
+        .unwrap();
+        let started: JsonValue =
+            serde_json::from_str(&plane.start_named("old", "null").unwrap()).unwrap();
+        let id = parse_task_id(started["taskId"].as_str().unwrap()).unwrap();
+        assert!(plane.replace_source("export default {".into()).is_err());
+        assert!(plane.start_named("old", "null").is_ok());
+        plane.replace_source("export default {durable:{async new(){return 2}}};".into()).unwrap();
+        assert!(plane.start_named("old", "null").unwrap_err().contains("not registered"));
+        let new: JsonValue =
+            serde_json::from_str(&plane.start_named("new", "null").unwrap()).unwrap();
+        assert_eq!(new["value"].as_f64(), Some(2.0));
+        plane.send_signal(&id.to_string(), "go", "true").unwrap();
+        tokio::time::timeout(Duration::from_secs(3), async {
+            while store.completion(id).unwrap().is_none() {
+                tokio::time::sleep(Duration::from_millis(10)).await;
+            }
+        })
+        .await
+        .unwrap();
+        assert_eq!(store.completion(id).unwrap().unwrap().value.as_f64(), Some(1.0));
+        plane.shutdown().await.unwrap();
+    }
+
     #[tokio::test]
     async fn task_boundary_error_does_not_stop_scheduler_or_accept_failed_retry() {
         let store = Arc::new(SqliteStore::in_memory().unwrap());

From f60d86d559fa11530f48153b94a22841d0e04693 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Wed, 9 Sep 2026 14:35:22 +0800
Subject: [PATCH 26/31] perf(runtime): wake durable scheduler after signal
 commits

---
 crates/tysel-runtime/src/durable_plane.rs |   9 +-
 crates/tysel-runtime/src/durable_poll.rs  | 112 +++++++++++++++++++++-
 2 files changed, 116 insertions(+), 5 deletions(-)

diff --git a/crates/tysel-runtime/src/durable_plane.rs b/crates/tysel-runtime/src/durable_plane.rs
index e876021..c36bfeb 100644
--- a/crates/tysel-runtime/src/durable_plane.rs
+++ b/crates/tysel-runtime/src/durable_plane.rs
@@ -28,6 +28,7 @@ pub struct DurablePlane {
     source: RwLock<Arc<RegisteredSource>>,
     config: IsolateConfig,
     shutdown: PollerShutdown,
+    wakeup: Arc<tokio::sync::Notify>,
     health: watch::Receiver<PollerHealth>,
     join: Mutex<Option<JoinHandle<Result<(), PollerError>>>>,
     hooks: Mutex<std::sync::Weak<DurableControl>>,
@@ -156,6 +157,7 @@ impl DurablePlane {
             Arc::new(DurableDispatcher::new(store.clone(), owner, lease_duration_ms, config)?);
         let poller =
             DurablePoller::new_persistent_modules(dispatcher.clone(), POLL_INTERVAL, POLL_BATCH)?;
+        let wakeup = poller.wakeup();
         let shutdown = PollerShutdown::default();
         let (health_tx, health) = watch::channel(PollerHealth::Healthy);
         let join = tokio::spawn({
@@ -190,6 +192,7 @@ impl DurablePlane {
             source: RwLock::new(source),
             config,
             shutdown,
+            wakeup,
             health,
             join: Mutex::new(Some(join)),
             hooks: Mutex::new(std::sync::Weak::new()),
@@ -309,8 +312,10 @@ impl DurablePlane {
             Some(key) => store.send_signal_once(task_id, name, &payload, key, now_ms),
             None => store.send_signal(task_id, name, &payload, now_ms),
         }
-        .map(|_| ())
-        .map_err(|err| err.to_string())
+        .map_err(|err| err.to_string())?;
+        // Wake only after commit; a lost hint is repaired by the periodic scan.
+        self.wakeup.notify_one();
+        Ok(())
     }
 
     pub fn health(&self) -> PollerHealth {
diff --git a/crates/tysel-runtime/src/durable_poll.rs b/crates/tysel-runtime/src/durable_poll.rs
index 5c8dab1..74a1635 100644
--- a/crates/tysel-runtime/src/durable_poll.rs
+++ b/crates/tysel-runtime/src/durable_poll.rs
@@ -3,7 +3,7 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, RwLock};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
-use tokio::sync::watch;
+use tokio::sync::{Notify, watch};
 use tokio::task::JoinSet;
 use tysel_durable::{
     DurableError, DurableProgramKind, DurableStore, MAX_DURABLE_PROGRAM_BYTES,
@@ -203,6 +203,7 @@ pub struct DurablePoller {
     interval: Duration,
     batch_size: usize,
     cursor: AtomicUsize,
+    wakeup: Arc<Notify>,
     execution: ProgramExecution,
 }
 
@@ -274,10 +275,16 @@ impl DurablePoller {
             interval,
             batch_size,
             cursor: AtomicUsize::new(0),
+            wakeup: Arc::new(Notify::new()),
             execution,
         })
     }
 
+    // Notifications are coalesced hints. Persistent scans remain authoritative.
+    pub(crate) fn wakeup(&self) -> Arc<Notify> {
+        self.wakeup.clone()
+    }
+
     pub async fn poll_once(&self) -> Result<Vec<DurableRun>, PollerError> {
         self.poll_batch(None, &mut || {}).await
     }
@@ -424,7 +431,9 @@ impl DurablePoller {
             };
             tokio::select! {
                 () = shutdown.cancelled() => return Ok(()),
-                () = tokio::time::sleep(delay) => {}
+                () = tokio::time::sleep(delay) => {},
+                // Do not let producers bypass storage-error backoff.
+                () = self.wakeup.notified(), if attempt == 0 => {}
             }
         }
     }
@@ -452,7 +461,8 @@ impl DurablePoller {
             }
             tokio::select! {
                 () = shutdown.cancelled() => return Ok(()),
-                () = tokio::time::sleep(self.interval) => {}
+                () = tokio::time::sleep(self.interval) => {},
+                () = self.wakeup.notified() => {}
             }
         }
     }
@@ -906,6 +916,102 @@ mod tests {
         tokio::time::timeout(Duration::from_secs(1), task).await.unwrap().unwrap().unwrap();
     }
 
+    #[tokio::test]
+    async fn notification_does_not_bypass_storage_error_backoff() {
+        let path = std::env::temp_dir().join(format!(
+            "tysel-notify-backoff-{}-{}.db",
+            std::process::id(),
+            unix_time_ms()
+        ));
+        let store = Arc::new(SqliteStore::open(&path).unwrap());
+        let db = rusqlite::Connection::open(&path).unwrap();
+        db.execute_batch("ALTER TABLE durable_programs RENAME TO unavailable_programs").unwrap();
+        let poller = DurablePoller::new_persistent_modules(
+            dispatcher(store, "notify-backoff"),
+            Duration::from_millis(1),
+            8,
+        )
+        .unwrap();
+        let wakeup = poller.wakeup();
+        let stop = PollerShutdown::default();
+        let shutdown = stop.clone();
+        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
+        let task = tokio::spawn(async move {
+            poller
+                .run_supervised(
+                    shutdown,
+                    |_| {},
+                    |health| {
+                        tx.send(health).unwrap();
+                    },
+                )
+                .await
+        });
+        assert_eq!(
+            tokio::time::timeout(Duration::from_secs(2), rx.recv()).await.unwrap(),
+            Some(PollerHealth::Recovering { attempt: 1 })
+        );
+        for _ in 0..100 {
+            wakeup.notify_one();
+        }
+        let early = tokio::time::timeout(Duration::from_millis(100), rx.recv()).await;
+        stop.cancel();
+        task.await.unwrap().unwrap();
+        assert!(early.is_err(), "notification bypassed the minimum 200 ms storage backoff");
+        drop(db);
+        std::fs::remove_file(path).unwrap();
+    }
+
+    #[tokio::test]
+    async fn committed_signal_notification_interrupts_long_poll_interval() {
+        let store = Arc::new(SqliteStore::in_memory().unwrap());
+        let dispatcher = dispatcher(store.clone(), "notify");
+        let programs = DurableProgramRegistry::default();
+        for id in [TaskId(801), TaskId(802)] {
+            store.put_program(id, WAIT_SCRIPT, unix_time_ms()).unwrap();
+            assert!(matches!(
+                dispatcher.start(id, WAIT_SCRIPT).result,
+                Ok(crate::DurableRunStatus::Suspended)
+            ));
+            programs.register(id, WAIT_SCRIPT).unwrap();
+        }
+        store
+            .send_signal(TaskId(801), "approval", &serde_json::json!(true), unix_time_ms())
+            .unwrap();
+        let poller = DurablePoller::new(dispatcher, programs, Duration::from_secs(60), 8).unwrap();
+        let wakeup = poller.wakeup();
+        let stop = PollerShutdown::default();
+        let shutdown = stop.clone();
+        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
+        let task = tokio::spawn(async move {
+            poller
+                .run_supervised(
+                    shutdown,
+                    |run| {
+                        tx.send(run.task_id).unwrap();
+                    },
+                    |_| {},
+                )
+                .await
+        });
+        assert_eq!(
+            tokio::time::timeout(Duration::from_secs(2), rx.recv()).await.unwrap(),
+            Some(TaskId(801))
+        );
+        store
+            .send_signal(TaskId(802), "approval", &serde_json::json!(true), unix_time_ms())
+            .unwrap();
+        // notify_one retains a permit even if the loop has not entered select yet.
+        for _ in 0..100 {
+            wakeup.notify_one();
+        }
+        let received = tokio::time::timeout(Duration::from_secs(2), rx.recv()).await;
+        stop.cancel();
+        task.await.unwrap().unwrap();
+        assert_eq!(received.unwrap(), Some(TaskId(802)));
+        assert!(store.completion(TaskId(802)).unwrap().is_some());
+    }
+
     #[tokio::test]
     async fn idle_poller_shutdown_does_not_wait_for_the_interval() {
         let poller = DurablePoller::new(

From 87476d0a62f8bdf9ebbaa4736e9e41d06c7f203b Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Wed, 9 Sep 2026 14:35:43 +0800
Subject: [PATCH 27/31] test(perf): add resource comparisons and bounded
 failure checks

---
 tests/p1/performance_ab.py           | 267 +++++++++++++++++++++++++++
 tests/p1/performance_control.py      |  85 +++++++++
 tests/p1/performance_harness_test.py |  94 ++++++++++
 3 files changed, 446 insertions(+)
 create mode 100644 tests/p1/performance_ab.py
 create mode 100644 tests/p1/performance_control.py
 create mode 100644 tests/p1/performance_harness_test.py

diff --git a/tests/p1/performance_ab.py b/tests/p1/performance_ab.py
new file mode 100644
index 0000000..7bfeebe
--- /dev/null
+++ b/tests/p1/performance_ab.py
@@ -0,0 +1,267 @@
+"""macOS loopback A/B benchmark. Service CPU/RSS and disk I/O use proc_pid_rusage.
+
+Timings retain default SQLite journaling. Child logs are drained into parent
+memory so child-attributed storage writes are database/journal I/O, not logs.
+Separate fixed-count probes also report retained database file growth.
+Each phase starts a fresh process/database, warms up, then uses closed-loop clients.
+"""
+import concurrent.futures as futures
+import ctypes as C
+import hashlib
+import http.client
+import http.server
+import json
+import math
+import os
+from pathlib import Path
+import shutil
+import socket
+import sqlite3
+import statistics
+import subprocess
+import sys
+import threading
+import time
+
+ROOT = Path(os.environ.get('TYSEL_AB_ROOT', '/tmp/tysel-perf-20260909'))
+OUT = ROOT / 'measurements'
+OUT.mkdir(exist_ok=True)
+SECONDS = float(os.environ.get('TYSEL_AB_SECONDS', '10'))
+REPEATS = int(os.environ.get('TYSEL_AB_REPEATS', '3'))
+STARTUP_TIMEOUT = 30
+CLIENT_READY_TIMEOUT = 30
+STOP_TIMEOUT = 15
+BEFORE = Path(os.environ.get('TYSEL_AB_BEFORE_BIN',str(ROOT / 'before-bin')))
+AFTER = ROOT / 'after-bin'
+FIELDS = 'user_time system_time pkg_idle_wkups interrupt_wkups pageins wired_size resident_size phys_footprint proc_start_abstime proc_exit_abstime child_user_time child_system_time child_pkg_idle_wkups child_interrupt_wkups child_pageins child_elapsed_abstime diskio_bytesread diskio_byteswritten'.split()
+class Usage(C.Structure):
+    _fields_ = [('uuid', C.c_uint8 * 16)] + [(k, C.c_uint64) for k in FIELDS]
+lib = C.CDLL('/usr/lib/libproc.dylib', use_errno=True)
+lib.proc_pid_rusage.argtypes = [C.c_int, C.c_int, C.c_void_p]
+class Timebase(C.Structure):
+    _fields_=[('numer',C.c_uint32),('denom',C.c_uint32)]
+timebase=Timebase()
+C.CDLL('/usr/lib/libSystem.B.dylib').mach_timebase_info(C.byref(timebase))
+TICK_NS=timebase.numer/timebase.denom
+def usage(pid):
+    u = Usage()
+    if lib.proc_pid_rusage(pid, 2, C.byref(u)) != 0:
+        raise OSError(C.get_errno(), 'proc_pid_rusage')
+    return {k: getattr(u, k) for k in FIELDS}
+
+def port():
+    with socket.socket() as s:
+        s.bind(('127.0.0.1', 0))
+        return s.getsockname()[1]
+
+SOURCE = '''export default {durable:{
+ async one(ctx){return await ctx.effect('one',async()=>42)},
+ async ten(ctx){let n=0;for(let i=0;i<10;i++)n+=await ctx.effect('e'+i,async()=>1);return n},
+ async payload(ctx){return await ctx.effect('payload',async()=>'x'.repeat(65536))}
+},fetch(req){const p=new URL(req.url).pathname.slice(1);if(!p)return new Response('ready');
+ if(p==='http')return Response.json({ok:true});return Response.json(tysel.durable.start(p,null));}};'''
+
+class Provider(http.server.BaseHTTPRequestHandler):
+    def log_message(self, *_): pass
+    def do_GET(self):
+        body=json.dumps({'full_name':'owner/repo','default_branch':'main'}).encode()
+        self.send_response(200);self.send_header('Content-Type','application/json');self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
+    def do_POST(self):
+        self.rfile.read(int(self.headers.get('content-length', '0')))
+        body=json.dumps({'id':'fake', 'output_text':json.dumps({'type':'final','output':{'summary':'ready'}}), 'usage':{'input_tokens':12,'output_tokens':24}}).encode()
+        self.send_response(200);self.send_header('Content-Type','application/json');self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
+
+class Service:
+    def __init__(self, version, workload, label):
+        self.root=OUT/label;self.root.mkdir();self.port=port();self.workload=workload
+        app=workload=='app'
+        # Default app comparison isolates application changes on one runtime.
+        # Opt in when comparing runtime changes against identical application source.
+        same_runtime = app and os.environ.get('TYSEL_AB_APP_COMPARE_RUNTIME') != '1'
+        bin_dir=AFTER if same_runtime or version=='after' else BEFORE
+        env={k:v for k,v in os.environ.items() if not k.startswith(('TYSEL_','OTEL_'))}
+        env.update(OTEL_SDK_DISABLED='true', TYSEL_WORKER=str(bin_dir/'tysel-worker'))
+        if app:
+            shutil.copytree(ROOT/('app-'+version)/'src',self.root/'src')
+            (self.root/'src/entry.ts').write_text("import {createApp} from './app.js';export default createApp({githubBaseUrl:"+json.dumps(PROVIDER_URL)+"});")
+            source='src/entry.ts';database='agent-runner.db'
+            env.update(OPENAI_API_KEY='fake-key',GITHUB_TOKEN='fake-key',TYSEL_LLM_ENDPOINT=PROVIDER_URL+'/v1/responses',TYSEL_LLM_MODEL='fake',TYSEL_LLM_ALIAS='default',TYSEL_LLM_SECRET='OPENAI_API_KEY')
+        else:
+            (self.root/'index.js').write_text(SOURCE);source='index.js';database='app.db'
+        (self.root/'tysel.toml').write_text(f'''[app]
+name="perf-ab"
+entry="{source}"
+profile="service"
+[server]
+listen="127.0.0.1:{self.port}"
+workers=8
+[permissions]
+fetch=["127.0.0.1"]
+secrets=["OPENAI_API_KEY","GITHUB_TOKEN"]
+[limits]
+request_timeout_ms=10000
+cpu_ms_per_turn=1000
+memory_mb=128
+max_in_flight=64
+[durable]
+store="sqlite"
+path="./data/{database}"
+[observability]
+logs="off"
+''')
+        self.logs=[]
+        self.process=subprocess.Popen([str(bin_dir/'tysel'),'-C',str(self.root),'run'],env=env,stdout=subprocess.PIPE,stderr=subprocess.STDOUT,text=True)
+        self.log_thread=threading.Thread(target=lambda:self.logs.extend(self.process.stdout),daemon=True)
+        try:
+            self.log_thread.start()
+            deadline=time.monotonic()+STARTUP_TIMEOUT
+            while True:
+                assert self.process.poll() is None,''.join(self.logs)
+                c=http.client.HTTPConnection('127.0.0.1',self.port,timeout=2)
+                try:
+                    c.request('GET','/health' if app else '/');r=c.getresponse();r.read()
+                    if r.status==200:break
+                except OSError:pass
+                finally:c.close()
+                assert time.monotonic()<deadline,'startup timeout';time.sleep(.05)
+            self.dbpath=self.root/'data/durable-events.db'
+        except BaseException as error:
+            try:self.stop(check_exit=False)
+            except Exception as cleanup_error:raise error from cleanup_error
+            raise
+    def stop(self, check_exit=True):
+        forced=False
+        try:
+            if self.process.poll() is None:self.process.terminate()
+            try:self.process.wait(timeout=STOP_TIMEOUT)
+            except subprocess.TimeoutExpired:
+                forced=True;self.process.kill();self.process.wait(timeout=5)
+        finally:
+            if self.log_thread.ident is not None:self.log_thread.join(timeout=2)
+            (self.root/'service.log').write_text(''.join(self.logs))
+            if not self.log_thread.is_alive():self.process.stdout.close()
+        if check_exit:
+            assert not forced,'service required SIGKILL during shutdown'
+            assert self.process.returncode==0,''.join(self.logs)
+    def operation(self, conn, db):
+        started=time.monotonic()
+        if self.workload=='app':
+            conn.request('POST','/runs',json.dumps({'repository':'owner/repo','tagName':'final-perf','changes':'benchmark change'}),{'Content-Type':'application/json'})
+        else:conn.request('GET','/'+self.workload)
+        r=conn.getresponse();body=r.read();admission=(time.monotonic()-started)*1000
+        assert r.status in (200,202),(r.status,body[:200])
+        data=json.loads(body)
+        if self.workload=='http':assert data=={'ok':True}
+        elif self.workload=='app':
+            rid=data['runId'];deadline=time.monotonic()+15
+            while True:
+                row=db.execute('SELECT status,task_id FROM runs WHERE run_id=?',(rid,)).fetchone()
+                if row and row[0]=='completed' and row[1] and db.execute('SELECT 1 FROM runtime.durable_completions WHERE task_id=?',(bytes.fromhex(row[1].zfill(32)),)).fetchone():break
+                assert not row or row[0] not in ('failed','cancelled','rejected'),row
+                assert time.monotonic()<deadline,'completion timeout';time.sleep(.002)
+        else:
+            expected={'one':42,'ten':10,'payload':'x'*65536}[self.workload]
+            if data.get('status')=='accepted':
+                deadline=time.monotonic()+15
+                while True:
+                    row=db.execute('SELECT result_json FROM durable_completions WHERE task_id=?',(bytes.fromhex(data['taskId'].zfill(32)),)).fetchone()
+                    if row:assert json.loads(row[0])==expected;break
+                    assert time.monotonic()<deadline,'completion timeout';time.sleep(.002)
+            else:assert data.get('status')=='completed' and data.get('value')==expected,data
+        return (time.monotonic()-started)*1000,admission
+    def connection(self):
+        dbfile=self.root/'data/agent-runner.db' if self.workload=='app' else self.dbpath
+        db=sqlite3.connect('file:'+str(dbfile)+'?mode=ro',uri=True)
+        try:
+            if self.workload=='app':db.execute('ATTACH DATABASE ? AS runtime',('file:'+str(self.dbpath)+'?mode=ro',))
+            return http.client.HTTPConnection('127.0.0.1',self.port,timeout=15),db
+        except BaseException:
+            db.close();raise
+    def warm(self):
+        conn,db=self.connection()
+        try:
+            for _ in range(20):self.operation(conn,db)
+        finally:conn.close();db.close()
+    def completed(self):
+        with sqlite3.connect('file:'+str(self.dbpath)+'?mode=ro',uri=True) as db:
+            return db.execute('SELECT count(*) FROM durable_completions').fetchone()[0]
+
+def percentile(values,p):return sorted(values)[max(0,math.ceil(len(values)*p)-1)]
+def phase(version,workload,clients,repeat):
+    s=Service(version,workload,f'{workload}-c{clients}-r{repeat}-{version}')
+    try:
+        s.warm();count0=s.completed();start_usage=usage(s.process.pid);barrier=threading.Barrier(clients+1)
+        cancelled=threading.Event();errors=[];error_lock=threading.Lock()
+        def client():
+            conn=db=None
+            try:
+                conn,db=s.connection();samples=[];admissions=[]
+                barrier.wait(timeout=CLIENT_READY_TIMEOUT);deadline=time.monotonic()+SECONDS
+                while not cancelled.is_set() and time.monotonic()<deadline:
+                    latency,admission=s.operation(conn,db);samples.append(latency);admissions.append(admission)
+                return samples,admissions,time.monotonic()
+            except BaseException as error:
+                if not isinstance(error, threading.BrokenBarrierError):
+                    with error_lock:errors.append(error)
+                cancelled.set();barrier.abort()
+                raise
+            finally:
+                if conn is not None:conn.close()
+                if db is not None:db.close()
+        with futures.ThreadPoolExecutor(clients) as pool:
+            jobs=[]
+            try:
+                jobs=[pool.submit(client) for _ in range(clients)]
+                start=time.monotonic();barrier.wait(timeout=CLIENT_READY_TIMEOUT);rss=[];footprint=[]
+                while not all(j.done() for j in jobs):
+                    u=usage(s.process.pid);rss.append(u['resident_size']);footprint.append(u['phys_footprint']);time.sleep(.1)
+                end_usage=usage(s.process.pid)
+                if errors:raise errors[0]
+                data=[j.result() for j in jobs]
+            except BaseException as error:
+                cancelled.set();barrier.abort()
+                if isinstance(error, threading.BrokenBarrierError) and errors:raise errors[0] from error
+                raise
+        duration=max(x[2] for x in data)-start;samples=sum([x[0] for x in data],[]);admissions=sum([x[1] for x in data],[]);n=len(samples)
+        deadline=time.monotonic()+5
+        while workload!='http' and s.completed()-count0!=n:
+            assert time.monotonic()<deadline,'completion count mismatch';time.sleep(.02)
+        cpu_ns=sum(end_usage[k]-start_usage[k] for k in ['user_time','system_time'])*TICK_NS
+        result={'version':version,'workload':workload,'clients':clients,'repeat':repeat,'completed':n,'seconds':duration,'throughput_s':n/duration,'p95_ms':percentile(samples,.95),'p99_ms':percentile(samples,.99),'admission_p95_ms':percentile(admissions,.95),'admission_p99_ms':percentile(admissions,.99),'cpu_core_percent':cpu_ns/1e9/duration*100,'cpu_ms_per_op':cpu_ns/1e6/n,'rss_peak_mib':max(rss)/2**20,'footprint_peak_mib':max(footprint)/2**20,'database_storage_write_bytes_per_op':(end_usage['diskio_byteswritten']-start_usage['diskio_byteswritten'])/n,'fixture':str(s.root)}
+        (s.root/'latencies.json').write_text(json.dumps({'completion_ms':samples,'admission_ms':admissions}))
+        return result
+    finally:s.stop(check_exit=sys.exc_info()[0] is None)
+
+def write_probe(version,workload):
+    s=Service(version,workload,f'write-{workload}-{version}')
+    try:
+        s.warm();paths=[s.dbpath]+([s.root/'data/agent-runner.db'] if workload=='app' else [])
+        configs={}
+        for path in paths:
+            with sqlite3.connect('file:'+str(path)+'?mode=ro',uri=True) as db:
+                configs[path.name]={'journal_mode':db.execute('PRAGMA journal_mode').fetchone()[0],'page_size':db.execute('PRAGMA page_size').fetchone()[0]}
+        count0=s.completed();sizes={p.name:p.stat().st_size for p in paths};before=usage(s.process.pid)
+        conn,db=s.connection()
+        for _ in range(50):s.operation(conn,db)
+        conn.close();db.close();assert s.completed()-count0==50
+        time.sleep(.1);after=usage(s.process.pid)
+        return {'version':version,'workload':workload,'operations':50,'configuration':configs,'database_storage_write_bytes_per_op':(after['diskio_byteswritten']-before['diskio_byteswritten'])/50,'retained_database_growth_bytes_per_op':{p.name:(p.stat().st_size-sizes[p.name])/50 for p in paths}}
+    finally:s.stop(check_exit=sys.exc_info()[0] is None)
+
+if __name__=='__main__':
+    provider=http.server.ThreadingHTTPServer(('127.0.0.1',0),Provider);PROVIDER_URL=f'http://127.0.0.1:{provider.server_port}'
+    threading.Thread(target=provider.serve_forever,daemon=True).start()
+    results=[];wal=[]
+    workloads=os.environ.get('TYSEL_AB_WORKLOADS','http,one,ten,payload,app').split(',')
+    try:
+        for workload in workloads:
+            for clients in ([8] if workload=='http' else [1,8]):
+                for repeat in range(REPEATS):
+                    for version in (['before','after'] if repeat%2==0 else ['after','before']):
+                        result=phase(version,workload,clients,repeat);results.append(result);print(json.dumps(result),flush=True)
+                        (OUT/'results.json').write_text(json.dumps(results,indent=2)+'\n')
+            if workload!='http':
+                for version in ['before','after']:
+                    result=write_probe(version,workload);wal.append(result);print('WRITE '+json.dumps(result),flush=True)
+                    (OUT/'writes.json').write_text(json.dumps(wal,indent=2)+'\n')
+    finally:provider.shutdown();provider.server_close()
diff --git a/tests/p1/performance_control.py b/tests/p1/performance_control.py
new file mode 100644
index 0000000..a5cc5e1
--- /dev/null
+++ b/tests/p1/performance_control.py
@@ -0,0 +1,85 @@
+"""Interleave same-binary A/A and before/after A/B macOS performance controls.
+
+Uses performance_ab.py's completion-checked, fresh-process SQLite workload.
+Example: python3 tests/p1/performance_control.py --root /tmp/new-control \
+    --before-bin /path/to/baseline --after-bin /path/to/candidate
+Evidence must be retained even when a subsequent batch reverses direction.
+"""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import runpy
+import statistics
+
+
+def summarize(rows):
+    output = {}
+    for condition in ('AA', 'AB'):
+        grouped = {v: sorted((r for r in rows if r['condition'] == condition and r['version'] == v),
+                             key=lambda r: r['block']) for v in ('before', 'after')}
+        assert grouped['before'] and len(grouped['before']) == len(grouped['after'])
+        assert [r['block'] for r in grouped['before']] == [r['block'] for r in grouped['after']]
+        if condition == 'AA':
+            assert len({r['binary_sha256'] for v in grouped.values() for r in v}) == 1
+        metrics = {}
+        for name in ('throughput_s', 'p95_ms', 'p99_ms', 'cpu_ms_per_op',
+                     'cpu_core_percent', 'rss_peak_mib', 'database_storage_write_bytes_per_op'):
+            b, a = ([r[name] for r in grouped[v]] for v in ('before', 'after'))
+            bm, am = statistics.median(b), statistics.median(a)
+            metrics[name] = {'before_median': bm, 'after_median': am,
+                             'median_ratio_delta_percent': (am / bm - 1) * 100 if bm else None,
+                             'before_range': [min(b), max(b)], 'after_range': [min(a), max(a)],
+                             'paired_delta_percent': [(y / x - 1) * 100 if x else None for x, y in zip(b, a)]}
+        output[condition] = metrics
+    return output
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--root', type=Path, required=True)
+    parser.add_argument('--before-bin', type=Path)
+    parser.add_argument('--after-bin', type=Path)
+    parser.add_argument('--seconds', type=float, default=15)
+    parser.add_argument('--repeats', type=int, default=3)
+    parser.add_argument('--summarize-only', action='store_true')
+    args = parser.parse_args()
+    root = args.root.resolve()
+    result_path = root / 'measurements/results.json'
+    if args.summarize_only:
+        rows = json.loads(result_path.read_text())
+    else:
+        if not args.before_bin or not args.after_bin or args.seconds <= 0 or args.repeats < 1:
+            parser.error('provide both binary directories, positive seconds and repeats')
+        if (root / 'measurements').exists():
+            parser.error('use a fresh root to preserve earlier measurements')
+        root.mkdir(parents=True, exist_ok=True)
+        old, new = args.before_bin.resolve(), args.after_bin.resolve()
+        for directory in (old, new):
+            assert (directory / 'tysel').is_file() and (directory / 'tysel-worker').is_file()
+        os.environ['TYSEL_AB_ROOT'] = str(root)
+        os.environ['TYSEL_AB_SECONDS'] = str(args.seconds)
+        harness = runpy.run_path(str(Path(__file__).with_name('performance_ab.py')))
+        context = harness['Service'].__init__.__globals__
+        rows = []
+        for block in range(args.repeats):
+            for condition in (('AA', 'AB') if block % 2 == 0 else ('AB', 'AA')):
+                context['BEFORE'] = new if condition == 'AA' else old
+                context['AFTER'] = new
+                for version in (('before', 'after') if block % 2 == 0 else ('after', 'before')):
+                    binary = (context['BEFORE'] if version == 'before' else new) / 'tysel'
+                    digest = hashlib.sha256(binary.read_bytes()).hexdigest()
+                    row = harness['phase'](version, 'one', 1, str(block) + '-' + condition)
+                    assert hashlib.sha256(binary.read_bytes()).hexdigest() == digest
+                    row.update(condition=condition, block=block, binary_sha256=digest)
+                    rows.append(row)
+                    result_path.write_text(json.dumps(rows, indent=2) + '\n')
+                    print(json.dumps(row), flush=True)
+    output = summarize(rows)
+    (root / 'control-summary.json').write_text(json.dumps(output, indent=2) + '\n')
+    print(json.dumps(output, indent=2))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/tests/p1/performance_harness_test.py b/tests/p1/performance_harness_test.py
new file mode 100644
index 0000000..e1f30b0
--- /dev/null
+++ b/tests/p1/performance_harness_test.py
@@ -0,0 +1,94 @@
+"""Bounded failure-path checks for the macOS performance harness; no network."""
+import os
+from pathlib import Path
+import runpy
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+import types
+import unittest
+
+
+def exercise(case):
+    with tempfile.TemporaryDirectory(prefix='tysel-perf-failure-') as root:
+        os.environ['TYSEL_AB_ROOT'] = root
+        h = runpy.run_path(str(Path(__file__).with_name('performance_ab.py')))
+        g = h['phase'].__globals__
+        if case in ('client_failure', 'barrier_timeout'):
+            stopped = []; closed = []; lock = threading.Lock(); count = [0]
+            class Resource:
+                def close(self): closed.append(True)
+            class Service:
+                process = types.SimpleNamespace(pid=0)
+                def __init__(self, *args): pass
+                def warm(self): pass
+                def completed(self): return 0
+                def connection(self):
+                    with lock:
+                        count[0] += 1; index = count[0]
+                    if index == 1:
+                        if case == 'client_failure': raise OSError('injected connection error')
+                        time.sleep(.15)
+                    return Resource(), Resource()
+                def stop(self, **kwargs): stopped.append(True)
+            g.update(Service=Service, usage=lambda pid: {}, CLIENT_READY_TIMEOUT=.05)
+            try:
+                h['phase']('before', 'one', 2, 0)
+                raise AssertionError('failure was not propagated')
+            except OSError as error:
+                assert case == 'client_failure' and str(error) == 'injected connection error'
+            except threading.BrokenBarrierError:
+                assert case == 'barrier_timeout'
+            assert stopped == [True]
+            assert len(closed) == (2 if case == 'client_failure' else 4), closed
+        else:
+            children = []; connections = []
+            popen = subprocess.Popen
+            def launch(*args, **kwargs):
+                code = "import time;print('startup diagnostic',flush=True);time.sleep(60)"
+                if case == 'startup_forced':
+                    code = "import signal;signal.signal(signal.SIGTERM,signal.SIG_IGN);" + code
+                child = popen([sys.executable, '-u', '-c', code], stdout=subprocess.PIPE,
+                              stderr=subprocess.STDOUT, text=True)
+                children.append(child)
+                return child
+            class Http:
+                status = 503
+                def __init__(self, *args, **kwargs): self.closed = False; connections.append(self)
+                def request(self, *args): pass
+                def getresponse(self): return self
+                def read(self): return b'not ready'
+                def close(self): self.closed = True
+            g.update(port=lambda: 1, STARTUP_TIMEOUT=.3, STOP_TIMEOUT=.1,
+                     subprocess=types.SimpleNamespace(Popen=launch, PIPE=-1, STDOUT=-2,
+                                                      TimeoutExpired=subprocess.TimeoutExpired),
+                     http=types.SimpleNamespace(client=types.SimpleNamespace(HTTPConnection=Http)))
+            try:
+                try:
+                    h['Service']('before', 'one', case)
+                    raise AssertionError('startup did not fail')
+                except AssertionError as error:
+                    assert str(error) == 'startup timeout', error
+                assert all(p.poll() is not None and p.stdout.closed for p in children)
+                assert connections and all(c.closed for c in connections)
+                assert 'startup diagnostic' in (Path(root)/'measurements'/case/'service.log').read_text()
+                if case == 'startup_forced': assert children[0].returncode == -9
+            finally:
+                for child in children:
+                    if child.poll() is None: child.kill(); child.wait(timeout=2)
+
+
+class FailurePaths(unittest.TestCase):
+    def test_bounded_failures(self):
+        for case in ('client_failure', 'barrier_timeout', 'startup_timeout', 'startup_forced'):
+            with self.subTest(case=case):
+                result = subprocess.run([sys.executable, __file__, case], capture_output=True,
+                                        text=True, timeout=8)
+                self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+
+
+if __name__ == '__main__':
+    if len(sys.argv) == 2: exercise(sys.argv[1])
+    else: unittest.main()

From f03d402c72a19885895eee276229267cc0ccc468 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Wed, 9 Sep 2026 15:17:28 +0800
Subject: [PATCH 28/31] test(durable): isolate PostgreSQL live test schemas

---
 crates/tysel-durable/tests/postgres_live.rs | 43 +++++++++++++++++----
 1 file changed, 36 insertions(+), 7 deletions(-)

diff --git a/crates/tysel-durable/tests/postgres_live.rs b/crates/tysel-durable/tests/postgres_live.rs
index 178ad33..b4aec2d 100644
--- a/crates/tysel-durable/tests/postgres_live.rs
+++ b/crates/tysel-durable/tests/postgres_live.rs
@@ -7,9 +7,39 @@ use tysel_durable::{
 };
 use tysel_task::TaskId;
 
-fn store() -> Option<Arc<PostgresStore>> {
+struct TestSchema {
+    admin: postgres::Client,
+    schema: String,
+    url: String,
+}
+
+impl Drop for TestSchema {
+    fn drop(&mut self) {
+        let result = self.admin.batch_execute(&format!("DROP SCHEMA {} CASCADE", self.schema));
+        if !std::thread::panicking() {
+            result.expect("remove test schema");
+        }
+    }
+}
+
+fn store() -> Option<(Arc<PostgresStore>, TestSchema)> {
     let url = std::env::var("TYSEL_POSTGRES_TEST_URL").ok()?;
-    Some(Arc::new(PostgresStore::connect_with_pool_size(&url, 8).expect("connect durable store")))
+    let schema = format!("tysel_live_{}", task(0).0);
+    let mut admin = postgres::Client::connect(&url, postgres::NoTls).expect("connect schema owner");
+    admin.batch_execute(&format!("CREATE SCHEMA {schema}")).expect("create test schema");
+    let scoped = if url.contains("://") {
+        format!(
+            "{url}{}options=-csearch_path%3D{schema}",
+            if url.contains('?') { "&" } else { "?" }
+        )
+    } else {
+        format!("{url} options='-c search_path={schema}'")
+    };
+    let fixture = TestSchema { admin, schema, url: scoped };
+    let store = Arc::new(
+        PostgresStore::connect_with_pool_size(&fixture.url, 8).expect("connect durable store"),
+    );
+    Some((store, fixture))
 }
 
 fn task(offset: u128) -> TaskId {
@@ -19,7 +49,7 @@ fn task(offset: u128) -> TaskId {
 
 #[test]
 fn postgres_preserves_replay_claim_signal_and_catalog_contracts() {
-    let Some(store) = store() else {
+    let Some((store, _fixture)) = store() else {
         return;
     };
     assert_eq!(store.log_version().unwrap(), DURABLE_LOG_VERSION);
@@ -85,7 +115,7 @@ fn postgres_preserves_replay_claim_signal_and_catalog_contracts() {
 
 #[test]
 fn postgres_completion_serializes_with_writers_and_prunes_only_terminal_tasks() {
-    let Some(store) = store() else {
+    let Some((store, _fixture)) = store() else {
         return;
     };
     let initial = store.program_count().unwrap();
@@ -200,11 +230,10 @@ fn postgres_v1_migration_keeps_unclassified_work_and_reopens_completion_counters
 
 #[test]
 fn postgres_completion_rechecks_lease_after_task_and_quota_lock_waits() {
-    let Some(store) = store() else {
+    let Some((store, fixture)) = store() else {
         return;
     };
-    let url = std::env::var("TYSEL_POSTGRES_TEST_URL").unwrap();
-    let mut blocker = postgres::Client::connect(&url, postgres::NoTls).unwrap();
+    let mut blocker = postgres::Client::connect(&fixture.url, postgres::NoTls).unwrap();
     for quota in [false, true] {
         let id = task(901 + u128::from(quota));
         store.put_program(id, "42", 0).unwrap();

From 0f253f90074ad8dad40e279b427e8d35ec0c20c9 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Wed, 9 Sep 2026 15:17:45 +0800
Subject: [PATCH 29/31] chore(release): prepare 0.3.0 versions and
 documentation

---
 Cargo.lock                                    |  56 ++++-----
 Cargo.toml                                    |   2 +-
 .../comparison/runtimes-tysel-workers-2.json  |   2 +-
 .../comparison/runtimes-tysel-workers-4.json  |   2 +-
 benchmarks/comparison/runtimes.lock.json      |   2 +-
 .../tysel-build/src/runtime-components.json   | 106 +++++++++---------
 crates/tysel-cli/tests/dev_check.rs           |   2 +-
 crates/tysel-component-sdk/README.md          |   2 +-
 docs/guides/wasm-component-rust.md            |   2 +-
 docs/operations/production.md                 |  15 +--
 docs/reference/cli/installation.md            |   2 +-
 docs/reference/cli/tasks.md                   |  11 +-
 docs/reference/component/rust-sdk.md          |   2 +-
 docs/reference/errors-and-output.md           |   3 +-
 docs/reference/runtime/durable.md             |  13 ++-
 docs/reference/runtime/types.md               |   2 +-
 fuzz/Cargo.lock                               |  22 ++--
 packages/tysel-test/package.json              |   2 +-
 packages/tysel-types/package.json             |   2 +-
 packages/tysel/package.json                   |   2 +-
 runtime-js/bootstrap/index.ts                 |   2 +-
 runtime-js/compatibility.json                 |   2 +-
 runtime-js/package.json                       |   2 +-
 runtime-js/test/runtime.test.mjs              |   2 +-
 runtime-js/web-api/index.ts                   |   2 +-
 sdk/examples/rust-echo/Cargo.lock             |   2 +-
 website/components/home/home-page.tsx         |   2 +-
 .../docs/concepts/durable-execution.mdx       |   5 +-
 .../docs/guides/concurrency-backpressure.mdx  |  17 ++-
 .../docs/guides/wasm-component-rust.mdx       |   2 +-
 .../content/docs/operations/production.mdx    |  95 +++++++++++++++-
 website/content/reference/cli/index.mdx       |   2 +-
 .../content/reference/cli/installation.mdx    |   2 +-
 website/content/reference/cli/tasks.mdx       |  40 +++++++
 .../content/reference/component/rust-sdk.mdx  |   2 +-
 .../content/reference/errors-and-output.mdx   |  17 +--
 .../content/reference/limits-and-defaults.mdx |  10 +-
 website/content/reference/manifest/limits.mdx |   2 +-
 website/content/reference/runtime/durable.mdx |  79 +++++++++++--
 website/content/reference/runtime/types.mdx   |   2 +-
 .../docs/concepts/durable-execution.mdx       |   2 +-
 .../docs/guides/concurrency-backpressure.mdx  |   8 +-
 .../docs/guides/wasm-component-rust.mdx       |   2 +-
 .../content/docs/operations/production.mdx    |  41 ++++++-
 .../zh-CN/content/reference/cli/index.mdx     |   2 +-
 .../content/reference/cli/installation.mdx    |   2 +-
 .../zh-CN/content/reference/cli/tasks.mdx     |  20 ++++
 .../content/reference/component/rust-sdk.mdx  |   2 +-
 .../content/reference/errors-and-output.mdx   |   6 +-
 .../content/reference/limits-and-defaults.mdx |   8 +-
 .../content/reference/manifest/limits.mdx     |   2 +-
 .../content/reference/runtime/durable.mdx     |  38 ++++++-
 .../zh-CN/content/reference/runtime/types.mdx |   2 +-
 website/locales/zh-CN/manifest.json           |  52 ++++-----
 54 files changed, 526 insertions(+), 202 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2480240..651f3b8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3673,7 +3673,7 @@ checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
 
 [[package]]
 name = "tysel-bench-compare"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "anyhow",
  "clap",
@@ -3689,7 +3689,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-build"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "anyhow",
  "ed25519-dalek",
@@ -3708,14 +3708,14 @@ dependencies = [
 
 [[package]]
 name = "tysel-cap-fs"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "tysel-cap-llm"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "bytes",
  "http-body-util",
@@ -3731,7 +3731,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-cap-mcp"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -3740,7 +3740,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-cap-postgres"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "bytes",
  "futures-util",
@@ -3754,7 +3754,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-cap-redis"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "redis",
  "tokio",
@@ -3763,7 +3763,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-cap-sqlite"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "rusqlite",
  "serde_json",
@@ -3772,7 +3772,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-capability"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "semver",
  "serde",
@@ -3781,7 +3781,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-cli"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "anyhow",
  "clap",
@@ -3814,7 +3814,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-component-sdk"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -3822,7 +3822,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-distribution"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "semver",
  "serde",
@@ -3832,7 +3832,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-durable"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "getrandom 0.4.3",
  "native-tls",
@@ -3849,14 +3849,14 @@ dependencies = [
 
 [[package]]
 name = "tysel-engine"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "thiserror",
 ]
 
 [[package]]
 name = "tysel-engine-qjs"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "bytes",
  "futures-util",
@@ -3890,7 +3890,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-engine-wasm"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "serde_json",
  "sha2 0.10.9",
@@ -3905,7 +3905,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-ipc"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -3915,7 +3915,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-isolate"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "libc",
  "serde_json",
@@ -3930,7 +3930,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-manifest"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -3941,7 +3941,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-observability"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "opentelemetry",
  "opentelemetry-otlp",
@@ -3953,7 +3953,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-package"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "semver",
  "serde",
@@ -3964,14 +3964,14 @@ dependencies = [
 
 [[package]]
 name = "tysel-policy"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "tysel-capability",
 ]
 
 [[package]]
 name = "tysel-release-signing"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "anyhow",
  "ed25519-dalek",
@@ -3983,7 +3983,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-runtime"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "bytes",
  "futures-util",
@@ -4018,7 +4018,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-scheduler"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "thiserror",
  "tysel-task",
@@ -4026,7 +4026,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-task"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "serde_json",
  "thiserror",
@@ -4034,7 +4034,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-task-rpc"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -4044,7 +4044,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-testkit"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "anyhow",
  "bytes",
diff --git a/Cargo.toml b/Cargo.toml
index 6101d2d..a90e2db 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.2.0"
+version = "0.3.0"
 edition = "2024"
 license = "Apache-2.0"
 rust-version = "1.95.0"
diff --git a/benchmarks/comparison/runtimes-tysel-workers-2.json b/benchmarks/comparison/runtimes-tysel-workers-2.json
index f6040d0..3aad250 100644
--- a/benchmarks/comparison/runtimes-tysel-workers-2.json
+++ b/benchmarks/comparison/runtimes-tysel-workers-2.json
@@ -8,7 +8,7 @@
   }],
   "runtimes": [{
     "id": "tysel",
-    "expectedVersion": "0.2.0",
+    "expectedVersion": "0.3.0",
     "executable": "target/linux-arm64-verify/release/tysel",
     "args": ["run", "--manifest", "benchmarks/comparison/adapters/tysel/tysel-workers-2.toml"],
     "readinessPrefix": "tysel listen ",
diff --git a/benchmarks/comparison/runtimes-tysel-workers-4.json b/benchmarks/comparison/runtimes-tysel-workers-4.json
index 0a315c9..a5a720d 100644
--- a/benchmarks/comparison/runtimes-tysel-workers-4.json
+++ b/benchmarks/comparison/runtimes-tysel-workers-4.json
@@ -8,7 +8,7 @@
   }],
   "runtimes": [{
     "id": "tysel",
-    "expectedVersion": "0.2.0",
+    "expectedVersion": "0.3.0",
     "executable": "target/linux-arm64-verify/release/tysel",
     "args": ["run", "--manifest", "benchmarks/comparison/adapters/tysel/tysel-workers-4.toml"],
     "readinessPrefix": "tysel listen ",
diff --git a/benchmarks/comparison/runtimes.lock.json b/benchmarks/comparison/runtimes.lock.json
index c34d5ec..a865209 100644
--- a/benchmarks/comparison/runtimes.lock.json
+++ b/benchmarks/comparison/runtimes.lock.json
@@ -19,7 +19,7 @@
   "runtimes": [
     {
       "id": "tysel",
-      "expectedVersion": "0.2.0",
+      "expectedVersion": "0.3.0",
       "executable": "target/release/tysel",
       "args": [
         "run",
diff --git a/crates/tysel-build/src/runtime-components.json b/crates/tysel-build/src/runtime-components.json
index 370f459..624e49b 100644
--- a/crates/tysel-build/src/runtime-components.json
+++ b/crates/tysel-build/src/runtime-components.json
@@ -1,6 +1,6 @@
 {
   "inventory_version": 1,
-  "cargo_lock_sha256": "124d6184ae5fe5b7fd53af46018f884b1448c5affa8fd1247f3bbb1452ba6d80",
+  "cargo_lock_sha256": "001add1e9594e03c8b8d168ca98df5d5eaf323b5c8be6f012accfecb9b382bde",
   "roots": [
     "tysel-cli",
     "tysel-isolate",
@@ -2894,184 +2894,184 @@
     },
     {
       "name": "tysel-build",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-build@0.2.0",
+      "purl": "pkg:cargo/tysel-build@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-cap-fs",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-cap-fs@0.2.0",
+      "purl": "pkg:cargo/tysel-cap-fs@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-cap-llm",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-cap-llm@0.2.0",
+      "purl": "pkg:cargo/tysel-cap-llm@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-cap-mcp",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-cap-mcp@0.2.0",
+      "purl": "pkg:cargo/tysel-cap-mcp@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-cap-postgres",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-cap-postgres@0.2.0",
+      "purl": "pkg:cargo/tysel-cap-postgres@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-cap-redis",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-cap-redis@0.2.0",
+      "purl": "pkg:cargo/tysel-cap-redis@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-cap-sqlite",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-cap-sqlite@0.2.0",
+      "purl": "pkg:cargo/tysel-cap-sqlite@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-capability",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-capability@0.2.0",
+      "purl": "pkg:cargo/tysel-capability@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-cli",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-cli@0.2.0",
+      "purl": "pkg:cargo/tysel-cli@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-distribution",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-distribution@0.2.0",
+      "purl": "pkg:cargo/tysel-distribution@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-durable",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-durable@0.2.0",
+      "purl": "pkg:cargo/tysel-durable@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-engine-qjs",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-engine-qjs@0.2.0",
+      "purl": "pkg:cargo/tysel-engine-qjs@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-engine-wasm",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-engine-wasm@0.2.0",
+      "purl": "pkg:cargo/tysel-engine-wasm@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-engine",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-engine@0.2.0",
+      "purl": "pkg:cargo/tysel-engine@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-ipc",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-ipc@0.2.0",
+      "purl": "pkg:cargo/tysel-ipc@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-isolate",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-isolate@0.2.0",
+      "purl": "pkg:cargo/tysel-isolate@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-manifest",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-manifest@0.2.0",
+      "purl": "pkg:cargo/tysel-manifest@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-observability",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-observability@0.2.0",
+      "purl": "pkg:cargo/tysel-observability@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-package",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-package@0.2.0",
+      "purl": "pkg:cargo/tysel-package@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-policy",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-policy@0.2.0",
+      "purl": "pkg:cargo/tysel-policy@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-release-signing",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-release-signing@0.2.0",
+      "purl": "pkg:cargo/tysel-release-signing@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-runtime",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-runtime@0.2.0",
+      "purl": "pkg:cargo/tysel-runtime@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-scheduler",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-scheduler@0.2.0",
+      "purl": "pkg:cargo/tysel-scheduler@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-task-rpc",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-task-rpc@0.2.0",
+      "purl": "pkg:cargo/tysel-task-rpc@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-task",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-task@0.2.0",
+      "purl": "pkg:cargo/tysel-task@0.3.0",
       "source": "workspace"
     },
     {
       "name": "tysel-testkit",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "Apache-2.0",
-      "purl": "pkg:cargo/tysel-testkit@0.2.0",
+      "purl": "pkg:cargo/tysel-testkit@0.3.0",
       "source": "workspace"
     },
     {
diff --git a/crates/tysel-cli/tests/dev_check.rs b/crates/tysel-cli/tests/dev_check.rs
index 8c538f3..c2e9491 100644
--- a/crates/tysel-cli/tests/dev_check.rs
+++ b/crates/tysel-cli/tests/dev_check.rs
@@ -586,7 +586,7 @@ fn init_rejects_a_stale_existing_tysel_tsconfig_before_writing() {
     let dir = temp_app("init-stale-tsconfig");
     fs::write(
         dir.join("package.json"),
-        r#"{"devDependencies":{"@tysel/types":"0.2.0","@tysel/test":"0.2.0"}}"#,
+        r#"{"devDependencies":{"@tysel/types":"0.3.0","@tysel/test":"0.3.0"}}"#,
     )
     .unwrap();
     fs::write(dir.join("tsconfig.tysel.json"), r#"{"files":["src/old.ts"]}"#).unwrap();
diff --git a/crates/tysel-component-sdk/README.md b/crates/tysel-component-sdk/README.md
index f75747b..a2ec333 100644
--- a/crates/tysel-component-sdk/README.md
+++ b/crates/tysel-component-sdk/README.md
@@ -5,7 +5,7 @@ Rust guest-side JSON dispatch for the experimental
 
 ```toml
 [dependencies]
-tysel-component-sdk = "0.2.0"
+tysel-component-sdk = "0.3.0"
 ```
 
 Implement one typed task:
diff --git a/docs/guides/wasm-component-rust.md b/docs/guides/wasm-component-rust.md
index ed5fa1e..29137f8 100644
--- a/docs/guides/wasm-component-rust.md
+++ b/docs/guides/wasm-component-rust.md
@@ -50,7 +50,7 @@ For a project created without the starter, depend on the public SDK crate and
 copy the matching WIT package into the project:
 
 ```toml
-tysel-component-sdk = "0.2.0"
+tysel-component-sdk = "0.3.0"
 ```
 
 The crate version follows the Tysel product release. The WIT contract keeps its
diff --git a/docs/operations/production.md b/docs/operations/production.md
index ac7fa6a..8f0c450 100644
--- a/docs/operations/production.md
+++ b/docs/operations/production.md
@@ -107,8 +107,7 @@ Shutdown:
 On SIGTERM or Ctrl-C, packaged services and `tysel run` close the listener,
 stop new durable claims, and drain HTTP/1 and HTTP/2 connections. Idle sockets
 close immediately. WebSockets receive close code 1001 (Going Away) when the
-transport can send it. Connections that remain after `request_timeout_ms +
-1000` milliseconds are closed forcibly. This HTTP grace is shared across
+transport can send it. Connections that remain after `request_timeout_ms + 1000` milliseconds are closed forcibly. This HTTP grace is shared across
 connections; task-plane shutdown and telemetry flushing can add time, so keep
 the service-manager grace longer. Development servers use the same draining
 path, with enough grace for the largest timeout seen during reloads.
@@ -133,13 +132,11 @@ task in the same scheduling batch encounters a storage failure.
 Retries remain subject to the original lease. Completion transactions check fresh
 time after acquiring their locks and again before commit; expiry rolls back both
 the result and quota changes. An identical already-committed outcome can still be
-acknowledged after expiry. Lease expiry or shutdown with pending outcomes reports
-failure. Persisted execution eligibility survives process death; a new scheduler
-can reclaim the same task after expiry. Every execution has a unique token and
-generation, and stale history/suspension/completion writes are rejected. Interrupted
-unrecorded effects are re-entered: reconcile external outcomes or use provider
-idempotency before repeating writes. Automatic replay does not imply exactly-once
-external effects.
+acknowledged after expiry. Shutdown reports failure if outcomes still await
+persistence. Execution eligibility survives process death, and stale executors
+cannot write history, suspension or completion records. An interrupted effect
+without a recorded outcome can run again; reconcile external outcomes or use
+provider idempotency before repeating writes.
 
 For admission and signal acknowledgement gaps, use the optional stable
 `idempotencyKey` and an application outbox. The runtime atomically records each
diff --git a/docs/reference/cli/installation.md b/docs/reference/cli/installation.md
index 19a92c6..905ea8d 100644
--- a/docs/reference/cli/installation.md
+++ b/docs/reference/cli/installation.md
@@ -41,7 +41,7 @@ tysel doctor --install
 tysel upgrade --check --json
 tysel upgrade --channel canary --yes
 tysel upgrade --channel stable --yes
-tysel upgrade --version 0.2.0 --yes
+tysel upgrade --version 0.3.0 --yes
 tysel upgrade --rollback
 ```
 
diff --git a/docs/reference/cli/tasks.md b/docs/reference/cli/tasks.md
index 7b44573..efdcb48 100644
--- a/docs/reference/cli/tasks.md
+++ b/docs/reference/cli/tasks.md
@@ -80,17 +80,18 @@ unknown, or previously pruned task.
 `prune` defaults to retaining seven days and deleting at most 32 tasks. The
 limit must be 1–100. Only explicit completions strictly older than the cutoff
 are eligible; pending wakeups, leases, and signal waits prevent deletion. A
-batch also stops at 16 MiB of retained program, result, history, and inbox
-payload, allowing one larger task so cleanup can progress. The JSON report
+batch also stops at 16 MiB of retained program, result, history, inbox and keyed
+signal receipt data, allowing one larger task so cleanup can progress. The JSON report
 contains `deleted`, `beforeMs`, and `limit`. A batch may delete fewer than its
 limit; repeat it deliberately if more cleanup is needed.
 
-Pruning permanently removes the selected result, program, events, and inbox.
+Pruning permanently removes the selected result, program, events, inbox,
+admission identity and signal receipts.
 It does not cancel active tasks or automatically compact database files.
 PostgreSQL retains a small per-task synchronization row to keep concurrent
 writers safe. Do not reuse pruned task IDs: completion deduplication is retained
 only until pruning. There is no automatic retention timer.
 
-Opening a store, including through these commands, migrates durable log v1 to
-v2. Follow the [upgrade procedure](../../operations/production.md#durable-log-v2-upgrade)
+Opening a store, including through these commands, migrates durable log v1/v2 to
+v3. Follow the [upgrade procedure](../../operations/production.md#durable-log-v3-upgrade)
 before pointing this release at an existing store.
diff --git a/docs/reference/component/rust-sdk.md b/docs/reference/component/rust-sdk.md
index e2dcb18..810f34c 100644
--- a/docs/reference/component/rust-sdk.md
+++ b/docs/reference/component/rust-sdk.md
@@ -4,7 +4,7 @@ Status: **experimental and versioned**. For a Rust Component project, use the
 published crate that matches the installed Tysel minor release:
 
 ```toml
-tysel-component-sdk = "0.2.0"
+tysel-component-sdk = "0.3.0"
 ```
 
 The release starter is also self-contained: it vendors the same SDK version and
diff --git a/docs/reference/errors-and-output.md b/docs/reference/errors-and-output.md
index d0dfd65..508ae3e 100644
--- a/docs/reference/errors-and-output.md
+++ b/docs/reference/errors-and-output.md
@@ -117,8 +117,7 @@ An oversized inbound body returns HTTP `413` with the same shape and code
 An internal serialization fallback can return only
 `{"error":{"code":"INTERNAL_ERROR"}}`.
 
-Packaged services and `tysel run` return the fixed message `request execution
-failed` for unhandled failures. Arbitrary exception text, source paths, and
+Packaged services and `tysel run` return the fixed message `request execution failed` for unhandled failures. Arbitrary exception text, source paths, and
 stacks are not included in that public response. `tysel dev` retains mapped
 source diagnostics and detailed error messages for local debugging.
 
diff --git a/docs/reference/runtime/durable.md b/docs/reference/runtime/durable.md
index 25c4657..06aed60 100644
--- a/docs/reference/runtime/durable.md
+++ b/docs/reference/runtime/durable.md
@@ -86,11 +86,14 @@ when another execution owns the task or it is already queued/waiting. `accepted`
 is not a suspension acknowledgement or a terminal result.
 
 The optional start key is scoped to the entire durable store: namespace it by
-tenant and operation. Repeating it with the same bundled handler and canonical
-JSON input returns the same task ID without starting a replacement. Changing the
-handler or input under the same key is a conflict. A failed task returns an
-explicit error on same-key admission retry; it is not acknowledged as `accepted`. Without a key, every call is a
-new admission; a lost acknowledgement cannot be safely repaired by another start.
+tenant and operation. Repeating it with the same full bundle source, export name
+and canonical JSON input returns the same task ID without starting a replacement.
+Changing any of these under the same key is a conflict, even if the target
+handler itself is unchanged. Across deployments, admission retries from an
+outbox therefore need the original bundle; changing the key creates a new task
+and does not repair the original admission. A failed task returns an explicit
+error on same-key retry. Without a key, every call is a new admission; a lost
+acknowledgement cannot be safely repaired by another start.
 
 Signal keys are scoped to a task. Receipt and inbox insertion share one transaction.
 Repeating the same name, payload and key is acknowledged even after consumption or
diff --git a/docs/reference/runtime/types.md b/docs/reference/runtime/types.md
index 8c52406..81c636d 100644
--- a/docs/reference/runtime/types.md
+++ b/docs/reference/runtime/types.md
@@ -126,7 +126,7 @@ remain undiscoverable.
 | Execution | `ExecutionProfile`, `TrustMode`, `CapabilityRequirement`, `RequestContext` | [Execution and trust](#execution-and-trust) |
 | Application | `FetchHandler`, `RuntimeFetchHandler`, `CronTask`, `QueueTask`, `McpInputType`, `McpInputSchema`, `InferMcpInput`, `McpTask`, `AppTask`, `TyselApp` | [Application module](application.md) |
 | Durable handler | `DurableHandler`, `DurableDuration`, `DurableRetryPolicy`, `DurableContext`, `DurableHost` | [Durable API](durable.md) |
-| Durable control | `DurableSuspendedResult`, `DurableCompletedResult`, `DurableStartResult`, `DurableControlClient` | [Durable control](durable.md#control-api) |
+| Durable control | `DurableRequestOptions`, `DurableAcceptedResult`, `DurableSuspendedResult`, `DurableCompletedResult`, `DurableStartResult`, `DurableControlClient` | [Durable control](durable.md#control-api) |
 | SQL and files | `SqlParameter`, `SqlRow`, `SqlClient`, `FileSystemClient` | [Host capabilities](capabilities.md) |
 | Redis | `RedisSetOptions`, `RedisClient` | [Redis](capabilities.md#redis) |
 | Secrets | `SecretReference`, `SecretClient` | [Secrets](capabilities.md#secrets) |
diff --git a/fuzz/Cargo.lock b/fuzz/Cargo.lock
index f984208..f38cc95 100644
--- a/fuzz/Cargo.lock
+++ b/fuzz/Cargo.lock
@@ -2379,7 +2379,7 @@ checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
 
 [[package]]
 name = "tysel-build"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "anyhow",
  "ed25519-dalek",
@@ -2397,7 +2397,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-capability"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "semver",
  "serde",
@@ -2406,7 +2406,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-distribution"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "semver",
  "serde",
@@ -2416,14 +2416,14 @@ dependencies = [
 
 [[package]]
 name = "tysel-engine"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "thiserror",
 ]
 
 [[package]]
 name = "tysel-engine-wasm"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "serde_json",
  "sha2 0.10.9",
@@ -2450,7 +2450,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-ipc"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -2460,7 +2460,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-manifest"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -2470,7 +2470,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-package"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "semver",
  "serde",
@@ -2481,7 +2481,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-release-signing"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "anyhow",
  "ed25519-dalek",
@@ -2493,7 +2493,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-task"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "serde_json",
  "thiserror",
@@ -2501,7 +2501,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-task-rpc"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "serde",
  "serde_json",
diff --git a/packages/tysel-test/package.json b/packages/tysel-test/package.json
index 3659c9b..969803e 100644
--- a/packages/tysel-test/package.json
+++ b/packages/tysel-test/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@tysel/test",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "license": "Apache-2.0",
   "description": "Test helpers for Tysel fetch handlers and durable tasks.",
diff --git a/packages/tysel-types/package.json b/packages/tysel-types/package.json
index fc156a8..dec7fc8 100644
--- a/packages/tysel-types/package.json
+++ b/packages/tysel-types/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@tysel/types",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "license": "Apache-2.0",
   "description": "Shared TypeScript types for Tysel applications and capabilities.",
diff --git a/packages/tysel/package.json b/packages/tysel/package.json
index b2eb078..b99e7f9 100644
--- a/packages/tysel/package.json
+++ b/packages/tysel/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@tysel/sdk",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "license": "Apache-2.0",
   "description": "Tysel application SDK: defineApp, durable tasks, and capability imports.",
diff --git a/runtime-js/bootstrap/index.ts b/runtime-js/bootstrap/index.ts
index f814ece..0b39ee8 100644
--- a/runtime-js/bootstrap/index.ts
+++ b/runtime-js/bootstrap/index.ts
@@ -1,5 +1,5 @@
 /** Build-time manifest for the JavaScript layers embedded by `tysel-engine-qjs`. */
-export const runtimeJsVersion = "0.2.0";
+export const runtimeJsVersion = "0.3.0";
 
 export const runtimeLayers = ["web-api", "capability-client", "durable"] as const;
 
diff --git a/runtime-js/compatibility.json b/runtime-js/compatibility.json
index 7010545..dd663d6 100644
--- a/runtime-js/compatibility.json
+++ b/runtime-js/compatibility.json
@@ -1,6 +1,6 @@
 {
   "schemaVersion": 3,
-  "runtimeJsVersion": "0.2.0",
+  "runtimeJsVersion": "0.3.0",
   "tap": {
     "minimumSupportedVersion": 1,
     "maximumSupportedVersion": 5
diff --git a/runtime-js/package.json b/runtime-js/package.json
index b70b6ea..0fe7fc9 100644
--- a/runtime-js/package.json
+++ b/runtime-js/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@tysel/runtime-js",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "private": true,
   "type": "module",
   "license": "Apache-2.0",
diff --git a/runtime-js/test/runtime.test.mjs b/runtime-js/test/runtime.test.mjs
index f7cb9fe..4ea1a3d 100644
--- a/runtime-js/test/runtime.test.mjs
+++ b/runtime-js/test/runtime.test.mjs
@@ -18,7 +18,7 @@ test("bootstrap completes without replacing host globals", () => {
 
 test("web API version is a stable semantic version", () => {
   assert.match(webApiVersion, /^\d+\.\d+\.\d+$/);
-  assert.equal(webApiVersion, "0.2.0");
+  assert.equal(webApiVersion, "0.3.0");
   assert.equal(runtimeJsVersion, webApiVersion);
   assert.deepEqual(runtimeLayers, ["web-api", "capability-client", "durable"]);
 });
diff --git a/runtime-js/web-api/index.ts b/runtime-js/web-api/index.ts
index 73f84c0..2dcc9a6 100644
--- a/runtime-js/web-api/index.ts
+++ b/runtime-js/web-api/index.ts
@@ -2,7 +2,7 @@ import type * as Streams from "./vendor/web-streams-polyfill/types.js";
 export type { ReadableStream, WritableStream, TransformStream, ReadableStreamDefaultReader, WritableStreamDefaultWriter, QueuingStrategy } from "./vendor/web-streams-polyfill/types.js";
 
 /** Versioned, server-side Web API subset installed into each isolate. */
-export const webApiVersion = "0.2.0";
+export const webApiVersion = "0.3.0";
 
 export type WebEventListener<E extends TyselEvent = TyselEvent> =
   | ((event: E) => void)
diff --git a/sdk/examples/rust-echo/Cargo.lock b/sdk/examples/rust-echo/Cargo.lock
index b2cec4e..2f8148a 100644
--- a/sdk/examples/rust-echo/Cargo.lock
+++ b/sdk/examples/rust-echo/Cargo.lock
@@ -195,7 +195,7 @@ dependencies = [
 
 [[package]]
 name = "tysel-component-sdk"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "serde",
  "serde_json",
diff --git a/website/components/home/home-page.tsx b/website/components/home/home-page.tsx
index bde8d3c..c492ce0 100644
--- a/website/components/home/home-page.tsx
+++ b/website/components/home/home-page.tsx
@@ -51,7 +51,7 @@ const jsonLd = {
       description,
       url: canonicalUrl(),
       downloadUrl: absoluteUrl("/install.sh"),
-      softwareVersion: "0.2.0",
+      softwareVersion: "0.3.0",
       applicationCategory: "DeveloperApplication",
       operatingSystem: "Linux, macOS",
       isAccessibleForFree: true,
diff --git a/website/content/docs/concepts/durable-execution.mdx b/website/content/docs/concepts/durable-execution.mdx
index 1478fea..1dd250d 100644
--- a/website/content/docs/concepts/durable-execution.mdx
+++ b/website/content/docs/concepts/durable-execution.mdx
@@ -40,8 +40,9 @@ export default {
 Typed projects created by `tysel init` already contain `tysel-env.d.ts`. Run
 `tysel types` after changing the durable store or other manifest capabilities.
 
-`tysel.durable.start` returns a task ID and either a completed or suspended
-status. Send an external event with
+`tysel.durable.start` returns a task ID and a completed, suspended, or accepted
+status. Use a stable `idempotencyKey` option to repair lost acknowledgements; see
+the [control contract](/reference/runtime/durable#control-api). Send an external event with
 `tysel.durable.sendSignal(taskId, "approval", payload)`.
 
 ## Durable boundaries
diff --git a/website/content/docs/guides/concurrency-backpressure.mdx b/website/content/docs/guides/concurrency-backpressure.mdx
index 805b58f..779ac99 100644
--- a/website/content/docs/guides/concurrency-backpressure.mdx
+++ b/website/content/docs/guides/concurrency-backpressure.mdx
@@ -43,6 +43,21 @@ before dispatching a request:
 Setting `max_in_flight = 0` deliberately sheds every request and can serve as a
 circuit breaker. It does not mean unlimited.
 
+## Request deadlines
+
+`request_timeout_ms` starts when a parsed HTTP request is admitted. It includes
+body consumption, waiting for a worker, and execution; dequeuing does not reset
+it. Expired or canceled queued requests are skipped before entering JavaScript.
+In the isolated profile, the remaining budget is forwarded to the worker, and
+canceled requests waiting for the supervisor are skipped before IPC dispatch.
+An already dispatched isolated request remains bounded by its remaining deadline.
+
+A timeout before response headers yields `504 REQUEST_TIMEOUT`. After headers,
+a streamed response ends with a body error. Request-header receipt and sending
+an already buffered response to a slow client are separate transport concerns;
+configure ingress timeouts as well. Cancellation does not roll back effects
+that already happened.
+
 ## Choose an initial value
 
 Use measured service time and a target throughput as a starting estimate:
@@ -104,7 +119,7 @@ provider concurrency limits, or deployment-level CPU and memory controls.
 | Immediate `503 OVERLOADED` | HTTP admission full | Reduce demand, shorten work, or raise the measured limit carefully. |
 | `413 BODY_TOO_LARGE` | Request-body limit | Reject or chunk earlier; raise only for a documented payload need. |
 | `500 RESPONSE_TOO_LARGE` | Response-body limit | Paginate, stream within the bound, or reduce output. |
-| Runtime timeout | Handler deadline | Bound upstream calls and keep the ingress deadline longer than Tysel's. |
+| `504 REQUEST_TIMEOUT`, or an aborted stream | Admission-to-execution deadline | Bound upstream calls and keep the ingress deadline longer than Tysel's. |
 | Memory grows after adding workers | Per-isolate budget multiplied | Reduce worker count or state; confirm external storage and cache strategy. |
 
 See [Application limits](/reference/manifest/limits),
diff --git a/website/content/docs/guides/wasm-component-rust.mdx b/website/content/docs/guides/wasm-component-rust.mdx
index 9002ac2..24471ea 100644
--- a/website/content/docs/guides/wasm-component-rust.mdx
+++ b/website/content/docs/guides/wasm-component-rust.mdx
@@ -53,7 +53,7 @@ For a project created without the starter, depend on the public SDK crate and
 copy the matching WIT package into the project:
 
 ```toml
-tysel-component-sdk = "0.2.0"
+tysel-component-sdk = "0.3.0"
 ```
 
 The crate version follows the Tysel product release. The WIT contract keeps its
diff --git a/website/content/docs/operations/production.mdx b/website/content/docs/operations/production.mdx
index 0d4ed95..a6d83b7 100644
--- a/website/content/docs/operations/production.mdx
+++ b/website/content/docs/operations/production.mdx
@@ -107,8 +107,75 @@ Shutdown:
 3. Wait through the configured grace period.
 4. If the process remains, capture logs and process state before forcing it.
 
+On SIGTERM or Ctrl-C, packaged services and `tysel run` close the listener,
+stop new durable claims, and drain HTTP/1 and HTTP/2 connections. Idle sockets
+close immediately. WebSockets receive close code 1001 (Going Away) when the
+transport can send it. Connections that remain after `request_timeout_ms + 1000` milliseconds are closed forcibly. This HTTP grace is shared across
+connections; task-plane shutdown and telemetry flushing can add time, so keep
+the service-manager grace longer. Development servers use the same draining
+path, with enough grace for the largest timeout seen during reloads.
+
 Clean shutdown flushes OTLP providers and stops the service-owned task plane.
 
+Durable storage availability errors move the scheduler to `recovering`, with
+exponential retry from 200 ms to a 5-second base plus at most 25% jitter. New
+durable starts fail while recovery is pending. A successful poll restores
+`healthy`. Unrecoverable store/scheduler failures, such as a corrupt program
+digest, reach the service owner, which drains and exits unsuccessfully.
+Completion-write availability failures retain the JSON outcome in memory and retry
+persistence without rerunning the handler while the execution lease is valid.
+If that authority expires or is superseded, the pending handle and its slot are
+released without reporting completion. The scheduler can reclaim the original
+managed task and replay its history; recorded effects do not execute again.
+At most 32 active executions and pending
+finalizations share reserved slots. Pending entries retain compact results and
+lease/sequence metadata, releasing consumed replay history. `completion_pending`
+logs the affected task ID. Completed outcomes are still reported when a different
+task in the same scheduling batch encounters a storage failure.
+Retries remain subject to the original lease. Completion transactions check fresh
+time after acquiring their locks and again before commit; expiry rolls back both
+the result and quota changes. An identical already-committed outcome can still be
+acknowledged after expiry. Shutdown reports failure if outcomes still await
+persistence. Execution eligibility survives process death, and stale executors
+cannot write history, suspension or completion records. An interrupted effect
+without a recorded outcome can run again; reconcile external outcomes or use
+provider idempotency before repeating writes.
+
+For admission and signal acknowledgement gaps, use the optional stable
+`idempotencyKey` and an application outbox. The runtime atomically records each
+keyed request in its own database; it cannot atomically commit the application's
+separate database. See the [control contract](/reference/runtime/durable#control-api).
+
+Per-task execution failures are logged as `task_failed`; they do not by
+themselves stop unrelated work. These states
+and task outcomes are bounded `durable` log events containing task IDs and
+attempt counts, without payloads, source, or database credentials. An HTTP-only
+health route may still succeed during recovery; use scheduler diagnostics for
+durable health.
+
+### Durable log v3 upgrade
+
+This release migrates durable log v1/v2 to v3 transactionally on store open. The
+application manifest schema remains version 1. Before upgrading:
+
+1. Drain and stop **all** old writers and schedulers.
+2. Back up the complete durable store and verify that it can be restored.
+3. Start the new release or its admin command; verify replay and completion.
+4. Resume traffic only after those checks pass.
+
+Do not run old and new writers together. Old runtimes reject v3 on startup;
+rollback requires restoring the pre-upgrade snapshot and its matching release.
+Existing v1/v2 programs remain active unless a new execution explicitly completes
+them. An absent wakeup is not proof of completion. Completion results and the
+active catalog counters persist across reopen. Retained data is removed only
+by [`tysel durable prune`](/reference/cli/tasks#tysel-durable).
+
+Failed executions are retained for investigation. Legacy interrupted runs without
+a wakeup or a v3 execution record remain unclassified and are not automatically
+replayed. Do not infer a safe replacement write from absent runtime history.
+Completion pruning also removes admission identities and signal receipts; keep
+retention longer than the application outbox retry horizon.
+
 ## Durable Postgres backup and restore
 
 Use PostgreSQL for production durable state. SQLite is a local or single-writer
@@ -125,7 +192,8 @@ storage option, not a shared multi-replica durable backend.
 5. Resume writers only after durable backup completion.
 
 The backup must contain all Tysel durable tables, including metadata, programs,
-events, wakeups, signals, task locks, and statistics. Do not copy selected task
+events, wakeups, signals, completions, execution leases, idempotency receipts,
+task locks, and statistics. Do not copy selected task
 rows or individual tables.
 
 ### Restore
@@ -220,3 +288,28 @@ logs.
 
 After recovery, rerun release admission and one durable restart/replay test
 before closing the incident. See [Debugging](/docs/guides/debugging).
+
+### Active-crash and acknowledgement gates
+
+From a checked-out runtime source tree, build the local binaries and run:
+
+```sh
+cargo build --locked -p tysel-cli -p tysel-runtime -p tysel-isolate --bins
+python3 tests/p1/crash_recovery.py
+```
+
+The gate uses only loopback services and disposable databases. It covers six
+SIGKILL windows in both `tysel run` and standalone mode with an empty PATH:
+initial unacknowledged admission, before the external write, external commit
+before response, response before effect recording, after effect recording, and
+projection update before signal-wait registration. It also retries a persisted
+signal after its HTTP acknowledgement is lost. Passing requires the same task
+to complete with the reconciled result, a single external create, and a single
+consumed approval event. The fake provider reconciles by stable operation ID;
+the runtime does not make arbitrary provider writes exactly-once.
+
+Run `cargo test --locked -p tysel-durable --test execution` with a disposable
+`TYSEL_POSTGRES_TEST_URL` to also exercise PostgreSQL execution fencing and
+idempotency. The SIGKILL gate above uses SQLite; PostgreSQL deployment crash and
+capacity checks, and an application's own outbox integration, remain separate
+release verification work.
diff --git a/website/content/reference/cli/index.mdx b/website/content/reference/cli/index.mdx
index 5fe95af..46682cb 100644
--- a/website/content/reference/cli/index.mdx
+++ b/website/content/reference/cli/index.mdx
@@ -41,7 +41,7 @@ tysel run --manifest services/worker/tysel.toml
 | --- | --- |
 | Project setup | [`init`, `config`](/reference/cli/project) |
 | Development | [`check`, `types`, `compat`, `test`, `dev`, `run`, `inspect`](/reference/cli/development) |
-| Tasks and protocols | [`task`, `queue`, `mcp`](/reference/cli/tasks) |
+| Tasks and protocols | [`task`, `queue`, `mcp`, `durable`](/reference/cli/tasks) |
 | Delivery | [`build`, `image`](/reference/cli/delivery) |
 | Installation | [`doctor`, `upgrade`](/reference/cli/installation) |
 | Evidence | [`bench`, `release`](/reference/cli/evidence) |
diff --git a/website/content/reference/cli/installation.mdx b/website/content/reference/cli/installation.mdx
index 6182ce9..5b892c0 100644
--- a/website/content/reference/cli/installation.mdx
+++ b/website/content/reference/cli/installation.mdx
@@ -44,7 +44,7 @@ tysel doctor --install
 tysel upgrade --check --json
 tysel upgrade --channel canary --yes
 tysel upgrade --channel stable --yes
-tysel upgrade --version 0.2.0 --yes
+tysel upgrade --version 0.3.0 --yes
 tysel upgrade --rollback
 ```
 
diff --git a/website/content/reference/cli/tasks.mdx b/website/content/reference/cli/tasks.mdx
index e9ada41..3e5fa1f 100644
--- a/website/content/reference/cli/tasks.mdx
+++ b/website/content/reference/cli/tasks.mdx
@@ -58,3 +58,43 @@ from `kind: "mcp"` entries in the application's `tasks` export.
 
 See [Application module](/reference/runtime/application) for queue and MCP handler
 types and [Limits and defaults](/reference/limits-and-defaults) for protocol bounds.
+
+
+## `tysel durable`
+
+Inspect retained results or delete a bounded batch of completed history from
+the selected project's durable store. The application is not loaded or executed.
+
+```sh
+tysel -C services/worker durable result 00000000000000000000000000000001
+tysel -C services/worker durable prune --older-than-secs 604800 --limit 32
+```
+
+`--manifest FILE` is also accepted. Store selection follows the runtime:
+`TYSEL_DURABLE_POSTGRES_URL` takes precedence, then `TYSEL_DURABLE_SQLITE_PATH`,
+then the `durable-events.db` beside the manifest's SQLite capability path.
+An absent SQLite event store is an error; the command does not create it.
+
+`result` writes JSON with `taskId` and `completion`. A retained completion has
+`status: "completed"`, `value`, and `completedAtMs`. A null completion means no
+retained result is available; it does not distinguish an active, failed,
+unknown, or previously pruned task.
+
+`prune` defaults to retaining seven days and deleting at most 32 tasks. The
+limit must be 1–100. Only explicit completions strictly older than the cutoff
+are eligible; pending wakeups, leases, and signal waits prevent deletion. A
+batch also stops at 16 MiB of retained program, result, history, inbox and keyed
+signal receipt data, allowing one larger task so cleanup can progress. The JSON report
+contains `deleted`, `beforeMs`, and `limit`. A batch may delete fewer than its
+limit; repeat it deliberately if more cleanup is needed.
+
+Pruning permanently removes the selected result, program, events, inbox,
+admission identity and signal receipts.
+It does not cancel active tasks or automatically compact database files.
+PostgreSQL retains a small per-task synchronization row to keep concurrent
+writers safe. Do not reuse pruned task IDs: completion deduplication is retained
+only until pruning. There is no automatic retention timer.
+
+Opening a store, including through these commands, migrates durable log v1/v2 to
+v3. Follow the [upgrade procedure](/docs/operations/production#durable-log-v3-upgrade)
+before pointing this release at an existing store.
diff --git a/website/content/reference/component/rust-sdk.mdx b/website/content/reference/component/rust-sdk.mdx
index 557c0b2..ebc839a 100644
--- a/website/content/reference/component/rust-sdk.mdx
+++ b/website/content/reference/component/rust-sdk.mdx
@@ -7,7 +7,7 @@ Status: **experimental and versioned**. For a Rust Component project, use the
 published crate that matches the installed Tysel minor release:
 
 ```toml
-tysel-component-sdk = "0.2.0"
+tysel-component-sdk = "0.3.0"
 ```
 
 The release starter is also self-contained: it vendors the same SDK version and
diff --git a/website/content/reference/errors-and-output.mdx b/website/content/reference/errors-and-output.mdx
index 347e327..2f88acf 100644
--- a/website/content/reference/errors-and-output.mdx
+++ b/website/content/reference/errors-and-output.mdx
@@ -109,7 +109,7 @@ Unhandled runtime failures return HTTP `500` with JSON:
 {
   "error": {
     "code": "RUNTIME_ERROR",
-    "message": "...",
+    "message": "request execution failed",
     "requestId": "000000000000002a"
   }
 }
@@ -120,12 +120,15 @@ An oversized inbound body returns HTTP `413` with the same shape and code
 An internal serialization fallback can return only
 `{"error":{"code":"INTERNAL_ERROR"}}`.
 
-`tysel dev` uses the generated source map to symbolicate application stack
-information. Although the map is embedded during packaging, the packaged HTTP
-dispatcher does not currently apply it, so production messages can contain
-bundle locations. Treat all runtime messages as operator diagnostics: map
-errors to an application-owned response before exposing sensitive internals to
-public clients.
+Packaged services and `tysel run` return the fixed message `request execution failed` for unhandled failures. Arbitrary exception text, source paths, and
+stacks are not included in that public response. `tysel dev` retains mapped
+source diagnostics and detailed error messages for local debugging.
+
+A request whose deadline expires before response headers returns HTTP `504`
+with code `REQUEST_TIMEOUT` and message `request deadline exceeded`. The
+budget includes admitted queue time and handler execution. If headers have
+already been sent, a streaming timeout terminates the body with an error;
+it cannot replace the existing status with `504`.
 
 ## Application errors
 
diff --git a/website/content/reference/limits-and-defaults.mdx b/website/content/reference/limits-and-defaults.mdx
index 5122ae0..211634d 100644
--- a/website/content/reference/limits-and-defaults.mdx
+++ b/website/content/reference/limits-and-defaults.mdx
@@ -85,8 +85,16 @@ request limit. The smaller applicable bound wins.
 | History | 10,000 events and 16 MiB |
 | Pending signal inbox | 1,000 signals and 16 MiB |
 | One durable program | 1 MiB |
-| Program catalog | 10,000 programs and 64 MiB total |
+| Active program catalog | 10,000 programs and 64 MiB total source |
+| Retained completion result | 1 MiB per task |
+| Retention cleanup | At most 100 tasks; 16 MiB of retained payload per batch, or one larger task |
 | Concurrent durable polling | 16 |
+| Idempotency key | 1–256 UTF-8 bytes |
+| Retained keyed signal receipts | 10,000 per task; removed with completed-task cleanup |
+
+Completed programs and history remain stored until explicit cleanup, but do
+not consume the active catalog quota. Legacy records without an explicit
+completion remain active. See [Durable administration](/reference/cli/tasks#tysel-durable).
 
 ## LLM bounds
 
diff --git a/website/content/reference/manifest/limits.mdx b/website/content/reference/manifest/limits.mdx
index 9c8eacc..69df832 100644
--- a/website/content/reference/manifest/limits.mdx
+++ b/website/content/reference/manifest/limits.mdx
@@ -10,7 +10,7 @@ are non-negative integers; omitted fields receive the values below.
 | --- | ---: | --- | --- |
 | `memory_mb` | `128` | MiB | QuickJS or isolated-worker memory budget. |
 | `cpu_ms_per_turn` | `50` | ms | CPU budget for one JavaScript turn. |
-| `request_timeout_ms` | `30000` | ms | Invocation deadline; also bounds configured LLM calls. |
+| `request_timeout_ms` | `30000` | ms | HTTP deadline includes admitted queue time and execution; also bounds configured LLM calls. |
 | `max_in_flight` | `1000` | requests | Maximum admitted HTTP requests, held through response-body completion. |
 | `max_response_mb` | `16` | MiB | Maximum cumulative HTTP response-body size. |
 | `max_request_mb` | `16` | MiB | Inbound request-body limit. |
diff --git a/website/content/reference/runtime/durable.mdx b/website/content/reference/runtime/durable.mdx
index cca9565..7200c42 100644
--- a/website/content/reference/runtime/durable.mdx
+++ b/website/content/reference/runtime/durable.mdx
@@ -1,10 +1,11 @@
 ---
 title: "Durable API"
-description: "Durable handlers record effect boundaries so interrupted work can resume without repeating already committed external actions."
+description: "Durable handlers record effect outcomes so interrupted work can replay recorded boundaries."
 ---
 
-Durable handlers record effect boundaries so interrupted work can resume
-without repeating already committed external actions.
+Durable handlers record effect outcomes so interrupted work can replay recorded
+boundaries. An external commit without a recorded outcome still requires provider
+idempotency or reconciliation when the callback is entered again.
 
 ```ts
 interface DurableContext {
@@ -74,12 +75,76 @@ their results are not wrapped by a recorded boundary.
 ## Control API
 
 ```ts
-const status = tysel.durable.start("provision", input);
-tysel.durable.sendSignal(status.taskId, "approval", { approved: true });
+const status = tysel.durable.start("provision", input, {
+  idempotencyKey: "tenant-42:provision:request-123",
+});
+tysel.durable.sendSignal(status.taskId, "approval", { approved: true }, {
+  idempotencyKey: "approval-decision-456",
+});
 ```
 
-`start` returns either a completed result or a suspended status.
-`sendSignal` appends a JSON signal for a waiting workflow.
+`start` atomically persists the task, immutable input and restart eligibility
+before executing the handler. It returns `completed`, `suspended`, or `accepted`
+when another execution owns the task or it is already queued/waiting. `accepted`
+is not a suspension acknowledgement or a terminal result.
+
+The optional start key is scoped to the entire durable store: namespace it by
+tenant and operation. Repeating it with the same full bundle source, export name
+and canonical JSON input returns the same task ID without starting a replacement.
+Changing any of these under the same key is a conflict, even if the target
+handler itself is unchanged. Across deployments, admission retries from an
+outbox therefore need the original bundle; changing the key creates a new task
+and does not repair the original admission. A failed task returns an explicit
+error on same-key retry. Without a key, every call is a new admission; a lost
+acknowledgement cannot be safely repaired by another start.
+
+Signal keys are scoped to a task. Receipt and inbox insertion share one transaction.
+Repeating the same name, payload and key is acknowledged even after consumption or
+completion, without adding another signal. Conflicting reuse is rejected. Unkeyed
+signals retain FIFO semantics and each call enqueues a new signal. New signals to
+completed tasks are rejected. Up to 10,000 keyed signal receipts are retained per
+task, independently of the pending inbox bound.
+
+Applications using a separate database should persist an outbox intent and stable
+key in their own transaction, retry the exact request after uncertain delivery,
+and mark it delivered after acknowledgement. This provides a repairable protocol,
+**not a transaction across the application and runtime databases**. Tysel does not
+run or drain the application's outbox. Both admission and signal deduplication
+last until explicit `prune` removes the completed task; retain tasks longer than
+the application's retry horizon, and do not reuse keys after cleanup.
+
+## Active crash recovery
+
+The service scheduler persists an execution lease independently of wakeups.
+After process death, an eligible task is claimed after lease expiry and resumes
+against its original source and history. Recorded effects return their recorded
+result; an effect interrupted before recording its outcome is entered again.
+Use the same provider operation key or reconcile its outcome before another write.
+Execution generations and unique ownership tokens fence history, suspension and
+completion writes from stale executors. They cannot fence an external provider's
+in-flight request. The lease is the request timeout plus the scheduler margin;
+recovery is not instantaneous. Pending completion retries also respect that
+lease: a stale completion handle is discarded without stopping the service, and
+the original managed task becomes eligible for normal fenced recovery.
+
+A storage failure at a durable boundary invalidates the current execution attempt,
+even if handler code catches the JavaScript exception. The runtime preserves the
+storage error and restart eligibility rather than committing a fallback result.
+After storage recovers and the lease expires, the original history is replayed.
+Ordinary handler exceptions and task boundary validation/limit errors fail only
+the task; they do not stop the scheduler. Lost execution authority abandons the
+stale attempt without stopping other tasks.
+
+Completion releases active quota while retaining program, history and receipts.
+Legacy v1/v2 tasks with persisted wakeups can enter the managed lifecycle when
+resumed. Legacy orphan tasks with neither a wakeup nor an execution record are
+not guessed runnable; investigate them before initiating further external writes.
+Low-level caller-owned Rust sessions and in-memory registries retain their
+caller-managed lifecycle contract.
+
+Use [`tysel durable result` and `tysel durable prune`](/reference/cli/tasks#tysel-durable)
+to read a retained result or remove an aged batch. Failed and legacy tasks are
+never inferred complete from the absence of a wakeup.
 
 Durable inputs and results are limited to 1 MiB, with additional history,
 signal, and program bounds listed under [Limits and defaults](/reference/limits-and-defaults).
diff --git a/website/content/reference/runtime/types.mdx b/website/content/reference/runtime/types.mdx
index c522a56..eb82703 100644
--- a/website/content/reference/runtime/types.mdx
+++ b/website/content/reference/runtime/types.mdx
@@ -129,7 +129,7 @@ remain undiscoverable.
 | Execution | `ExecutionProfile`, `TrustMode`, `CapabilityRequirement`, `RequestContext` | [Execution and trust](#execution-and-trust) |
 | Application | `FetchHandler`, `RuntimeFetchHandler`, `CronTask`, `QueueTask`, `McpInputType`, `McpInputSchema`, `InferMcpInput`, `McpTask`, `AppTask`, `TyselApp` | [Application module](/reference/runtime/application) |
 | Durable handler | `DurableHandler`, `DurableDuration`, `DurableRetryPolicy`, `DurableContext`, `DurableHost` | [Durable API](/reference/runtime/durable) |
-| Durable control | `DurableSuspendedResult`, `DurableCompletedResult`, `DurableStartResult`, `DurableControlClient` | [Durable control](/reference/runtime/durable#control-api) |
+| Durable control | `DurableRequestOptions`, `DurableAcceptedResult`, `DurableSuspendedResult`, `DurableCompletedResult`, `DurableStartResult`, `DurableControlClient` | [Durable control](/reference/runtime/durable#control-api) |
 | SQL and files | `SqlParameter`, `SqlRow`, `SqlClient`, `FileSystemClient` | [Host capabilities](/reference/runtime/capabilities) |
 | Redis | `RedisSetOptions`, `RedisClient` | [Redis](/reference/runtime/capabilities#redis) |
 | Secrets | `SecretReference`, `SecretClient` | [Secrets](/reference/runtime/capabilities#secrets) |
diff --git a/website/locales/zh-CN/content/docs/concepts/durable-execution.mdx b/website/locales/zh-CN/content/docs/concepts/durable-execution.mdx
index 0342844..0379e83 100644
--- a/website/locales/zh-CN/content/docs/concepts/durable-execution.mdx
+++ b/website/locales/zh-CN/content/docs/concepts/durable-execution.mdx
@@ -37,7 +37,7 @@ export default {
 
 由 `tysel init` 创建的类型化项目已经包含 `tysel-env.d.ts`。修改持久存储或其他清单能力后，请运行 `tysel types`。
 
-`tysel.durable.start` 返回任务 ID，以及已完成或已暂停的状态。可通过 `tysel.durable.sendSignal(taskId, "approval", payload)` 发送外部事件。
+`tysel.durable.start` 返回任务 ID，以及已完成、已暂停或已接受的状态。使用稳定的 `idempotencyKey` 修复确认丢失，详见[控制约定](/reference/runtime/durable#control-api)。可通过 `tysel.durable.sendSignal(taskId, "approval", payload)` 发送外部事件。
 
 ## 持久边界
 
diff --git a/website/locales/zh-CN/content/docs/guides/concurrency-backpressure.mdx b/website/locales/zh-CN/content/docs/guides/concurrency-backpressure.mdx
index 22da863..fefca42 100644
--- a/website/locales/zh-CN/content/docs/guides/concurrency-backpressure.mdx
+++ b/website/locales/zh-CN/content/docs/guides/concurrency-backpressure.mdx
@@ -36,6 +36,12 @@ HTTP 监听器共享 `max_in_flight`。Tysel 会在分派请求前尝试获取
 
 将 `max_in_flight = 0` 会有意拒绝所有请求，可用作熔断器。零不表示无限制。
 
+## 请求截止时间
+
+`request_timeout_ms` 从解析后的 HTTP 请求获准进入系统时开始计时，包含正文读取、等待工作线程和执行；出队不会重置截止时间。排队期间已超时或已取消的请求不会进入 JavaScript。隔离执行配置会将剩余时间传给工作进程，在等待监督器期间取消的请求不会通过 IPC 分派；已分派的请求仍受剩余截止时间约束。
+
+响应头发出前超时会返回 `504 REQUEST_TIMEOUT`，发出后超时会以正文错误结束流式响应。接收请求头和向慢客户端发送已缓冲响应属于独立的传输阶段，还需配置入口超时。取消不会回滚已经发生的副作用。
+
 ## 选择初始值
 
 可使用测得的服务时间和目标吞吐量进行初步估算：
@@ -86,7 +92,7 @@ retry-after: 1
 | 立即返回 `503 OVERLOADED` | HTTP 准入已满 | 降低需求、缩短处理时间，或谨慎提高经过测量的限额。 |
 | `413 BODY_TOO_LARGE` | 请求正文限额 | 更早拒绝或分块；只有明确的载荷需求才提高限额。 |
 | `500 RESPONSE_TOO_LARGE` | 响应正文限额 | 分页、在边界内流式传输，或减少输出。 |
-| 运行时超时 | 处理程序截止时间 | 限制上游调用，并使 Ingress 截止时间长于 Tysel。 |
+| `504 REQUEST_TIMEOUT` 或流被中止 | 从准入到执行的截止时间 | 限制上游调用，并使 Ingress 截止时间长于 Tysel。 |
 | 增加工作线程后内存增长 | 每个隔离实例的预算倍增 | 减少工作线程或状态；确认外部存储和缓存策略。 |
 
 请参阅[应用限额](/reference/manifest/limits)、[限额与默认值](/reference/limits-and-defaults)以及[性能验证材料](/docs/performance)。
diff --git a/website/locales/zh-CN/content/docs/guides/wasm-component-rust.mdx b/website/locales/zh-CN/content/docs/guides/wasm-component-rust.mdx
index 79763f4..b9a79b8 100644
--- a/website/locales/zh-CN/content/docs/guides/wasm-component-rust.mdx
+++ b/website/locales/zh-CN/content/docs/guides/wasm-component-rust.mdx
@@ -45,7 +45,7 @@ cd tysel-component-starters/rust-echo
 未使用起始项目时，应依赖公开 SDK crate，并将匹配的 WIT 包复制到项目中：
 
 ```toml
-tysel-component-sdk = "0.2.0"
+tysel-component-sdk = "0.3.0"
 ```
 
 crate 版本跟随 Tysel 产品版本。WIT 约定使用独立的 `tysel:component/task@0.4.0` ABI 版本。
diff --git a/website/locales/zh-CN/content/docs/operations/production.mdx b/website/locales/zh-CN/content/docs/operations/production.mdx
index bba4a0a..d5f2734 100644
--- a/website/locales/zh-CN/content/docs/operations/production.mdx
+++ b/website/locales/zh-CN/content/docs/operations/production.mdx
@@ -96,8 +96,33 @@ tysel build --release --target linux-x64 --output dist/APP
 3. 等待配置的宽限期结束。
 4. 如果进程仍未退出，请在强制终止前捕获日志和进程状态。
 
+收到 SIGTERM 或 Ctrl-C 时，打包服务和 `tysel run` 会关闭监听器、停止新的持久任务认领，并排空 HTTP/1、HTTP/2 连接。空闲连接立即关闭；传输允许时，WebSocket 会收到关闭码 1001（Going Away）。超过 `request_timeout_ms + 1000` 毫秒仍未结束的连接会被强制关闭。所有连接共享此 HTTP 宽限期；任务子系统关闭和遥测发送还会耗时，因此服务管理器应配置更长宽限期。开发服务器使用相同排空路径，并按热更新期间见过的最大超时留足时间。
+
 正常关闭时会将 OTLP 提供器中缓冲的遥测数据发送出去，并停止由服务管理的任务执行子系统。
 
+持久存储不可用时，调度器进入 `recovering`，按 200 ms 到 5 秒基数进行指数退避，并增加最多 25% 抖动。恢复期间新的持久启动会失败；成功轮询恢复 `healthy`。程序摘要损坏等不可恢复的存储或调度故障会传给服务所有者，触发排空并以失败状态退出。
+
+完成写入遇到可用性故障时，会在内存保留 JSON 结果，在执行租约有效期间重试持久化而不重跑处理程序。权限到期或被替代后，待完成句柄及槽位会被释放，不报告完成。调度器可重新认领原始托管任务并回放历史，已记录的 effect 不会再次执行。最多 32 个活跃执行和待完成结果共享预留槽位；待完成项只保留紧凑结果与租约、序号元数据，释放已消费的回放历史。`completion_pending` 日志包含任务 ID。同批其他任务遇到存储故障时，已经完成的结果仍会报告。
+
+重试仍受原始租约约束。完成事务获取锁后和提交前都会检查最新时间，到期会回滚结果与配额变更。完全相同且已提交的结果仍可在到期后被确认。关闭时若仍有结果等待持久化，会报告关闭失败。执行资格跨进程死亡保留，旧执行者无法写入历史、暂停或完成记录。尚未记录结果的中断 effect 可能再次执行；重复写入前应核对外部结果或使用提供方幂等机制。
+
+准入与信号确认丢失时，应使用可选的稳定 `idempotencyKey` 和应用 outbox。运行时仅能在自己的数据库中原子记录带键请求，无法原子提交应用的独立数据库。参见[控制约定](/reference/runtime/durable#control-api)。
+
+任务执行失败记录为 `task_failed`，不会单独使无关任务停止。这些状态和结果使用有界的 `durable` 日志，包含任务 ID 和尝试次数，不包含载荷、源码或数据库凭据。仅检查 HTTP 的健康路由可能在恢复期间仍成功，应使用调度器诊断判断持久执行健康状态。
+
+### Durable log v3 upgrade
+
+本版本在打开存储时，以事务将持久日志 v1/v2 迁移到 v3；应用清单 schema 仍为版本 1。升级前：
+
+1. 排空并停止**所有**旧写入者和调度器。
+2. 备份完整持久存储，并验证能够恢复。
+3. 启动新版本或管理命令，验证回放与完成行为。
+4. 仅在检查通过后恢复流量。
+
+不要混用新旧写入者。旧运行时启动时会拒绝 v3；回滚需要恢复升级前快照及匹配版本。已有 v1/v2 程序仍计为活跃，除非新执行明确完成它们。缺少唤醒不是完成证据。完成结果和活跃目录计数在重新打开后保留。保留数据只通过 [`tysel durable prune`](/reference/cli/tasks#tysel-durable) 删除。
+
+失败执行保留供调查。既无唤醒也无 v3 执行记录的旧中断任务仍属未分类，不会自动回放。不能凭历史缺失推断可安全发起替代写入。完成清理还会删除准入身份和信号回执；保留期必须长于应用 outbox 重试窗口。
+
 ## 持久执行 PostgreSQL 的备份与恢复
 
 生产持久状态请使用 PostgreSQL。SQLite 适用于本地或单写入者存储，并非多副本共享的持久后端。
@@ -110,7 +135,7 @@ tysel build --release --target linux-x64 --output dist/APP
 4. 按照保留计划测试恢复。
 5. 只有持久状态备份完成后才恢复写入者。
 
-备份必须包含所有 Tysel 持久执行表，包括元数据、程序、事件、唤醒、信号、任务锁和统计信息。不要只复制选定的任务行或个别表。
+备份必须包含所有 Tysel 持久执行表，包括元数据、程序、事件、唤醒、信号、完成记录、执行租约、幂等回执、任务锁和统计信息。不要只复制选定的任务行或个别表。
 
 ### 恢复
 
@@ -189,3 +214,17 @@ Tysel JSON 日志会省略查询字符串、标头、正文、SQL、文件系统
 | 遥测中断 | 使用独立的健康检查和审计日志，恢复收集器，并通过合成请求验证。 | 将 OTLP 凭据加入端点 URL。 |
 
 恢复后，重新运行发布准入和一次持久重启/回放测试，然后再关闭事件。请参阅[调试](/docs/guides/debugging)。
+
+
+### 活跃崩溃与确认门禁
+
+在运行时源码检出目录中构建本地二进制并运行：
+
+```sh
+cargo build --locked -p tysel-cli -p tysel-runtime -p tysel-isolate --bins
+python3 tests/p1/crash_recovery.py
+```
+
+门禁只使用回环服务与临时数据库，覆盖 `tysel run` 和空 PATH 单文件模式的六种 SIGKILL 窗口：初始准入未确认、外部写入前、外部提交后响应前、响应后 effect 记录前、effect 记录后、投影更新后注册信号等待前。它还会在 HTTP 确认丢失后重试已持久化信号。通过要求是同一任务完成并返回核对后的结果，外部创建一次，审批事件消费一次。伪提供方按稳定操作 ID 核对结果，运行时不会让任意提供方写入自动具备恰好一次语义。
+
+对临时 `TYSEL_POSTGRES_TEST_URL` 运行 `cargo test --locked -p tysel-durable --test execution`，可进一步验证 PostgreSQL 执行隔离与幂等。上述 SIGKILL 门禁默认使用 SQLite；PostgreSQL 部署级崩溃、容量检查及应用自身 outbox 集成仍需单独进行发布验证。
diff --git a/website/locales/zh-CN/content/reference/cli/index.mdx b/website/locales/zh-CN/content/reference/cli/index.mdx
index d8af5f0..85d067d 100644
--- a/website/locales/zh-CN/content/reference/cli/index.mdx
+++ b/website/locales/zh-CN/content/reference/cli/index.mdx
@@ -35,7 +35,7 @@ tysel run --manifest services/worker/tysel.toml
 | --- | --- |
 | 项目设置 | [`init`, `config`](/reference/cli/project) |
 | 开发 | [`check`, `types`, `compat`, `test`, `dev`, `run`, `inspect`](/reference/cli/development) |
-| 任务与协议 | [`task`, `queue`, `mcp`](/reference/cli/tasks) |
+| 任务与协议 | [`task`, `queue`, `mcp`, `durable`](/reference/cli/tasks) |
 | 交付 | [`build`, `image`](/reference/cli/delivery) |
 | 安装 | [`doctor`, `upgrade`](/reference/cli/installation) |
 | 验证材料 | [`bench`, `release`](/reference/cli/evidence) |
diff --git a/website/locales/zh-CN/content/reference/cli/installation.mdx b/website/locales/zh-CN/content/reference/cli/installation.mdx
index fc40f11..370faa0 100644
--- a/website/locales/zh-CN/content/reference/cli/installation.mdx
+++ b/website/locales/zh-CN/content/reference/cli/installation.mdx
@@ -42,7 +42,7 @@ tysel doctor --install
 tysel upgrade --check --json
 tysel upgrade --channel canary --yes
 tysel upgrade --channel stable --yes
-tysel upgrade --version 0.2.0 --yes
+tysel upgrade --version 0.3.0 --yes
 tysel upgrade --rollback
 ```
 
diff --git a/website/locales/zh-CN/content/reference/cli/tasks.mdx b/website/locales/zh-CN/content/reference/cli/tasks.mdx
index f6028d1..7a1b15f 100644
--- a/website/locales/zh-CN/content/reference/cli/tasks.mdx
+++ b/website/locales/zh-CN/content/reference/cli/tasks.mdx
@@ -52,3 +52,23 @@ tysel mcp [ENTRY] [--manifest FILE]
 `ENTRY` 会覆盖 `app.entry`。协议输入和输出专用于 MCP 消息；人类可读的诊断信息会单独写出。工具注册来自应用 `tasks` 导出中 `kind: "mcp"` 的条目。
 
 队列和 MCP 处理程序类型请参阅[应用模块](/reference/runtime/application)，协议边界请参阅[限额与默认值](/reference/limits-and-defaults)。
+
+
+## `tysel durable`
+
+从所选项目的持久存储中查看保留结果，或删除有界的一批已完成历史。命令不会加载或执行应用。
+
+```sh
+tysel -C services/worker durable result 00000000000000000000000000000001
+tysel -C services/worker durable prune --older-than-secs 604800 --limit 32
+```
+
+也接受 `--manifest FILE`。存储选择与运行时一致：优先 `TYSEL_DURABLE_POSTGRES_URL`，其次 `TYSEL_DURABLE_SQLITE_PATH`，最后是清单 SQLite 能力路径旁的 `durable-events.db`。不存在的 SQLite 事件存储会报错，命令不会创建它。
+
+`result` 输出含 `taskId` 和 `completion` 的 JSON。保留的完成记录包含 `status: "completed"`、`value` 和 `completedAtMs`。空 completion 表示无保留结果，不能区分活跃、失败、未知或已清理的任务。
+
+`prune` 默认保留七天，每次最多删除 32 个任务。limit 必须为 1–100。只有严格早于截止时间的显式完成记录才符合条件；待处理唤醒、租约和信号等待会阻止删除。每批保留程序、结果、历史、收件箱及带键信号回执的数据总量达到 16 MiB 时也会停止，但允许单个更大的任务以保证清理能推进。JSON 报告包含 `deleted`、`beforeMs` 和 `limit`；实际删除数可能低于 limit，需要更多清理时应主动重复执行。
+
+清理会永久移除所选结果、程序、事件、收件箱、准入身份和信号回执，不会取消活跃任务或自动压缩数据库文件。PostgreSQL 会保留小型任务同步行以保护并发写入。不要复用已清理的任务 ID：完成去重只保留到清理时。没有自动保留定时器。
+
+打开存储（包括这些管理命令）会将持久日志 v1/v2 迁移到 v3。在使用此版本打开已有存储前，请遵循[升级流程](/docs/operations/production#durable-log-v3-upgrade)。
diff --git a/website/locales/zh-CN/content/reference/component/rust-sdk.mdx b/website/locales/zh-CN/content/reference/component/rust-sdk.mdx
index 0e1b8d6..9c69786 100644
--- a/website/locales/zh-CN/content/reference/component/rust-sdk.mdx
+++ b/website/locales/zh-CN/content/reference/component/rust-sdk.mdx
@@ -6,7 +6,7 @@ description: "Rust Component 项目应使用与已安装 Tysel 次版本匹配
 状态：**实验性且带版本**。Rust Component 项目应使用与已安装 Tysel 次版本匹配的已发布 crate：
 
 ```toml
-tysel-component-sdk = "0.2.0"
+tysel-component-sdk = "0.3.0"
 ```
 
 发布起始项目同样是自包含的：它内置相同版本的 SDK，并使用 `tysel-component-sdk = { path = "sdk/tysel-component-sdk" }`。自己的项目可以使用 crates.io 依赖；如果可复现或离线构建起始项目更重要，则保留内置的路径依赖。
diff --git a/website/locales/zh-CN/content/reference/errors-and-output.mdx b/website/locales/zh-CN/content/reference/errors-and-output.mdx
index 97c872b..e5c2268 100644
--- a/website/locales/zh-CN/content/reference/errors-and-output.mdx
+++ b/website/locales/zh-CN/content/reference/errors-and-output.mdx
@@ -83,7 +83,7 @@ tysel upgrade --check --json
 {
   "error": {
     "code": "RUNTIME_ERROR",
-    "message": "...",
+    "message": "request execution failed",
     "requestId": "000000000000002a"
   }
 }
@@ -91,7 +91,9 @@ tysel upgrade --check --json
 
 过大的入站正文返回 HTTP `413`，结构相同，错误码为 `BODY_TOO_LARGE`。`requestId` 是固定宽度的十六进制关联值。内部序列化回退可能只返回 `{"error":{"code":"INTERNAL_ERROR"}}`。
 
-`tysel dev` 使用生成的源码映射解析应用堆栈信息。虽然打包时会嵌入映射，但打包后的 HTTP 分派器目前不会应用它，因此生产消息可能包含打包位置。所有运行时消息都应视为运维诊断：向公共客户端暴露前，应将错误映射为应用自行定义的响应，以免泄露敏感内部信息。
+打包服务和 `tysel run` 对未处理的失败返回固定消息 `request execution failed`，不会在公共响应中包含任意异常文本、源码路径或堆栈。`tysel dev` 保留映射后的源码诊断和详细错误，便于本地调试。
+
+请求在响应头发出前超时会返回 HTTP `504`，错误码为 `REQUEST_TIMEOUT`，消息为 `request deadline exceeded`。时间预算包含准入后的排队和处理程序执行。响应头已发出时，流式超时会以错误终止正文，无法把已发送的状态改成 `504`。
 
 ## 应用错误
 
diff --git a/website/locales/zh-CN/content/reference/limits-and-defaults.mdx b/website/locales/zh-CN/content/reference/limits-and-defaults.mdx
index c7be1ba..7ce9ea7 100644
--- a/website/locales/zh-CN/content/reference/limits-and-defaults.mdx
+++ b/website/locales/zh-CN/content/reference/limits-and-defaults.mdx
@@ -76,8 +76,14 @@ description: "本页汇总分散在清单、协议和宿主实现中的限额。
 | 历史 | 10,000 个事件且总计 16 MiB |
 | 待处理信号收件箱 | 1,000 个信号且总计 16 MiB |
 | 单个持久程序 | 1 MiB |
-| 程序目录 | 10,000 个程序且总计 64 MiB |
+| 活跃程序目录 | 10,000 个程序，源码总计 64 MiB |
+| 保留的完成结果 | 每任务 1 MiB |
+| 保留数据清理 | 每批最多 100 个任务、16 MiB 保留载荷，或单个更大的任务 |
 | 并发持久轮询数 | 16 |
+| 幂等键 | 1–256 个 UTF-8 字节 |
+| 保留的带键信号回执 | 每任务 10,000 条；随已完成任务清理而移除 |
+
+已完成程序和历史会保留到显式清理，但不占用活跃目录配额。没有显式完成记录的旧数据仍算活跃。参见[持久任务管理](/reference/cli/tasks#tysel-durable)。
 
 ## LLM 边界
 
diff --git a/website/locales/zh-CN/content/reference/manifest/limits.mdx b/website/locales/zh-CN/content/reference/manifest/limits.mdx
index e30f1eb..b241246 100644
--- a/website/locales/zh-CN/content/reference/manifest/limits.mdx
+++ b/website/locales/zh-CN/content/reference/manifest/limits.mdx
@@ -9,7 +9,7 @@ description: "可选的 [limits] 表定义应用级资源预算。所有字段
 | --- | ---: | --- | --- |
 | `memory_mb` | `128` | MiB | QuickJS 或隔离工作进程的内存预算。 |
 | `cpu_ms_per_turn` | `50` | ms | 单轮 JavaScript 执行的 CPU 预算。 |
-| `request_timeout_ms` | `30000` | ms | 调用截止时间；也限制已配置的 LLM 调用。 |
+| `request_timeout_ms` | `30000` | ms | HTTP 截止时间包含准入后的排队与执行，也约束已配置的 LLM 调用。 |
 | `max_in_flight` | `1000` | 请求 | 允许同时进入的 HTTP 请求上限，许可保持到响应正文完成。 |
 | `max_response_mb` | `16` | MiB | HTTP 响应正文的累计大小上限。 |
 | `max_request_mb` | `16` | MiB | 入站请求正文上限。 |
diff --git a/website/locales/zh-CN/content/reference/runtime/durable.mdx b/website/locales/zh-CN/content/reference/runtime/durable.mdx
index 8a1d7ec..efecae7 100644
--- a/website/locales/zh-CN/content/reference/runtime/durable.mdx
+++ b/website/locales/zh-CN/content/reference/runtime/durable.mdx
@@ -1,9 +1,11 @@
 ---
 title: "持久 API"
-description: "持久处理程序记录副作用边界，使中断的工作可以恢复，而不会重复已经提交的外部操作。"
+description: "持久处理程序记录副作用结果，使中断的工作可以回放已记录的边界。"
 ---
 
-持久处理程序记录副作用边界，使中断的工作可以恢复，而不会重复已经提交的外部操作。
+持久处理程序记录副作用结果，使中断的工作可以回放已记录的边界。
+
+外部提交若尚未记录结果，重新进入回调时仍需提供方幂等机制或结果核对。
 
 ```ts
 interface DurableContext {
@@ -69,10 +71,34 @@ export default app;
 ## 控制 API
 
 ```ts
-const status = tysel.durable.start("provision", input);
-tysel.durable.sendSignal(status.taskId, "approval", { approved: true });
+const status = tysel.durable.start("provision", input, {
+  idempotencyKey: "tenant-42:provision:request-123",
+});
+tysel.durable.sendSignal(status.taskId, "approval", { approved: true }, {
+  idempotencyKey: "approval-decision-456",
+});
 ```
 
-`start` 返回已完成结果或暂停状态。`sendSignal` 为等待中的工作流追加一个 JSON 信号。
+`start` 在执行处理程序前，原子持久化任务、不可变输入和重启恢复资格。它返回 `completed`、`suspended`，或在其他执行拥有任务、任务已排队或等待时返回 `accepted`。`accepted` 不是暂停确认，也不是终态结果。
+
+可选启动键的作用域是整个持久存储，应按租户与操作划分命名空间。使用相同的完整 bundle 源码、导出名称及规范化 JSON 输入重试同一键，会返回同一任务 ID，不创建替代任务。任一项变化都会导致同键冲突，即使目标处理程序本身没有变化。因此，跨版本部署的 outbox 准入重试需要原始 bundle；更换键会创建新任务，不能修复原始准入。失败任务的同键重试会明确报错。不提供键时，每次调用都是新准入；确认丢失后不能通过再次启动来安全修复。
+
+信号键以任务为作用域，回执与收件箱写入属于同一事务。即使信号已消费或任务已完成，重复相同名称、载荷和键也会确认成功，不追加信号；冲突复用会被拒绝。无键信号保持 FIFO，每次调用都会入队新信号。已完成任务拒绝新信号。每任务最多保留 10,000 条带键信号回执，与待处理收件箱限制独立。
+
+使用独立数据库的应用应在自身事务中持久化 outbox 意图与稳定键，交付不确定时重试完全相同的请求，收到确认后标记已交付。这是可修复协议，**不是应用与运行时数据库之间的跨库事务**。Tysel 不负责运行或清空应用 outbox。准入与信号去重持续到显式 `prune` 删除已完成任务；任务保留期应长于应用重试窗口，清理后不要复用键。
+
+## 活跃任务崩溃恢复
+
+服务调度器独立于唤醒记录持久化执行租约。进程死亡后，符合条件的任务会在租约到期后被重新认领，并使用原始源码与历史恢复。已记录的 effect 返回记录结果；尚未记录结果就中断的 effect 会重新进入。再次写入前，应使用相同的提供方操作键或核对已有结果。
+
+执行代次和唯一所有者令牌会拒绝过期执行者的历史、暂停及完成写入，但无法阻止外部提供方已在处理的请求。租约为请求超时加调度余量，因此恢复不是即时的。待完成结果的写入重试也受租约约束：过期句柄会被丢弃且不停止服务，原始托管任务重新获得正常的受租约保护的恢复资格。
+
+持久边界上的存储失败会使当前执行失效，即使处理程序捕获 JavaScript 异常也如此。运行时会保留存储错误与重启资格，不会提交回退结果。存储恢复且租约到期后会回放原始历史。普通处理程序异常、任务边界校验或限额错误只使该任务失败，不停止调度器。失去执行权限会放弃过期尝试，不停止其他任务。
+
+完成会释放活跃配额，同时保留程序、历史和回执。具有持久唤醒记录的旧 v1/v2 任务可在恢复时进入托管生命周期。既无唤醒记录也无执行记录的旧孤儿任务不会被猜测为可运行；再次发起外部写入前应调查。低层调用者持有的 Rust session 和内存注册表仍使用调用者管理的生命周期。
+
+使用 [`tysel durable result` 与 `tysel durable prune`](/reference/cli/tasks#tysel-durable) 读取保留结果或移除一批旧数据。不能因缺少唤醒记录就推断失败或旧任务已完成。
+
+持久输入和结果上限为 1 MiB，其他历史、信号及程序限制见[限制与默认值](/reference/limits-and-defaults)。
 
-持久输入和结果限制为 1 MiB；其他历史、信号和程序边界列在[限额与默认值](/reference/limits-and-defaults)中。修改存在运行中实例的处理程序之前，请阅读[持久执行](/docs/concepts/durable-execution)。
+更改仍有运行中实例的处理程序前，请阅读[持久执行](/docs/concepts/durable-execution)。
diff --git a/website/locales/zh-CN/content/reference/runtime/types.mdx b/website/locales/zh-CN/content/reference/runtime/types.mdx
index c88e521..5939e58 100644
--- a/website/locales/zh-CN/content/reference/runtime/types.mdx
+++ b/website/locales/zh-CN/content/reference/runtime/types.mdx
@@ -110,7 +110,7 @@ interface LlmResponse<Output = JsonValue> {
 | 执行 | `ExecutionProfile`、`TrustMode`、`CapabilityRequirement`、`RequestContext` | [执行与信任](#execution-and-trust) |
 | 应用 | `FetchHandler`、`RuntimeFetchHandler`、`CronTask`、`QueueTask`、`McpInputType`、`McpInputSchema`、`InferMcpInput`、`McpTask`、`AppTask`、`TyselApp` | [应用模块](/reference/runtime/application) |
 | 持久处理程序 | `DurableHandler`、`DurableDuration`、`DurableRetryPolicy`、`DurableContext`、`DurableHost` | [持久 API](/reference/runtime/durable) |
-| 持久控制 | `DurableSuspendedResult`、`DurableCompletedResult`、`DurableStartResult`、`DurableControlClient` | [持久控制](/reference/runtime/durable#control-api) |
+| 持久控制 | `DurableRequestOptions`、`DurableAcceptedResult`、`DurableSuspendedResult`、`DurableCompletedResult`、`DurableStartResult`、`DurableControlClient` | [持久控制](/reference/runtime/durable#control-api) |
 | SQL 与文件 | `SqlParameter`、`SqlRow`、`SqlClient`、`FileSystemClient` | [宿主能力](/reference/runtime/capabilities) |
 | Redis | `RedisSetOptions`、`RedisClient` | [Redis](/reference/runtime/capabilities#redis) |
 | 密钥 | `SecretReference`、`SecretClient` | [密钥](/reference/runtime/capabilities#secrets) |
diff --git a/website/locales/zh-CN/manifest.json b/website/locales/zh-CN/manifest.json
index e1c7d46..93501e6 100644
--- a/website/locales/zh-CN/manifest.json
+++ b/website/locales/zh-CN/manifest.json
@@ -2074,13 +2074,13 @@
       "status": "reviewed"
     },
     "reference/cli/index.mdx": {
-      "sourceHash": "4aa3fab1c41a0694c91e4c01bc3ac9de2691026f286771a41e16d6eec90a368e",
-      "translationHash": "d550cbe29d988f8dada09d8c1b5faec83b6cf2f3f75b2ec47b785ae93a12bbb6",
+      "sourceHash": "47ae0ba133d49252ec77b27c3624710500cde9276d7b13e20ba78dc9b7dde518",
+      "translationHash": "89464720ca22aceb6b7e981f8e7bebf159b8d37e24d5ed1631b52e1eee79a96f",
       "status": "reviewed"
     },
     "reference/cli/installation.mdx": {
-      "sourceHash": "d59cb6740c462e65a3603bb3339faef2de2b9f42d56f783a1bd1bfda4a5c7ba6",
-      "translationHash": "126716cdee67cf67885e89fe548ab857559c89d18ada41234e864396fd27db02",
+      "sourceHash": "9a43b5ea2845677c8e832c887c05b9fc76caea54588996619c3f6d3fb7d20779",
+      "translationHash": "7f78f32e050c9f0e9a7e61d3c6127290e4f0e28d074f322d91962cfd1d9f948a",
       "status": "reviewed"
     },
     "reference/runtime/index.mdx": {
@@ -2099,13 +2099,13 @@
       "status": "reviewed"
     },
     "reference/cli/tasks.mdx": {
-      "sourceHash": "ff5255c0ca17f8bade09a9e7d783ee4e2596e27f1912677ba14b809633d6ec74",
-      "translationHash": "9ce93d245469f5575566963175bb60417598215846eac543f578a9da021db92c",
+      "sourceHash": "f7978a24b391190f48948c02d5a13d0c0d572a3b3ad6ab6501538fa922a91e09",
+      "translationHash": "1a0806aab45bc4675b4928edcd4a9e0927fb22c6b75d7a455e18e440b7a86f48",
       "status": "reviewed"
     },
     "docs/concepts/durable-execution.mdx": {
-      "sourceHash": "2e68a5f95eeebce606127e40dec9725e5e49b74f2a82e3d1b04690cb26d12b8b",
-      "translationHash": "e7b15ae198604e28fa0b1ab59ca6447ffda3d2de1d7d8089b27d4361d2b5d525",
+      "sourceHash": "9cec62c820248302469e7a5d8486c7f5a87852d148735262294098c893c82294",
+      "translationHash": "f729e74eed53de89aa12ee014ec691a39d7609abac92fae3c6eea703207af077",
       "status": "reviewed"
     },
     "docs/concepts/execution-profiles.mdx": {
@@ -2159,8 +2159,8 @@
       "status": "reviewed"
     },
     "reference/component/rust-sdk.mdx": {
-      "sourceHash": "af7df701c4d0ec207e023c11d8d67f84f48b55a053aa35718d273d0d6dcfd7cd",
-      "translationHash": "a6386b032b302697b156ff1daad1272dfffcbc25db4e3c5a87b84c4f5dfd2143",
+      "sourceHash": "8009128a6bee9e2fd77dfe8402cc45bde999ae353585ec68d6ba0a5df510e215",
+      "translationHash": "af2839f0982c6539708f443b0225ea8b7f5df27a89ce3871ffe53991ccf65991",
       "status": "reviewed"
     },
     "reference/manifest/durable-observability.mdx": {
@@ -2169,8 +2169,8 @@
       "status": "reviewed"
     },
     "reference/manifest/limits.mdx": {
-      "sourceHash": "3bfa8de2deef27e1572ae1ab01d136b406891a77d55e88ae111619ea1f839559",
-      "translationHash": "d50eb2af1b750a5c887779e720eecadb8a1800f40eade2d4b4c7aa3df38a83eb",
+      "sourceHash": "bc38e5c92eeba14a2ca3a94016530e5447bcfa6b3b9d85b261c925b4f3691bfe",
+      "translationHash": "ca3b4c46fc34680e37cdfdf390d59248a555dc94b658f46aef847fbb859197c0",
       "status": "reviewed"
     },
     "reference/manifest/tasks.mdx": {
@@ -2214,13 +2214,13 @@
       "status": "reviewed"
     },
     "reference/limits-and-defaults.mdx": {
-      "sourceHash": "392aa2c7ff52202c7cdd2a658608c1aceacea093b36192c28118bbf12e9ebf7f",
-      "translationHash": "ce294f87a1aa7d02706216475d24b1d494194352212548ea0e91421ba68d40fd",
+      "sourceHash": "951c391759a22096f12d0a65d9764609fa2157a7a49d251c3bdc7840d96e3091",
+      "translationHash": "0f5df081759e031e2f80fb14cbbfc7080da36f60052faac97b35de559db9dbfd",
       "status": "reviewed"
     },
     "reference/runtime/durable.mdx": {
-      "sourceHash": "4835cf1fb7d275ff25c03c3c306fea62235a9d1e7f7505f27f8d3a02073ef8ec",
-      "translationHash": "395f6d2c417078f720458775359a80eabfa7512e1b36d2e7fbab5465a4618a8e",
+      "sourceHash": "85fdc5a321d48ae8ab5de745f0d5121dd591db1fff25fd20fa61baca765faec7",
+      "translationHash": "5e4e58ed5091316bae8e42f69e9d57a46045759833dd737c717955145b0e4080",
       "status": "reviewed"
     },
     "reference/runtime/testing.mdx": {
@@ -2234,13 +2234,13 @@
       "status": "reviewed"
     },
     "reference/runtime/types.mdx": {
-      "sourceHash": "1cf8061857b9806f84ecc68c2ebcca590bdc150d1965f48bbbdb5fe1c61dd4cf",
-      "translationHash": "e9d0be559d9f905bd10eb0a8c7d6cce8a53424fe296f71cc35c134d9e7823ce7",
+      "sourceHash": "28c60162cbcd2489576ac5b2f2ca3a3e1ec6d466c0d0cab554e6722c94ad2c8b",
+      "translationHash": "1a2a09de75bc0d3e03d54f0140092ba64d60e1dd9e5737ff05a8a21a4bae1597",
       "status": "reviewed"
     },
     "reference/errors-and-output.mdx": {
-      "sourceHash": "b4c0f1849252797359fc17b91bb62a9d0c0a1c6621d882f03a2e28949861f150",
-      "translationHash": "6703555343b4b012af239d5c6753555cdb99a72ecbbdc59d3532ae98869bf217",
+      "sourceHash": "f9aa1cf2c38fd09657a70bc67135a39379337ca35fcb37f2446bd76ebb23b64a",
+      "translationHash": "9d1895380ec7313941825e0fab6033a9b375d6e860e802b6b0cb3efbc6c14c2b",
       "status": "reviewed"
     },
     "reference/runtime/application.mdx": {
@@ -2259,13 +2259,13 @@
       "status": "reviewed"
     },
     "docs/guides/wasm-component-rust.mdx": {
-      "sourceHash": "bdf1470ad9de6928f8180a9808e3fc36216449060dc0cfba85f316cf94dfe8d0",
-      "translationHash": "a731ebb7bc37162dcfcc2f7f8ff77920d488dcc1e8e04ef5603a12c2948ec2f9",
+      "sourceHash": "48b7fdb01d7f79599d8350a60990dc1692e7c6a733915a89820049ca543f2609",
+      "translationHash": "62beb555b2bb9643714a6196d01db05a2d79069bb500f97c35deb91a3f9aa4f2",
       "status": "reviewed"
     },
     "docs/guides/concurrency-backpressure.mdx": {
-      "sourceHash": "de69dabd5700e284947ed5dd91935f1e02c9062247244a302ed2e05ca6b8e782",
-      "translationHash": "490a0aeffc261282742e9671a289608f249e8761c41aa0fe6dd5b077f38f726a",
+      "sourceHash": "7d08839c4fa8ca52ecf82b3bbd3441e89d7e14d97753bd3aaceb0b26507e7d36",
+      "translationHash": "46d0ce2c6a352b0d3d455b0c6a3b746cb2e1b2fb5f2381e16d4eb49a1324a3f8",
       "status": "reviewed"
     },
     "docs/guides/cron-queue.mdx": {
@@ -2349,8 +2349,8 @@
       "status": "reviewed"
     },
     "docs/operations/production.mdx": {
-      "sourceHash": "641b9cbc094cd04e82334f8b7a707e6234eee599fc9e8e2ba9e5a7325628a733",
-      "translationHash": "31ecfd97d5004432ce8874cded686af7215c4c97a6d77a12b928eb505e4b912e",
+      "sourceHash": "59d5859749ac8ea0dfdbf51ad0b472740bcf3acfd51a8c3ed5dea115789e5e45",
+      "translationHash": "b3e5da0aaa2764ed4914d9d7451398d34d1e4024bcd6b021bbc293d227cb6c2c",
       "status": "reviewed"
     },
     "blog/durable-execution-recovery-semantics.mdx": {

From 484b2a71747212cb9c8b4b914f10369514b8beab Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Wed, 9 Sep 2026 16:29:49 +0800
Subject: [PATCH 30/31] chore(release): maintain changelog and validate release
 notes

---
 .github/scripts/release-notes.py      | 78 +++++++++++++++++++++++++
 .github/scripts/test-release-notes.py | 81 ++++++++++++++++++++++++++
 .github/workflows/ci.yml              |  4 ++
 .github/workflows/release.yml         | 24 +++++++-
 CHANGELOG.md                          | 84 +++++++++++++++++++++++++++
 README.md                             |  1 +
 6 files changed, 271 insertions(+), 1 deletion(-)
 create mode 100644 .github/scripts/release-notes.py
 create mode 100644 .github/scripts/test-release-notes.py
 create mode 100644 CHANGELOG.md

diff --git a/.github/scripts/release-notes.py b/.github/scripts/release-notes.py
new file mode 100644
index 0000000..772769d
--- /dev/null
+++ b/.github/scripts/release-notes.py
@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Extract one version's release body from the repository changelog."""
+import argparse
+from datetime import date
+import json
+from pathlib import Path
+import re
+import sys
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def version_headings(text):
+    headings = []
+    fence = None
+    offset = 0
+    for line in text.splitlines(keepends=True):
+        marker = re.fullmatch(r" {0,3}(`{3,}|~{3,})([^\n]*)\n?", line)
+        if fence:
+            if (marker and marker[1][0] == fence[0]
+                    and len(marker[1]) >= len(fence) and not marker[2].strip()):
+                fence = None
+        elif marker and (marker[1][0] == "~" or "`" not in marker[2]):
+            fence = marker[1]
+        else:
+            heading = re.fullmatch(r"## (.+?)\s*", line)
+            if heading:
+                headings.append((heading[1], offset, offset + len(line)))
+        offset += len(line)
+    if fence:
+        raise ValueError("unclosed changelog code fence")
+    return headings
+
+
+def extract(text, version, require_date=False):
+    if not re.fullmatch(r"[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?", version):
+        raise ValueError("expected an unprefixed release version")
+    text = text.replace("\r\n", "\n")
+    headings = version_headings(text)
+    matches = [i for i, h in enumerate(headings)
+               if re.fullmatch(r"\[" + re.escape(version) + r"\](?: - .+)?", h[0])]
+    if len(matches) != 1:
+        raise ValueError(f"expected exactly one changelog section for {version}")
+    i = matches[0]
+    if require_date:
+        dated = re.fullmatch(r"\[" + re.escape(version) + r"\] - (\d{4}-\d{2}-\d{2})", headings[i][0])
+        if not dated:
+            raise ValueError(f"release {version} requires a YYYY-MM-DD date, not a draft status")
+        try:
+            date.fromisoformat(dated[1])
+        except ValueError:
+            raise ValueError(f"invalid release date for {version}: {dated[1]}") from None
+    end = headings[i + 1][1] if i + 1 < len(headings) else len(text)
+    body = text[headings[i][2]:end].strip()
+    if not any(line.strip() and not line.lstrip().startswith('#') for line in body.splitlines()):
+        raise ValueError(f"empty changelog section for {version}")
+    return body + "\n"
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("version", nargs="?")
+    parser.add_argument("--changelog", type=Path, default=ROOT / "CHANGELOG.md")
+    parser.add_argument("--release-tag", help="require the matching vVERSION tag and a valid release date")
+    args = parser.parse_args()
+    version = args.version or json.loads((ROOT / "packages/tysel/package.json").read_text())["version"]
+    try:
+        if args.release_tag is not None and args.release_tag != f"v{version}":
+            raise ValueError(f"release tag {args.release_tag} does not match version {version}")
+        notes = extract(args.changelog.read_text(encoding="utf-8"), version,
+                        require_date=args.release_tag is not None)
+    except (OSError, ValueError) as error:
+        parser.exit(1, f"release notes: {error}\n")
+    sys.stdout.write(notes)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.github/scripts/test-release-notes.py b/.github/scripts/test-release-notes.py
new file mode 100644
index 0000000..9eb39b8
--- /dev/null
+++ b/.github/scripts/test-release-notes.py
@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+import importlib.util
+from pathlib import Path
+import unittest
+import subprocess
+import sys
+import tempfile
+
+spec = importlib.util.spec_from_file_location("release_notes", Path(__file__).with_name("release-notes.py"))
+notes = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(notes)
+
+
+class ReleaseNotesTests(unittest.TestCase):
+    def test_exact_version_and_boundaries(self):
+        text = "# Changelog\n\n## [Unreleased]\nFuture\n\n## [0.3.0] - Unreleased\n\n### Fixed\n- Recovery.\n\n## [0.2.0]\nOld\n"
+        self.assertEqual(notes.extract(text, "0.3.0"), "### Fixed\n- Recovery.\n")
+        self.assertEqual(notes.extract(text, "0.2.0"), "Old\n")
+
+    def test_prerelease_is_not_stable(self):
+        text = "## [0.3.0-rc.1]\nPreview\n## [0.3.0]\nStable\n"
+        self.assertEqual(notes.extract(text, "0.3.0-rc.1"), "Preview\n")
+        self.assertEqual(notes.extract(text, "0.3.0"), "Stable\n")
+
+    def test_fenced_headings_preserve_migration_steps(self):
+        for opening, interior, closing in [
+            ("```markdown", "## Example heading", "```"),
+            ("~~~~markdown", "## [0.3.0]\n~~~\n## More examples", "~~~~"),
+            ("  ````", "```\n## [0.2.0]", "  `````"),
+        ]:
+            body = f"### Migration\n{opening}\n{interior}\n{closing}\n- Required migration step.\n"
+            text = f"## [0.3.0] - 2026-09-09\n{body}\n## [0.2.0]\nOld\n"
+            with self.subTest(opening=opening):
+                self.assertEqual(notes.extract(text, "0.3.0", require_date=True), body)
+                self.assertEqual(notes.extract(text.replace("\n", "\r\n"), "0.3.0"), body)
+        with self.assertRaisesRegex(ValueError, "unclosed"):
+            notes.extract("## [0.3.0]\n```\n## Example\n", "0.3.0")
+
+    def test_release_dates(self):
+        for suffix in ["", " - Unreleased", " - Unpublished draft", " - 2026-02-29", " - 2026-13-01", " - 2026-9-09"]:
+            text = f"## [0.3.0]{suffix}\n- Changes.\n"
+            with self.subTest(suffix=suffix):
+                self.assertEqual(notes.extract(text, "0.3.0"), "- Changes.\n")
+                with self.assertRaises(ValueError):
+                    notes.extract(text, "0.3.0", require_date=True)
+        for version in ["0.3.0", "0.3.0-rc.1"]:
+            self.assertEqual(notes.extract(f"## [{version}] - 2024-02-29\n- Changes.\n", version, require_date=True), "- Changes.\n")
+
+    def test_cli_release_mode(self):
+        script = str(Path(__file__).with_name("release-notes.py").resolve())
+        with tempfile.TemporaryDirectory() as folder:
+            changelog = Path(folder) / "CHANGELOG.md"
+            for status, tag, succeeds in [
+                ("Unreleased", None, True),
+                ("Unreleased", "v0.3.0", False),
+                ("2026-09-09", "v0.3.0", True),
+                ("2026-09-09", "v0.2.0", False),
+                ("2026-02-30", "v0.3.0", False),
+            ]:
+                changelog.write_text(f"## [0.3.0] - {status}\n- Changes.\n")
+                command = [sys.executable, script, "0.3.0", "--changelog", str(changelog)]
+                if tag:
+                    command += ["--release-tag", tag]
+                result = subprocess.run(command, capture_output=True, text=True)
+                with self.subTest(status=status, tag=tag):
+                    self.assertEqual(result.returncode == 0, succeeds, result.stderr)
+                    self.assertEqual(result.stdout, "- Changes.\n" if succeeds else "")
+
+    def test_missing_duplicate_empty_and_invalid_fail(self):
+        for text, version in [
+            ("## [0.2.0]\nOld", "0.3.0"),
+            ("## [0.3.0]\nA\n## [0.3.0] - Today\nB", "0.3.0"),
+            ("## [0.3.0]\n\n### Fixed\n", "0.3.0"),
+            ("## [0.3.0]\nValid", "v0.3.0"),
+        ]:
+            with self.subTest(text=text, version=version), self.assertRaises(ValueError):
+                notes.extract(text, version)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 3cff632..fae8380 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -35,6 +35,10 @@ jobs:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
         with:
           fetch-depth: 0
+      - name: Validate release notes
+        run: |
+          python3 .github/scripts/test-release-notes.py
+          python3 .github/scripts/release-notes.py > /dev/null
       - name: Classify changed files
         id: classify
         shell: bash
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 3d8f2e3..7a6ef6a 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -22,7 +22,22 @@ env:
   TYSEL_TOOLCHAIN_IMAGE: ghcr.io/wangcch/tysel-toolchain
 
 jobs:
+  release-notes:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+      - name: Validate changelog before building release artifacts
+        run: |
+          python3 .github/scripts/test-release-notes.py
+          args=()
+          if [[ "$GITHUB_REF_TYPE" == tag ]]; then
+            args+=(--release-tag "$GITHUB_REF_NAME")
+          fi
+          python3 .github/scripts/release-notes.py "${args[@]}" > /dev/null
+
   policy:
+    needs: release-notes
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
@@ -100,6 +115,7 @@ jobs:
           if-no-files-found: error
 
   package-npm:
+    needs: release-notes
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
@@ -124,6 +140,7 @@ jobs:
           if-no-files-found: error
 
   package-rust-sdk:
+    needs: release-notes
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
@@ -139,6 +156,7 @@ jobs:
           if-no-files-found: error
 
   package-component-starters:
+    needs: release-notes
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
@@ -186,6 +204,7 @@ jobs:
           if-no-files-found: error
 
   build-linux:
+    needs: release-notes
     strategy:
       fail-fast: false
       matrix:
@@ -260,6 +279,7 @@ jobs:
           if-no-files-found: error
 
   build-darwin:
+    needs: release-notes
     strategy:
       fail-fast: false
       matrix:
@@ -543,13 +563,15 @@ jobs:
           version="$(bash .github/scripts/check-version-sync.sh)"
           channel="$(bash .github/scripts/release-channel.sh "$version")"
           bash .github/scripts/verify-release-assets.sh target/publish "$version"
+          python3 .github/scripts/release-notes.py "$version" --release-tag "$GITHUB_REF_NAME" > target/release-notes.md
           if gh release view "$GITHUB_REF_NAME" --json isDraft > target/release-state.json 2>/dev/null; then
             jq -e '.isDraft == true' target/release-state.json > /dev/null || {
               echo "release is already public and immutable" >&2
               exit 1
             }
+            gh release edit "$GITHUB_REF_NAME" --notes-file target/release-notes.md
           else
-            release_flags=(--draft --verify-tag --generate-notes)
+            release_flags=(--draft --verify-tag --notes-file target/release-notes.md)
             [[ "$channel" == stable ]] || release_flags+=(--prerelease)
             gh release create "$GITHUB_REF_NAME" "${release_flags[@]}"
           fi
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..f9bbef5
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,84 @@
+# Changelog
+
+User-visible changes are recorded here. Release notes reuse the matching version
+section; detailed contracts and procedures remain in the linked documentation.
+Use an exact version heading (including any prerelease suffix), and replace
+`Unreleased` with the release date before tagging. Keep entries focused on user
+impact rather than individual commits. PR checks allow `Unreleased`; tag releases
+require a matching version and a valid date before artifact builds start.
+
+## [0.3.0] - 2026-09-09
+
+### Upgrade notes
+
+- Durable stores migrate from log v1/v2 to v3 on open. Stop old writers and back
+  up the complete store first; rollback requires the pre-upgrade snapshot and
+  matching runtime. Legacy tasks without wakeup or execution records are not
+  automatically recovered. See the [upgrade procedure](https://tysel.dev/docs/operations/production#durable-log-v3-upgrade).
+- External writes still need provider idempotency or reconciliation. Applications
+  own outbox delivery: admission retries require the original bundle, and completed
+  tasks must be retained beyond the retry horizon because pruning removes deduplication
+  records. See the [durable contract](https://tysel.dev/reference/runtime/durable).
+
+### Added and fixed
+
+- Recover active durable tasks after process death and preserve recovery across
+  hot reload, with execution fencing and retries for temporary completion-storage failures.
+- Add stable idempotency keys for durable admission and signals, plus retained
+  results and cleanup through `tysel durable result` and `tysel durable prune`.
+- Add Streams, `TextEncoder.encodeInto`, `TextEncoderStream`, body `bytes()` helpers,
+  `Response.error()` and `Response.redirect()`; fix HTTP body byte preservation,
+  URL path handling and malformed query decoding.
+- Add guided project setup, automatic manifest-type synchronization during
+  development, and structured diagnostics for manifest and import errors.
+- Include queue time and body consumption in HTTP deadlines, and drain connections
+  during shutdown.
+- Add reviewed Chinese documentation and localized website navigation.
+- Fix promise retention during stream backpressure.
+
+### Performance
+
+- Cache durable export metadata per source revision and wake the local scheduler
+  after signal commits, while retaining periodic polling for recovery and other instances.
+
+## [0.2.0] - 2026-09-04
+
+- Added verified cross-target packaging for Linux and macOS on x64 and arm64,
+  with authenticated runtime downloads and offline reuse of verified cached
+  runtimes. Cross-target builds require a managed installation and trust policy.
+- Published Linux toolchain images and hardened `tysel image` handling of
+  existing binaries, release sidecars and generated container metadata.
+- Added `tysel test --filter` and `--list`, including machine-readable discovery
+  and exact test-ID selection.
+- Added source-mapped development diagnostic events and improved installer
+  feedback and the development server's displayed URL.
+- Upgraded QuickJS-NG to 0.16.2.
+
+[Release](https://github.com/wangcch/tysel/releases/tag/v0.2.0) ·
+[Changes since 0.1.1](https://github.com/wangcch/tysel/compare/v0.1.1...v0.2.0)
+
+## [0.1.1] - 2026-09-02
+
+- Corrected TypeScript SDK publication to the scoped `@tysel/sdk` package.
+- Made registry publication recoverable after partial release failures.
+
+[Release](https://github.com/wangcch/tysel/releases/tag/v0.1.1) ·
+[Changes since 0.1.0](https://github.com/wangcch/tysel/compare/v0.1.0...v0.1.1)
+
+## [0.1.0] - Unpublished draft
+
+The tag exists, but its GitHub Release remains a draft with no publication date.
+This section records the tagged baseline, not a completed public release.
+
+- Introduced native packaging of TypeScript applications as a single executable,
+  with host-platform builds and a Web-API-first runtime.
+- Provided HTTP services, cron and queue workers, MCP tools and explicit host
+  capability configuration.
+- Added durable steps, effects, sleeps, retries and signal waits with persisted
+  boundary history. Active-execution crash recovery was not guaranteed; the
+  recovery and admission fixes are recorded under 0.3.0.
+- Included experimental Rust and Go Wasm Component tasks with bounded execution.
+- Provided project setup, development, testing, compatibility checks and signed
+  release verification tooling.
+
+[Tagged source](https://github.com/wangcch/tysel/tree/v0.1.0)
diff --git a/README.md b/README.md
index 64f63ba..6ec7cb3 100644
--- a/README.md
+++ b/README.md
@@ -19,6 +19,7 @@
   <a href="docs/getting-started.md">Get started</a> ·
   <a href="docs/guides/examples.md">Examples</a> ·
   <a href="docs/index.md">Documentation</a> ·
+  <a href="CHANGELOG.md">Changelog</a> ·
   <a href="docs/security/README.md">Security</a>
 </p>
 

From 2aaffcaa9a548cdf728898640e8a5844aacc3007 Mon Sep 17 00:00:00 2001
From: wangcch <wangcch.cc@gmail.com>
Date: Wed, 9 Sep 2026 16:57:30 +0800
Subject: [PATCH 31/31] test(cli): wait for worker exit before asserting
 recovery

---
 crates/tysel-cli/tests/examples.rs | 35 ++++++++++++++++++++++++++++--
 1 file changed, 33 insertions(+), 2 deletions(-)

diff --git a/crates/tysel-cli/tests/examples.rs b/crates/tysel-cli/tests/examples.rs
index c89176a..51c1648 100644
--- a/crates/tysel-cli/tests/examples.rs
+++ b/crates/tysel-cli/tests/examples.rs
@@ -25,7 +25,7 @@ fn isolated_plugin_enforces_profile_and_recovers() {
             .stderr(Stdio::piped()),
         "isolated plugin example",
     );
-    let (addr, _log) = wait_listen(&mut child, Duration::from_secs(8));
+    let (addr, log) = wait_listen(&mut child, Duration::from_secs(8));
 
     let (status, root) = http_json(&addr, "/");
     assert_eq!(status, 200);
@@ -51,9 +51,18 @@ fn isolated_plugin_enforces_profile_and_recovers() {
         .status()
         .expect("kill isolated worker");
     assert!(status.success());
+    // Signal delivery is asynchronous. A request racing worker exit can fail
+    // with an uncertain outcome and must not be transparently replayed. This
+    // test checks recovery after confirmed exit; supervisor tests cover the race.
+    wait_for_worker_exit(original, Duration::from_secs(5));
 
     let (status, recovered) = http_json(&addr, "/");
-    assert_eq!(status, 200, "worker did not recover: {recovered}");
+    assert_eq!(
+        status,
+        200,
+        "worker did not recover: {recovered}; logs: {}",
+        log.lock().expect("captured service log")
+    );
     assert_eq!(recovered["plugin"], "echo");
     let replacement = wait_for_worker(child.id(), Some(original), Duration::from_secs(5));
     assert_ne!(replacement, original);
@@ -174,6 +183,28 @@ fn wait_for_worker(parent: u32, exclude: Option<u32>, timeout: Duration) -> u32
     panic!("timed out waiting for tysel-worker child of {parent}");
 }
 
+fn wait_for_worker_exit(pid: u32, timeout: Duration) {
+    let started = Instant::now();
+    loop {
+        let output = Command::new("ps")
+            .args(["-p", &pid.to_string(), "-o", "stat="])
+            .output()
+            .expect("inspect killed worker");
+        assert!(
+            output.status.success() || output.status.code() == Some(1),
+            "ps failed: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        let state = String::from_utf8_lossy(&output.stdout);
+        // A zombie has exited and can be reaped by the supervisor's try_wait.
+        if state.trim().is_empty() || state.trim_start().starts_with('Z') {
+            return;
+        }
+        assert!(started.elapsed() < timeout, "worker {pid} did not exit: {state}");
+        thread::sleep(Duration::from_millis(5));
+    }
+}
+
 fn worker_children(parent: u32) -> Vec<u32> {
     let output =
         Command::new("ps").args(["-axo", "pid=,ppid=,comm="]).output().expect("list processes");