🐛 LSP formatting deletes Astro frontmatter/HTML in multi-project workspaces (html.experimentalFullSupportEnabled)

[affanshahid]

Environment information

Details

CLI:
  Version:                      2.5.6
  Color support:                true

Platform:
  CPU Architecture:             aarch64
  OS:                           macos

Environment:
  BIOME_DISTRIBUTION:                npm
  BIOME_LOG_PATH:                    unset
  BIOME_LOG_PREFIX_NAME:             unset
  BIOME_LOG_LEVEL:                   unset
  BIOME_LOG_KIND:                    unset
  BIOME_CONFIG_PATH:                 unset
  BIOME_THREADS:                     unset
  BIOME_WATCHER_KIND:                unset
  BIOME_WATCHER_POLLING_INTERVAL:    unset
  NO_COLOR:                     unset
  TERM:                         xterm-ghostty
  JS_RUNTIME_VERSION:           v22.22.0
  JS_RUNTIME_NAME:              node
  NODE_PACKAGE_MANAGER:         pnpm/12.0.0-beta.2

Biome Configuration:
  Status:                       Loaded successfully.
  Path:                         biome.json
  Formatter enabled:            true
  Linter enabled:               true
  Assist enabled:               true
  VCS enabled:                  true
  HTML full support enabled:    unset

Workspace:
  Open Documents:               0

What happened?

With html.experimentalFullSupportEnabled: true set on an .astro file's biome.json, a specific sequence of LSP requests makes textDocument/formatting return edits that delete the frontmatter fences and the HTML body.

Repro repo: https://github.com/affanshahid/biome-astro-bug

  git clone https://github.com/affanshahid/biome-astro-bug
  cd biome-astro-bug
  pnpm install

  # Step 1: prove the CLI is unaffected
  pnpm run repro:cli
  # -> formats correctly, fences/HTML survive

  # Step 2: reproduce via the LSP
  pnpm run repro:lsp
  # -> textDocument/formatting returns edits that delete the fences and HTML

The trigger requires two things together:

1. The LSP's workspace root must be a folder under which Biome's own project scan discovers more than one biome.json. A single-project workspace does not trigger it, even with the identical file and edits.

2. This exact sequence on the open document: move the cursor to the end of the file, type a space, undo it, then save (which fires source.fixAll.biome followed by textDocument/formatting). The timing between these steps matters, not just which requests are sent.

Note: AI was used heavily to create the repro scripts but they are based on events captured from my live Zed session then wrapped in a script to run programatically.

Expected result

textDocument/formatting should return the same small whitespace fix the CLI produces (biome format --write), not delete the frontmatter fences and HTML body.

Code of Conduct

• I agree to follow Biome's Code of Conduct

[github-actions]

✅ Organic activity

No automation signals detected in the analyzed events.

View full analysis →

_{This is an automated analysis by AgentScan}

[dyc3]

Thank you. How did you create your reproduction? I'm thinking it could be useful to document.

[affanshahid]

I first tried getting the RPC logs from Zed itself but that was not sufficient to repro the issue programatically (even though it would happen every single time in the editor).

Then I had Claude write a wrapper script that logged every RPC event between the editor and the LSP. I then configured Zed to use this wrapper script as the "LSP" and reproduced the issue on Zed.

After that it was just a matter of asking Claude to create a script that ran the LSP programatically and re-ran the same sequence of events to produce the bug.

Here is the "wiretap" script I used, hope it helps. Let me know if you need anything else.

  #!/usr/bin/env node
  // Transparent stdio wiretap for Biome's LSP.
  //
  // Point an editor's LSP binary override at this script instead of the real
  // `biome` binary. It spawns the real binary (resolved relative to cwd, i.e.
  // wherever the editor launches it from — normally the workspace root) with
  // whatever args were passed through (normally just "lsp-proxy"), and pipes
  // stdin/stdout straight through unmodified — the editor and Biome never
  // notice it's there. Every raw byte in both directions is also appended to
  // a log file with a direction marker and timestamp, so you can see exactly
  // what the editor sends and what Biome replies, instead of guessing.

  import { spawn } from "node:child_process";
  import { appendFileSync } from "node:fs";
  import path from "node:path";

  const REAL_BIOME = path.join(process.cwd(), "node_modules/@biomejs/biome/bin/biome");
  const LOG_PATH = "some/log/path";

  const args = process.argv.slice(2);

  appendFileSync(
    LOG_PATH,
    `\n\n========== NEW SESSION ${new Date().toISOString()} (cwd: ${process.cwd()}, args: ${JSON.stringify(args)}) ==========\n\n`
  );

  const child = spawn(REAL_BIOME, args, {
    cwd: process.cwd(),
    stdio: ["pipe", "pipe", "pipe"],
  });

  function logChunk(direction, chunk) {
    const ts = new Date().toISOString();
    appendFileSync(LOG_PATH, `\n----[${direction} @ ${ts}, ${chunk.length} bytes]----\n`);
    appendFileSync(LOG_PATH, chunk);
  }

  // editor -> us -> real biome
  process.stdin.on("data", (chunk) => {
    logChunk("EDITOR->BIOME", chunk);
    child.stdin.write(chunk);
  });
  process.stdin.on("end", () => child.stdin.end());

  // real biome -> us -> editor
  child.stdout.on("data", (chunk) => {
    logChunk("BIOME->EDITOR", chunk);
    process.stdout.write(chunk);
  });

  // Pass stderr through untouched, but log it too (Biome's own error/panic messages land here).
  child.stderr.on("data", (chunk) => {
    logChunk("BIOME-STDERR", chunk);
    process.stderr.write(chunk);
  });

  child.on("exit", (code, signal) => {
    appendFileSync(LOG_PATH, `\n========== biome exited: code=${code} signal=${signal} ==========\n`);
    process.exit(code ?? 1);
  });

  child.on("error", (err) => {
    appendFileSync(LOG_PATH, `\n========== failed to spawn real biome: ${err} ==========\n`);
    process.exit(1);
  });

  process.on("SIGTERM", () => child.kill("SIGTERM"));
  process.on("SIGINT", () => child.kill("SIGINT"));