cpp-wire-func-func-term-double-wrap

Answer

Root cause. The generated-columns parser treated every driver-supplied term as a VALUE expression first, then wrapped the compiled value with the implicit-var scope {sym0}:

// BUGGY (PHASE3-VEC generated-columns parse)
wire_func_t compile_generated_column(scope_env_t *env, protob_t<const Term> &&t) {
    // 1. compile the driver term as a VALUE expression
    counted_t<const datum_t> value = datum_eval(env, std::move(t));
    // 2. wrap it in a func with the implicit-var binding {sym0}
    return wire_func_t(value, var_scope_t{{sym0, /* current row */}});
}

When the driver sends a lambda (any r.row(...)-style or explicit lambda expression), the wire term is Term::FUNC, which is already a function. Compiling it "as a VALUE expression" yields a FUNCTION value, and wrapping that value as the body of an implicit-var function double-wraps it: calling the resulting func per-row returns a FUNCTION, and the row expression that expected a DATUM fails with Expected type DATUM but found FUNCTION.

Fix (code). Detect Term::FUNC, extract the var-decl array + body exactly like func_term_t does, and build wire_func_t(body, args). Non-FUNC expressions keep the {sym0} implicit-var binding:

// FIXED — mirror func_term_t arg parsing; never compile FUNC as a VALUE.
wire_func_t compile_generated_column(scope_env_t *env, protob_t<const Term> &&t) {
    if (t->type() == Term::FUNC) {
        // FUNC wire shape: args(0) = MAKE_ARRAY of STRING var-decls, args(1) = body.
        rcheck(t->args_size() == 2, base_exc_t::LOGIC,
               "Expected FUNC term to have 2 arguments (var-decls, body).");
        const Term &decls = t->args(0);
        rcheck(decls.type() == Term::MAKE_ARRAY, base_exc_t::LOGIC,
               "Expected FUNC var-declarations to be an array.");
        std::vector<datum_t> arg_names;
        arg_names.reserve(decls.args_size());
        for (int i = 0; i < decls.args_size(); ++i) {
            const Term &name = decls.args(i);
            rcheck(name.type() == Term::DATUM && name.has_datum()
                   && name.datum().get_type() == datum_t::R_STR,
                   base_exc_t::LOGIC,
                   "Expected FUNC variable names to be STRING datums.");
            arg_names.push_back(name.datum());
        }
        // Build the func from the BODY + declared args (scope binds exactly
        // the declared args; the {sym0} implicit-var binding is NOT added).
        protob_t<const Term> body = make_counted_term(&t->args(1));
        return wire_func_t(env->scope, std::move(body), std::move(arg_names));
    }

    // Non-FUNC expression: keep the {sym0} implicit-var binding so
    // r.row("x")-style expressions see the current row.
    return wire_func_t(eval_as_implicit_func(env, std::move(t)),   // {sym0} scope
                       var_scope_t{{sym0, env->env->get_row()}});
}

This is exactly func_term_t's contract (Term::FUNC with args(0) a MAKE_ARRAY of STRING datums, args(1) the body) — the safest formulation is func_term_t ft(std::move(t)); followed by constructing the wire_func_t from ft's parsed body and arg ids, so validation messages stay identical to every other function-taking term.

E2E stale-server fix. Crashed runs leak zombie rethinkdb processes on the fixed ports, which keep serving the old binary to later runs. Kill the ports in the harness preamble (and on exit) before each run:

# test/run-e2e.sh preamble
for port in 28015 29015 29016 8080; do
  fuser -k -n tcp "$port" 2>/dev/null || true   # kill zombies holding fixed ports
done
# ... then build fresh, start servers, run E2E
trap 'for port in 28015 29015 29016 8080; do fuser -k -n tcp "$port" 2>/dev/null || true; done' EXIT