expect(registry.get("r2")?.state).toBe("exited");

expect(registry.get("r3")?.state).toBe("exited");

});

it("filters listByScope and returns detached copies", () => {

const registry = createRunRegistry();

addRunningRecord(registry, {

runId: "r1",

sessionId: "s1",

scopeKey: "scope:a",

startedAtMs: 1,

});

addRunningRecord(registry, {

runId: "r2",

sessionId: "s2",

scopeKey: "scope:b",

startedAtMs: 2,

});

expect(registry.listByScope(" ")).toStrictEqual([]);

const scoped = registry.listByScope("scope:a");

expect(scoped).toHaveLength(1);

const [firstScoped] = scoped;

expect(firstScoped?.runId).toBe("r1");

if (!firstScoped) {

throw new Error("missing scoped record");

}

firstScoped.state = "exited";

expect(registry.get("r1")?.state).toBe("running");

});

});

export type RunRegistry = {

add: (record: RunRecord) => void;

get: (runId: string) => RunRecord | undefined;

list: () => RunRecord[];

listByScope: (scopeKey: string) => RunRecord[];

updateState: (

runId: string,

state: RunState,

exitSignal: NodeJS.Signals | number | null;

},

) => { record: RunRecord; firstFinalize: boolean } | null;

delete: (runId: string) => void;

};

/**

return record ? { ...record } : undefined;

};

const list: RunRegistry["list"] = () => {

return Array.from(records.values()).map((record) => Object.assign({}, record));

};

const listByScope: RunRegistry["listByScope"] = (scopeKey) => {

if (!scopeKey.trim()) {

return [];

}

return Array.from(records.values())

.filter((record) => record.scopeKey === scopeKey)

.map((record) => Object.assign({}, record));

};

const updateState: RunRegistry["updateState"] = (runId, state, patch) => {

const current = records.get(runId);

if (!current) {

return { record: { ...next }, firstFinalize };

};

const del: RunRegistry["delete"] = (runId) => {

records.delete(runId);

};

return {

add,

get,

list,

listByScope,

updateState,

touchOutput,

finalize,

delete: del,

};

}