db.c.insertMany([{_id: 1, a: 1, b: 1, d: "x"}, {_id: 2, b: 2, d: "y"}, {_id: 3, a: 2, b: 3, d: "z"}]);
db.c.createIndex({a: 1, b: 1});
db.c.aggregate([{$sort: {a: 1, b: 1}}, {$group: {_id: {v: "$a"}, f: {$first: "$d"}}}]);

DISTINCT_SCAN, SBE or classic (default):   { _id: { },        f: "y" }   <-- wrong
collection scan (hint {$natural: 1}):      { _id: { v: null }, f: "y" }
DISTINCT_SCAN with _id: "$a":              { _id: null,        f: "y" }
no index, classic, optimization barriers:  { _id: { v: null }, f: "y" }

/**
 * {$sort: {a: 1}} followed by {$group: {_id: {v: "$a"}}} is rewritten to a DISTINCT_SCAN when an
 * index on 'a' exists. For a document that has no 'a' the group key comes back as {} instead of
 * {v: null}: the rewrite builds the key with an object expression, which omits a missing value,
 * while $group (collection scan, any other plan, or _id: "$a") turns a missing key value into
 * null. The same wrong answer comes from the classic and SBE engines.
 */
const conn = MongoRunner.runMongod({setParameter: {internalQueryDisablePlanCache: true}});
const db = conn.getDB(jsTestName());
assert.commandWorked(db.c.insertMany([
    {_id: 1, a: 1, b: 1, d: "x"},
    {_id: 2, b: 2, d: "y"},  // no 'a'
    {_id: 3, a: 2, b: 3, d: "z"},
]));
assert.commandWorked(db.c.createIndex({a: 1, b: 1}));

const sorted = (docs) => docs.map((d) => tojson(d)).sort();
function stages(explain) {
    const names = new Set();
    (function walk(x) {
        if (Array.isArray(x)) return x.forEach(walk);
        if (x === null || typeof x !== "object") return;
        if (typeof x.stage === "string") names.add(x.stage);
        Object.keys(x).filter((k) => k.startsWith("$")).forEach((k) => names.add(k));
        Object.values(x).forEach(walk);
    })(explain);
    return names;
}
function run(label, engine, pipeline, options = {}) {
    assert.commandWorked(
        db.adminCommand({setParameter: 1, internalQueryFrameworkControl: engine}));
    const used = stages(db.c.explain().aggregate(pipeline, options));
    const got = sorted(db.c.aggregate(pipeline, options).toArray());
    jsTest.log.info("run", {label, engine, distinctScan: used.has("DISTINCT_SCAN"), got});
    return {got, distinctScan: used.has("DISTINCT_SCAN")};
}

const objKey = [{$sort: {a: 1, b: 1}}, {$group: {_id: {v: "$a"}, f: {$first: "$d"}}}];
const pathKey = [{$sort: {a: 1, b: 1}}, {$group: {_id: "$a", f: {$first: "$d"}}}];
const wantObj = sorted([{_id: {v: null}, f: "y"}, {_id: {v: 1}, f: "x"}, {_id: {v: 2}, f: "z"}]);
const wantPath = sorted([{_id: null, f: "y"}, {_id: 1, f: "x"}, {_id: 2, f: "z"}]);

// Controls: a collection scan and the plain-path key give null for the missing value.
assert.eq(run("collscan", "trySbeEngine", objKey, {hint: {$natural: 1}}).got, wantObj, "collscan");
const path = run("path key on distinct scan", "trySbeEngine", pathKey);
assert(path.distinctScan, "the path-key control did not use a DISTINCT_SCAN");
assert.eq(path.got, wantPath, "_id: '$a' on a distinct scan");
// Mechanism: the object-key pipeline uses the distinct scan.
for (const engine of ["trySbeEngine", "forceClassicEngine"]) {
    assert(run("object key", engine, objKey).distinctScan, "no DISTINCT_SCAN: the repro tests nothing");
}
// Fails at the local build (2026-09-17): the key for the document without 'a' is {} in both engines.
assert.eq(run("object key", "forceClassicEngine", objKey).got, wantObj, "object key, classic");
assert.eq(run("object key", "trySbeEngine", objKey).got, wantObj, "object key, SBE");
MongoRunner.stopMongod(conn);