}

function mockCallArg(mock: { mock: { calls: unknown[][] } }, index = 0, argIndex = 0): unknown {

const call = mock.mock.calls[index];

const call = mock.mock.calls.at(index);

if (!call) {

throw new Error(`expected mock call ${index}`);

}

return call[argIndex];

}

function directRoomTrackerOptions(): DirectRoomTrackerOptions {

const opts = mockCallArg(hoisted.createDirectRoomTracker, 0, 1);

if (!opts || typeof opts !== "object") {

throw new Error("expected direct room tracker options");

}

return opts as DirectRoomTrackerOptions;

}

function lastMockCallArg(mock: { mock: { calls: unknown[][] } }, argIndex = 0): unknown {

const call = mock.mock.calls.at(-1);

if (!call) {

it("resolves text chunk limit for the effective Matrix account", async () => {

await startMonitorAndAbortAfterStartup();

const textLimitCall = hoisted.resolveTextChunkLimit.mock.calls[0];

if (textLimitCall?.[0] === undefined) {

throw new Error("Expected Matrix text chunk limit config argument");

}

expect(textLimitCall?.[1]).toBe("matrix");

expect(textLimitCall?.[2]).toBe("default");

expect(mockCallArg(hoisted.resolveTextChunkLimit, 0, 0)).toBeDefined();

expect(mockCallArg(hoisted.resolveTextChunkLimit, 0, 1)).toBe("matrix");

expect(mockCallArg(hoisted.resolveTextChunkLimit, 0, 2)).toBe("default");

});

it("starts monitoring without waiting for best-effort deviceId backfill", async () => {

it("wires recent-invite promotion to fail closed when room metadata is unresolved", async () => {

await startMonitorAndAbortAfterStartup();

const trackerOpts = hoisted.createDirectRoomTracker.mock.calls[0]?.[1];

const trackerOpts = directRoomTrackerOptions();

if (!trackerOpts?.canPromoteRecentInvite) {

throw new Error("recent invite promotion callback was not wired");

}

it("wires recent-invite promotion to reject named rooms", async () => {

await startMonitorAndAbortAfterStartup();

const trackerOpts = hoisted.createDirectRoomTracker.mock.calls[0]?.[1];

const trackerOpts = directRoomTrackerOptions();

if (!trackerOpts?.canPromoteRecentInvite) {

throw new Error("recent invite promotion callback was not wired");

}

await startMonitorAndAbortAfterStartup();

const trackerOpts = hoisted.createDirectRoomTracker.mock.calls[0]?.[1];

const trackerOpts = directRoomTrackerOptions();

if (!trackerOpts?.canPromoteRecentInvite) {

throw new Error("recent invite promotion callback was not wired");

}

it("does not wire unmapped strict room promotion for per-user DM scope", async () => {

await startMonitorAndAbortAfterStartup();

const trackerOpts = hoisted.createDirectRoomTracker.mock.calls[0]?.[1];

const trackerOpts = directRoomTrackerOptions();

expect(trackerOpts?.canPromoteUnmappedStrictRoom).toBeUndefined();

});

await startMonitorAndAbortAfterStartup();

const trackerOpts = hoisted.createDirectRoomTracker.mock.calls[0]?.[1];

const trackerOpts = directRoomTrackerOptions();

if (!trackerOpts?.canPromoteUnmappedStrictRoom) {

throw new Error("per-room strict fallback callback was not wired");

}

it("treats unresolved room metadata as indeterminate for local promotion revalidation", async () => {

await startMonitorAndAbortAfterStartup();

const trackerOpts = hoisted.createDirectRoomTracker.mock.calls[0]?.[1];

const trackerOpts = directRoomTrackerOptions();

if (!trackerOpts?.shouldKeepLocallyPromotedDirectRoom) {

throw new Error("local promotion revalidation callback was not wired");

}