What and why?

Fixes a Live Debugger transform bug where curried functions like this could emit invalid JavaScript:

const make = (dep) => function named() {
    return dep;
};

Before this fix, the outer arrow instrumentation could overwrite the inner function's closing-brace instrumentation. The generated output effectively looked like this, with the inner try missing its catch/finally:

const make = (dep) => {
    const $dd_p0 = $dd_probes('src/utils.ts;make');
    try {
        if ($dd_p0) $dd_entry($dd_p0, this, {dep});
        const $dd_rv0 = function named() {
            const $dd_p1 = $dd_probes('src/utils.ts;named');
            try {
                let $dd_rv1;
                if ($dd_p1) $dd_entry($dd_p1, this);
                return ($dd_rv1 = dep, $dd_p1 ? $dd_return($dd_p1, $dd_rv1, this) : $dd_rv1);
        };
        if ($dd_p0) $dd_return($dd_p0, $dd_rv0, this, {dep});
        return $dd_rv0;
    } catch(e) { if ($dd_p0) $dd_throw($dd_p0, e, this, {dep}); throw e; }
};

That invalid output fails downstream parsers with errors like Missing catch or finally clause or Expected a semicolon.

How?

The expression-body path now updates the first body character as before, but appends the suffix at bodyEnd instead of rewriting [bodyEnd - 1, bodyEnd]. This keeps the inner block-body postamble intact when the arrow body is another function or arrow.

Added table-driven nested-function regression coverage for named function expressions, exported function-expression factories, triple-nested callback shapes, and curried arrows across namedOnly modes.