queen-mq 1.2.0 → 2.0.0

package/test-v2/run.js

@@ -1,4 +1,3 @@
-import pg from 'pg';
 import { Queen } from '../client-v2/index.js'
 import * as queueTests from './queue.js'
 import * as pushTests from './push.js'
@@ -9,7 +8,6 @@ import * as dlqTests from './dlq.js'
 import * as completeTests from './complete.js'
 import * as transactionTests from './transaction.js'
 import * as subscriptionTests from './subscription.js'
-import * as maintenanceTests from './maintenance.js'
 import * as retentionTests from './retention.js'
 import * as bootstrapTests from './bootstrap.js'
 import * as loggerTests from './logger.js'
@@ -28,46 +26,43 @@ import { LoadBalancer } from '../client-v2/http/LoadBalancer.js';
 
 export const TEST_CONFIG_SINGLE = {
     baseUrls: [process.env.QUEEN_SERVER_URL || 'http://localhost:6632'],
-    loadBalancingStrategy: 'affinity',
-    dbConfig: {
-      host: process.env.PG_HOST || 'localhost',
-      port: process.env.PG_PORT || 5432,
-      database: process.env.PG_DB || 'postgres',
-      user: process.env.PG_USER || 'postgres',
-      password: process.env.PG_PASSWORD || 'postgres'
-    }
+    loadBalancingStrategy: 'affinity'
   };
 
 export const TEST_CONFIG_MULTIPLE = {
   baseUrls: ['http://localhost:6632','http://localhost:6633'],
-  loadBalancingStrategy: 'round-robin',
-  dbConfig: {
-    host: process.env.PG_HOST || 'localhost',
-    port: process.env.PG_PORT || 5432,
-    database: process.env.PG_DB || 'postgres',
-    user: process.env.PG_USER || 'postgres',
-    password: process.env.PG_PASSWORD || 'postgres'
-  }
+  loadBalancingStrategy: 'round-robin'
 };
 
 export const TEST_CONFIG = process.env.TEST_CONFIG === 'multiple' ? TEST_CONFIG_MULTIPLE : TEST_CONFIG_SINGLE;
 console.log('TEST_CONFIG:', TEST_CONFIG);
 
 // Global test state
-export let dbPool;  
-
-// Initialize database pool
-export async function initDb() {
-  dbPool = new pg.Pool(TEST_CONFIG.dbConfig);
-  await dbPool.query('SELECT 1');
-  return dbPool;
-}
-
-// Close database pool
-export async function closeDb() {
-  if (dbPool) {
-    await dbPool.end();
-  }
+let activeClient;
+
+// The suite talks to the broker through its public HTTP API only: there is no
+// database and no cleanup step. test/run.sh gives every lane a FRESH broker
+// (its data volume is created empty and destroyed with `down -v`), so the
+// suite starts on an empty store. A second run against the same broker is not
+// expected to be green: fixed-name fixtures (docs.js's fixed transactionId,
+// the kv and timer suites) would find the first run's state.
+//
+// The preflight makes a missing or unhealthy broker fail the run up front,
+// with the reason, instead of as a wall of per-test connection errors.
+async function preflightBroker(baseUrl) {
+    const url = `${baseUrl}/health`
+    let res
+    try {
+        res = await fetch(url, { signal: AbortSignal.timeout(5000) })
+    } catch (e) {
+        throw new Error(`broker preflight ${url}: ${e.cause?.message || e.message}`)
+    }
+    // Drain the body so the connection is released either way.
+    await res.arrayBuffer().catch(() => {})
+    if (!res.ok) {
+        throw new Error(`broker preflight ${url}: HTTP ${res.status}`)
+    }
+    log(true, `Broker preflight ${url}: HTTP ${res.status}`)
 }
 
 function log (success, ...args) {
@@ -92,78 +87,13 @@ function printResults() {
     console.log('='.repeat(80))
 }
 
-export const cleanupTestData = async () => {
-    // All the LIKE patterns test queues use. The three exact names are the
-    // documentation queues (test-v2/docs.js): purging them here is what lets
-    // the published dedup snippet keep a fixed transactionId across runs.
-    const patterns = ['test-%', 'edge-%', 'pattern-%', 'workflow-%', 'orders', 'payments', 'invoices'];
-    try {
-      // Drop streaming queries first (CASCADE removes their state rows).
-      // Safe even when queen_streams isn't installed yet — we swallow the
-      // error if the schema doesn't exist.
-      try {
-        await dbPool.query(`DELETE FROM queen_streams.queries WHERE name LIKE 'test-%'`);
-      } catch (e) {
-        // queen_streams schema not installed — ignore.
-      }
-
-      // Queue identity is now the queen.queues id (log_queues was merged
-      // away): log_partitions, consumer_watermarks, consumer_groups_metadata
-      // and queue_lag_metrics all cascade from the queues row. Only log_txns
-      // and log_dlq have NO foreign key by design, so they get an explicit
-      // purge keyed via log_partitions first. Without it, every suite run
-      // inherits the previous run's messages and dedup window entries —
-      // fixed-transactionId tests report 'duplicate' on their FIRST push.
-      try {
-        await dbPool.query(`
-          WITH parts AS (
-            SELECT lp.id FROM queen.log_partitions lp
-            JOIN queen.queues q ON q.id = lp.queue_id
-            WHERE q.name LIKE ANY($1::text[])
-          ),
-          d1 AS (DELETE FROM queen.log_txns WHERE partition_id IN (SELECT id FROM parts)),
-          d2 AS (DELETE FROM queen.log_dlq  WHERE partition_id IN (SELECT id FROM parts))
-          SELECT 1`, [patterns]);
-      } catch (e) {
-        // Log-engine schema not installed (rows-only server) — ignore.
-      }
-
-      await dbPool.query(`DELETE FROM queen.queues WHERE name LIKE ANY($1::text[])`, [patterns]);
-
-      // KV keys and pending timers (PLAN_KV_TIMERS.md §10.4). NOT cosmetic:
-      // without this purge a putIfAbsent test is green on its first run and red
-      // forever after, an incr test accumulates between runs, and a timer left
-      // pending by an earlier run fires into a later one and shows up as a
-      // phantom message in an unrelated test. Neither table has a foreign key
-      // to queen.queues -- log_timers is keyed by NAMES on purpose -- so the
-      // queue delete above does not reach them.
-      //
-      // Both are deleted across every tenant: a test rig may run with
-      // QUEEN_TENANCY_HEADER on, and the rows to purge are identified by the
-      // test naming convention, never by tenant.
-      //
-      // These two used to be wrapped in a swallowing try/catch, on the grounds
-      // that a broker booted with the kv/timer flags off had never applied
-      // 024_kv.sql / 025_timers.sql. There are no such flags: schema.rs applies
-      // both on every boot, so a missing `queen.kv` or `queen.log_timers` is a
-      // broken rig and must be loud. Swallowing it would leave the purge silently
-      // undone, which is exactly the failure the purge exists to prevent -- a
-      // putIfAbsent test green on its first run and red forever after.
-      await dbPool.query(`DELETE FROM queen.kv WHERE namespace LIKE ANY($1::text[])`, [patterns]);
-      await dbPool.query(`DELETE FROM queen.log_timers WHERE queue LIKE ANY($1::text[])`, [patterns]);
-
-      log(true, 'Test data cleaned up (rows + segments + kv + timers)');
-    } catch (error) {
-      log(false, `Cleanup error: ${error.message}`);
-    }
-  };
-
 async function main() {
     const client = new Queen({
         urls: TEST_CONFIG.baseUrls,
         loadBalancingStrategy: TEST_CONFIG.loadBalancingStrategy
     })
-    await initDb()
+    activeClient = client
+    await preflightBroker(TEST_CONFIG.baseUrls[0])
 
     // Separate human and AI tests
     const humanTests = [
@@ -177,7 +107,6 @@ async function main() {
         transactionTests,
         subscriptionTests,
         retentionTests,
-        maintenanceTests,
         bootstrapTests,
         loggerTests,
         watermarkTests,
@@ -194,7 +123,7 @@ async function main() {
     ]
 
     // Streaming tests (queen-streams). Run via `node run.js stream`.
-    // Require Queen v0.2+ with the queen_streams schema applied.
+    // Require a broker that serves the /streams/v1 routes.
     const streamGroupTests = [streamTests]
 
     const allTests = [...humanTests, ...aiTests, ...streamGroupTests]
@@ -240,8 +169,7 @@ async function main() {
             humanTestFunctions.forEach(t => console.log(`  - ${t.name}`))
             console.log('\n🌊 queen-streams tests:')
             streamTestFunctions.forEach(t => console.log(`  - ${t.name}`))
-            await closeDb()
-            process.exit(1)
+            return 1
         }
         testsToRun = [testFunc]
         mode = 'single'
@@ -250,9 +178,6 @@ async function main() {
         log(true, `Running all tests (${allTestFunctions.length} tests)...`)
     }
 
-    // Cleanup test data
-    await cleanupTestData()
-    
     for (const test of testsToRun) {
         try {
             console.log('Running test:', test.name)
@@ -279,17 +204,28 @@ async function main() {
         console.log('\n💡 Tip: Run "node run.js" to test all tests')
     }
     
-    //await cleanupTestData()
-    await closeDb()
-    // Queen.close() destroys the per-client HTTP agent, releasing keep-alive
-    // sockets so the loop can drain; the explicit exit code is for CI.
-    await client.close()
     const failedCount = testResults.filter(x => !x.success).length
-    process.exit(failedCount > 0 ? 1 : 0)
+    return failedCount > 0 ? 1 : 0
 }
 
+let exitCode = 1
 try {
-    await main()
+    exitCode = await main()
 } catch (error) {
     log(false, 'Main error:', error.message)
-}
+} finally {
+    // Always release the client. Previously, an init failure skipped this
+    // teardown and the outer catch returned a successful process status,
+    // allowing a broken integration lane to appear green.
+    const cleanupResults = await Promise.allSettled([
+        activeClient ? activeClient.close() : Promise.resolve()
+    ])
+    for (const result of cleanupResults) {
+        if (result.status === 'rejected') {
+            exitCode = 1
+            log(false, 'Cleanup error:', result.reason?.message || String(result.reason))
+        }
+    }
+}
+
+process.exit(exitCode)

package/test-v2/runner-unit/fatalExit.test.js

@@ -0,0 +1,64 @@
+import assert from 'node:assert/strict'
+import { spawn } from 'node:child_process'
+import net from 'node:net'
+import { fileURLToPath } from 'node:url'
+import path from 'node:path'
+import { describe, it } from 'node:test'
+
+const suiteRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..')
+
+// A loopback port with nothing listening on it: bind an ephemeral port, then
+// release it. Not port 1: fetch() rejects the Fetch-spec "bad ports" (1 is one
+// of them) before it ever connects, so the preflight would fail with "bad port"
+// and never exercise a refused connection.
+function closedLoopbackPort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer()
+    server.once('error', reject)
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address()
+      server.close(error => (error ? reject(error) : resolve(port)))
+    })
+  })
+}
+
+function runWithUnreachableBroker(brokerUrl) {
+  return new Promise((resolve, reject) => {
+    const env = { ...process.env, QUEEN_SERVER_URL: brokerUrl }
+    // TEST_CONFIG=multiple would point run.js at its fixed localhost URLs
+    // instead of QUEEN_SERVER_URL.
+    delete env.TEST_CONFIG
+    const child = spawn(process.execPath, ['test-v2/run.js', 'human'], {
+      cwd: suiteRoot,
+      env,
+      stdio: ['ignore', 'pipe', 'pipe']
+    })
+
+    let output = ''
+    const deadline = setTimeout(() => {
+      child.kill('SIGKILL')
+      reject(new Error(`integration runner did not exit within 5s:\n${output}`))
+    }, 5000)
+    child.stdout.on('data', chunk => { output += chunk })
+    child.stderr.on('data', chunk => { output += chunk })
+    child.once('error', error => {
+      clearTimeout(deadline)
+      reject(error)
+    })
+    child.once('close', (code, signal) => {
+      clearTimeout(deadline)
+      resolve({ code, signal, output })
+    })
+  })
+}
+
+describe('integration runner lifecycle', () => {
+  it('returns a failure status when the broker preflight fails', async () => {
+    const port = await closedLoopbackPort()
+    const result = await runWithUnreachableBroker(`http://127.0.0.1:${port}`)
+
+    assert.equal(result.signal, null)
+    assert.equal(result.code, 1, result.output)
+    assert.match(result.output, /Main error: broker preflight .*ECONNREFUSED/)
+  })
+})

package/test-v2/semantics.js

@@ -16,9 +16,9 @@
  *     AFTER the group registered (durable subscription record).
  *  8. Queue-mode pops never skip backlog, even when carrying subscriptionMode.
  *  9. Empty polls while another worker holds the lease never strand backlog
- *     (wildcard watermark guard).
- * 10. Push-only (never-configured) queues get a queen.queues row: visible in
- *     resources, discoverable by namespace pop.
+ *     (an empty answer must not hide the partition once the lease lapses).
+ * 10. Push-only (never-configured) queues are registered by the push: visible
+ *     in resources, discoverable by namespace pop.
  * 11. GET /api/v1/messages/:pid/:txn keeps the full v0.16.0 shape (including
  *     consumerGroups[].name — not .group).
  * 12. Transactions honor `retry` and `dlq` ack statuses (not collapsed to a
@@ -39,7 +39,7 @@
  * Run: node run.js <testName>   e.g. node run.js implicitAckCompletesBatch
  */
 
-import { dbPool, TEST_CONFIG } from './run.js'
+import { TEST_CONFIG } from './run.js'
 
 // Lazy: run.js imports this module before TEST_CONFIG is initialized (TDZ),
 // so the base URL must be resolved at call time, not module-eval time.
@@ -369,7 +369,7 @@ export async function queueModePopNeverSkipsBacklog(client) {
 }
 
 // ============================================================================
-// 9. Watermark: empty polls during a held lease must not strand backlog
+// 9. Empty polls during a held lease must not strand backlog
 // ============================================================================
 export async function leasedBacklogNotStrandedByEmptyPolls(client) {
     const queue = uniq('watermark-lease')
@@ -385,34 +385,26 @@ export async function leasedBacklogNotStrandedByEmptyPolls(client) {
     if (a.length !== 1) return { success: false, message: 'Worker A did not get the message' }
 
     // Worker B (same group) polls empty repeatedly while A holds the lease.
-    // A buggy engine advances the empty-scan watermark here even though the
-    // backlog is only invisible because of A's lease.
+    // The backlog is invisible here ONLY because of A's lease: a broker that
+    // remembers these empty answers as "nothing to deliver" keeps hiding the
+    // partition after the lease lapses.
     for (let i = 0; i < 3; i++) {
         await client.queue(queue).group(group).batch(1).wait(false).pop()
         await sleep(100)
     }
 
-    // Defeat the 2-minute candidate-filter grace so a wrongly-advanced
-    // watermark actually hides the partition (same trick as watermark.js).
-    // Queue identity is now the queen.queues id (log_queues merged away).
-    await dbPool.query(`
-        UPDATE queen.log_partitions p
-        SET last_write_at = last_write_at - interval '10 minutes'
-        FROM queen.queues q
-        WHERE p.queue_id = q.id AND q.name = $1
-    `, [queue])
-
-    // Wait for A's lease to lapse. NO new push arrives.
+    // Wait for A's lease to lapse. NO new push arrives, so nothing but the
+    // lease expiry can make the message deliverable again.
     await sleep(3500)
 
     const b = await popRetry(client, queue, { group, tries: 10 })
     if (b.length !== 1) {
         return {
             success: false,
-            message: 'Backlog stranded: empty polls during a held lease advanced the watermark past unconsumed data'
+            message: 'Backlog stranded: after empty polls during a held lease, the message never came back once the lease lapsed'
         }
     }
-    return { success: true, message: 'Backlog survived lease churn + empty polls (watermark guard holds)' }
+    return { success: true, message: 'Backlog survived lease churn + empty polls' }
 }
 
 // ============================================================================
@@ -433,7 +425,7 @@ export async function pushOnlyQueueIsDiscoverable(client) {
     const list = Array.isArray(body) ? body : (body.queues || [])
     const entry = list.find(q => (q.name || q.queue) === queue)
     if (!entry) {
-        return { success: false, message: 'Push-only queue missing from /api/v1/resources/queues (no queen.queues row?)' }
+        return { success: false, message: 'Push-only queue missing from /api/v1/resources/queues (never registered by the push?)' }
     }
     const entryNs = entry.namespace ?? entry.ns
     if (entryNs !== ns) {
@@ -455,19 +447,13 @@ export async function pushOnlyQueueIsDiscoverable(client) {
         if (!found) await sleep(200)
     }
 
-    // Cleanup: queue identity is now the queen.queues id, and deleting the
-    // queues row cascades partitions/watermarks/metadata/lag-metrics. Only
-    // log_txns/log_dlq are FK-less by design → explicit purge via partitions.
-    await dbPool.query(`
-        WITH parts AS (
-          SELECT lp.id FROM queen.log_partitions lp
-          JOIN queen.queues q ON q.id = lp.queue_id
-          WHERE q.name = $1
-        ),
-        d1 AS (DELETE FROM queen.log_txns WHERE partition_id IN (SELECT id FROM parts)),
-        d2 AS (DELETE FROM queen.log_dlq  WHERE partition_id IN (SELECT id FROM parts))
-        SELECT 1`, [queue])
-    await dbPool.query(`DELETE FROM queen.queues WHERE name = $1`, [queue])
+    // Best-effort cleanup through the public API. The lane's broker is thrown
+    // away after the run anyway, so a failed delete is not this test's verdict.
+    try {
+        await client.queue(queue).delete()
+    } catch (e) {
+        // Ignore
+    }
 
     if (!found) {
         return { success: false, message: 'Namespace discovery pop never found the push-only queue' }

package/test-v2/stream/_helpers.js

@@ -1,13 +1,12 @@
 /**
  * Shared utilities for streaming tests.
  *
- * Tests in test-v2/stream/* are run live against a Queen instance and a
- * Postgres database. Each test:
+ * Tests in test-v2/stream/* are run live against a Queen broker. Each test:
  *   - generates a unique queue/query name to avoid collisions across runs
  *   - sets up source + sink queues
  *   - runs a Stream pipeline for a bounded time
  *   - asserts on the resulting sink-queue contents and/or runner metrics
- *   - stops the stream and lets the global cleanup hook drop the rows
+ *   - stops the stream (the lane's broker is thrown away after the run)
  *
  * Test-name uniqueness is achieved with the test function's name + a
  * monotonic counter so the same suite can be re-run without state bleed.
@@ -20,7 +19,7 @@ let _nameCounter = 0
 
 /**
  * Build a unique queue/query name scoped to a test. The prefix is always
- * "test-stream-" so the global cleanup query in run.js deletes it.
+ * "test-stream-", the suite's test-name convention.
  *
  * @param {string} testName - e.g. fn.name
  * @param {string} suffix   - 'src' | 'sink' | 'query' | etc.
@@ -89,12 +88,12 @@ export async function pushSpread(client, queueName, items) {
  * the broker default of 'new' its cursor would be seeded at the sink's tail
  * and the emits under test would be invisible.
  *
- * NOTE on batch size: we use batch=1 so that each ack triggers
- * `acked_count >= batch_size` in queen.partition_consumers and the lease
- * is released between pops. With a larger batch the lease would stay
- * held until acked_count reached the full batch_size (often never on
- * intermittent emits), and subsequent pops would skip the partition as
- * "leased by another worker." Worth the round-trip overhead in tests.
+ * NOTE on batch size: we use batch=1 so that each ack reaches the end of
+ * the leased batch and the lease is released between pops. With a larger
+ * batch the lease would stay held until the acks reached the end of the
+ * full batch (often never on intermittent emits), and subsequent pops would
+ * skip the partition as "leased by another worker." Worth the round-trip
+ * overhead in tests.
  */
 export async function drainSink(client, queueName, { timeoutMs = 5000, group } = {}) {
   const cg = group || `drain-${Date.now()}-${Math.floor(Math.random() * 1e6)}`
@@ -110,7 +109,7 @@ export async function drainSink(client, queueName, { timeoutMs = 5000, group } =
       .pop()
     if (!popped || popped.length === 0) break
     for (const m of popped) out.push(m)
-    // Pass the consumer group so the SP validates the lease against OUR
+    // Pass the consumer group so the broker validates the lease against OUR
     // group, not the default __QUEUE_MODE__. queen-mq uses `context.group`
     // (NOT `consumerGroup`) for the ack-context shape.
     await client.ack(popped, true, { group: cg })
@@ -187,11 +186,3 @@ export async function runStreamFor(streamFactory, runMs) {
   await handle.stop()
   return handle
 }
-
-/**
- * Helpful guard for tests that need a clean queen_streams.queries row for
- * a given query name. Drops it (state cascades) before the test runs.
- */
-export async function dropStreamQuery(dbPool, queryName) {
-  await dbPool.query(`DELETE FROM queen_streams.queries WHERE name = $1`, [queryName])
-}

package/test-v2/stream/cron.js

@@ -3,7 +3,7 @@
  *   'second' | 'minute' | 'hour' | 'day' | 'week'
  *
  * Boundaries are anchored to UTC. Day = midnight UTC; week = Monday 00:00
- * UTC. Tests here exercise live behaviour (in-PG state) for the second
+ * UTC. Tests here exercise live behaviour (broker-side state) for the second
  * granularity (fast enough to test in seconds rather than hours).
  */
 

package/test-v2/stream/gate.js

@@ -0,0 +1,54 @@
+/**
+ * .gate() against a live broker: the partial ack counts SOURCE MESSAGES.
+ *
+ * The gate's partial ack is an offset commit -- the broker advances
+ * `ack.count` messages from the head of the leased batch and keeps the lease
+ * -- and the runner used to count the envelopes the gate saw instead. With a
+ * .flatMap() in front, a denied message was acked together with its
+ * predecessor and never came back (2026-10-02, 2.0.0-beta.6: 4 of 6 sink
+ * items, message 2 lost). The unit tests pin the cycle body
+ * (streams-unit/gate.test.js); this one pins the broker's side of it.
+ */
+
+import { Stream } from '../../client-v2/index.js'
+import { STREAMS_URL, mkName, drainUntil, expect, summarise } from './_helpers.js'
+
+export async function streamGateFlatMapPartialAck(client) {
+  const src = mkName('streamGateFlatMapPartialAck', 'src')
+  const sink = mkName('streamGateFlatMapPartialAck', 'sink')
+  const queryId = mkName('streamGateFlatMapPartialAck', 'q')
+
+  // A short lease: the denied tail comes back when it expires.
+  await client.queue(src).config({ leaseTime: 2 }).create()
+  await client.queue(sink).create()
+  await client.queue(src).partition('tenant-1').push([{ data: { n: 1 } }, { data: { n: 2 } }, { data: { n: 3 } }])
+
+  // Every message becomes two values; message 2 is denied the first time it
+  // is seen and allowed after its redelivery.
+  let deniedOnce = false
+  const handle = await Stream
+    .from(client.queue(src))
+    .flatMap(m => [m.data, m.data])
+    .gate((v) => {
+      if (v.n === 2 && !deniedOnce) {
+        deniedOnce = true
+        return false
+      }
+      return true
+    })
+    .to(client.queue(sink))
+    .run({ queryId, url: STREAMS_URL, batchSize: 10, maxPartitions: 1, reset: true, subscriptionMode: 'all' })
+
+  const drained = await drainUntil(client, sink, { until: out => out.length >= 6, timeoutMs: 15000 })
+  await handle.stop()
+
+  const count = (n) => drained.filter(m => m.data.n === n).length
+  const checks = [
+    expect(deniedOnce, '===', true, 'the gate denied message 2 once'),
+    expect(count(1), '===', 2, 'message 1 on the sink'),
+    expect(count(2), '===', 2, 'message 2 on the sink after its redelivery'),
+    expect(count(3), '===', 2, 'message 3 on the sink'),
+    expect(handle.metrics().errorsTotal, '===', 0, 'no errors')
+  ]
+  return summarise('streamGateFlatMapPartialAck', checks)
+}

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

@@ -149,12 +149,16 @@ export async function tumblingAggregateAllStats(client) {
   await client.queue(src).create()
   await client.queue(sink).create()
 
-  // Push 5 values into the SAME window (all within 1 second), then idle
-  // flush will close it. Sum = 50, count = 5, avg = 10, min = 2, max = 30.
-  const values = [10, 5, 30, 2, 3]
-  for (const v of values) {
-    await client.queue(src).partition('p').push([{ data: { v } }])
-  }
+  // One batched push = one segment = one timestamp, so the five values cannot
+  // straddle a 3-second window boundary. Pushing them "within 1 second" of each
+  // other does NOT put them in one window: the bucket is absolute-aligned
+  // (floor(ts / 3000) * 3000), so two pushes milliseconds apart still split when
+  // a boundary falls between them, and the assertion below reads only the FIRST
+  // emit. Sum = 50, count = 5, avg = 10, min = 2, max = 30.
+  await client.queue(src).partition('p').push([
+    { data: { v: 10 } }, { data: { v: 5 } }, { data: { v: 30 } },
+    { data: { v: 2 } }, { data: { v: 3 } },
+  ])
 
   const handle = await Stream
     .from(client.queue(src))
@@ -290,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')
+    })
+  })
+})