queen-mq 1.3.0 → 2.0.2

package/test-v2/stream/index.js

@@ -12,6 +12,7 @@
  *   recovery.js   — config_hash mismatch + reset + mid-stream resume
  *   throughput.js — multi-partition / many-window throughput
  *   combined.js   — full pipelines + concurrent streams
+ *   gate.js       — .gate() partial acks against the broker
  */
 
 export * from './operators.js'
@@ -23,3 +24,4 @@ export * from './eventTime.js'
 export * from './recovery.js'
 export * from './throughput.js'
 export * from './combined.js'
+export * from './gate.js'

package/test-v2/stream/tumbling.js

@@ -294,9 +294,9 @@ export async function tumblingForeachCtxHasWindowAndPartition(client) {
   const queryId = mkName('tumblingForeachCtxHasWindowAndPartition', 'q')
 
   await client.queue(src).create()
-  for (let i = 0; i < 3; i++) {
-    await client.queue(src).partition('myKey').push([{ data: { v: i } }])
-  }
+  // One push, so all three get the same broker createdAt: three pushes can
+  // straddle a second and split across two 1 s windows (count 1, then 2).
+  await client.queue(src).partition('myKey').push([0, 1, 2].map(v => ({ data: { v } })))
 
   const captured = []
   const handle = await Stream

package/test-v2/streams-unit/ack.test.js

@@ -201,3 +201,64 @@ describe('Queen.ack batch (/api/v1/ack/batch)', () => {
     )
   })
 })
+
+// The consumer group of an ack. /ack and /ack/batch judge an ack that names no
+// group in queue mode, so a message popped by a group and acked without one
+// came back `invalid or expired lease` (found 2026-10-02 against
+// 2.0.0-beta.6). Every pop answers each message with its `consumerGroup`.
+describe('Queen.ack — the group the message was popped under', () => {
+  const okFor = (body) => (body.acknowledgments || [body]).map((a, i) => ackResultItem(i, a.transactionId, true))
+  const popped = (n, group) => ({ transactionId: `tx-${n}`, partitionId: 'p-1', leaseId: 'lease-1', consumerGroup: group })
+
+  it('single: takes consumerGroup from the message when the caller names none', async () => {
+    await withAckServer(okFor, async (client, requests) => {
+      await client.ack(popped(1, 'workers'), true)
+      assert.equal(requests[0].body.consumerGroup, 'workers')
+    })
+  })
+
+  it('single: a queue-mode or hand-built message still sends consumerGroup null', async () => {
+    await withAckServer(okFor, async (client, requests) => {
+      await client.ack(popped(1, '__QUEUE_MODE__'), true)
+      await client.ack(MSG, true)
+      assert.equal(requests[0].body.consumerGroup, null)
+      assert.equal(requests[1].body.consumerGroup, null)
+    })
+  })
+
+  it('single: an explicit { group } wins', async () => {
+    await withAckServer(okFor, async (client, requests) => {
+      await client.ack(popped(1, 'workers'), false, { group: 'auditors' })
+      assert.equal(requests[0].body.consumerGroup, 'auditors')
+    })
+  })
+
+  it('batch: the group the messages share', async () => {
+    await withAckServer(okFor, async (client, requests) => {
+      const result = await client.ack([popped(1, 'workers'), popped(2, 'workers')], true)
+      assert.equal(result.success, true)
+      assert.equal(requests[0].path, '/api/v1/ack/batch')
+      assert.equal(requests[0].body.consumerGroup, 'workers')
+    })
+  })
+
+  it('batch: queue-mode messages still send consumerGroup null', async () => {
+    await withAckServer(okFor, async (client, requests) => {
+      await client.ack([popped(1, '__QUEUE_MODE__'), popped(2, '__QUEUE_MODE__')], true)
+      assert.equal(requests[0].body.consumerGroup, null)
+    })
+  })
+
+  it('batch: messages from two groups are refused before anything is sent', async () => {
+    await withAckServer(okFor, async (client, requests) => {
+      await assert.rejects(
+        () => client.ack([popped(1, 'a'), popped(2, 'b')], true),
+        /different consumer groups in one call \(a, b\)/
+      )
+      assert.equal(requests.length, 0)
+      // ... unless the caller names the group, which is then theirs to get right.
+      await client.ack([popped(1, 'a'), popped(2, 'b')], true, { group: 'a' })
+      assert.equal(requests[0].body.consumerGroup, 'a')
+    })
+  })
+})

package/test-v2/streams-unit/cycle.test.js

@@ -100,7 +100,7 @@ describe('Runner — windowed aggregation', () => {
     // The 10:00 window is closed (created and closed in the same batch
     // since the third message crosses the minute boundary). The 10:01
     // window stays open. Because the 10:00 window was never persisted to
-    // PG (created+closed in one cycle), no delete state op is emitted —
+    // the broker (created+closed in one cycle), no delete state op is emitted —
     // only the closed-window push and the open-window upsert.
     assert.equal(c.push_items.length, 1, 'one closed-window emit')
     assert.deepEqual(c.push_items[0].payload, { count: 2, sum: 30 })

package/test-v2/streams-unit/e2e.test.js

@@ -1,5 +1,5 @@
 /**
- * End-to-end test for queen-streams against a live Queen server + PG.
+ * End-to-end test for queen-streams against a live Queen server.
  *
  * What it covers (per the plan's Definition of Done):
  *   1. 10,000 messages across 50 partitions
@@ -8,14 +8,10 @@
  *   4. Exactly-once on the sink queue
  *   5. Per-partition state isolation
  *   6. Downstream consumer of sink wakes up immediately
- *      (validates inline update_partition_lookup_v1 in streams_cycle_v1)
  *
  * Prerequisites:
  *   - Queen running on QUEEN_URL (default http://localhost:6632)
- *   - The streams procedures applied (auto-loaded on Queen boot):
- *     002_streams_schema, 007_log_streams, 008_streams_register_query_v1,
- *     009_streams_state_get_v1 (the retired rows-era streams cycle's role
- *     now lives in 007_log_streams' log_streams_cycle_v1)
+ *   - A broker serving the /streams/v1 routes (register, state/get, cycle)
  *
  * Run:
  *   QUEEN_URL=http://localhost:6632 node --test test/e2e.test.js
@@ -129,7 +125,7 @@ describe('queen-streams e2e (live Queen)', { skip: !SHOULD_RUN }, () => {
 
     // 3. Mid-stream kill: after 1.5s, stop the runner abruptly to simulate
     //    a worker crash, then restart it. Cursor + state should reconcile
-    //    via Queen's lease/retry + queen_streams.state PK.
+    //    via Queen's lease/retry + the per-partition streams state key.
     setTimeout(async () => {
       if (!stopped) {
         await handle.stop()
@@ -205,8 +201,8 @@ describe('queen-streams e2e (live Queen)', { skip: !SHOULD_RUN }, () => {
       const winKey = m.data && m.data.__winKey
       // The aggregate value doesn't carry windowKey by default; we check for
       // duplicates by (partition + transactionId) instead, which Queen
-      // guarantees unique across a partition. The streams_cycle_v1 SP
-      // dedupes via the SAME unique constraint that push_messages_v3 uses.
+      // guarantees unique across a partition. The streams cycle's sink
+      // pushes go through the SAME transactionId dedup as any push.
       const dedupKey = `${m.partition}|${m.transactionId}`
       assert.ok(!seen.has(dedupKey), 'duplicate sink message for ' + dedupKey)
       seen.add(dedupKey)
@@ -214,7 +210,7 @@ describe('queen-streams e2e (live Queen)', { skip: !SHOULD_RUN }, () => {
 
     // 6. Per-partition state isolation: every cycle the runner committed
     //    must touch state rows ONLY for its own partition. We can't easily
-    //    observe this from the client side (no DB access), but the
+    //    observe this from the client side (the stored state is private), but the
     //    aggregate-shape correctness in (5) above implies it (a leaked
     //    cross-partition write would produce wrong sums).
 

package/test-v2/streams-unit/gate.test.js

@@ -0,0 +1,189 @@
+/**
+ * .gate() settles SOURCE MESSAGES, not envelopes.
+ *
+ * The gate's partial ack is an offset commit: a 2.x broker advances the
+ * cursor `ack.count` messages from the head of the leased batch and keeps the
+ * lease (release_lease=false). A pre-stage breaks the one-to-one map between
+ * messages and the envelopes the gate sees -- `.filter()` leaves a message
+ * with none, `.flatMap()` with several -- and the runner counted envelopes:
+ *
+ *   flatMap x2, message 2 denied   count 2 = messages 1 AND 2 acked; the
+ *                                  denied message was never redelivered
+ *                                  (reproduced live on 2.0.0-beta.6: 4 of 6
+ *                                  sink items, message 2 lost)
+ *   filter drops every message     nothing committed; the batch came back on
+ *                                  every lease expiry, forever
+ *
+ * Same fix as the Rust client (clients/client-rust/src/streams/runner.rs,
+ * gate_cycle): a message is settled only when every envelope it produced is
+ * allowed, and what a denied message did to the state is rolled back.
+ */
+
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { Stream } from '../../client-v2/streams/Stream.js'
+import { createFakeStreamsServer, createFakeSource, fakeMessage } from './fakeServer.js'
+
+const PART = '00000000-0000-0000-0000-00000000ga7e'
+
+const batch = (...ns) => ns.map((n, i) => fakeMessage({
+  partitionId: PART,
+  partitionName: 'tenant-1',
+  data: { n },
+  createdAt: `2026-10-02T10:00:0${i}.000Z`
+}))
+
+const quiet = { info() {}, warn() {}, error() {}, debug() {} }
+
+// Run until `cycles` cycles were committed (or the time is up), then stop.
+async function runFor(server, stream, { cycles = 1, timeoutMs = 1500, queryId }) {
+  const baseline = server.recorded.cycles.length
+  const handle = await stream.run({ queryId, url: server.url, logger: quiet })
+  const start = Date.now()
+  while (server.recorded.cycles.length - baseline < cycles && Date.now() - start < timeoutMs) {
+    await new Promise(r => setTimeout(r, 20))
+  }
+  await handle.stop()
+  return { handle, cycles: server.recorded.cycles.slice(baseline) }
+}
+
+describe('.gate() — the partial ack counts source messages', () => {
+  let server
+  before(async () => { server = await createFakeStreamsServer() })
+  after(async () => { await server.close() })
+
+  it('flatMap before the gate: a denied message is not acked with its predecessor', async () => {
+    const msgs = batch(1, 2, 3)
+    const stream = Stream.from(createFakeSource('src', [msgs]))
+      .flatMap(m => [m.data, m.data])
+      .gate(v => v.n !== 2)
+      .to({ _queueName: 'sink' })
+
+    const { cycles } = await runFor(server, stream, { queryId: 'gate.flatmap' })
+    assert.equal(cycles.length, 1)
+    const c = cycles[0]
+    assert.equal(c.ack.count, 1, 'one MESSAGE settled; two envelopes acked messages 1 and 2')
+    assert.equal(c.ack.transactionId, msgs[0].transactionId)
+    assert.equal(c.release_lease, false, 'the denied tail stays leased, in order')
+    assert.deepEqual(c.push_items.map(p => p.payload.n), [1, 1], 'only the settled message reaches the sink')
+  })
+
+  it('flatMap before the gate: a message half allowed is not settled at all', async () => {
+    let seen = 0
+    const stream = Stream.from(createFakeSource('src', [batch(1, 2)]))
+      .flatMap(m => [m.data, m.data])
+      .gate(() => ++seen === 1)     // the first value of message 1 passes, its second does not
+
+    const { cycles } = await runFor(server, stream, { queryId: 'gate.half', timeoutMs: 400 })
+    assert.equal(cycles.length, 0, 'nothing settled, nothing committed: the lease brings both back')
+  })
+
+  it('filter before the gate: dropped messages are settled with the prefix', async () => {
+    const msgs = batch(1, 2, 3)
+    const stream = Stream.from(createFakeSource('src', [msgs]))
+      .filter(m => m.data.n === 3)
+      .gate(() => true)
+      .to({ _queueName: 'sink' })
+
+    const { cycles } = await runFor(server, stream, { queryId: 'gate.filter' })
+    assert.equal(cycles.length, 1)
+    assert.equal(cycles[0].ack.count, 3, 'all three messages are done; one envelope is not one message')
+    assert.equal(cycles[0].ack.transactionId, msgs[2].transactionId)
+    assert.equal(cycles[0].release_lease, true)
+    assert.deepEqual(cycles[0].push_items.map(p => p.payload.n), [3])
+  })
+
+  it('filter that drops the whole batch: the batch is acked, not held forever', async () => {
+    const msgs = batch(1, 2)
+    const stream = Stream.from(createFakeSource('src', [msgs]))
+      .filter(() => false)
+      .gate(() => true)
+      .to({ _queueName: 'sink' })
+
+    const { cycles } = await runFor(server, stream, { queryId: 'gate.allfiltered' })
+    assert.equal(cycles.length, 1, 'a cycle is committed even though the gate saw nothing')
+    assert.equal(cycles[0].ack.count, 2)
+    assert.equal(cycles[0].release_lease, true)
+    assert.equal(cycles[0].push_items.length, 0)
+    assert.equal(cycles[0].state_ops.length, 0)
+  })
+
+  it('filter, then a deny: the count stops before the denied message', async () => {
+    const msgs = batch(1, 2, 3, 4)
+    const stream = Stream.from(createFakeSource('src', [msgs]))
+      .filter(m => m.data.n !== 2)      // message 2 produces nothing
+      .gate(v => v.n !== 3)             // message 3 is denied
+
+    const { cycles } = await runFor(server, stream, { queryId: 'gate.filterdeny' })
+    assert.equal(cycles.length, 1)
+    assert.equal(cycles[0].ack.count, 2, 'messages 1 and 2 settled; the gate allowed one envelope')
+    assert.equal(cycles[0].ack.transactionId, msgs[1].transactionId)
+    assert.equal(cycles[0].release_lease, false)
+  })
+
+  it('a denied first message still commits nothing', async () => {
+    const stream = Stream.from(createFakeSource('src', [batch(1, 2)]))
+      .gate(() => false)
+    const { cycles, handle } = await runFor(server, stream, { queryId: 'gate.firstdeny', timeoutMs: 400 })
+    assert.equal(cycles.length, 0)
+    assert.equal(handle.metrics().gateDenialsTotal, 2, 'denials are counted in messages')
+  })
+})
+
+describe('.gate() — a denied message did not happen', () => {
+  let server
+  before(async () => { server = await createFakeStreamsServer() })
+  after(async () => { await server.close() })
+
+  it('what a denied message did to the state is not persisted', async () => {
+    // A counter the gate bumps BEFORE deciding: message 1 is allowed at 1,
+    // message 2 bumps it to 2 and is denied. The state that commits is 1.
+    const stream = Stream.from(createFakeSource('src', [batch(1, 2)]))
+      .gate((v, ctx) => {
+        ctx.state.count = (ctx.state.count || 0) + 1
+        return v.n === 1
+      })
+
+    const { cycles } = await runFor(server, stream, { queryId: 'gate.rollback' })
+    assert.equal(cycles.length, 1)
+    assert.equal(cycles[0].ack.count, 1)
+    assert.deepEqual(cycles[0].state_ops, [{ type: 'upsert', key: PART, value: { count: 1 } }])
+  })
+
+  it('a key only a denied message touched is not written at all', async () => {
+    const stream = Stream.from(createFakeSource('src', [batch(1, 2)]))
+      .keyBy(m => `k${m.data.n}`)
+      .gate((v, ctx) => {
+        ctx.state.seen = true
+        return v.n === 1
+      })
+
+    const { cycles } = await runFor(server, stream, { queryId: 'gate.untouched' })
+    assert.equal(cycles.length, 1)
+    assert.deepEqual(cycles[0].state_ops.map(op => op.key), ['k1'])
+  })
+})
+
+describe('.gate() — the prefix is the broker\'s, in offset order', () => {
+  let server
+  before(async () => { server = await createFakeStreamsServer() })
+  after(async () => { await server.close() })
+
+  it('orders by offset when the broker sends one, not by (createdAt, id)', async () => {
+    // Two producers pushed in the same millisecond: same createdAt, and the
+    // message the broker stored FIRST carries the higher id. Sorting by
+    // (createdAt, id) put it second, so a deny on it acked it anyway.
+    const createdAt = '2026-10-02T10:00:00.000Z'
+    const first = { ...fakeMessage({ partitionId: PART, data: { n: 'first' }, createdAt }), id: 'msg-z', offset: 10 }
+    const second = { ...fakeMessage({ partitionId: PART, data: { n: 'second' }, createdAt }), id: 'msg-a', offset: 11 }
+    const stream = Stream.from(createFakeSource('src', [[second, first]]))
+      .gate(v => v.n === 'first')
+
+    const { cycles } = await runFor(server, stream, { queryId: 'gate.offsetorder' })
+    assert.equal(cycles.length, 1)
+    assert.equal(cycles[0].ack.count, 1)
+    assert.equal(cycles[0].ack.transactionId, first.transactionId, 'the settled prefix is offset 10, the one the broker acks')
+    assert.equal(cycles[0].release_lease, false)
+  })
+})

package/test-v2/timers.js

@@ -1,8 +1,9 @@
 /**
  * Timer integration suite (PLAN_KV_TIMERS.md §4, §9.6, §20.2).
  *
- * Repeatable only because run.js purges `queen.log_timers` for the `test-%`
- * queues before the run: a pending timer left behind by a previous run fires
+ * Repeatable only because every run starts on a fresh broker (test/run.sh
+ * creates the lane's data volume empty and destroys it with `down -v`): on a
+ * broker that kept it, a pending timer left behind by a previous run fires
  * into the queue of the next one and shows up as a phantom message in an
  * unrelated test.
  *
@@ -21,7 +22,7 @@ export async function timerSchedulesAndFires(client) {
   // A per-run marker, so a message left in this queue by an earlier run can
   // never be mistaken for this run's delivery. It is the one place in these
   // suites where per-run uniqueness is right: the assertion is about THIS
-  // timer's identity, and the purge cannot be relied on to prove identity.
+  // timer's identity, and a clean start cannot be relied on to prove identity.
   const run = `fire-${Date.now()}`
   const res = await client.timer(queueName)
     .key('fire-1')
@@ -34,8 +35,8 @@ export async function timerSchedulesAndFires(client) {
   }
 
   // deliverAt is "not before", never "exactly at", and the visibility of a
-  // fired timer to a consumer is bounded by the hot-list reseed, not by the
-  // delay -- see popUntil, which measured it. The assertion is arrival.
+  // fired timer to a consumer is bounded by the broker's fire step, not by the
+  // delay -- see popUntil. The assertion is arrival.
   const mine = await popUntil(client, queueName, m => m.data && m.data.run === run)
 
   if (mine.length !== 1) {

package/test-v2/transaction.js

@@ -1,3 +1,5 @@
+import { TEST_CONFIG } from './run.js'
+
 export async function transactionBasicPushAck(client) {
     const queueA = await client.queue('test-queue-v2-txn-basic-a').create()
     const queueB = await client.queue('test-queue-v2-txn-basic-b').create()
@@ -572,3 +574,170 @@ export async function transactionAckWithConsumerGroup(client) {
     }
 }
 
+
+// An ack takes the consumer group the message was popped under (2026-10-02,
+// 2.0.0-beta.6). Without an explicit { consumerGroup } the op was judged in
+// queue mode and the bundle rolled back with rejected_ack; queen.ack() came
+// back "invalid or expired lease" the same way.
+export async function transactionAckTakesGroupFromMessage(client) {
+    const source = 'test-queue-v2-txn-group-from-msg'
+    const sink = 'test-queue-v2-txn-group-from-msg-out'
+    const group = 'test-txn-group-from-msg'
+    const qa = await client.queue(source).create()
+    const qb = await client.queue(sink).create()
+    if (!qa.configured || !qb.configured) {
+        return { success: false, message: 'Queues not created' }
+    }
+    await client.queue(source).push([{ data: { value: 1 } }, { data: { value: 2 } }])
+
+    const messages = await client.queue(source).group(group).subscriptionMode('all').batch(2).wait(false).pop()
+    if (messages.length !== 2) {
+        return { success: false, message: `Expected 2 messages, got ${messages.length}` }
+    }
+    if (messages[0].consumerGroup !== group) {
+        return { success: false, message: `pop answered consumerGroup=${messages[0].consumerGroup}, expected ${group}` }
+    }
+
+    let committed
+    try {
+        committed = await client.transaction()
+            .ack(messages[0])
+            .queue(sink).push([{ data: { from: messages[0].data.value } }])
+            .commit()
+    } catch (error) {
+        return { success: false, message: `commit threw (${error.reason}): ${error.message}` }
+    }
+    const direct = await client.ack(messages[1], true)
+    const after = await client.queue(source).group(group).batch(2).wait(false).pop()
+    const forwarded = await client.queue(sink).batch(1).wait(false).pop()
+
+    const success = committed.success === true && direct.success === true && after.length === 0 && forwarded.length === 1
+    return {
+        success,
+        message: success
+            ? 'transaction().ack and queen.ack took the group from the message'
+            : `txn=${committed.success} direct=${direct.success} (${direct.error}) after=${after.length} forwarded=${forwarded.length}`
+    }
+}
+
+// ============================================================================
+// A bundle that acks messages of two leases (2026-10-03, 2.0.0-beta.6)
+// ============================================================================
+//
+// A Queen 2 broker fences each ack with the leaseId the operation carries, and
+// lends requiredLeases to an ack without one only when the bundle names a
+// single lease. An ack that left its lease in requiredLeases alone was applied
+// in a bundle of two leases even after its lease expired and another consumer
+// took the message. The builder has no per-pop lease knob, so these pops go
+// through fetch, as in semantics.js.
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
+const fenceQueue = name => `test-queue-v2-txn-fence-${name}-${Date.now()}`
+
+/** One message of a queue-mode pop leased for `leaseSeconds`, or null. */
+async function popLeased(queue, leaseSeconds, tries = 20) {
+    const qs = new URLSearchParams({
+        batch: '1',
+        wait: 'false',
+        leaseSeconds: String(leaseSeconds),
+        subscriptionMode: 'all'
+    })
+    // Lazy: run.js imports this module before TEST_CONFIG is initialized.
+    const url = `${TEST_CONFIG.baseUrls[0]}/api/v1/pop/queue/${queue}?${qs}`
+    for (let i = 0; i < tries; i++) {
+        const res = await fetch(url)
+        if (res.status !== 204) {
+            if (!res.ok) throw new Error(`pop ${queue}: HTTP ${res.status}`)
+            const body = await res.json()
+            if (body.messages && body.messages.length > 0) return body.messages[0]
+        }
+        await sleep(150)
+    }
+    return null
+}
+
+/** The outcome of a commit, whether the client threw the refusal or returned it. */
+async function commitOutcome(transaction) {
+    try {
+        const result = await transaction.commit()
+        return { committed: result.success === true, error: result.error || null }
+    } catch (error) {
+        return { committed: false, error: error.message }
+    }
+}
+
+export async function transactionTwoLeaseBundleExpiredLeaseRefused(client) {
+    const queueA = fenceQueue('stale-a')
+    const queueB = fenceQueue('stale-b')
+    const qa = await client.queue(queueA).create()
+    const qb = await client.queue(queueB).create()
+    if (!qa.configured || !qb.configured) {
+        return { success: false, message: 'Queues not created' }
+    }
+    await client.queue(queueA).push([{ data: { name: 'a' } }])
+    await client.queue(queueB).push([{ data: { name: 'b' } }])
+
+    const a = await popLeased(queueA, 1)
+    const b = await popLeased(queueB, 60)
+    if (!a?.leaseId || !b?.leaseId || a.leaseId === b.leaseId) {
+        return { success: false, message: `Expected two messages under two leases, got a=${a?.leaseId} b=${b?.leaseId}` }
+    }
+
+    // Lease A expires, and another consumer takes the message.
+    const taken = await popLeased(queueA, 60, 100)
+    if (!taken || taken.transactionId !== a.transactionId || taken.leaseId === a.leaseId) {
+        return { success: false, message: 'The message of the expired lease was not delivered again under a new lease' }
+    }
+
+    const stale = await commitOutcome(client.transaction().ack(a).ack(b))
+    if (stale.committed) {
+        return { success: false, message: 'The bundle committed: the ack under the expired lease was applied unfenced' }
+    }
+    if (!/rolled back/.test(stale.error || '')) {
+        return { success: false, message: `The bundle was refused, but not as a rollback: ${stale.error}` }
+    }
+
+    // Nothing of the bundle happened: each holder still settles its own message.
+    const takenAck = await commitOutcome(client.transaction().ack(taken))
+    const bAck = await commitOutcome(client.transaction().ack(b))
+    const leftA = await client.queue(queueA).batch(10).wait(false).pop()
+    const leftB = await client.queue(queueB).batch(10).wait(false).pop()
+
+    const success = takenAck.committed && bAck.committed && leftA.length === 0 && leftB.length === 0
+    return {
+        success,
+        message: success
+            ? 'A bundle with an ack under an expired lease was refused whole; each holder then settled its own message'
+            : `new holder ack=${takenAck.committed} (${takenAck.error}), B ack=${bAck.committed} (${bAck.error}), left A=${leftA.length} B=${leftB.length}`
+    }
+}
+
+export async function transactionTwoLeaseBundleLiveLeasesCommit(client) {
+    const queueA = fenceQueue('live-a')
+    const queueB = fenceQueue('live-b')
+    const qa = await client.queue(queueA).create()
+    const qb = await client.queue(queueB).create()
+    if (!qa.configured || !qb.configured) {
+        return { success: false, message: 'Queues not created' }
+    }
+    await client.queue(queueA).push([{ data: { name: 'a' } }])
+    await client.queue(queueB).push([{ data: { name: 'b' } }])
+
+    const a = await popLeased(queueA, 60)
+    const b = await popLeased(queueB, 60)
+    if (!a?.leaseId || !b?.leaseId || a.leaseId === b.leaseId) {
+        return { success: false, message: `Expected two messages under two leases, got a=${a?.leaseId} b=${b?.leaseId}` }
+    }
+
+    const outcome = await commitOutcome(client.transaction().ack(a).ack(b))
+    const leftA = await client.queue(queueA).batch(10).wait(false).pop()
+    const leftB = await client.queue(queueB).batch(10).wait(false).pop()
+
+    const success = outcome.committed && leftA.length === 0 && leftB.length === 0
+    return {
+        success,
+        message: success
+            ? 'A bundle of two live leases completed both messages'
+            : `commit=${outcome.committed} (${outcome.error}), left A=${leftA.length} B=${leftB.length}`
+    }
+}