@indigoai-us/hq-cloud 6.18.44-alpha.9 → 6.18.44

package/dist/sync/push-receiver.test.js

@@ -1,2851 +0,0 @@
-/**
- * US-009 — push-receiver unit tests.
- *
- * Covers the five required behaviors from the PRD AC, against the SQS-backed
- * {@link SqsPushReceiver} (mocked SQS client — NO real AWS) and the
- * {@link InMemoryPushReceiver} (in-process fanout analogue):
- *
- *   1. subscribe lifecycle — start opens the poll loop / subscription, dispose
- *      stops it; double-start is a no-op; flag-OFF stays dormant.
- *   2. dedupe              — an event with sequenceNumber <= the highest seen
- *      for its path is skipped; per-path counters are independent.
- *   3. reconnect-replay    — a transient receiveMessage failure backs off and
- *      resumes; SQS retention redelivers the buffered events; dedupe absorbs
- *      redelivery (in-memory: disconnect buffers, reconnect drains).
- *   4. flag gating         — dormant when the per-tenant flag is OFF; no queue
- *      polled, connected stays false.
- *   5. dispose drain       — dispose aborts + awaits the in-flight syncFn, then
- *      disconnects; the loop terminates with no leaked timers.
- *
- * The live per-client SQS queue is NOT provisioned yet (server provisioning
- * Lambda is an unbuilt follow-up — see references.md). Every test injects a
- * fake SQS client / in-memory fanout.
- */
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { describe, expect, it, vi } from "vitest";
-import { encodePushEvent } from "./push-event.js";
-import { hashFile } from "../journal.js";
-import { InMemoryFanout, InMemoryPushReceiver, NoopPushReceiver, RealtimeWakeReceiver, SqsPushReceiver, createPushReceiver, decodeRealtimeWake, } from "./push-receiver.js";
-import { isInboundEventPlaceable } from "./inbound-event-admission.js";
-// ─── Fixtures ────────────────────────────────────────────────────────────────
-const TENANT = "tenant-indigo";
-const QUEUE_URL = "https://sqs.us-east-1.amazonaws.com/123456789012/sync-push-indigo-deviceA";
-function makeEvent(overrides = {}) {
-    return {
-        relativePath: "companies/indigo/notes.md",
-        kind: "upsert",
-        contentHash: "sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-        mtime: "2026-05-21T12:34:56.000Z",
-        originDeviceId: "device-A",
-        originTenantId: TENANT,
-        sequenceNumber: 1,
-        eventTimestamp: "2026-05-21T12:34:56.500Z",
-        ...overrides,
-    };
-}
-function msg(event, receiptHandle = `rh-${event.sequenceNumber}`) {
-    return {
-        Body: encodePushEvent(event),
-        ReceiptHandle: receiptHandle,
-        MessageId: `m-${event.relativePath}-${event.sequenceNumber}`,
-    };
-}
-async function changeVisibilityBatchIndividually(changeVisibility, args) {
-    const failedEntries = [];
-    for (const entry of args.entries) {
-        try {
-            await changeVisibility({
-                queueUrl: args.queueUrl,
-                receiptHandle: entry.receiptHandle,
-                visibilityTimeoutSeconds: args.visibilityTimeoutSeconds,
-            });
-        }
-        catch (error) {
-            const failure = error;
-            failedEntries.push({
-                id: entry.id,
-                ...(failure.code === undefined ? {} : { code: failure.code }),
-                message: failure.message ?? String(error),
-            });
-        }
-    }
-    return { failedEntries };
-}
-/**
- * A scriptable fake SQS client. `enqueue` adds batches that successive
- * `receiveMessage` calls drain (one batch per call); once drained, it blocks
- * on the abort signal (modeling an idle long-poll) so dispose ends it cleanly.
- * `failNext(n)` makes the next `n` receiveMessage calls reject (transient).
- */
-class FakeSqs {
-    batches = [];
-    inFlight = new Map();
-    released = [];
-    failCount = 0;
-    deleted = [];
-    visibilityChanges = [];
-    visibilityBatchCalls = [];
-    visibilityFailure = null;
-    visibilityBatchFailures = new Map();
-    receiveCalls = 0;
-    receivedReceiptHandles = [];
-    receiveWaitTimes = [];
-    enqueue(messages) {
-        this.batches.push({ messages, drainable: false });
-    }
-    /** A page already available to a zero-wait drain receive. */
-    enqueueDrainable(messages) {
-        this.batches.push({ messages, drainable: true });
-    }
-    failNext(n) {
-        this.failCount += n;
-    }
-    failNextVisibilityChange(error = new Error("simulated visibility change failure")) {
-        this.visibilityFailure = error;
-    }
-    failVisibilityBatchEntry(receiptHandle, failure = {
-        code: "InvalidParameterValue",
-        message: "simulated per-entry visibility failure",
-    }) {
-        this.visibilityBatchFailures.set(receiptHandle, failure);
-    }
-    async receiveMessage(args) {
-        this.receiveCalls += 1;
-        this.receiveWaitTimes.push(args.waitTimeSeconds);
-        if (this.failCount > 0) {
-            this.failCount -= 1;
-            throw new Error("simulated SQS receive failure");
-        }
-        if (this.released.length > 0 && args.waitTimeSeconds > 1) {
-            const messages = this.released.splice(0);
-            for (const message of messages) {
-                if (message.ReceiptHandle) {
-                    this.inFlight.set(message.ReceiptHandle, message);
-                    this.receivedReceiptHandles.push(message.ReceiptHandle);
-                }
-            }
-            return { messages };
-        }
-        const next = this.batches[0];
-        // Ordinary enqueued batches model work that arrives after this drain's
-        // one-second confirmation window; only a regular long poll starts their
-        // next receive cycle. Dedicated drainable and false-negative fakes cover
-        // pages that must be collected by the current drain.
-        if (next && (next.drainable || args.waitTimeSeconds > 1)) {
-            const messages = next.messages.splice(0, args.maxMessages);
-            if (next.messages.length === 0)
-                this.batches.shift();
-            for (const message of messages) {
-                if (message.ReceiptHandle) {
-                    this.inFlight.set(message.ReceiptHandle, message);
-                    this.receivedReceiptHandles.push(message.ReceiptHandle);
-                }
-            }
-            return { messages };
-        }
-        if (args.waitTimeSeconds === 0)
-            return { messages: [] };
-        // Idle long-poll: resolve empty on the next tick (or promptly on abort).
-        return new Promise((resolve) => {
-            if (args.signal.aborted)
-                return resolve({ messages: [] });
-            const t = setTimeout(() => resolve({ messages: [] }), 5);
-            t.unref?.();
-            args.signal.addEventListener("abort", () => {
-                clearTimeout(t);
-                resolve({ messages: [] });
-            }, { once: true });
-        });
-    }
-    async deleteMessage(args) {
-        this.deleted.push(args.receiptHandle);
-        this.inFlight.delete(args.receiptHandle);
-    }
-    async changeMessageVisibility(args) {
-        this.visibilityChanges.push({
-            receiptHandle: args.receiptHandle,
-            visibilityTimeoutSeconds: args.visibilityTimeoutSeconds,
-        });
-        if (this.visibilityFailure) {
-            const error = this.visibilityFailure;
-            this.visibilityFailure = null;
-            throw error;
-        }
-        if (args.visibilityTimeoutSeconds !== 0)
-            return;
-        const message = this.inFlight.get(args.receiptHandle);
-        if (!message)
-            throw new Error(`unknown receipt ${args.receiptHandle}`);
-        this.inFlight.delete(args.receiptHandle);
-        this.released.push(message);
-    }
-    async changeMessageVisibilityBatch(args) {
-        this.visibilityBatchCalls.push({
-            entries: args.entries.map(({ id, receiptHandle }) => ({ id, receiptHandle })),
-            visibilityTimeoutSeconds: args.visibilityTimeoutSeconds,
-        });
-        const failedEntries = [];
-        for (const entry of args.entries) {
-            const failure = this.visibilityBatchFailures.get(entry.receiptHandle);
-            if (failure) {
-                this.visibilityBatchFailures.delete(entry.receiptHandle);
-                failedEntries.push({ id: entry.id, ...failure });
-                continue;
-            }
-            await this.changeMessageVisibility({
-                queueUrl: args.queueUrl,
-                receiptHandle: entry.receiptHandle,
-                visibilityTimeoutSeconds: args.visibilityTimeoutSeconds,
-            });
-        }
-        return { failedEntries };
-    }
-}
-/** FIFO fake used to prove that a slow pass cannot stall backlog intake. */
-class BacklogSqs {
-    visible;
-    inFlight = new Map();
-    deleted = [];
-    released = [];
-    received = [];
-    constructor(messages) {
-        this.visible = [...messages];
-    }
-    get remaining() {
-        return this.visible.length + this.inFlight.size;
-    }
-    async receiveMessage(args) {
-        const messages = this.visible.splice(0, args.maxMessages);
-        if (messages.length > 0) {
-            for (const message of messages) {
-                if (message.ReceiptHandle) {
-                    this.inFlight.set(message.ReceiptHandle, message);
-                    this.received.push(message.ReceiptHandle);
-                }
-            }
-            return { messages };
-        }
-        if (args.waitTimeSeconds === 0)
-            return { messages: [] };
-        // Drain confirmations must observe an empty queue; the outer long-poll
-        // remains blocked until disposal so this fixture cannot busy-spin.
-        if (args.waitTimeSeconds <= 1)
-            return { messages: [] };
-        return new Promise((resolve) => {
-            if (args.signal.aborted)
-                return resolve({ messages: [] });
-            args.signal.addEventListener("abort", () => resolve({ messages: [] }), { once: true });
-        });
-    }
-    async deleteMessage(args) {
-        if (!this.inFlight.delete(args.receiptHandle)) {
-            throw new Error(`delete received an unknown receipt ${args.receiptHandle}`);
-        }
-        this.deleted.push(args.receiptHandle);
-    }
-    async changeMessageVisibility(args) {
-        if (args.visibilityTimeoutSeconds !== 0)
-            return;
-        const message = this.inFlight.get(args.receiptHandle);
-        if (!message)
-            throw new Error(`release received an unknown receipt ${args.receiptHandle}`);
-        this.inFlight.delete(args.receiptHandle);
-        this.released.push(args.receiptHandle);
-        this.visible.unshift(message);
-    }
-    async changeMessageVisibilityBatch(args) {
-        return changeVisibilityBatchIndividually((entry) => this.changeMessageVisibility(entry), args);
-    }
-}
-/** Models SQS short-poll sampling: receive #2 is empty while work remains. */
-class FalseNegativeSqs {
-    messages;
-    skippedSecondReceive = false;
-    deleted = [];
-    receiveWaitTimes = [];
-    constructor(messages) {
-        this.messages = [...messages];
-    }
-    async receiveMessage(args) {
-        this.receiveWaitTimes.push(args.waitTimeSeconds);
-        if (!this.skippedSecondReceive && this.receiveWaitTimes.length === 2) {
-            this.skippedSecondReceive = true;
-            return { messages: [] };
-        }
-        const page = this.messages.splice(0, args.maxMessages);
-        if (page.length > 0)
-            return { messages: page };
-        if (args.waitTimeSeconds === 0)
-            return { messages: [] };
-        return new Promise((resolve) => {
-            if (args.signal.aborted)
-                return resolve({ messages: [] });
-            const t = setTimeout(() => resolve({ messages: [] }), 5);
-            t.unref?.();
-            args.signal.addEventListener("abort", () => {
-                clearTimeout(t);
-                resolve({ messages: [] });
-            }, { once: true });
-        });
-    }
-    async deleteMessage(args) {
-        this.deleted.push(args.receiptHandle);
-    }
-    async changeMessageVisibility(_args) {
-        // This fixture never returns more paths than its configured cap.
-    }
-    async changeMessageVisibilityBatch(_args) {
-        return { failedEntries: [] };
-    }
-}
-/**
- * Scaled-time SQS fixture: an omitted receive visibility lease expires before
- * the delayed pass can delete its receipt. A supplied 600-second lease does
- * not. This makes the production redelivery failure deterministic in millis.
- */
-class VisibilityExpirySqs {
-    event;
-    visibleAt = 0;
-    leaseExpiresAt = 0;
-    currentReceipt = "";
-    nextReceipt = 0;
-    deliveries = [];
-    deleted = [];
-    deleteAttempts = [];
-    requestedVisibilityTimeouts = [];
-    visibilityChanges = [];
-    deleteDelayMs = 0;
-    constructor(event) {
-        this.event = event;
-    }
-    async receiveMessage(args) {
-        this.requestedVisibilityTimeouts.push(args.visibilityTimeoutSeconds);
-        if (Date.now() < this.visibleAt) {
-            if (args.waitTimeSeconds <= 1)
-                return { messages: [] };
-            return new Promise((resolve) => {
-                if (args.signal.aborted)
-                    return resolve({ messages: [] });
-                args.signal.addEventListener("abort", () => resolve({ messages: [] }), { once: true });
-            });
-        }
-        const receiptHandle = `visibility-rh-${++this.nextReceipt}`;
-        this.currentReceipt = receiptHandle;
-        this.deliveries.push(receiptHandle);
-        // One fake second is five real milliseconds. The queue's default lease is
-        // deliberately one fake second; the receiver's 600-second lease is 3s.
-        this.leaseExpiresAt = Date.now() + (args.visibilityTimeoutSeconds ?? 1) * 5;
-        this.visibleAt = this.leaseExpiresAt;
-        return { messages: [msg(this.event, receiptHandle)] };
-    }
-    async deleteMessage(args) {
-        if (this.deleteDelayMs > 0) {
-            await new Promise((resolve) => setTimeout(resolve, this.deleteDelayMs));
-        }
-        if (Date.now() >= this.leaseExpiresAt) {
-            this.visibleAt = 0;
-            this.deleteAttempts.push({ receiptHandle: args.receiptHandle, expired: true });
-            throw new Error("stale receipt handle after visibility expiry");
-        }
-        if (args.receiptHandle !== this.currentReceipt) {
-            this.deleteAttempts.push({ receiptHandle: args.receiptHandle, expired: true });
-            throw new Error("stale receipt handle");
-        }
-        this.deleted.push(args.receiptHandle);
-        this.deleteAttempts.push({ receiptHandle: args.receiptHandle, expired: false });
-        this.visibleAt = Number.POSITIVE_INFINITY;
-    }
-    async changeMessageVisibility(args) {
-        if (args.receiptHandle !== this.currentReceipt)
-            throw new Error("stale receipt handle");
-        this.visibilityChanges.push({
-            receiptHandle: args.receiptHandle,
-            visibilityTimeoutSeconds: args.visibilityTimeoutSeconds,
-        });
-        this.visibleAt = Date.now() + args.visibilityTimeoutSeconds * 5;
-        this.leaseExpiresAt = this.visibleAt;
-    }
-    async changeMessageVisibilityBatch(args) {
-        return changeVisibilityBatchIndividually((entry) => this.changeMessageVisibility(entry), args);
-    }
-}
-/** Queue fixture that honors ReceiveMessage.MaxNumberOfMessages. */
-class OverCapSqs {
-    queued;
-    inFlight = new Map();
-    receiveCalls = [];
-    deleted = [];
-    releases = [];
-    constructor(initialMessages) {
-        this.queued = [...initialMessages];
-    }
-    enqueue(message) {
-        this.queued.push(message);
-    }
-    async receiveMessage(args) {
-        this.receiveCalls.push({
-            waitTimeSeconds: args.waitTimeSeconds,
-            maxMessages: args.maxMessages,
-        });
-        if (this.queued.length > 0) {
-            const messages = this.queued.splice(0, args.maxMessages);
-            for (const message of messages) {
-                if (message.ReceiptHandle)
-                    this.inFlight.set(message.ReceiptHandle, message);
-            }
-            return { messages };
-        }
-        if (args.waitTimeSeconds <= 1)
-            return { messages: [] };
-        return new Promise((resolve) => {
-            if (args.signal.aborted)
-                return resolve({ messages: [] });
-            args.signal.addEventListener("abort", () => resolve({ messages: [] }), { once: true });
-        });
-    }
-    async deleteMessage(args) {
-        this.inFlight.delete(args.receiptHandle);
-        this.deleted.push(args.receiptHandle);
-    }
-    async changeMessageVisibility(args) {
-        this.releases.push({ receiptHandle: args.receiptHandle, visibilityTimeoutSeconds: args.visibilityTimeoutSeconds });
-        const released = this.inFlight.get(args.receiptHandle);
-        if (!released)
-            throw new Error("unknown receipt handle");
-        this.inFlight.delete(args.receiptHandle);
-        this.queued.unshift(released);
-    }
-    async changeMessageVisibilityBatch(args) {
-        return changeVisibilityBatchIndividually((entry) => this.changeMessageVisibility(entry), args);
-    }
-}
-/** Wait until `predicate()` is true or `timeoutMs` elapses. */
-async function waitFor(predicate, timeoutMs = 1000) {
-    const start = Date.now();
-    while (!predicate()) {
-        if (Date.now() - start > timeoutMs) {
-            throw new Error("waitFor: timed out");
-        }
-        await new Promise((r) => setTimeout(r, 5));
-    }
-}
-// fast, abortable sleep so backoff doesn't slow the suite
-const fastSleep = (ms, signal) => new Promise((resolve) => {
-    if (signal.aborted)
-        return resolve();
-    const t = setTimeout(resolve, Math.min(ms, 5));
-    signal.addEventListener("abort", () => { clearTimeout(t); resolve(); }, { once: true });
-});
-describe("realtime v2 wake envelope", () => {
-    it("accepts only the cursor-only normative envelope", () => {
-        expect(decodeRealtimeWake(JSON.stringify({
-            contractVersion: 2,
-            eventType: "vault.changed",
-            scopeHandle: "scope_handle_1",
-            cursor: "cursor_hint_1",
-        }))).toEqual({
-            contractVersion: 2,
-            eventType: "vault.changed",
-            scopeHandle: "scope_handle_1",
-            cursor: "cursor_hint_1",
-        });
-    });
-    it("accepts the existing opaque cursor alphabet without interpreting it", () => {
-        expect(decodeRealtimeWake(JSON.stringify({
-            contractVersion: 2,
-            eventType: "vault.changed",
-            scopeHandle: "scope_handle_1",
-            cursor: "cursor/+==",
-        })).cursor).toBe("cursor/+==");
-    });
-    it("rejects path-bearing or extended wakes before they reach scheduling", () => {
-        expect(() => decodeRealtimeWake(JSON.stringify({
-            contractVersion: 2,
-            eventType: "vault.changed",
-            scopeHandle: "scope_handle_1",
-            cursor: "cursor_hint_1",
-            relativePath: "companies/indigo/private.md",
-        }))).toThrow(/unknown field/);
-    });
-    it("does not compare opaque cursors and stops delivery after disposal", async () => {
-        const sourceState = { listener: null };
-        const source = {
-            start: (next) => { sourceState.listener = next; },
-            dispose: vi.fn(),
-        };
-        const received = [];
-        const receiver = new RealtimeWakeReceiver({
-            source,
-            onWake: (wake) => received.push(wake.scopeHandle),
-        });
-        await receiver.start();
-        sourceState.listener?.(JSON.stringify({ contractVersion: 2, eventType: "vault.changed", scopeHandle: "scope_a", cursor: "cursor_z" }));
-        sourceState.listener?.(JSON.stringify({ contractVersion: 2, eventType: "vault.changed", scopeHandle: "scope_a", cursor: "cursor_a" }));
-        expect(received).toEqual(["scope_a", "scope_a"]);
-        await receiver.dispose();
-        sourceState.listener?.(JSON.stringify({ contractVersion: 2, eventType: "vault.changed", scopeHandle: "scope_a", cursor: "cursor_new" }));
-        expect(received).toEqual(["scope_a", "scope_a"]);
-        expect(source.dispose).toHaveBeenCalledOnce();
-    });
-});
-// ─── SqsPushReceiver ─────────────────────────────────────────────────────────
-describe("US-OBS: SqsPushReceiver — origin observability", () => {
-    async function collectOriginRecords(logOrigins) {
-        const sqs = new FakeSqs();
-        const records = [];
-        sqs.enqueue([msg(makeEvent({ originDeviceId: "device-origin", sequenceNumber: 1 }))]);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn: async () => undefined,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            ...(logOrigins === undefined ? {} : { logOrigins }),
-            logger: {
-                debug: () => undefined,
-                warn: () => undefined,
-                error: () => undefined,
-                info: (record) => { records.push(record); },
-            },
-        });
-        await receiver.start();
-        await waitFor(() => records.some((record) => record.event === "fanout.receive") &&
-            records.some((record) => record.event === "receiver.drain"));
-        await receiver.dispose();
-        return records;
-    }
-    it("omits both origin fields by default", async () => {
-        const records = await collectOriginRecords();
-        const fanout = records.find((record) => record.event === "fanout.receive");
-        const drain = records.find((record) => record.event === "receiver.drain");
-        expect(fanout).toBeDefined();
-        expect(drain).toBeDefined();
-        expect([
-            Object.hasOwn(fanout, "originDeviceId"),
-            Object.hasOwn(drain, "origins"),
-        ]).toEqual([false, false]);
-    });
-    it("omits both origin fields when logOrigins is false", async () => {
-        const records = await collectOriginRecords(false);
-        const fanout = records.find((record) => record.event === "fanout.receive");
-        const drain = records.find((record) => record.event === "receiver.drain");
-        expect(fanout).toBeDefined();
-        expect(drain).toBeDefined();
-        expect([
-            Object.hasOwn(fanout, "originDeviceId"),
-            Object.hasOwn(drain, "origins"),
-        ]).toEqual([false, false]);
-    });
-    it("includes both origin fields when logOrigins is true", async () => {
-        const records = await collectOriginRecords(true);
-        const fanout = records.find((record) => record.event === "fanout.receive");
-        const drain = records.find((record) => record.event === "receiver.drain");
-        expect(fanout).toMatchObject({ originDeviceId: "device-origin" });
-        expect(drain).toMatchObject({ origins: { "device-origin": 1 } });
-    });
-    it("includes the event originDeviceId in each fanout.receive record", async () => {
-        const sqs = new FakeSqs();
-        const receivedRecords = [];
-        sqs.enqueue([msg(makeEvent({ originDeviceId: "device-origin", sequenceNumber: 1 }))]);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn: async () => undefined,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logOrigins: true,
-            logger: {
-                debug: () => undefined,
-                warn: () => undefined,
-                error: () => undefined,
-                info: (record) => { receivedRecords.push(record); },
-            },
-        });
-        await receiver.start();
-        await waitFor(() => receivedRecords.some((record) => record.event === "fanout.receive" && record.relativePath === "companies/indigo/notes.md"));
-        await receiver.dispose();
-        expect(receivedRecords.find((record) => record.event === "fanout.receive"))
-            .toMatchObject({ originDeviceId: "device-origin" });
-    });
-    it("counts filtered and processed origin events in the receiver.drain record", async () => {
-        const sqs = new FakeSqs();
-        const drainRecords = [];
-        sqs.enqueueDrainable([
-            msg(makeEvent({ originDeviceId: "device-A", relativePath: "companies/indigo/a.md", sequenceNumber: 1 }), "rh-origin-a1"),
-            msg(makeEvent({ originDeviceId: "device-A", relativePath: "companies/indigo/b.md", sequenceNumber: 2 }), "rh-origin-a2"),
-            msg(makeEvent({ originDeviceId: "device-self", relativePath: "companies/indigo/self.md", sequenceNumber: 3 }), "rh-origin-self"),
-        ]);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            shouldProcess: (event) => event.originDeviceId !== "device-self",
-            syncBatchFn: async () => undefined,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logOrigins: true,
-            logger: {
-                debug: () => undefined,
-                warn: () => undefined,
-                error: () => undefined,
-                info: (record) => {
-                    if (record.event === "receiver.drain")
-                        drainRecords.push(record);
-                },
-            },
-        });
-        await receiver.start();
-        await waitFor(() => drainRecords.some((record) => record.received === 3));
-        await receiver.dispose();
-        expect(drainRecords.find((record) => record.received === 3)?.origins)
-            .toEqual({ "device-A": 2, "device-self": 1 });
-    });
-    it("caps receiver.drain origins at twenty device keys plus _other", async () => {
-        const sqs = new FakeSqs();
-        const drainRecords = [];
-        const events = Array.from({ length: 25 }, (_, index) => makeEvent({
-            originDeviceId: `device-${String(index).padStart(2, "0")}`,
-            relativePath: `companies/indigo/origins/${index}.md`,
-            sequenceNumber: index + 1,
-        }));
-        sqs.enqueueDrainable(events.map((event, index) => msg(event, `rh-origin-cap-${index}`)));
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn: async () => undefined,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logOrigins: true,
-            logger: {
-                debug: () => undefined,
-                warn: () => undefined,
-                error: () => undefined,
-                info: (record) => {
-                    if (record.event === "receiver.drain")
-                        drainRecords.push(record);
-                },
-            },
-        });
-        await receiver.start();
-        await waitFor(() => drainRecords.some((record) => record.received === 25));
-        await receiver.dispose();
-        const origins = drainRecords.find((record) => record.received === 25)?.origins;
-        expect(origins).toEqual({
-            ...Object.fromEntries(Array.from({ length: 20 }, (_, index) => [
-                `device-${String(index).padStart(2, "0")}`,
-                1,
-            ])),
-            _other: 5,
-        });
-        expect(Object.keys(origins)).toHaveLength(21);
-    });
-});
-describe("US-009: SqsPushReceiver — subscribe lifecycle", () => {
-    it("start opens the poll loop and processes a received event via syncFn, then deletes it", async () => {
-        const sqs = new FakeSqs();
-        const seen = [];
-        const syncFn = async (ctx) => {
-            seen.push(ctx.event.relativePath);
-        };
-        sqs.enqueue([msg(makeEvent({ sequenceNumber: 1 }))]);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncFn,
-            sleep: fastSleep,
-        });
-        await receiver.start();
-        expect(receiver.connected).toBe(true);
-        await waitFor(() => receiver.processedCount === 1);
-        expect(seen).toEqual(["companies/indigo/notes.md"]);
-        expect(sqs.deleted).toContain("rh-1");
-        await receiver.dispose();
-        expect(receiver.connected).toBe(false);
-    });
-    it("double-start is a no-op (single poll loop)", async () => {
-        const sqs = new FakeSqs();
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncFn: async () => undefined,
-            sleep: fastSleep,
-        });
-        await receiver.start();
-        await receiver.start();
-        // Let a couple poll iterations happen; a duplicated loop would roughly
-        // double the receive call rate. We just assert it stays connected + clean.
-        await new Promise((r) => setTimeout(r, 30));
-        expect(receiver.connected).toBe(true);
-        await receiver.dispose();
-    });
-    it("subscribes ONLY to its own tenant's queue (cross-tenant isolation boundary)", async () => {
-        const sqs = new FakeSqs();
-        const urls = [];
-        const spy = {
-            receiveMessage: (a) => {
-                urls.push(a.queueUrl);
-                return sqs.receiveMessage(a);
-            },
-            deleteMessage: (a) => sqs.deleteMessage(a),
-            changeMessageVisibility: (a) => sqs.changeMessageVisibility(a),
-            changeMessageVisibilityBatch: (a) => sqs.changeMessageVisibilityBatch(a),
-        };
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs: spy,
-            syncFn: async () => undefined,
-            sleep: fastSleep,
-        });
-        await receiver.start();
-        await waitFor(() => urls.length >= 1);
-        await receiver.dispose();
-        expect(new Set(urls)).toEqual(new Set([QUEUE_URL]));
-    });
-    it("constructor rejects empty tenantId / queueUrl", () => {
-        expect(() => new SqsPushReceiver({
-            tenantId: "",
-            queueUrl: QUEUE_URL,
-            sqs: new FakeSqs(),
-            syncFn: async () => undefined,
-        })).toThrow(/tenantId is required/);
-        expect(() => new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: "",
-            sqs: new FakeSqs(),
-            syncFn: async () => undefined,
-        })).toThrow(/queueUrl is required/);
-    });
-});
-describe("receiver drain diagnostics", () => {
-    it("acknowledges paths proven unchanged without dispatching a pull", async () => {
-        const event = makeEvent({ relativePath: "companies/indigo/unchanged.md" });
-        const sqs = new FakeSqs();
-        sqs.enqueueDrainable([msg(event, "rh-unchanged")]);
-        const syncBatchFn = vi.fn(async () => undefined);
-        const drainRecords = [];
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn,
-            skipUnchangedFn: async (events) => new Set(events.map((entry) => entry.relativePath)),
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: {
-                info: (record) => {
-                    if (record.event === "receiver.drain")
-                        drainRecords.push(record);
-                },
-                warn: () => undefined,
-                error: () => undefined,
-                debug: () => undefined,
-            },
-        });
-        await receiver.start();
-        await waitFor(() => sqs.deleted.length === 1 && drainRecords.length === 1);
-        await receiver.dispose();
-        expect(sqs.deleted).toEqual(["rh-unchanged"]);
-        expect(syncBatchFn).not.toHaveBeenCalled();
-        expect(drainRecords[0]).toMatchObject({
-            received: 1,
-            coalesced: 1,
-            processed: 0,
-            skippedUnchanged: 1,
-            deleted: 1,
-            remaining: 0,
-        });
-    });
-    it("falls back to a targeted pull when the unchanged proof fails", async () => {
-        const event = makeEvent({ relativePath: "companies/indigo/proof-error.md" });
-        const sqs = new FakeSqs();
-        sqs.enqueueDrainable([msg(event, "rh-proof-error")]);
-        const syncBatchFn = vi.fn(async () => undefined);
-        const warnings = [];
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn,
-            skipUnchangedFn: async () => { throw new Error("journal unavailable"); },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: {
-                info: () => undefined,
-                warn: (record) => warnings.push(record),
-                error: () => undefined,
-                debug: () => undefined,
-            },
-        });
-        await receiver.start();
-        await waitFor(() => sqs.deleted.length === 1 && syncBatchFn.mock.calls.length === 1);
-        await receiver.dispose();
-        expect(syncBatchFn.mock.calls[0]?.[0].events).toEqual([event]);
-        expect(warnings).toContainEqual(expect.objectContaining({
-            event: "receiver.unchanged.check.failed",
-            err: { message: "journal unavailable" },
-        }));
-    });
-    it("reports redelivery count, oldest sent age, and filtered self echoes", async () => {
-        const nowMs = 10_000;
-        const sqs = new FakeSqs();
-        sqs.enqueueDrainable([
-            {
-                ...msg(makeEvent({ relativePath: "companies/indigo/first.md", sequenceNumber: 1 })),
-                approximateReceiveCount: 1,
-                sentTimestampMs: 7_000,
-            },
-            {
-                ...msg(makeEvent({ relativePath: "companies/indigo/second.md", sequenceNumber: 2 })),
-                approximateReceiveCount: 3,
-                sentTimestampMs: 8_000,
-            },
-            {
-                ...msg(makeEvent({
-                    relativePath: "companies/indigo/self.md",
-                    sequenceNumber: 3,
-                    originDeviceId: "this-device",
-                })),
-                approximateReceiveCount: 2,
-                sentTimestampMs: 9_000,
-            },
-        ]);
-        const drainRecords = [];
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            shouldProcess: (event) => event.originDeviceId !== "this-device",
-            syncBatchFn: async () => undefined,
-            sleep: fastSleep,
-            now: () => nowMs,
-            publishMetric: async () => undefined,
-            logger: {
-                info: (record) => {
-                    if (record.event === "receiver.drain")
-                        drainRecords.push(record);
-                },
-                warn: () => undefined,
-                error: () => undefined,
-                debug: () => undefined,
-            },
-        });
-        await receiver.start();
-        await waitFor(() => sqs.deleted.length === 3);
-        await receiver.dispose();
-        expect(sqs.deleted).toHaveLength(3);
-        expect(drainRecords).toHaveLength(1);
-        expect(drainRecords[0]).toMatchObject({
-            received: 3,
-            coalesced: 2,
-            processed: 2,
-            deleted: 3,
-            released: 0,
-            remaining: 0,
-            redelivered: 2,
-            maxReceiveCount: 3,
-            oldestAgeMs: 3_000,
-            filtered: 1,
-        });
-    });
-    it("clamps oldest message age to zero when the local clock trails SQS", async () => {
-        const sqs = new FakeSqs();
-        sqs.enqueueDrainable([{
-                ...msg(makeEvent()),
-                sentTimestampMs: 11_000,
-            }]);
-        const drainRecords = [];
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn: async () => undefined,
-            sleep: fastSleep,
-            now: () => 10_000,
-            publishMetric: async () => undefined,
-            logger: {
-                info: (record) => {
-                    if (record.event === "receiver.drain")
-                        drainRecords.push(record);
-                },
-                warn: () => undefined,
-                error: () => undefined,
-                debug: () => undefined,
-            },
-        });
-        await receiver.start();
-        await waitFor(() => sqs.deleted.length === 1);
-        await receiver.dispose();
-        expect(drainRecords).toHaveLength(1);
-        expect(drainRecords[0]?.oldestAgeMs).toBe(0);
-    });
-});
-describe("US-009: SqsPushReceiver — dedupe", () => {
-    it("REGRESSION: collapses 500 received messages across 3 paths into one sync pass", async () => {
-        const sqs = new FakeSqs();
-        const batches = [];
-        const syncBatchFn = async (ctx) => {
-            batches.push(ctx);
-        };
-        const paths = [
-            "companies/indigo/a.md",
-            "companies/indigo/b.md",
-            "companies/indigo/c.md",
-        ];
-        const messages = Array.from({ length: 500 }, (_, index) => msg(makeEvent({
-            relativePath: paths[index % paths.length],
-            sequenceNumber: index + 1,
-        }), `rh-batch-${index}`));
-        for (let start = 0; start < messages.length; start += 10) {
-            sqs.enqueueDrainable(messages.slice(start, start + 10));
-        }
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn,
-            sleep: fastSleep,
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount === 3);
-        await receiver.dispose();
-        expect(batches).toHaveLength(1);
-        expect(batches[0].events.map((event) => event.relativePath).sort()).toEqual(paths);
-    });
-    it("fills a 500-receipt drain after an empty short-poll false negative", async () => {
-        const receipts = Array.from({ length: 500 }, (_, index) => msg(makeEvent({
-            relativePath: `companies/indigo/false-negative/${index}.md`,
-            sequenceNumber: index + 1,
-        }), `rh-false-negative-${index}`));
-        const sqs = new FalseNegativeSqs(receipts);
-        const batches = [];
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            drainMaxMessages: 500,
-            batchMaxPaths: 500,
-            syncBatchFn: async (ctx) => { batches.push(ctx); },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount === 500);
-        await receiver.dispose();
-        expect(batches.map((batch) => batch.events.length)).toEqual([500]);
-        expect(sqs.deleted).toHaveLength(500);
-        expect(sqs.receiveWaitTimes.slice(0, 3)).toEqual([20, 0, 1]);
-    });
-    it("caps each 1,000-receipt drain at 256 paths and processes the remaining receipts", async () => {
-        const sqs = new FakeSqs();
-        const receipts = Array.from({ length: 1_000 }, (_, index) => msg(makeEvent({
-            relativePath: `companies/indigo/deep/${index % 256}.md`,
-            sequenceNumber: index + 1,
-        }), `rh-deep-${index}`));
-        for (let start = 0; start < receipts.length; start += 10) {
-            sqs.enqueueDrainable(receipts.slice(start, start + 10));
-        }
-        const batches = [];
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn: async (ctx) => { batches.push(ctx); },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        await waitFor(() => sqs.deleted.length === 1_000, 5_000);
-        await receiver.dispose();
-        expect(batches.map((batch) => batch.events.length)).toEqual([256]);
-        expect(sqs.deleted).toHaveLength(1_000);
-        expect(sqs.visibilityChanges).toEqual([]);
-        expect(sqs.receiveWaitTimes[0]).toBe(20);
-    });
-    it("reports a nonempty large drain before it can later report an empty long-poll", async () => {
-        const sqs = new FakeSqs();
-        const activity = [];
-        const receipts = Array.from({ length: 1_000 }, (_, index) => msg(makeEvent({
-            relativePath: `companies/indigo/bulk/${index % 256}.md`,
-            sequenceNumber: index + 1,
-        }), `rh-activity-${index}`));
-        for (let start = 0; start < receipts.length; start += 10) {
-            sqs.enqueueDrainable(receipts.slice(start, start + 10));
-        }
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn: async () => undefined,
-            onReceiveActivity: (hasMessages) => activity.push(hasMessages),
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount >= 256 && activity.includes(false));
-        await receiver.dispose();
-        expect(activity[0]).toBe(true);
-        expect(activity).toContain(false);
-        expect(sqs.deleted).toHaveLength(1_000);
-    });
-    it("ends a near-empty drain after three short-poll confirmations without busy-looping", async () => {
-        const sqs = new FakeSqs();
-        sqs.enqueue([msg(makeEvent({ sequenceNumber: 1 }), "rh-near-empty")]);
-        const batches = [];
-        const startedAt = Date.now();
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn: async (ctx) => { batches.push(ctx); },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount === 1);
-        const elapsedMs = Date.now() - startedAt;
-        await receiver.dispose();
-        expect(batches).toHaveLength(1);
-        expect(sqs.receiveWaitTimes.slice(0, 5)).toEqual([20, 0, 1, 1, 1]);
-        expect(sqs.receiveCalls).toBeLessThanOrEqual(6);
-        expect(elapsedMs).toBeLessThan(5_000);
-    });
-    it("REGRESSION: leases a receipt through a slow pass so it is received exactly once", async () => {
-        const sqs = new VisibilityExpirySqs(makeEvent({ sequenceNumber: 41 }));
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn: async () => {
-                await new Promise((resolve) => setTimeout(resolve, 25));
-            },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        await waitFor(() => sqs.deleted.length === 1);
-        await receiver.dispose();
-        expect(sqs.requestedVisibilityTimeouts[0]).toBe(600);
-        expect(sqs.deliveries).toHaveLength(1);
-    });
-    it("heartbeats a receipt when a targeted pull outlives its visibility lease", async () => {
-        const sqs = new VisibilityExpirySqs(makeEvent({ sequenceNumber: 42 }));
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            visibilityTimeoutSeconds: 1,
-            visibilityHeartbeatIntervalMs: 1,
-            syncBatchFn: async () => {
-                await new Promise((resolve) => setTimeout(resolve, 30));
-            },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        try {
-            await waitFor(() => sqs.deleteAttempts.length === 1);
-        }
-        finally {
-            await receiver.dispose();
-        }
-        expect(sqs.requestedVisibilityTimeouts[0]).toBe(1);
-        expect(sqs.visibilityChanges.length).toBeGreaterThan(0);
-        expect(sqs.deliveries).toHaveLength(1);
-        expect(sqs.deleted).toHaveLength(1);
-    });
-    it("keeps the receipt lease alive until a slow successful delete completes", async () => {
-        const sqs = new VisibilityExpirySqs(makeEvent({ sequenceNumber: 43 }));
-        sqs.deleteDelayMs = 30;
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            visibilityTimeoutSeconds: 1,
-            visibilityHeartbeatIntervalMs: 1,
-            syncBatchFn: async () => undefined,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        try {
-            await waitFor(() => sqs.deleteAttempts.length === 1);
-        }
-        finally {
-            await receiver.dispose();
-        }
-        expect(sqs.visibilityChanges.some((change) => change.visibilityTimeoutSeconds === 1)).toBe(true);
-        expect(sqs.deleteAttempts).toEqual([{ receiptHandle: "visibility-rh-1", expired: false }]);
-        expect(sqs.deliveries).toHaveLength(1);
-        expect(sqs.deleted).toHaveLength(1);
-    });
-    it("waits for an in-flight receipt heartbeat before releasing a failed delete", async () => {
-        let delivered = false;
-        let resolveHeartbeat;
-        const heartbeatGate = new Promise((resolve) => { resolveHeartbeat = resolve; });
-        let releaseDelete;
-        const deleteGate = new Promise((resolve) => { releaseDelete = resolve; });
-        const calls = [];
-        const sqs = {
-            receiveMessage: async ({ signal, waitTimeSeconds }) => {
-                if (!delivered) {
-                    delivered = true;
-                    return { messages: [msg(makeEvent({ sequenceNumber: 44 }), "rh-failed-delete")] };
-                }
-                if (signal.aborted || waitTimeSeconds <= 1)
-                    return { messages: [] };
-                return new Promise((resolve) => {
-                    signal.addEventListener("abort", () => resolve({ messages: [] }), { once: true });
-                });
-            },
-            deleteMessage: async () => {
-                calls.push("delete-start");
-                await deleteGate;
-                calls.push("delete-failed");
-                throw new Error("simulated delete failure");
-            },
-            changeMessageVisibility: async ({ visibilityTimeoutSeconds }) => {
-                if (visibilityTimeoutSeconds === 0) {
-                    calls.push("release");
-                    return;
-                }
-                calls.push("heartbeat-start");
-                await heartbeatGate;
-                calls.push("heartbeat-end");
-            },
-            changeMessageVisibilityBatch: async ({ entries, visibilityTimeoutSeconds }) => {
-                for (const _entry of entries) {
-                    if (visibilityTimeoutSeconds === 0) {
-                        calls.push("release");
-                    }
-                    else {
-                        calls.push("heartbeat-start");
-                        await heartbeatGate;
-                        calls.push("heartbeat-end");
-                    }
-                }
-                return { failedEntries: [] };
-            },
-        };
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            visibilityHeartbeatIntervalMs: 5,
-            syncBatchFn: async () => undefined,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        try {
-            await waitFor(() => calls.includes("delete-start"));
-            await waitFor(() => calls.includes("heartbeat-start"));
-            releaseDelete();
-            await waitFor(() => calls.includes("delete-failed"));
-            expect(calls).toEqual(["delete-start", "heartbeat-start", "delete-failed"]);
-            resolveHeartbeat();
-            await waitFor(() => calls.includes("release"));
-            expect(calls).toEqual([
-                "delete-start",
-                "heartbeat-start",
-                "delete-failed",
-                "heartbeat-end",
-                "release",
-            ]);
-        }
-        finally {
-            releaseDelete();
-            resolveHeartbeat();
-            await receiver.dispose();
-        }
-    });
-    it("REGRESSION: drains a 5,000-message FIFO backlog through bounded slow passes without lease-expiry redelivery", async () => {
-        const total = 5_000;
-        const sqs = new BacklogSqs(Array.from({ length: total }, (_, index) => msg(makeEvent({
-            relativePath: `companies/indigo/backlog/${index}.md`,
-            sequenceNumber: index + 1,
-        }), `rh-backlog-${index + 1}`)));
-        const drains = [];
-        let activePasses = 0;
-        let maxActivePasses = 0;
-        const startedAt = Date.now();
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            batchMaxPaths: 256,
-            drainMaxMessages: 256,
-            maxInFlightDrains: 2,
-            syncBatchFn: async () => {
-                activePasses += 1;
-                maxActivePasses = Math.max(maxActivePasses, activePasses);
-                await new Promise((resolve) => setTimeout(resolve, 30));
-                activePasses -= 1;
-            },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: {
-                debug: () => undefined,
-                warn: () => undefined,
-                error: () => undefined,
-                info: (record) => {
-                    if (record.event === "receiver.drain")
-                        drains.push(record);
-                },
-            },
-        });
-        await receiver.start();
-        await waitFor(() => sqs.deleted.length === total, 10_000);
-        const elapsedMs = Date.now() - startedAt;
-        await receiver.dispose();
-        const throughputPerMinute = total / elapsedMs * 60_000;
-        expect(throughputPerMinute).toBeGreaterThanOrEqual(300);
-        expect(maxActivePasses).toBe(2);
-        expect(sqs.received).toHaveLength(total);
-        expect(sqs.deleted).toHaveLength(total);
-        expect(sqs.released).toEqual([]);
-        expect(sqs.remaining).toBe(0);
-        expect(sqs.deleted[0]).toBe("rh-backlog-1");
-        expect(drains).toHaveLength(Math.ceil(total / 256));
-        expect(drains).toEqual(expect.arrayContaining([
-            expect.objectContaining({ remaining: 0 }),
-        ]));
-    }, 15_000);
-    it("stops a capped distinct-path drain before receiving and releasing more messages", async () => {
-        const first = [
-            msg(makeEvent({ relativePath: "companies/indigo/a.md", sequenceNumber: 1 }), "rh-a"),
-            msg(makeEvent({ relativePath: "companies/indigo/b.md", sequenceNumber: 2 }), "rh-b"),
-            msg(makeEvent({ relativePath: "companies/indigo/backlog.md", sequenceNumber: 3 }), "rh-backlog"),
-        ];
-        const sqs = new OverCapSqs(first);
-        const batches = [];
-        const fresh = msg(makeEvent({ relativePath: "companies/indigo/fresh.md", sequenceNumber: 4 }), "rh-fresh");
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            batchMaxPaths: 2,
-            drainMaxPaths: 2,
-            drainMaxMessages: 3,
-            syncBatchFn: async ({ events }) => {
-                batches.push(events.map((event) => event.relativePath));
-                if (batches.length === 1)
-                    sqs.enqueue(fresh);
-            },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        await waitFor(() => batches.some((batch) => batch.includes("companies/indigo/fresh.md")));
-        await receiver.dispose();
-        expect(sqs.receiveCalls[0]).toEqual({ waitTimeSeconds: 20, maxMessages: 2 });
-        expect(sqs.receiveCalls.filter((call) => call.waitTimeSeconds === 0)).toEqual([]);
-        expect(sqs.releases).toEqual([]);
-        expect(sqs.deleted).toHaveLength(4);
-        expect(batches[0]).toEqual([
-            "companies/indigo/a.md",
-            "companies/indigo/b.md",
-        ]);
-        expect(batches[1]).toContain("companies/indigo/fresh.md");
-    });
-    it("dispatches the collected batch and keeps polling when a confirmation receive fails", async () => {
-        const initial = msg(makeEvent({ sequenceNumber: 1 }), "rh-confirmation-failure");
-        const receiveWaitTimes = [];
-        let receiveCalls = 0;
-        let initialDelivered = false;
-        let confirmationFailed = false;
-        const deleted = [];
-        const warnings = [];
-        const sqs = {
-            receiveMessage: async (args) => {
-                receiveCalls += 1;
-                receiveWaitTimes.push(args.waitTimeSeconds);
-                if (!initialDelivered && args.waitTimeSeconds === 20) {
-                    initialDelivered = true;
-                    return { messages: [initial] };
-                }
-                if (args.waitTimeSeconds === 0)
-                    return { messages: [] };
-                if (args.waitTimeSeconds === 1 && !confirmationFailed) {
-                    confirmationFailed = true;
-                    throw new Error("transient confirmation receive failure");
-                }
-                return new Promise((resolve) => {
-                    if (args.signal.aborted)
-                        return resolve({ messages: [] });
-                    args.signal.addEventListener("abort", () => resolve({ messages: [] }), { once: true });
-                });
-            },
-            deleteMessage: async ({ receiptHandle }) => { deleted.push(receiptHandle); },
-            changeMessageVisibility: async () => { },
-            changeMessageVisibilityBatch: async () => ({ failedEntries: [] }),
-        };
-        const batches = [];
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn: async (ctx) => { batches.push(ctx); },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            reconnect: { initialMs: 1, maxMs: 4, jitter: false },
-            logger: {
-                info: () => undefined,
-                warn: (record) => { warnings.push(record); },
-                error: () => undefined,
-                debug: () => undefined,
-            },
-        });
-        await receiver.start();
-        await waitFor(() => batches.length === 1 && deleted.length === 1 && receiveCalls >= 4);
-        await receiver.dispose();
-        expect(batches).toHaveLength(1);
-        expect(batches[0].events).toHaveLength(1);
-        expect(deleted).toEqual(["rh-confirmation-failure"]);
-        expect(receiveWaitTimes.slice(0, 4)).toEqual([20, 0, 1, 20]);
-        expect(receiver.receiveErrorCount).toBe(1);
-        expect(warnings).toContainEqual(expect.objectContaining({
-            event: "receiver.receive.failed",
-            tenantId: TENANT,
-            err: { message: "transient confirmation receive failure" },
-        }));
-    });
-    it("keeps only the highest sequence number for each path within a coalesced pass", async () => {
-        const sqs = new FakeSqs();
-        const batches = [];
-        sqs.enqueue([
-            msg(makeEvent({ sequenceNumber: 1 }), "rh-seq-1"),
-            msg(makeEvent({ sequenceNumber: 3 }), "rh-seq-3"),
-            msg(makeEvent({ sequenceNumber: 2 }), "rh-seq-2"),
-        ]);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn: async (ctx) => { batches.push(ctx); },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount === 1);
-        await receiver.dispose();
-        expect(batches).toHaveLength(1);
-        expect(batches[0].events).toHaveLength(1);
-        expect(batches[0].events[0].sequenceNumber).toBe(3);
-        expect(sqs.deleted).toEqual(expect.arrayContaining(["rh-seq-1", "rh-seq-2", "rh-seq-3"]));
-    });
-    it("REGRESSION: coalesces create-then-delete receipts across receive pages before bounded pulls", async () => {
-        const pathCount = 256;
-        const creates = Array.from({ length: pathCount }, (_, index) => msg(makeEvent({
-            relativePath: `companies/indigo/dead-burst/${index}.md`,
-            sequenceNumber: index + 1,
-            kind: "upsert",
-        }), `rh-create-${index}`));
-        const deletes = Array.from({ length: pathCount }, (_, index) => msg(makeEvent({
-            relativePath: `companies/indigo/dead-burst/${index}.md`,
-            sequenceNumber: pathCount + index + 1,
-            kind: "delete",
-        }), `rh-delete-${index}`));
-        const sqs = new FakeSqs();
-        sqs.enqueueDrainable([...creates, ...deletes]);
-        const batches = [];
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            batchMaxPaths: 64,
-            drainMaxPaths: pathCount * 2,
-            drainMaxMessages: pathCount * 2,
-            syncBatchFn: async ({ events }) => { batches.push([...events]); },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount === pathCount);
-        await receiver.dispose();
-        expect(batches).toHaveLength(4);
-        expect(batches.flat()).toHaveLength(pathCount);
-        expect(batches.every((batch) => batch.length <= 64)).toBe(true);
-        expect(batches.flat().every((event) => event.kind === "delete")).toBe(true);
-        expect(sqs.deleted).toHaveLength(pathCount * 2);
-    });
-    it("keeps a newer create after delete and the latest repeated overwrite", async () => {
-        const sqs = new FakeSqs();
-        const earlierDelete = makeEvent({
-            relativePath: "companies/indigo/revived.md",
-            sequenceNumber: 10,
-            kind: "delete",
-        });
-        const latestCreate = makeEvent({
-            relativePath: "companies/indigo/revived.md",
-            sequenceNumber: 11,
-            kind: "upsert",
-            contentHash: `sha256:${"b".repeat(64)}`,
-        });
-        const firstOverwrite = makeEvent({
-            relativePath: "companies/indigo/overwritten.md",
-            sequenceNumber: 12,
-            kind: "upsert",
-            contentHash: `sha256:${"c".repeat(64)}`,
-        });
-        const latestOverwrite = makeEvent({
-            relativePath: "companies/indigo/overwritten.md",
-            sequenceNumber: 13,
-            kind: "upsert",
-            contentHash: `sha256:${"d".repeat(64)}`,
-        });
-        sqs.enqueue([
-            msg(earlierDelete, "rh-revived-delete"),
-            msg(latestCreate, "rh-revived-create"),
-            msg(firstOverwrite, "rh-overwrite-1"),
-            msg(latestOverwrite, "rh-overwrite-2"),
-        ]);
-        const batches = [];
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn: async (context) => { batches.push(context); },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount === 2);
-        await receiver.dispose();
-        expect(batches).toHaveLength(1);
-        expect(batches[0].events).toEqual([latestCreate, latestOverwrite]);
-        expect(sqs.deleted).toHaveLength(4);
-    });
-    it("splits a backlog above the distinct-path bound into bounded sequential passes", async () => {
-        const sqs = new FakeSqs();
-        const batches = [];
-        sqs.enqueue(Array.from({ length: 5 }, (_, index) => msg(makeEvent({ relativePath: `companies/indigo/${index}.md`, sequenceNumber: index + 1 }), `rh-limit-${index}`)));
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            batchMaxPaths: 3,
-            syncBatchFn: async ({ events }) => { batches.push(events.length); },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount === 5);
-        await receiver.dispose();
-        expect(batches).toEqual([3, 2]);
-        expect(batches.every((count) => count <= 3)).toBe(true);
-    });
-    it("dispatches each bounded partition array itself so the runner keeps its lane", async () => {
-        // The runner keys each partition array's fast/slow lane in a WeakMap.
-        // Copying an array that already fits the bound loses that lane and gives
-        // every chunk a fresh fast-lane budget.
-        const sqs = new FakeSqs();
-        sqs.enqueue(Array.from({ length: 5 }, (_, index) => msg(makeEvent({ relativePath: `companies/indigo/${index}.md`, sequenceNumber: index + 1 }), `rh-lane-${index}`)));
-        const returned = [];
-        const dispatched = [];
-        const syncBatchFn = async ({ events }) => { dispatched.push(events); };
-        syncBatchFn.partition = (events, maxPaths) => {
-            const bound = maxPaths ?? events.length;
-            const chunks = [];
-            for (let offset = 0; offset < events.length; offset += bound) {
-                chunks.push(events.slice(offset, offset + bound));
-            }
-            returned.push(...chunks);
-            return chunks;
-        };
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            batchMaxPaths: 3,
-            syncBatchFn,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount === 5);
-        await receiver.dispose();
-        expect(dispatched.flat().map((event) => event.sequenceNumber)).toEqual([1, 2, 3, 4, 5]);
-        expect(dispatched.every((events) => events.length <= 3)).toBe(true);
-        expect(dispatched).toHaveLength(returned.length);
-        dispatched.forEach((events, index) => expect(events).toBe(returned[index]));
-    });
-    it("acknowledges receipts per successful lane and retains failed slow residue", async () => {
-        const sqs = new FakeSqs();
-        const fast = makeEvent({ relativePath: "companies/indigo/fast.md", sequenceNumber: 1 });
-        const slow = makeEvent({ relativePath: "companies/indigo/slow.md", sequenceNumber: 2 });
-        sqs.enqueue([msg(fast, "rh-fast"), msg(slow, "rh-slow")]);
-        sqs.enqueue([msg(slow, "rh-slow-redelivered")]);
-        const dispatched = [];
-        let slowAttempts = 0;
-        const syncBatchFn = async ({ events }) => {
-            const relativePath = events[0].relativePath;
-            dispatched.push(relativePath);
-            if (relativePath === slow.relativePath && slowAttempts++ === 0) {
-                throw new Error("slow lane failed");
-            }
-        };
-        syncBatchFn.partition = (events) => [[events[0]], [events[1]]];
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount === 2);
-        await receiver.dispose();
-        expect(sqs.deleted).toContain("rh-fast");
-        expect(sqs.deleted).not.toContain("rh-slow");
-        expect(sqs.deleted).toContain("rh-slow-redelivered");
-        // Regression: a slow failure must redeliver only slow. Replaying fast
-        // here would pull it again even though its receipt was already durable.
-        expect(dispatched).toEqual([fast.relativePath, slow.relativePath, slow.relativePath]);
-    });
-    it("deletes a self echo immediately and performs zero sync passes", async () => {
-        const sqs = new FakeSqs();
-        const syncBatchFn = vi.fn(async () => undefined);
-        sqs.enqueue([msg(makeEvent({ originDeviceId: "this-device" }), "rh-self")]);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            shouldProcess: (event) => event.originDeviceId !== "this-device",
-            syncBatchFn,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        await waitFor(() => sqs.deleted.includes("rh-self"));
-        await receiver.dispose();
-        expect(syncBatchFn).not.toHaveBeenCalled();
-        expect(receiver.processedCount).toBe(0);
-    });
-    it("deletes filtered retired-overlay events while dispatching a valid absent path", async () => {
-        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-push-receiver-"));
-        const personalPath = path.join(hqRoot, "personal/policies/legacy-rule.md");
-        fs.mkdirSync(path.dirname(personalPath), { recursive: true });
-        fs.writeFileSync(personalPath, "fixture\n");
-        const sqs = new FakeSqs();
-        const syncBatchFn = vi.fn(async () => undefined);
-        const filtered = vi.fn();
-        const valid = makeEvent({
-            relativePath: "personal/policies/new-on-this-device.md",
-            sequenceNumber: 1,
-        });
-        const retiredUpsert = makeEvent({
-            relativePath: "core/policies/legacy-rule.md",
-            contentHash: `sha256:${hashFile(personalPath)}`,
-            sequenceNumber: 2,
-        });
-        const retiredDelete = makeEvent({
-            relativePath: "core/policies/legacy-rule.md",
-            kind: "delete",
-            contentHash: undefined,
-            mtime: undefined,
-            sequenceNumber: 3,
-        });
-        sqs.enqueue([msg(valid, "rh-valid"), msg(retiredUpsert, "rh-retired-upsert"), msg(retiredDelete, "rh-retired-delete")]);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            shouldProcess: (event) => isInboundEventPlaceable(hqRoot, event),
-            onFilteredEvents: filtered,
-            syncBatchFn,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        try {
-            await receiver.start();
-            await waitFor(() => syncBatchFn.mock.calls.length === 1);
-            await waitFor(() => sqs.deleted.includes("rh-retired-delete"));
-            await receiver.dispose();
-            expect(syncBatchFn).toHaveBeenCalledWith(expect.objectContaining({
-                events: [valid],
-            }));
-            expect(sqs.deleted).toEqual(expect.arrayContaining(["rh-valid", "rh-retired-upsert", "rh-retired-delete"]));
-            expect(filtered).toHaveBeenCalledWith([retiredUpsert, retiredDelete]);
-        }
-        finally {
-            await receiver.dispose();
-            fs.rmSync(hqRoot, { recursive: true, force: true });
-        }
-    });
-    it("skips an event whose sequenceNumber <= the highest seen for that path", async () => {
-        const sqs = new FakeSqs();
-        const processed = [];
-        const syncFn = async (ctx) => {
-            processed.push(ctx.event.sequenceNumber);
-        };
-        // seq 1, then a redelivery of 1, then 2 — same path.
-        sqs.enqueue([msg(makeEvent({ sequenceNumber: 1 }), "rh-a")]);
-        sqs.enqueue([msg(makeEvent({ sequenceNumber: 1 }), "rh-b")]);
-        sqs.enqueue([msg(makeEvent({ sequenceNumber: 2 }), "rh-c")]);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncFn,
-            sleep: fastSleep,
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount === 2);
-        await receiver.dispose();
-        expect(processed).toEqual([1, 2]);
-        expect(receiver.dedupedCount).toBe(1);
-        // The deduped redelivery is still deleted (we don't need it again).
-        expect(sqs.deleted).toContain("rh-b");
-    });
-    it("dedupe is per-path — same sequence number on different paths both process", async () => {
-        const sqs = new FakeSqs();
-        const processed = [];
-        const syncFn = async (ctx) => {
-            processed.push(ctx.event.relativePath);
-        };
-        sqs.enqueue([
-            msg(makeEvent({ relativePath: "companies/indigo/a.md", sequenceNumber: 5 }), "rh-1"),
-            msg(makeEvent({ relativePath: "companies/indigo/b.md", sequenceNumber: 5 }), "rh-2"),
-        ]);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncFn,
-            sleep: fastSleep,
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount === 2);
-        await receiver.dispose();
-        expect(new Set(processed)).toEqual(new Set(["companies/indigo/a.md", "companies/indigo/b.md"]));
-        expect(receiver.dedupedCount).toBe(0);
-    });
-    it("drops an undecodable message at the wire boundary without crashing the loop", async () => {
-        const sqs = new FakeSqs();
-        sqs.enqueue([{ Body: "{not json", ReceiptHandle: "rh-bad", MessageId: "m-bad" }]);
-        sqs.enqueue([msg(makeEvent({ sequenceNumber: 1 }), "rh-good")]);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncFn: async () => undefined,
-            sleep: fastSleep,
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount === 1);
-        await receiver.dispose();
-        expect(receiver.decodeFailureCount).toBe(1);
-        expect(sqs.deleted).toContain("rh-bad"); // poison message deleted
-        expect(sqs.deleted).toContain("rh-good");
-    });
-});
-describe("US-009: SqsPushReceiver — reconnect / catch-up replay", () => {
-    it("leaves only the failed path unacknowledged and retries it", async () => {
-        const sqs = new FakeSqs();
-        const events = [
-            makeEvent({ relativePath: "companies/indigo/retry-a.md", sequenceNumber: 1 }),
-            makeEvent({ relativePath: "companies/indigo/retry-b.md", sequenceNumber: 1 }),
-            makeEvent({ relativePath: "companies/indigo/retry-c.md", sequenceNumber: 1 }),
-        ];
-        sqs.enqueue(events.map((event, index) => msg(event, `rh-failed-${index}`)));
-        sqs.enqueue([msg(events[0], "rh-redelivered-a")]);
-        let batchCalls = 0;
-        let retryAPathCalls = 0;
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            maxInFlightDrains: 1,
-            syncBatchFn: async ({ events: batch }) => {
-                if (batch.length > 1) {
-                    batchCalls += 1;
-                    throw new Error("coalesced pull failed for one path");
-                }
-                if (batch[0]?.relativePath === events[0].relativePath) {
-                    retryAPathCalls += 1;
-                    if (retryAPathCalls === 1)
-                        throw new Error("retry-a is temporarily unavailable");
-                }
-            },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount === 3 && sqs.deleted.includes("rh-redelivered-a"));
-        await receiver.dispose();
-        expect(batchCalls).toBe(2);
-        expect(retryAPathCalls).toBe(2);
-        expect(sqs.deleted).not.toContain("rh-failed-0");
-        expect(sqs.deleted).toEqual(expect.arrayContaining(["rh-failed-1", "rh-failed-2", "rh-redelivered-a"]));
-        expect(sqs.visibilityChanges).toEqual([
-            { receiptHandle: "rh-failed-0", visibilityTimeoutSeconds: 20 },
-        ]);
-    });
-    it("recovers from transient receiveMessage failures (backoff + resume) and replays the queue", async () => {
-        const sqs = new FakeSqs();
-        sqs.failNext(2); // two transient disconnects before the message lands
-        sqs.enqueue([msg(makeEvent({ sequenceNumber: 1 }), "rh-1")]);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncFn: async () => undefined,
-            sleep: fastSleep,
-            reconnect: { initialMs: 1, maxMs: 4, jitter: false },
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount === 1);
-        await receiver.dispose();
-        expect(receiver.receiveErrorCount).toBe(2);
-        expect(sqs.deleted).toContain("rh-1");
-    });
-    it("a syncFn throw does not crash the loop and the next event still processes", async () => {
-        const sqs = new FakeSqs();
-        let calls = 0;
-        const syncFn = async () => {
-            calls += 1;
-            if (calls === 1)
-                throw new Error("boom");
-        };
-        sqs.enqueue([msg(makeEvent({ relativePath: "companies/indigo/x.md", sequenceNumber: 1 }), "rh-1")]);
-        sqs.enqueue([msg(makeEvent({ relativePath: "companies/indigo/y.md", sequenceNumber: 1 }), "rh-2")]);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncFn,
-            sleep: fastSleep,
-        });
-        await receiver.start();
-        await waitFor(() => calls === 2);
-        await receiver.dispose();
-        // First threw (processedCount not incremented), second succeeded.
-        expect(receiver.processedCount).toBe(1);
-        // F10: a failed targeted pull is left undeleted for SQS redelivery; only the
-        // successful message (rh-2) is acknowledged. The thrown one (rh-1) stays on
-        // the queue so the visibility-timeout redelivery can retry it.
-        expect(sqs.deleted).toContain("rh-2");
-        expect(sqs.deleted).not.toContain("rh-1");
-    });
-    it("F10: leaves failed targeted pull messages undeleted so redelivery retries", async () => {
-        const sqs = new FakeSqs();
-        let calls = 0;
-        const syncFn = async () => {
-            calls += 1;
-            if (calls === 1)
-                throw new Error("targeted pull failed");
-        };
-        const event = makeEvent({
-            relativePath: "companies/indigo/retry-after-failure.md",
-            sequenceNumber: 7,
-        });
-        sqs.enqueue([msg(event, "rh-first-attempt")]);
-        sqs.enqueue([msg(event, "rh-redelivery")]);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncFn,
-            sleep: fastSleep,
-        });
-        await receiver.start();
-        await waitFor(() => sqs.deleted.includes("rh-redelivery"));
-        await receiver.dispose();
-        expect(calls).toBe(2);
-        expect(receiver.processedCount).toBe(1);
-        expect(receiver.dedupedCount).toBe(0);
-        expect(sqs.deleted).not.toContain("rh-first-attempt");
-        expect(sqs.deleted).toContain("rh-redelivery");
-    });
-    it("F29: bounds dedupe state by evicting least-recently-used paths", async () => {
-        const sqs = new FakeSqs();
-        const processed = [];
-        const syncFn = async (ctx) => {
-            processed.push(ctx.event.relativePath);
-        };
-        sqs.enqueue([msg(makeEvent({ relativePath: "companies/indigo/a.md", sequenceNumber: 1 }), "rh-a1")]);
-        sqs.enqueue([msg(makeEvent({ relativePath: "companies/indigo/b.md", sequenceNumber: 1 }), "rh-b1")]);
-        sqs.enqueue([msg(makeEvent({ relativePath: "companies/indigo/c.md", sequenceNumber: 1 }), "rh-c1")]);
-        sqs.enqueue([msg(makeEvent({ relativePath: "companies/indigo/a.md", sequenceNumber: 1 }), "rh-a-redelivered")]);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncFn,
-            sleep: fastSleep,
-            dedupeMaxPaths: 2,
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount === 4);
-        await receiver.dispose();
-        expect(processed).toEqual([
-            "companies/indigo/a.md",
-            "companies/indigo/b.md",
-            "companies/indigo/c.md",
-            "companies/indigo/a.md",
-        ]);
-        expect(receiver.dedupedCount).toBe(0);
-        expect(sqs.deleted).toContain("rh-a-redelivered");
-    });
-});
-describe("U15: SqsPushReceiver — server-granted handoff", () => {
-    it("starts from supplied server queue material with no tenant client gate", async () => {
-        const sqs = new FakeSqs();
-        sqs.enqueue([msg(makeEvent({ sequenceNumber: 1 }))]);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncFn: async () => undefined,
-            sleep: fastSleep,
-        });
-        await receiver.start();
-        await waitFor(() => receiver.processedCount === 1);
-        expect(receiver.connected).toBe(true);
-        await receiver.dispose();
-    });
-});
-describe("US-009: SqsPushReceiver — dispose drain", () => {
-    it("aborts and drains the in-flight syncFn, then disconnects", async () => {
-        const sqs = new FakeSqs();
-        let aborted = false;
-        let resolveSync = null;
-        const syncFn = (ctx) => new Promise((resolve) => {
-            resolveSync = resolve;
-            ctx.signal.addEventListener("abort", () => {
-                aborted = true;
-                resolve();
-            });
-        });
-        sqs.enqueue([msg(makeEvent({ sequenceNumber: 1 }))]);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncFn,
-            sleep: fastSleep,
-            disposeDrainMs: 200,
-        });
-        await receiver.start();
-        await waitFor(() => resolveSync !== null);
-        await receiver.dispose();
-        expect(aborted).toBe(true);
-        expect(receiver.connected).toBe(false);
-    });
-    it("dispose is idempotent", async () => {
-        const sqs = new FakeSqs();
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncFn: async () => undefined,
-            sleep: fastSleep,
-        });
-        await receiver.start();
-        await Promise.all([receiver.dispose(), receiver.dispose()]);
-        expect(receiver.connected).toBe(false);
-    });
-});
-// ─── InMemoryPushReceiver (transport analogue) ───────────────────────────────
-describe("US-009: InMemoryPushReceiver — disconnect buffering + reconnect drain", () => {
-    it("buffers events during disconnect and drains them on reconnect, deduping replays", async () => {
-        const fanout = new InMemoryFanout();
-        const processed = [];
-        const receiver = new InMemoryPushReceiver({
-            tenantId: TENANT,
-            fanout,
-            syncFn: async (ctx) => {
-                processed.push(ctx.event.sequenceNumber);
-            },
-        });
-        await receiver.start();
-        fanout.publish(encodePushEvent(makeEvent({ sequenceNumber: 1 })));
-        await waitFor(() => receiver.processedCount === 1);
-        receiver.simulateDisconnect();
-        expect(receiver.connected).toBe(false);
-        // Published while disconnected — buffered, not processed.
-        fanout.publish(encodePushEvent(makeEvent({ sequenceNumber: 2 })));
-        fanout.publish(encodePushEvent(makeEvent({ sequenceNumber: 1 }))); // stale replay
-        expect(receiver.bufferedCount).toBe(2);
-        receiver.simulateReconnect();
-        await waitFor(() => receiver.processedCount === 2);
-        await receiver.dispose();
-        // seq 2 processed; the stale seq-1 replay deduped.
-        expect(processed).toEqual([1, 2]);
-        expect(receiver.dedupedCount).toBe(1);
-    });
-    it("does not derive activation from a tenant flag", async () => {
-        const fanout = new InMemoryFanout();
-        let calls = 0;
-        const receiver = new InMemoryPushReceiver({
-            tenantId: TENANT,
-            fanout,
-            syncFn: async () => {
-                calls += 1;
-            },
-        });
-        await receiver.start();
-        fanout.publish(encodePushEvent(makeEvent()));
-        await new Promise((r) => setTimeout(r, 20));
-        await waitFor(() => calls === 1);
-        expect(receiver.connected).toBe(true);
-        expect(calls).toBe(1);
-        await receiver.dispose();
-    });
-});
-// ─── Factory + Noop ──────────────────────────────────────────────────────────
-describe("US-009: createPushReceiver factory", () => {
-    it("returns NoopPushReceiver for kind:noop", () => {
-        const r = createPushReceiver({ kind: "noop" });
-        expect(r).toBeInstanceOf(NoopPushReceiver);
-    });
-    it("returns SqsPushReceiver when a queue + sqs client are supplied", () => {
-        const r = createPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs: new FakeSqs(),
-            syncFn: async () => undefined,
-        });
-        expect(r).toBeInstanceOf(SqsPushReceiver);
-    });
-    it("NoopPushReceiver flips connected on start/dispose with no work", async () => {
-        const r = new NoopPushReceiver();
-        expect(r.connected).toBe(false);
-        await r.start();
-        expect(r.connected).toBe(true);
-        await r.dispose();
-        expect(r.connected).toBe(false);
-    });
-});
-describe("SqsPushReceiver failed-batch retry visibility", () => {
-    it("releases an overlong drain so the receiver resumes polling after two stuck drains", async () => {
-        vi.useFakeTimers();
-        const sqs = new FakeSqs();
-        const events = [
-            makeEvent({ relativePath: "companies/indigo/stuck-one.md", sequenceNumber: 1 }),
-            makeEvent({ relativePath: "companies/indigo/stuck-two.md", sequenceNumber: 2 }),
-            makeEvent({ relativePath: "companies/indigo/stuck-three.md", sequenceNumber: 3 }),
-        ];
-        sqs.enqueueDrainable([msg(events[0])]);
-        let syncCalls = 0;
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            maxInFlightDrains: 2,
-            visibilityTimeoutSeconds: 600,
-            visibilityHeartbeatIntervalMs: 300_000,
-            disposeDrainMs: 1,
-            syncBatchFn: async () => {
-                if (syncCalls === 0)
-                    sqs.enqueueDrainable([msg(events[1])]);
-                syncCalls += 1;
-                return new Promise(() => undefined);
-            },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: makeDrainLogger([]),
-        });
-        try {
-            await receiver.start();
-            await vi.waitFor(() => expect(syncCalls).toBe(2));
-            await vi.advanceTimersByTimeAsync(600_000);
-            await vi.waitFor(() => expect(sqs.receiveCalls).toBeGreaterThan(2));
-            expect(sqs.visibilityChanges).toContainEqual({
-                receiptHandle: "rh-1",
-                visibilityTimeoutSeconds: 20,
-            });
-            expect(sqs.visibilityChanges).toContainEqual({
-                receiptHandle: "rh-2",
-                visibilityTimeoutSeconds: 20,
-            });
-        }
-        finally {
-            const disposing = receiver.dispose();
-            await vi.advanceTimersByTimeAsync(10);
-            await disposing;
-            vi.useRealTimers();
-        }
-    });
-    it("settles a completed route group's receipt while another group is still running", async () => {
-        const sqs = new FakeSqs();
-        const fast = makeEvent({ relativePath: "personal/notes/fast.md", sequenceNumber: 1 });
-        const slow = makeEvent({ relativePath: "companies/indigo/slow.md", sequenceNumber: 2 });
-        sqs.enqueueDrainable([msg(fast, "rh-fast"), msg(slow, "rh-slow")]);
-        let started;
-        const passStarted = new Promise((resolve) => { started = resolve; });
-        let releaseSlow;
-        const slowGate = new Promise((resolve) => { releaseSlow = resolve; });
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            maxInFlightDrains: 1,
-            syncBatchFn: async (context) => {
-                started();
-                await context.settleEvents?.([fast]);
-                await slowGate;
-                await context.settleEvents?.([slow]);
-            },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: makeDrainLogger([]),
-        });
-        try {
-            await receiver.start();
-            await passStarted;
-            await vi.waitFor(() => expect(sqs.deleted).toContain("rh-fast"));
-            expect(sqs.deleted).not.toContain("rh-slow");
-            releaseSlow();
-            await vi.waitFor(() => expect(sqs.deleted).toContain("rh-slow"));
-        }
-        finally {
-            releaseSlow();
-            await receiver.dispose();
-        }
-    });
-    it("resumes lease heartbeats and accepts a later route settle after one settle throws", async () => {
-        const sqs = new FakeSqs();
-        const failed = makeEvent({ relativePath: "companies/indigo/failed-settle.md", sequenceNumber: 21 });
-        const next = makeEvent({ relativePath: "companies/indigo/next-settle.md", sequenceNumber: 22 });
-        const held = makeEvent({ relativePath: "companies/indigo/held-settle.md", sequenceNumber: 23 });
-        sqs.enqueueDrainable([
-            msg(failed, "rh-failed-settle"),
-            msg(next, "rh-next-settle"),
-            msg(held, "rh-held-settle"),
-        ]);
-        let releasePass;
-        const passGate = new Promise((resolve) => { releasePass = resolve; });
-        let laterSettleFinished = false;
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            visibilityTimeoutSeconds: 20,
-            visibilityHeartbeatIntervalMs: 5,
-            syncBatchFn: async (context) => {
-                const internals = receiver;
-                const originalSafeDelete = internals.safeDelete.bind(receiver);
-                internals.safeDelete = async (message) => {
-                    if (message.ReceiptHandle === "rh-failed-settle") {
-                        throw new Error("simulated acknowledgement failure");
-                    }
-                    return originalSafeDelete(message);
-                };
-                await expect(context.settleEvents?.([failed])).rejects.toThrow("simulated acknowledgement failure");
-                await context.settleEvents?.([next]);
-                laterSettleFinished = true;
-                await passGate;
-            },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: makeDrainLogger([]),
-        });
-        try {
-            await receiver.start();
-            await vi.waitFor(() => expect(laterSettleFinished).toBe(true));
-            await vi.waitFor(() => expect(sqs.deleted).toContain("rh-next-settle"));
-            await vi.waitFor(() => expect(sqs.visibilityChanges).toContainEqual({
-                receiptHandle: "rh-held-settle",
-                visibilityTimeoutSeconds: 20,
-            }));
-        }
-        finally {
-            releasePass();
-            await receiver.dispose();
-        }
-    });
-    it("keeps the outer heartbeat pause active when a nested delete fails", async () => {
-        const sqs = new FakeSqs();
-        const event = makeEvent({ relativePath: "companies/indigo/nested-settle.md", sequenceNumber: 24 });
-        const message = msg(event, "rh-delete-fails");
-        vi.useFakeTimers();
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            visibilityTimeoutSeconds: 20,
-            visibilityHeartbeatIntervalMs: 5,
-            syncFn: async () => undefined,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: makeDrainLogger([]),
-        });
-        const internals = receiver;
-        const heartbeat = internals.startReceiptLeaseHeartbeat();
-        heartbeat.add(message);
-        sqs.deleteMessage = async () => { throw new Error("simulated delete failure"); };
-        try {
-            await heartbeat.pause(); // settleEvents owns the outer pause.
-            try {
-                await sqs.deleteMessage({ queueUrl: QUEUE_URL, receiptHandle: "rh-delete-fails" });
-            }
-            catch {
-                await heartbeat.pause(); // acknowledge pauses while releasing a failed delete.
-            }
-            finally {
-                heartbeat.resume(); // acknowledge's finally must not resume the outer pause.
-            }
-            await vi.advanceTimersByTimeAsync(10);
-            expect(sqs.visibilityBatchCalls).toHaveLength(0);
-            heartbeat.resume();
-            await vi.advanceTimersByTimeAsync(5);
-            expect(sqs.visibilityBatchCalls).toHaveLength(1);
-            expect(sqs.visibilityBatchCalls[0]?.entries).toContainEqual({
-                id: "receipt-0",
-                receiptHandle: "rh-delete-fails",
-            });
-        }
-        finally {
-            await heartbeat.stop();
-            vi.useRealTimers();
-            await receiver.dispose();
-        }
-    });
-    it("waits for a timed-out pull to stop before applying its redelivery once", async () => {
-        const sqs = new FakeSqs();
-        const event = makeEvent({ relativePath: "companies/indigo/timeout-redelivery.md" });
-        sqs.enqueueDrainable([msg(event, "rh-timeout-original")]);
-        let oldPullStarted;
-        const oldPullStartedPromise = new Promise((resolve) => { oldPullStarted = resolve; });
-        let syncCalls = 0;
-        let oldPullStopped = false;
-        let applied = 0;
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            maxInFlightDrains: 2,
-            drainTimeoutMs: 100,
-            disposeDrainMs: 1,
-            syncBatchFn: async (context) => {
-                syncCalls += 1;
-                if (syncCalls === 1) {
-                    oldPullStarted();
-                    await new Promise((resolve) => {
-                        if (context.signal.aborted)
-                            resolve();
-                        else
-                            context.signal.addEventListener("abort", () => resolve(), { once: true });
-                    });
-                    oldPullStopped = context.signal.aborted;
-                    return;
-                }
-                expect(oldPullStopped).toBe(true);
-                applied += 1;
-            },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: makeDrainLogger([]),
-        });
-        try {
-            await receiver.start();
-            await oldPullStartedPromise;
-            await new Promise((resolve) => setTimeout(resolve, 120));
-            await vi.waitFor(() => expect(sqs.visibilityChanges).toContainEqual({
-                receiptHandle: "rh-timeout-original",
-                visibilityTimeoutSeconds: 20,
-            }));
-            sqs.enqueueDrainable([msg(event, "rh-timeout-redelivered")]);
-            await vi.waitFor(() => expect(sqs.receivedReceiptHandles).toContain("rh-timeout-redelivered"));
-            await vi.waitFor(() => expect(applied).toBe(1));
-            expect(oldPullStopped).toBe(true);
-            expect(sqs.deleted).toContain("rh-timeout-redelivered");
-            expect(applied).toBe(1);
-        }
-        finally {
-            await receiver.dispose();
-        }
-    });
-    it("releases a timed-out multi-path batch once without reporting success telemetry", async () => {
-        const sqs = new FakeSqs();
-        const firstEvent = makeEvent({ relativePath: "companies/indigo/timeout-first.md", sequenceNumber: 31 });
-        const secondEvent = makeEvent({ relativePath: "companies/indigo/timeout-second.md", sequenceNumber: 32 });
-        sqs.enqueueDrainable([
-            msg(firstEvent, "rh-timeout-first"),
-            msg(secondEvent, "rh-timeout-second"),
-        ]);
-        const metric = vi.fn(async () => undefined);
-        const infos = [];
-        let syncCalls = 0;
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            maxInFlightDrains: 2,
-            drainTimeoutMs: 30,
-            syncBatchFn: async ({ signal }) => {
-                syncCalls += 1;
-                await new Promise((resolve) => {
-                    if (signal.aborted)
-                        resolve();
-                    else
-                        signal.addEventListener("abort", () => resolve(), { once: true });
-                });
-            },
-            sleep: fastSleep,
-            publishMetric: metric,
-            logger: {
-                debug: () => undefined,
-                warn: () => undefined,
-                error: () => undefined,
-                info: (record) => infos.push(record),
-            },
-        });
-        try {
-            await receiver.start();
-            await vi.waitFor(() => {
-                expect(sqs.visibilityChanges).toEqual(expect.arrayContaining([
-                    { receiptHandle: "rh-timeout-first", visibilityTimeoutSeconds: 20 },
-                    { receiptHandle: "rh-timeout-second", visibilityTimeoutSeconds: 20 },
-                ]));
-            });
-            expect(syncCalls).toBe(1);
-            expect(metric).not.toHaveBeenCalled();
-            expect(infos.some((record) => record.event === "fanout.receive")).toBe(false);
-        }
-        finally {
-            await receiver.dispose();
-        }
-    });
-    it("applies a released receipt once when SQS redelivers it", async () => {
-        vi.useFakeTimers();
-        const sqs = new FakeSqs();
-        const event = makeEvent({ relativePath: "companies/indigo/redelivery-once.md" });
-        sqs.enqueueDrainable([msg(event)]);
-        let syncCalls = 0;
-        let applied = 0;
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            maxInFlightDrains: 2,
-            drainTimeoutMs: 100,
-            visibilityTimeoutSeconds: 600,
-            visibilityHeartbeatIntervalMs: 300_000,
-            disposeDrainMs: 1,
-            syncBatchFn: async ({ signal }) => {
-                syncCalls += 1;
-                if (syncCalls === 1) {
-                    await new Promise((resolve) => {
-                        signal.addEventListener("abort", () => resolve(), { once: true });
-                    });
-                    return;
-                }
-                applied += 1;
-            },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: makeDrainLogger([]),
-        });
-        try {
-            await receiver.start();
-            await vi.waitFor(() => expect(syncCalls).toBe(1));
-            await vi.advanceTimersByTimeAsync(100);
-            expect(sqs.visibilityChanges).toContainEqual({
-                receiptHandle: "rh-1",
-                visibilityTimeoutSeconds: 20,
-            });
-            // A new receipt handle for the same SQS message models the retry delivery.
-            sqs.enqueueDrainable([msg(event, "rh-redelivered")]);
-            await vi.waitFor(() => expect(syncCalls).toBe(2));
-            expect(applied).toBe(1);
-            expect(sqs.deleted).toEqual(["rh-redelivered"]);
-            expect(syncCalls).toBe(2);
-        }
-        finally {
-            const disposing = receiver.dispose();
-            await vi.advanceTimersByTimeAsync(10);
-            await disposing;
-            vi.useRealTimers();
-        }
-    });
-    const first = makeEvent({
-        relativePath: "companies/indigo/retry-first.md",
-        sequenceNumber: 101,
-    });
-    const second = makeEvent({
-        relativePath: "companies/indigo/retry-second.md",
-        sequenceNumber: 102,
-    });
-    function partitionEachEvent(events) {
-        return events.map((event) => [event]);
-    }
-    function makeDrainLogger(drains, warnings = []) {
-        return {
-            debug: () => undefined,
-            warn: (record) => warnings.push(record),
-            error: () => undefined,
-            info: (record) => {
-                if (record.event === "receiver.drain")
-                    drains.push(record);
-            },
-        };
-    }
-    it("removes an invalid heartbeat receipt after logging the failure once", async () => {
-        const sqs = new FakeSqs();
-        sqs.enqueueDrainable([msg(first, "rh-invalid-heartbeat")]);
-        sqs.failVisibilityBatchEntry("rh-invalid-heartbeat", {
-            code: "ReceiptHandleIsInvalid",
-            message: "receipt handle is no longer valid",
-            senderFault: true,
-        });
-        const warnings = [];
-        let started = false;
-        let releasePass;
-        const passBlockedOnAdmission = new Promise((resolve) => {
-            releasePass = resolve;
-        });
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn: async () => {
-                started = true;
-                await passBlockedOnAdmission;
-            },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            visibilityHeartbeatIntervalMs: 5,
-            logger: makeDrainLogger([], warnings),
-        });
-        try {
-            await receiver.start();
-            await waitFor(() => started && sqs.visibilityBatchCalls.length >= 1);
-            await new Promise((resolve) => setTimeout(resolve, 40));
-            expect(sqs.visibilityBatchCalls).toHaveLength(1);
-            expect(warnings.filter((warning) => warning.event === "receiver.lease.extend.failed"))
-                .toHaveLength(1);
-            expect(warnings[0]).toMatchObject({
-                event: "receiver.lease.extend.failed",
-                code: "ReceiptHandleIsInvalid",
-            });
-        }
-        finally {
-            releasePass();
-            await receiver.dispose();
-        }
-    });
-    it("sets the failed batch receipts to 20 seconds without deleting them", async () => {
-        const sqs = new FakeSqs();
-        sqs.enqueueDrainable([
-            msg(first, "rh-retry-first"),
-            msg(second, "rh-retry-second"),
-        ]);
-        const calls = [];
-        const drains = [];
-        const syncBatchFn = Object.assign(async ({ events }) => {
-            calls.push(events.map((event) => event.relativePath));
-            if (calls.length === 1)
-                throw new Error("first targeted pull failed");
-        }, { partition: partitionEachEvent });
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: makeDrainLogger(drains),
-        });
-        await receiver.start();
-        await waitFor(() => drains.length === 1);
-        await receiver.dispose();
-        expect(calls[0]).toEqual([first.relativePath]);
-        expect(sqs.visibilityChanges).toEqual([
-            { receiptHandle: "rh-retry-first", visibilityTimeoutSeconds: 20 },
-        ]);
-        expect(sqs.deleted).not.toContain("rh-retry-first");
-        expect(drains[0]).toMatchObject({ retried: 1 });
-    });
-    it("dispatches the next batch in the same drain and deletes its receipts", async () => {
-        const sqs = new FakeSqs();
-        sqs.enqueueDrainable([
-            msg(first, "rh-next-first"),
-            msg(second, "rh-next-second"),
-        ]);
-        const calls = [];
-        const drains = [];
-        const syncBatchFn = Object.assign(async ({ events }) => {
-            calls.push(events.map((event) => event.relativePath));
-            if (calls.length === 1)
-                throw new Error("first targeted pull failed");
-        }, { partition: partitionEachEvent });
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: makeDrainLogger(drains),
-        });
-        await receiver.start();
-        await waitFor(() => drains.length === 1);
-        await receiver.dispose();
-        expect(calls).toEqual([[first.relativePath], [second.relativePath]]);
-        expect(sqs.deleted).toContain("rh-next-second");
-        expect(sqs.deleted).not.toContain("rh-next-first");
-    });
-    it("acks successful paths and retries only paths that fail inside a coalesced batch", async () => {
-        const blocked = makeEvent({
-            relativePath: "companies/indigo/out-of-scope.md",
-            sequenceNumber: 103,
-        });
-        const allowed = makeEvent({
-            relativePath: "companies/indigo/in-scope.md",
-            sequenceNumber: 104,
-        });
-        const sqs = new FakeSqs();
-        sqs.enqueueDrainable([
-            msg(blocked, "rh-out-of-scope"),
-            msg(allowed, "rh-in-scope"),
-        ]);
-        const calls = [];
-        const drains = [];
-        const syncBatchFn = async ({ events }) => {
-            const paths = events.map((event) => event.relativePath);
-            calls.push(paths);
-            if (paths.length > 1 || paths[0] === blocked.relativePath) {
-                throw new Error("targeted batch includes an out-of-scope path");
-            }
-        };
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: makeDrainLogger(drains),
-        });
-        await receiver.start();
-        await waitFor(() => drains.length === 1);
-        await receiver.dispose();
-        expect(calls).toEqual([
-            [blocked.relativePath, allowed.relativePath],
-            [blocked.relativePath],
-            [allowed.relativePath],
-        ]);
-        expect(sqs.deleted).toEqual(["rh-in-scope"]);
-        expect(sqs.visibilityChanges).toEqual([
-            { receiptHandle: "rh-out-of-scope", visibilityTimeoutSeconds: 20 },
-        ]);
-        expect(drains[0]).toMatchObject({ deleted: 1, retried: 1 });
-    });
-    it("holds the lease and resumes locally after a realtime-admission timeout", async () => {
-        const sqs = new FakeSqs();
-        sqs.enqueueDrainable([msg(first, "rh-admission-timeout")]);
-        const drains = [];
-        const warnings = [];
-        const errors = [];
-        const infos = [];
-        let attempts = 0;
-        const admissionTimeout = new Error("realtime admission timeout after 120000ms");
-        admissionTimeout.name = "RealtimeAdmissionTimeout";
-        const drainLogger = makeDrainLogger(drains, warnings);
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn: async () => {
-                attempts += 1;
-                if (attempts === 1)
-                    throw admissionTimeout;
-            },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: {
-                ...drainLogger,
-                error: (record) => errors.push(record),
-                info: (record) => {
-                    infos.push(record);
-                    drainLogger.info(record);
-                },
-            },
-        });
-        await receiver.start();
-        await waitFor(() => sqs.deleted.length === 1);
-        await receiver.dispose();
-        expect(attempts).toBe(2);
-        expect(sqs.visibilityChanges).toEqual([]);
-        expect(sqs.deleted).toEqual(["rh-admission-timeout"]);
-        expect(warnings.some((warning) => warning.event === "receiver.retry.failed")).toBe(false);
-        expect(drains[0]).toMatchObject({ deleted: 1, retried: 0 });
-        // A deferral, not a failure: no error-level line, one info line.
-        expect(errors).toEqual([]);
-        expect(infos.filter((record) => record.event === "receiver.sync.admission-timeout"))
-            .toHaveLength(1);
-    });
-    it("renews the receipt lease while it waits out repeated realtime-admission timeouts", async () => {
-        // The admission retry can hold a receipt for minutes behind a long
-        // reconcile. The lease heartbeat must keep renewing it for the whole
-        // wait, so the message cannot become visible to another receive and be
-        // delivered twice while this receiver still owns it.
-        const sqs = new FakeSqs();
-        sqs.enqueueDrainable([msg(first, "rh-admission-lease")]);
-        let attempts = 0;
-        const admissionTimeout = new Error("realtime admission timeout after 30000ms");
-        admissionTimeout.name = "RealtimeAdmissionTimeout";
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            visibilityTimeoutSeconds: 600,
-            visibilityHeartbeatIntervalMs: 5,
-            syncBatchFn: async () => {
-                attempts += 1;
-                if (attempts <= 3)
-                    throw admissionTimeout;
-            },
-            // Each retry wait spans several heartbeat intervals.
-            sleep: (_ms, signal) => new Promise((resolve) => {
-                if (signal.aborted)
-                    return resolve();
-                setTimeout(resolve, 30);
-            }),
-            publishMetric: async () => undefined,
-            logger: { debug: () => undefined, info: () => undefined, warn: () => undefined, error: () => undefined },
-        });
-        await receiver.start();
-        await waitFor(() => sqs.deleted.length === 1);
-        await receiver.dispose();
-        expect(attempts).toBe(4);
-        const leaseChanges = sqs.visibilityChanges.filter((change) => change.receiptHandle === "rh-admission-lease");
-        // Renewed at least once per retry wait, always to the full lease, and
-        // never released for redelivery.
-        expect(leaseChanges.length).toBeGreaterThanOrEqual(3);
-        expect(leaseChanges.every((change) => change.visibilityTimeoutSeconds === 600)).toBe(true);
-        expect(sqs.deleted).toEqual(["rh-admission-lease"]);
-    });
-    it("keeps the all-success path free of visibility changes and deletes every receipt", async () => {
-        const sqs = new FakeSqs();
-        sqs.enqueueDrainable([
-            msg(first, "rh-success-first"),
-            msg(second, "rh-success-second"),
-        ]);
-        const drains = [];
-        const syncBatchFn = Object.assign(async () => undefined, { partition: partitionEachEvent });
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: makeDrainLogger(drains),
-        });
-        await receiver.start();
-        await waitFor(() => drains.length === 1);
-        await receiver.dispose();
-        expect(sqs.visibilityChanges).toEqual([]);
-        expect(sqs.deleted).toEqual(["rh-success-first", "rh-success-second"]);
-    });
-    it("logs a retry visibility failure and still dispatches the next batch", async () => {
-        const sqs = new FakeSqs();
-        sqs.failNextVisibilityChange();
-        sqs.enqueueDrainable([
-            msg(first, "rh-visibility-failure-first"),
-            msg(second, "rh-visibility-failure-second"),
-        ]);
-        const calls = [];
-        const drains = [];
-        const warnings = [];
-        const syncBatchFn = Object.assign(async ({ events }) => {
-            calls.push(events.map((event) => event.relativePath));
-            if (calls.length === 1)
-                throw new Error("first targeted pull failed");
-        }, { partition: partitionEachEvent });
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: makeDrainLogger(drains, warnings),
-        });
-        await receiver.start();
-        await waitFor(() => drains.length === 1);
-        await receiver.dispose();
-        expect(calls).toEqual([[first.relativePath], [second.relativePath]]);
-        expect(sqs.deleted).toContain("rh-visibility-failure-second");
-        expect(warnings).toContainEqual(expect.objectContaining({
-            event: "receiver.retry.failed",
-            messageId: `m-${first.relativePath}-${first.sequenceNumber}`,
-        }));
-    });
-    it("bounds a 64-path transport failure to one dispatch and batches the retry lease", async () => {
-        const total = 64;
-        const events = Array.from({ length: total }, (_, index) => makeEvent({
-            relativePath: `companies/indigo/transport-${index}.md`,
-            sequenceNumber: index + 1,
-        }));
-        const sqs = new FakeSqs();
-        sqs.enqueueDrainable(events.map((event, index) => msg(event, `rh-transport-${index}`)));
-        const drains = [];
-        let dispatchCalls = 0;
-        const transportError = Object.assign(new Error("ECONNRESET: socket hang up while pulling remote objects"), { code: "ECONNRESET" });
-        const startedAt = Date.now();
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            drainMaxMessages: total,
-            batchMaxPaths: total,
-            syncBatchFn: async () => {
-                dispatchCalls += 1;
-                throw transportError;
-            },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: makeDrainLogger(drains),
-        });
-        await receiver.start();
-        await waitFor(() => drains.length === 1, 5_000);
-        await receiver.dispose();
-        expect(dispatchCalls).toBe(1);
-        expect(Date.now() - startedAt).toBeLessThan(5_000);
-        expect(sqs.deleted).toEqual([]);
-        expect(sqs.visibilityChanges.filter((change) => change.visibilityTimeoutSeconds === 20))
-            .toHaveLength(total);
-        const retryCalls = sqs.visibilityBatchCalls.filter((call) => call.visibilityTimeoutSeconds === 20);
-        expect(retryCalls).toHaveLength(7);
-        expect(retryCalls.every((call) => call.entries.length <= 10)).toBe(true);
-    });
-    it("bisects a path-specific batch failure and acknowledges the other 63 paths", async () => {
-        const total = 64;
-        const blocked = makeEvent({
-            relativePath: `companies/indigo/blocked-${total - 1}.md`,
-            sequenceNumber: total,
-        });
-        const events = Array.from({ length: total - 1 }, (_, index) => makeEvent({
-            relativePath: `companies/indigo/allowed-${index}.md`,
-            sequenceNumber: index + 1,
-        })).concat(blocked);
-        const sqs = new FakeSqs();
-        sqs.enqueueDrainable(events.map((event, index) => msg(event, `rh-path-${index}`)));
-        const drains = [];
-        let dispatchCalls = 0;
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            drainMaxMessages: total,
-            batchMaxPaths: total,
-            syncBatchFn: async ({ events: batch }) => {
-                dispatchCalls += 1;
-                if (batch.some((event) => event.relativePath === blocked.relativePath)) {
-                    throw new Error("out-of-scope path rejected by targeted pull");
-                }
-            },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: makeDrainLogger(drains),
-        });
-        await receiver.start();
-        await waitFor(() => drains.length === 1, 5_000);
-        await receiver.dispose();
-        expect(dispatchCalls).toBeLessThanOrEqual(13);
-        expect(sqs.deleted).toHaveLength(total - 1);
-        expect(sqs.deleted).not.toContain(`rh-path-${total - 1}`);
-        expect(sqs.visibilityChanges.filter((change) => change.visibilityTimeoutSeconds === 20))
-            .toEqual([{ receiptHandle: `rh-path-${total - 1}`, visibilityTimeoutSeconds: 20 }]);
-        expect(drains[0]).toMatchObject({ processed: total - 1, deleted: total - 1, retried: 1 });
-    });
-    it("reports failed retry entries separately from successful entries", async () => {
-        const sqs = new FakeSqs();
-        sqs.failVisibilityBatchEntry("rh-retry-entry-failed", {
-            code: "ReceiptHandleIsInvalid",
-            message: "one receipt was rejected",
-            senderFault: true,
-        });
-        sqs.enqueueDrainable([
-            msg(first, "rh-retry-entry-failed"),
-            msg(second, "rh-retry-entry-succeeded"),
-        ]);
-        const warnings = [];
-        const drains = [];
-        const transportError = Object.assign(new Error("network connection reset"), {
-            code: "ECONNRESET",
-        });
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn: async () => { throw transportError; },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: makeDrainLogger(drains, warnings),
-        });
-        await receiver.start();
-        await waitFor(() => drains.length === 1);
-        await receiver.dispose();
-        const failures = warnings.filter((warning) => warning.event === "receiver.retry.failed");
-        expect(failures).toHaveLength(1);
-        expect(failures[0]).toMatchObject({
-            messageId: `m-${first.relativePath}-${first.sequenceNumber}`,
-            code: "ReceiptHandleIsInvalid",
-            failureMessage: "one receipt was rejected",
-            senderFault: true,
-        });
-        expect(sqs.visibilityChanges).toEqual([
-            { receiptHandle: "rh-retry-entry-succeeded", visibilityTimeoutSeconds: 20 },
-        ]);
-        expect(drains[0]).toMatchObject({ retried: 1 });
-        expect(failures[0]).not.toMatchObject({
-            messageId: `m-${second.relativePath}-${second.sequenceNumber}`,
-        });
-    });
-    it("uses about 100 ten-receipt API calls for a 1,000-receipt heartbeat", async () => {
-        const total = 1_000;
-        const sqs = new FakeSqs();
-        const receipts = Array.from({ length: total }, (_, index) => msg(makeEvent({
-            relativePath: `companies/indigo/heartbeat-${index}.md`,
-            sequenceNumber: index + 1,
-        }), `rh-heartbeat-${index}`));
-        for (let offset = 0; offset < receipts.length; offset += 10) {
-            sqs.enqueueDrainable(receipts.slice(offset, offset + 10));
-        }
-        let startPass;
-        const passStarted = new Promise((resolve) => { startPass = resolve; });
-        let releasePass;
-        const passGate = new Promise((resolve) => { releasePass = resolve; });
-        let finishDrain;
-        const drainFinished = new Promise((resolve) => { finishDrain = resolve; });
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            drainMaxMessages: total,
-            batchMaxPaths: total,
-            maxInFlightDrains: 1,
-            visibilityTimeoutSeconds: 600,
-            visibilityHeartbeatIntervalMs: 1_000,
-            syncBatchFn: async () => {
-                startPass();
-                await passGate;
-                throw Object.assign(new Error("ECONNRESET while pulling the batch"), {
-                    code: "ECONNRESET",
-                });
-            },
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: {
-                debug: () => undefined,
-                warn: () => undefined,
-                error: () => undefined,
-                info: (record) => {
-                    if (record.event === "receiver.drain")
-                        finishDrain();
-                },
-            },
-        });
-        vi.useFakeTimers();
-        try {
-            await receiver.start();
-            await passStarted;
-            await vi.advanceTimersByTimeAsync(1_000);
-            const heartbeatCalls = sqs.visibilityBatchCalls.filter((call) => call.visibilityTimeoutSeconds === 600);
-            expect(heartbeatCalls.length).toBeLessThanOrEqual(110);
-            expect(heartbeatCalls.every((call) => call.entries.length <= 10)).toBe(true);
-            expect(heartbeatCalls.reduce((count, call) => count + call.entries.length, 0))
-                .toBe(total);
-            releasePass();
-            await drainFinished;
-            await receiver.dispose();
-            const retryCalls = sqs.visibilityBatchCalls.filter((call) => call.visibilityTimeoutSeconds === 20);
-            expect(retryCalls.length).toBeLessThanOrEqual(110);
-            expect(retryCalls.every((call) => call.entries.length <= 10)).toBe(true);
-            expect(retryCalls.reduce((count, call) => count + call.entries.length, 0))
-                .toBe(total);
-        }
-        finally {
-            releasePass();
-            await receiver.dispose();
-            vi.useRealTimers();
-        }
-    });
-    it("updates a large failed batch with bounded parallel visibility calls", async () => {
-        const total = 512;
-        const baseSqs = new FakeSqs();
-        const receipts = Array.from({ length: total }, (_, index) => msg(makeEvent({
-            relativePath: "companies/indigo/retry-large-batch.md",
-            sequenceNumber: index + 1,
-        }), `rh-retry-large-${index}`));
-        for (let offset = 0; offset < receipts.length; offset += 10) {
-            baseSqs.enqueueDrainable(receipts.slice(offset, offset + 10));
-        }
-        const visibilityBatchCalls = [];
-        let activeCalls = 0;
-        let maxActiveCalls = 0;
-        let releaseVisibility;
-        const visibilityGate = new Promise((resolve) => {
-            releaseVisibility = resolve;
-        });
-        let firstCallStarted;
-        const firstStarted = new Promise((resolve) => {
-            firstCallStarted = resolve;
-        });
-        const sqs = {
-            receiveMessage: (args) => baseSqs.receiveMessage(args),
-            deleteMessage: (args) => baseSqs.deleteMessage(args),
-            changeMessageVisibility: async ({ receiptHandle }) => {
-                visibilityBatchCalls.push({ receiptHandles: [receiptHandle], visibilityTimeoutSeconds: 20 });
-                activeCalls += 1;
-                maxActiveCalls = Math.max(maxActiveCalls, activeCalls);
-                firstCallStarted();
-                await visibilityGate;
-                activeCalls -= 1;
-            },
-            changeMessageVisibilityBatch: async ({ entries, visibilityTimeoutSeconds }) => {
-                visibilityBatchCalls.push({
-                    receiptHandles: entries.map((entry) => entry.receiptHandle),
-                    visibilityTimeoutSeconds,
-                });
-                activeCalls += 1;
-                maxActiveCalls = Math.max(maxActiveCalls, activeCalls);
-                firstCallStarted();
-                await visibilityGate;
-                activeCalls -= 1;
-                return { failedEntries: [] };
-            },
-        };
-        const drains = [];
-        const receiver = new SqsPushReceiver({
-            tenantId: TENANT,
-            queueUrl: QUEUE_URL,
-            sqs,
-            syncBatchFn: async () => {
-                throw new Error("large targeted pull failed");
-            },
-            drainMaxMessages: total,
-            sleep: fastSleep,
-            publishMetric: async () => undefined,
-            logger: makeDrainLogger(drains),
-        });
-        await receiver.start();
-        await firstStarted;
-        const parallelCallsBeforeRelease = maxActiveCalls;
-        releaseVisibility();
-        await waitFor(() => drains.length === 1);
-        await receiver.dispose();
-        expect(parallelCallsBeforeRelease).toBeGreaterThan(1);
-        expect(parallelCallsBeforeRelease).toBeLessThan(total);
-        expect(visibilityBatchCalls).toHaveLength(Math.ceil(total / 10));
-        expect(visibilityBatchCalls.every((call) => call.receiptHandles.length <= 10)).toBe(true);
-        expect(visibilityBatchCalls.flatMap((call) => call.receiptHandles)).toHaveLength(total);
-        expect(visibilityBatchCalls.every((call) => call.visibilityTimeoutSeconds === 20)).toBe(true);
-        expect(baseSqs.deleted).toEqual([]);
-    });
-});
-//# sourceMappingURL=push-receiver.test.js.map