Mercury Next Edit — Testing Playground

01 — Finish a recursive function body same-line

def factorial(n):
    if n <= 1:
        return 1

The empty indented line at the end of factorial (column 4).

Ghost text proposing the recursive case (e.g. return n * factorial(n - 1)). Tab accepts.

02 — Pattern continuation same-line

COLOR_RED = "#ff0000"
COLOR_GREEN = "#00ff00"
COLOR_BLUE =

End of line 3 (right after =).

Ghost text appending a hex color like "#0000ff".

03 — Mid-identifier completion same-line

def calculate_total(items):
    total = 0
    for item in items:
        total += item.price
    return tot

End of file (after return tot).

Ghost text completing the identifier (likely al → total).

04 — Loop body inference same-line

def calculate_total(items):
    total = 0
    for item in items:

    return total

The empty indented line inside the for loop (column 8).

Ghost text proposing the accumulator update.

05 — Sibling method body same-line

class Stack:
    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)

    def pop(self):


    def peek(self):
        return self.items[-1] if self.items else None

Empty indented line inside pop (column 8).

Ghost text proposing a body consistent with the symmetric push.

07 — Multi-line rename refactor off-cursor

def compute_user_score(u, w):
    base = u * 10
    bonus = w * 5
    penalty = u - w
    return base + bonus - penalty


def compute_user_score(user_id, weight):
    base = u * 10
    bonus = w * 5
    penalty = u - w
    return base + bonus - penalty

End of the renamed signature line (def compute_user_score(user_id, weight):).

Strikethrough on the body lines below + ghost showing the renamed body. First Tab jumps, second applies.

08 — Mixed insert + replace off-cursor

def sum_prices(items):
    total = 0
    for item in items:
    return total

End of total = 0.

Decoration on the broken for-loop area showing the corrected body (insertion + replacement combined).

10 — Mid-token completion same-line

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)


result = fib

End of the file (after result = fib).

Ghost text extending the identifier and supplying a call, e.g. onacci(10).

11 — Stub method with implemented siblings same-line

class Queue:
    def __init__(self):
        self.items = []

    def enqueue(self, item):
        self.items.append(item)

    def peek(self):
        return self.items[0] if self.items else None

    def size(self):
        return len(self.items)

    def is_empty(self):
        return not self.items

    def dequeue(self):


    def clear(self):
        self.items.clear()

Empty indented line inside dequeue (column 8).

Ghost text proposing a FIFO pop, e.g. return self.items.pop(0).

12 — Type annotation insertion same-line / off-cursor

def multiply(a: int, b: int) -> int:
    return a * b


def subtract(a: int, b: int) -> int:
    return a - b


def add(a, b):
    return a + b

End of def add(a, b): (the only un-annotated function).

Strikethrough on the signature line + ghost showing the typed version (def add(a: int, b: int) -> int:). May render same-line or off-cursor depending on where on the line you clicked.

13 — Docstring generation same-line

import datetime


def parse_iso_datetime(s):
    """Parse an ISO 8601 datetime string into a datetime.datetime."""
    return datetime.datetime.fromisoformat(s)


def parse_iso_date(s):

    return datetime.date.fromisoformat(s)

Empty indented line under def parse_iso_date(s): (column 4).

Ghost text inserting a one-line docstring matching the sibling's style.

14 — No-op suppression suppressed

def add(a: int, b: int) -> int:
    """Return the sum of two integers."""
    return a + b


def multiply(a: int, b: int) -> int:
    """Return the product of two integers."""
    return a * b


def subtract(a: int, b: int) -> int:
    """Return a minus b."""
    return a - b

End of return a + b.

Nothing. The code is already correct — either Mercury returns an identical reply or our suppression branch drops the proposal. Channel should show "no-op" or skip lines, never a render.

Any visible suggestion that just replays the existing code is a false positive worth reporting.

ts_07 — Array transform completion same-line

interface User {
    id: number;
    name: string;
    active: boolean;
}

function getActiveUserNames(users: User[]): string[] {
    return users
}

const sample: User[] = [
    { id: 1, name: "ada", active: true },
    { id: 2, name: "lin", active: false },
    { id: 3, name: "rin", active: true },
];

console.log(getActiveUserNames(sample));

End of return users inside getActiveUserNames.

Ghost text completing the chain, e.g. .filter(u => u.active).map(u => u.name).

ts_08 — Param type annotations off-cursor

function double(x: number): number {
    return x * 2;
}

function add(a, b) {
    return a + b;
}

function negate(x: number): number {
    return -x;
}

function main(): void {
    console.log(double(3));
    console.log(add(2, 4));
    console.log(negate(7));
}

main();

End of file (after main();).

Decoration on the add(a, b) signature proposing the typed version.

ts_09 — React event handler same-line

declare const React: {
    useState: <T>(initial: T) => [T, (next: T) => void];
};

function Counter(): JSX.Element {
    const [count, setCount] = React.useState<number>(0);

    function handleClick() {

    }

    return (
        <div>
            <p>Count: {count}</p>
            <button onClick={handleClick}>Increment</button>
        </div>
    );
}

export default Counter;

Empty indented line inside handleClick (column 4).

Ghost text incrementing count via setCount.

go_07 — Error handling block same-line

package main

import (
	"fmt"
	"os"
)

func loadConfig(path string) ([]byte, error) {
	data, err := os.ReadFile(path)

	return data, nil
}

func main() {
	cfg, err := loadConfig("config.json")
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(string(cfg))
}

Empty line right after data, err := os.ReadFile(path).

Ghost text proposing the canonical if err != nil { return nil, err }.

go_08 — Struct method body same-line

package main

import "fmt"

type Rectangle struct {
	Width  float64
	Height float64
}

func (r Rectangle) Perimeter() float64 {
	return 2 * (r.Width + r.Height)
}

func (r Rectangle) Area() float64 {

}

func main() {
	r := Rectangle{Width: 3, Height: 4}
	fmt.Println("perimeter:", r.Perimeter())
	fmt.Println("area:", r.Area())
}

Empty indented line inside Area().

Ghost text computing area from Width and Height.

go_09 — Goroutine + channel same-line

package main

import "fmt"

func main() {
	ch := make(chan int)

	go func() {

	}()

	for v := range ch {
		fmt.Println("got:", v)
	}
}

Empty indented line inside the goroutine.

Ghost text producing values onto the channel and closing it.

rs_07 — Match-arm completion same-line

enum Shape {
    Circle(f64),
    Square(f64),
    Rectangle(f64, f64),
    Triangle(f64, f64),
}

fn area(s: &Shape) -> f64 {
    match s {
        Shape::Circle(r) => std::f64::consts::PI * r * r,
        Shape::Square(side) => side * side,

    }
}

fn main() {
    let shapes = vec![
        Shape::Circle(1.0),
        Shape::Rectangle(2.0, 3.0),
        Shape::Triangle(4.0, 5.0),
    ];
    for s in &shapes {
        println!("area = {}", area(s));
    }
}

Empty indented line inside the match body, after the Square arm.

Ghost text adding the missing Rectangle and Triangle arms.

rs_08 — Result/Option chaining same-line

fn parse_int(s: &str) -> Option<i32> {
    let n = s.trim()
    Some(n * 2)
}

fn main() {
    let inputs = ["  21  ", "not-a-number", "10"];
    for s in &inputs {
        match parse_int(s) {
            Some(v) => println!("{} -> {}", s, v),
            None => println!("{} -> skipped", s),
        }
    }
}

End of let n = s.trim() (no semicolon yet).

Ghost text continuing the chain into a parsed i32.

rs_09 — Lifetime annotations off-cursor

fn longest(a: &str, b: &str) -> &str {
    if a.len() >= b.len() {
        a
    } else {
        b
    }
}

fn main() {
    let s1 = String::from("hello world");
    let s2 = String::from("hi");
    let out = longest(&s1, &s2);
    println!("longest = {}", out);
}

End of file.

Decoration on the fn longest signature proposing lifetime annotations.

js_07 — Async/await fetch same-line

async function fetchUser(id) {
    try {

    } catch (err) {
        console.error("fetchUser failed", err);
        return null;
    }
}

async function main() {
    const user = await fetchUser(42);
    console.log("user:", user);
}

main();

Empty indented line inside the try { block (column 8).

Ghost text completing the fetch + json parse.

js_08 — Express GET handler same-line

const app = {
    get: (_path, _handler) => app,
    post: (_path, _handler) => app,
    listen: (_port, cb) => cb && cb(),
};

const users = [
    { id: 1, name: "ada" },
    { id: 2, name: "lin" },
];

app.get("/users/:id", (req, res) => {

});

app.post("/users", (req, res) => {
    const user = { id: users.length + 1, name: req.body.name };
    users.push(user);
    res.status(201).json(user);
});

app.listen(3000, () => console.log("listening on :3000"));

Empty indented line inside the GET handler (column 4).

Ghost text proposing a get-by-id (lookup, 404, json response).

sql_07 — Missing JOIN same-line

SELECT
    c.name,
    SUM(o.total) AS total_spent
FROM orders o

WHERE o.created_at >= '2026-01-01'
GROUP BY c.name
ORDER BY total_spent DESC
LIMIT 10;

End of the line FROM orders o.

Ghost text completing the JOIN against customers.

sql_08 — WHERE filter same-line

SELECT id, email
FROM users
WHERE
ORDER BY last_login_at DESC;

End of the bare WHERE line.

Ghost text proposing a predicate.

md_07 — Prose should stay quiet suppressed

# Mercury Edit 2 — Quick Notes

Mercury Edit 2 is a small, fast model trained to predict the user's
next single edit given the current file, cursor position, and recent
edit history. It targets latency under 200 ms on typical files and
returns a unified-diff-like patch scoped to a window around the cursor.

Unlike chat-style completions, the model is biased toward minimal,
local changes — finishing a function body, fixing a typo, propagating
a rename — rather than generating new files from scratch.

End of the last sentence.

Nothing. If Mercury does propose a prose continuation it counts as a soft fail — we don't want a code model writing README content.