refactor(truapi-codegen): use writedoc!/formatdoc! in host_callbacks emitter

The new TS HostCallbacks emitter from #18 hand-chained 15 writeln! calls
to build the output. CLAUDE.md (this commit also) now requires codegen
modules to prefer indoc::writedoc! / formatdoc! over writeln! chains so
the emitted shape stays visible in source.

Switched host_callbacks.rs to:
- writedoc! for the header + import block (two multi-line writes)
- formatdoc! returning strings for trait interfaces, methods, and the
  super-interface; the parent function joins them
- render_jsdoc returns a String instead of writing through a sink

writeln! count: 15 → 2 (both inside writedoc! invocations themselves).
Golden test rebuilt clean; workspace tests all pass.

Author: pgherveou

CLAUDE.md

@@ -55,6 +55,7 @@ scripts/codegen.sh         regenerate the TS client from the Rust crate
 - In Rust format strings, prefer inlined variables: `"log value: {value:?}"` over `"log value: {:?}", value`.
 - Don't introduce typealias chains that just rename a public type from another crate (e.g. `pub type StorageError = crate::v01::HostLocalStorageReadError`). Use the canonical name directly. A typealias is only worth its indirection when it captures a real abstraction.
 - After any code change, update `README.md` (and CLAUDE.md if the layout changed) so the top-level docs reflect what the repo actually contains. Stale docs are a regression.
+- In codegen emitters, prefer `indoc::writedoc!` / `formatdoc!` over chains of `writeln!`. A single `writedoc!` with a multi-line raw string keeps the emitted shape visible in source instead of fragmenting it across one-line `writeln!` calls. Reserve `writeln!` for the genuinely-one-line case (a single import, a single statement inside a loop).
 
 ## First-time setup
 

rust/crates/truapi-codegen/src/ts/host_callbacks.rs

@@ -13,6 +13,7 @@ use std::fs;
 use std::path::Path;
 
 use anyhow::{Result, bail};
+use indoc::{formatdoc, writedoc};
 
 use crate::platform::{
     PlatformDefinition, PlatformInner, PlatformMethod, PlatformReturn, PlatformTrait,
@@ -29,62 +30,78 @@ pub fn generate(definition: &PlatformDefinition, output_dir: &str) -> Result<()>
 
 fn emit_host_callbacks(definition: &PlatformDefinition) -> Result<String> {
     let mut out = String::new();
-    writeln!(
+    writedoc!(
         out,
-        "// Auto-generated by truapi-codegen. Do not edit.\n//\n\
-        // Typed host-callbacks surface derived from the `truapi-platform`\n\
-        // capability traits. One interface per Rust trait + a composite\n\
-        // `HostCallbacks` interface that mirrors the `Platform` super-trait.\n"
+        r#"
+        // Auto-generated by truapi-codegen. Do not edit.
+        //
+        // Typed host-callbacks surface derived from the `truapi-platform`
+        // capability traits. One interface per Rust trait + a composite
+        // `HostCallbacks` interface that mirrors the `Platform` super-trait.
+
+        "#,
     )
     .unwrap();
 
     let imports = collect_named_types(definition);
     if !imports.is_empty() {
-        writeln!(out, "import type {{").unwrap();
-        for name in &imports {
-            writeln!(out, "  {name},").unwrap();
-        }
-        writeln!(out, "}} from \"@parity/truapi\";\n").unwrap();
+        let entries = imports
+            .iter()
+            .map(|name| format!("  {name},"))
+            .collect::<Vec<_>>()
+            .join("\n");
+        writedoc!(
+            out,
+            r#"
+            import type {{
+            {entries}
+            }} from "@parity/truapi";
+
+            "#,
+        )
+        .unwrap();
     }
 
     for trait_def in &definition.traits {
-        emit_trait_interface(&mut out, trait_def)?;
-        writeln!(out).unwrap();
+        out.push_str(&emit_trait_interface(trait_def)?);
+        out.push('\n');
     }
 
     // The Rust super-trait `Platform` becomes `HostCallbacks` on the TS
     // surface: that is the name every host implementer reaches for, and
     // it stays stable even if the Rust trait is renamed.
-    if let Some(super_trait) = &definition.super_trait {
-        emit_super_interface(
-            &mut out,
-            "HostCallbacks",
-            &super_trait.composes,
-            super_trait.docs.as_deref(),
-        );
-    } else {
-        let names: Vec<String> = definition.traits.iter().map(|t| t.name.clone()).collect();
-        emit_super_interface(&mut out, "HostCallbacks", &names, None);
-    }
+    let (composes, docs): (Vec<String>, Option<&str>) = match &definition.super_trait {
+        Some(s) => (s.composes.clone(), s.docs.as_deref()),
+        None => (
+            definition.traits.iter().map(|t| t.name.clone()).collect(),
+            None,
+        ),
+    };
+    out.push_str(&emit_super_interface("HostCallbacks", &composes, docs));
 
     Ok(out)
 }
 
-fn emit_trait_interface(out: &mut String, trait_def: &PlatformTrait) -> Result<()> {
-    write_jsdoc(out, "", trait_def.docs.as_deref());
-    writeln!(out, "export interface {} {{", trait_def.name).unwrap();
-    for (idx, method) in trait_def.methods.iter().enumerate() {
-        if idx > 0 {
-            writeln!(out).unwrap();
-        }
-        emit_method(out, method)?;
-    }
-    writeln!(out, "}}").unwrap();
-    Ok(())
+fn emit_trait_interface(trait_def: &PlatformTrait) -> Result<String> {
+    let jsdoc = render_jsdoc("", trait_def.docs.as_deref());
+    let body = trait_def
+        .methods
+        .iter()
+        .map(emit_method)
+        .collect::<Result<Vec<_>>>()?
+        .join("\n\n");
+    Ok(formatdoc! {
+        r#"
+        {jsdoc}export interface {name} {{
+        {body}
+        }}
+        "#,
+        name = trait_def.name,
+    })
 }
 
-fn emit_method(out: &mut String, method: &PlatformMethod) -> Result<()> {
-    write_jsdoc(out, "  ", method.docs.as_deref());
+fn emit_method(method: &PlatformMethod) -> Result<String> {
+    let jsdoc = render_jsdoc("  ", method.docs.as_deref());
     let params = method
         .params
         .iter()
@@ -95,18 +112,17 @@ fn emit_method(out: &mut String, method: &PlatformMethod) -> Result<()> {
         .collect::<Result<Vec<_>>>()?
         .join(", ");
     let ret = format_return(&method.return_shape)?;
-    writeln!(out, "  {}({params}): {ret};", to_camel_case(&method.name)).unwrap();
-    Ok(())
+    let name = to_camel_case(&method.name);
+    Ok(format!("{jsdoc}  {name}({params}): {ret};"))
 }
 
-fn emit_super_interface(out: &mut String, name: &str, composes: &[String], docs: Option<&str>) {
-    write_jsdoc(out, "", docs);
+fn emit_super_interface(name: &str, composes: &[String], docs: Option<&str>) -> String {
+    let jsdoc = render_jsdoc("", docs);
     if composes.is_empty() {
-        writeln!(out, "export interface {name} {{}}").unwrap();
-        return;
+        return format!("{jsdoc}export interface {name} {{}}\n");
     }
     let extends = composes.join(", ");
-    writeln!(out, "export interface {name} extends {extends} {{}}").unwrap();
+    format!("{jsdoc}export interface {name} extends {extends} {{}}\n")
 }
 
 fn collect_named_types(definition: &PlatformDefinition) -> BTreeSet<String> {
@@ -213,23 +229,26 @@ fn ts_type(ty: &TypeRef) -> Result<String> {
     }
 }
 
-fn write_jsdoc(out: &mut String, indent: &str, docs: Option<&str>) {
+fn render_jsdoc(indent: &str, docs: Option<&str>) -> String {
     let Some(docs) = docs else {
-        return;
+        return String::new();
     };
     let docs = docs.trim();
     if docs.is_empty() {
-        return;
+        return String::new();
     }
-    writeln!(out, "{indent}/**").unwrap();
-    for line in docs.lines() {
-        if line.is_empty() {
-            writeln!(out, "{indent} *").unwrap();
-        } else {
-            writeln!(out, "{indent} * {line}").unwrap();
-        }
-    }
-    writeln!(out, "{indent} */").unwrap();
+    let body = docs
+        .lines()
+        .map(|line| {
+            if line.is_empty() {
+                format!("{indent} *")
+            } else {
+                format!("{indent} * {line}")
+            }
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!("{indent}/**\n{body}\n{indent} */\n")
 }
 
 fn to_camel_case(name: &str) -> String {