@getstrata/core 2.2.14 → 2.2.16

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @getstrata/core changelog
 
+## 2.2.16
+
+Allow managed outbox workers to reuse a configured instance, preserving application tenant resolution, listener registration and delivery settings. Keep generated listeners-only defaults compatible, reject ambiguous worker sources, and cover configured SQL delivery, cancellation, cleanup and TypeScript contracts.
+
+## 2.2.15
+
+- Batch legacy list-queue priority polling while retaining recovery and ownership contracts.
+- Batch dialect-portable pivot writes with framework transaction/savepoint composition and consistent numeric/string ID toggle semantics. Noncanonical or textual IDs use sequential database comparisons to preserve coercion and collation behavior.
+- New Redis scaffolds explicitly select Streams; existing unset transport settings continue to select lists.
+- Generate the SQL outbox migration, listener registry and managed worker command. Durable publication and cache-invalidation activation remain explicit.
+
+- Primary-key ascending `chunk` queries reuse the existing keyset walk, including default primary-key ordering; projections, joins, grouping, locks and other orders retain OFFSET behavior.
+- Empty filtered pagination totals skip the row query. Nonempty page-number pagination preserves OFFSET semantics and its count-plus-row-query budget; explicit cursor/keyset APIs remain available for deep traversal.
+- Independent hashed write casts run concurrently. Deterministic regressions prove concurrent start, complete awaiting and failure before model observers or SQL writes; hydration and existing-hash behavior are preserved.
+- Streams workers poll retry promotion, pending recovery and new delivery across priorities in one bounded Redis script, preserving priority, ownership fencing and at-least-once delivery contracts.
+- Clarify historical 2.1.0–2.2.13 release notes and database/queue documentation. Remove the consolidated 1.x-to-2.x migration guide; existing projects are upgraded individually.
+
 ## 2.2.14
 
 Complete the scoped HTML rendering starter adoption: generated apps inject ViewRenderer through createViewProvider instead of copying renderPage; welcome pages opt into HTMX fragments with full-page fallbacks, auth retains existing contracts, and CORS preserves representation Vary headers. Includes generator, runtime auth and cache-header regressions.
@@ -8,7 +25,8 @@ Add optional typed resourceRoutes and strict mergeRouteMaps composition, preserv
 
 ## 2.2.13
 
-- Improve view rendering and better htmx support
+- Add a typed per-app HTML renderer on top of the native response path.
+- Add explicit HTMX page and fragment responses. A fragment can fall back to the full page. Layout and auth response contracts stay the same.
 
 ## 2.2.12
 
@@ -30,42 +48,47 @@ Add independently interruptible read-only SQLite and MySQL observations; extend
 
 ## 2.2.9
 
-- Support native cancellable transaction acquisition
+- Pool checkout can be cancelled. `reserve({ signal })` on the native driver aborts while it is still waiting for a connection. Drivers without that method are not given a fake one.
 
 ## 2.2.8
 
-- Add bounded read-only Postgres outbox metrics
+- Add bounded, read-only Postgres outbox metrics.
+- Add bounded, opt-in Redis queue metrics. List and Streams depth stay separate.
 
 ## 2.2.7
 
-- Where an ordinary operation needs SQL because the framework cannot express it
+- `ORDER BY` accepts explicit `nulls: "first" | "last"`. Postgres and SQLite emit `NULLS FIRST` / `NULLS LAST`. MySQL has no `NULLS FIRST` / `NULLS LAST` clause, so it orders nulls with an `IS NULL` discriminator and leaves the rest of the sort unchanged.
 
 ## 2.2.6
 
--  fix(cli): relay shutdown to children and simplify container launcher
+- The CLI, when it supervises the app or worker as a child, forwards shutdown signals to that child and waits for it. The container launcher no longer exits while the child is still running.
 
 ## 2.2.5
 
--  fix(starter): keep container readiness independent of API admission
+- Container readiness no longer means the API is admitting traffic. Database readiness no longer provisions roles or creates a missing database. A failed configured admin connection does not fall back to a generated password.
 
 ## 2.2.4
 
--  perf(database): seek Postgres composite keyset bounds
+- Composite keyset pages on Postgres seek with a row comparison (`(a, b) > (cursor)`), so the planner can start at the index bound instead of expanding the cursor into a chain of OR predicates.
 
 ## 2.2.3
 
-- feat(database): add scoped composite keyset pagination
+- Add scoped composite keyset pagination. The order must end with the primary key. Global scopes and caller filters stay in force across the cursor. Joins, grouping, and offset queries are rejected.
 
 ## 2.2.2
 
-- orm improvments
+- Schema `bigId` emits an explicit 64-bit generated identity.
+- Repository writes can be conditional and set-based.
+- Repositories and models can take a typed row lock inside the current transaction.
+- Generated Postgres query handles keep tagged-SQL typing.
 
 ## 2.2.1
 
-F02 — complete queue durability. Queues have leased reservations, recovery and fenced acknowledgement, but still use Redis lists. Persisted retry schedules, execution deadlines, cancellation and the planned Streams migration remain unfinished. Retries currently wait inside the running worker.
-F10 — production public-route tenancy. Separate anonymous access from development tenant headers, support a trusted-host resolver, reject unknown hosts, and accept forwarded hosts only through configured trusted proxies. The shop still lacks the approved-domain mapping.
-F12 — initial administrator provisioning and migration guidance. Automatic demo seeding is fixed. Secure initial-admin provisioning and a consolidated upgrade/operations guide remain.
-Distributed qualification. Cache generations/fill leases, scheduler ownership, OpenTelemetry, body limits and lifecycle controls now exist. Their implementation should no longer be described as entirely pending, but broader failure and capacity qualification is still required.
+- Opt-in Redis Streams (`QUEUE_REDIS_TRANSPORT=streams`). Lists stay the default. Streams adds consumer-group recovery, persisted retry schedules, total job deadlines, opt-in cancellation, and a stable job id across replay. Conversion from lists is a stopped maintenance step.
+- Failed jobs stay recorded until retry admission succeeds. Manual replay keeps `failed_job.job_id` when the row has one.
+- Public reads and tenant host selection are separate. Unknown hosts fail closed. Forwarded hosts are accepted only from configured trusted proxies.
+- Generated apps can provision one initial administrator with `auth:provision-admin` and a one-time claim migration. Demo seeding stays explicit and is rejected in production and staging.
+- Quota and in-memory throttle docs match the code: memory throttles stay process-local, and a Redis failure does not fall back to them.
 
 ## 2.2.0
 
@@ -102,7 +125,9 @@ Bounded memory throttling.
 
 ## 2.1.0
 
-- refactor(starter): reuse shared config and base repositories - fix(database): await password casts before model writes - fix(database): preserve concrete model types in query results
+- Generated apps reuse the shared config store and base repositories instead of a copied stack.
+- Password casts are awaited before the write reaches SQL or observers. Hydration does not hash.
+- Model queries keep the concrete model type in their results. Service tokens, route handlers, and the starter's generated infrastructure were tightened in the same release.
 
 ## 2.0.9
 

package/dist/core/database/baseRepository.d.ts

@@ -69,6 +69,7 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     softDeleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
     forceDeleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
     restoreById(id: TEntity[PrimaryKey]): Promise<TEntity | null>;
+    private primaryKeySeekDirection;
     withConnection(connection: DatabaseConnection): this;
     getConnection(): DatabaseConnection;
     getTable(): TableDefinition<TEntity, PrimaryKey>;

package/dist/core/database/defaultConnection.d.ts

@@ -2,5 +2,6 @@ import type { SqlDatabaseConnection } from "./baseRepository";
 declare function registerDefaultDatabasePool(connection: SqlDatabaseConnection): void;
 declare function getDefaultDatabasePool(): SqlDatabaseConnection;
 declare function getDefaultDatabaseQuery(): SqlDatabaseConnection;
+declare function isDefaultDatabaseConnection(connection: unknown): boolean;
 declare function resetDefaultDatabasePoolForTests(): void;
-export { getDefaultDatabasePool, getDefaultDatabaseQuery, registerDefaultDatabasePool, resetDefaultDatabasePoolForTests, };
+export { getDefaultDatabasePool, getDefaultDatabaseQuery, isDefaultDatabaseConnection, registerDefaultDatabasePool, resetDefaultDatabasePoolForTests, };

package/dist/core/database/relationQuery.d.ts

@@ -112,6 +112,7 @@ declare class BelongsToManyRelationQuery<TParent extends object, ParentKey exten
     hydrateEager(row: Record<string, unknown>, alias: string): unknown;
     toExistsClause(parentTable: string): ExistsClause;
     private connection;
+    private atomically;
     get(): Promise<RelatedRecord[]>;
     first(): Promise<RelatedRecord | null>;
     count(): Promise<number>;
@@ -123,6 +124,9 @@ declare class BelongsToManyRelationQuery<TParent extends object, ParentKey exten
     attach(ids: unknown | readonly unknown[]): Promise<void>;
     toggle(ids: unknown | readonly unknown[]): Promise<void>;
     detach(ids?: unknown | readonly unknown[]): Promise<void>;
+    private toggleOne;
+    private insertPivotRows;
+    private deletePivotRows;
     sync(ids: readonly unknown[]): Promise<void>;
     create(attributes?: Record<string, unknown>): Promise<RelatedRecord>;
 }

package/dist/core/queue/redisQueue.d.ts

@@ -15,6 +15,10 @@ type QueueReservation = {
 declare function queueInvalidKey(queueKey: string): string;
 declare function reserveQueueJob(client: RedisClient, queueKey: string, owner: string): Promise<QueueReservation | null>;
 declare function updateQueueReservation(client: RedisClient, queueKey: string, reservation: QueueReservation, action: "renew" | "ack" | "quarantine"): Promise<boolean>;
+declare function pollListPriorities(client: RedisClient, queueKeys: readonly string[], owner: string, reservationId: string, reclaim: boolean): Promise<{
+    queueKey: string;
+    reservation: QueueReservation;
+} | null>;
 declare function reclaimExpiredQueueReservations(client: RedisClient, queueKeys?: readonly string[]): Promise<number>;
 declare class RedisQueue implements Queue {
     private readonly client;
@@ -42,4 +46,4 @@ declare function countPendingQueueJobs(redisUrl: string): Promise<number>;
 export type { StreamReservation, StreamsEnqueueOptions } from "./redisStreams";
 export { migrateLegacyQueueToStreams, RedisStreamsQueue, RedisStreamsWorker, STREAM_GROUP, streamDeadLetterKey, streamQueueKey, updateStreamReservation, } from "./redisStreams";
 export type { QueueJobEnvelope, QueueReservation };
-export { countPendingQueueJobs, parseQueueJobEnvelope, QUEUE_HIGH_KEY, QUEUE_LIST_KEY, QUEUE_LOW_KEY, QueueWorker, queueInvalidKey, queueKeyForPriority, queueProcessingKey, queueProcessingLeaseKey, RedisQueue, reclaimExpiredQueueReservations, reservationExpired, reserveQueueJob, updateQueueReservation, };
+export { countPendingQueueJobs, parseQueueJobEnvelope, pollListPriorities, QUEUE_HIGH_KEY, QUEUE_LIST_KEY, QUEUE_LOW_KEY, QueueWorker, queueInvalidKey, queueKeyForPriority, queueProcessingKey, queueProcessingLeaseKey, RedisQueue, reclaimExpiredQueueReservations, reservationExpired, reserveQueueJob, updateQueueReservation, };

package/dist/core/queue/redisStreams.d.ts

@@ -18,6 +18,13 @@ declare function readStreamTime(client: RedisClient): Promise<number>;
 declare function watchStreamDeadline(client: RedisClient, deadlineAtMs: number, remainingMs: number, expire: () => void, fail: (error: unknown) => void): () => void;
 declare function scheduleStreamRetry(client: RedisClient, key: string, reservation: StreamReservation, envelope: QueueJobEnvelope, delayMs: number): Promise<void>;
 declare function promoteStreamRetries(client: RedisClient, key: string): Promise<number>;
+declare function pollStreamPriorities(client: RedisClient, queueKeys: readonly string[], owner: string, cursors: readonly string[]): Promise<{
+    cursors: string[];
+    hit: {
+        index: number;
+        reservation: StreamReservation;
+    } | null;
+}>;
 declare function readStreamQueueDepth(client: RedisClient, key: string): Promise<number>;
 type StreamReservation = {
     id: string;
@@ -58,7 +65,6 @@ declare class RedisStreamsWorker {
     isRunning(): boolean;
     close(): void;
     private initialize;
-    private reserve;
     processNext(): Promise<boolean>;
     private processOne;
     private handle;
@@ -70,4 +76,4 @@ declare function migrateLegacyQueueToStreams(client: RedisClient, options: {
     queueKeys?: readonly string[];
 }): Promise<number>;
 export type { StreamReservation, StreamsEnqueueOptions };
-export { cancelStreamJob, ensureStreamGroup, migrateLegacyQueueToStreams, promoteStreamRetries, RedisStreamsQueue, RedisStreamsWorker, readStreamCancellation, readStreamEntry, readStreamQueueDepth, readStreamTime, reserveStreamJob, STREAM_GROUP, scheduleStreamRetry, streamControlKey, streamDeadLetterKey, streamQueueKey, streamRetryKey, updateStreamReservation, watchStreamDeadline, };
+export { cancelStreamJob, ensureStreamGroup, migrateLegacyQueueToStreams, pollStreamPriorities, promoteStreamRetries, RedisStreamsQueue, RedisStreamsWorker, readStreamCancellation, readStreamEntry, readStreamQueueDepth, readStreamTime, reserveStreamJob, STREAM_GROUP, scheduleStreamRetry, streamControlKey, streamDeadLetterKey, streamQueueKey, streamRetryKey, updateStreamReservation, watchStreamDeadline, };

package/dist/entries/queue/createAppQueue.js

@@ -448,21 +448,6 @@ redis.call('XDEL', KEYS[1], ARGV[2])
 if #redis.call('XPENDING', KEYS[1], ARGV[1], '-', '+', 1, ARGV[3]) == 0 then redis.call('XGROUP', 'DELCONSUMER', KEYS[1], ARGV[1], ARGV[3]) end
 return 1
 `;
-var PROMOTE_RETRIES = `
-local kinds = {'stream','zset'}
-for i=1,2 do
-  local kind = redis.call('TYPE', KEYS[i]).ok
-  if kind ~= 'none' and kind ~= kinds[i] then return redis.error_reply('Invalid stream retry promotion key type') end
-end
-local now = redis.call('TIME')
-local due = tonumber(now[1])*1000 + math.floor(tonumber(now[2])/1000)
-local entries = redis.call('ZRANGE', KEYS[2], '-inf', due, 'BYSCORE', 'LIMIT', 0, 100)
-for _, payload in ipairs(entries) do
-  redis.call('XADD', KEYS[1], '*', 'payload', payload)
-  redis.call('ZREM', KEYS[2], payload)
-end
-return #entries
-`;
 async function scheduleStreamRetry(client, key, reservation, envelope, delayMs) {
   if (!Number.isSafeInteger(delayMs) || delayMs < 0 || delayMs > Number.MAX_SAFE_INTEGER / 2)
     throw new Error("Invalid Streams retry delay");
@@ -484,8 +469,93 @@ async function scheduleStreamRetry(client, key, reservation, envelope, delayMs)
   if (Number(scheduled) !== 1)
     throw new Error("Queue lease lost while scheduling retry");
 }
-async function promoteStreamRetries(client, key) {
-  return Number(await client.send("EVAL", [PROMOTE_RETRIES, "2", streamQueueKey(key), streamRetryKey(key)]));
+var POLL_STREAM_PRIORITIES = `
+local group = ARGV[1]
+local owner = ARGV[2]
+local visibility = ARGV[3]
+local function payloadOf(fields)
+  for index = 1, #fields, 2 do
+    if fields[index] == 'payload' and type(fields[index + 1]) == 'string' then return fields[index + 1] end
+  end
+  return ''
+end
+local cursors = {}
+for i = 1, #KEYS / 2 do cursors[i] = ARGV[3 + i] end
+for i = 1, #KEYS / 2 do
+  local stream = KEYS[(i - 1) * 2 + 1]
+  local retries = KEYS[(i - 1) * 2 + 2]
+  local cursor = ARGV[3 + i]
+  local streamKind = redis.call('TYPE', stream).ok
+  local retryKind = redis.call('TYPE', retries).ok
+  if streamKind ~= 'none' and streamKind ~= 'stream' then return redis.error_reply('Invalid stream retry promotion key type') end
+  if retryKind ~= 'none' and retryKind ~= 'zset' then return redis.error_reply('Invalid stream retry promotion key type') end
+  if streamKind == 'stream' then
+    local now = redis.call('TIME')
+    local due = tonumber(now[1]) * 1000 + math.floor(tonumber(now[2]) / 1000)
+    local ready = redis.call('ZRANGE', retries, '-inf', due, 'BYSCORE', 'LIMIT', 0, 100)
+    for _, payload in ipairs(ready) do
+      redis.call('XADD', stream, '*', 'payload', payload)
+      redis.call('ZREM', retries, payload)
+    end
+    local window = redis.call('XPENDING', stream, group, cursor, '+', 10)
+    local claimed = redis.call('XAUTOCLAIM', stream, group, owner, visibility, cursor, 'COUNT', 1)
+    for _, entry in ipairs(window) do
+      if entry[2] ~= owner and #redis.call('XPENDING', stream, group, '-', '+', 1, entry[2]) == 0 then
+        redis.call('XGROUP', 'DELCONSUMER', stream, group, entry[2])
+      end
+    end
+    if #redis.call('XPENDING', stream, group, '-', '+', 1, owner) == 0 then
+      redis.call('XGROUP', 'DELCONSUMER', stream, group, owner)
+    end
+    cursors[i] = claimed[1]
+    if #claimed[2] > 0 then
+      return {'1', tostring(i), claimed[2][1][1], payloadOf(claimed[2][1][2]), unpack(cursors)}
+    end
+    local fresh = redis.call('XREADGROUP', 'GROUP', group, owner, 'COUNT', 1, 'STREAMS', stream, '>')
+    if not fresh and #redis.call('XPENDING', stream, group, '-', '+', 1, owner) == 0 then
+      redis.call('XGROUP', 'DELCONSUMER', stream, group, owner)
+    end
+    if fresh and #fresh > 0 and #fresh[1][2] > 0 then
+      return {'1', tostring(i), fresh[1][2][1][1], payloadOf(fresh[1][2][1][2]), unpack(cursors)}
+    end
+  end
+end
+return {'0', unpack(cursors)}
+`;
+async function pollStreamPriorities(client, queueKeys, owner, cursors) {
+  const keys = [];
+  for (const key of queueKeys)
+    keys.push(streamQueueKey(key), streamRetryKey(key));
+  const raw = await client.send("EVAL", [
+    POLL_STREAM_PRIORITIES,
+    String(keys.length),
+    ...keys,
+    STREAM_GROUP,
+    owner,
+    String(readQueueVisibilityMs()),
+    ...cursors
+  ]);
+  if (!Array.isArray(raw))
+    throw new Error("Invalid Redis stream poll response");
+  const flag = String(raw[0]);
+  const cursorCount = queueKeys.length;
+  if (flag === "0") {
+    if (raw.length !== cursorCount + 1)
+      throw new Error("Invalid Redis stream poll response");
+    return { cursors: raw.slice(1).map(String), hit: null };
+  }
+  if (flag !== "1" || raw.length !== cursorCount + 4)
+    throw new Error("Invalid Redis stream poll response");
+  const index = Number(raw[1]);
+  if (!Number.isInteger(index) || index < 1 || index > queueKeys.length)
+    throw new Error("Invalid Redis stream poll response");
+  return {
+    cursors: raw.slice(4).map(String),
+    hit: {
+      index: index - 1,
+      reservation: { id: String(raw[2]), owner, payload: String(raw[3]) }
+    }
+  };
 }
 async function readStreamQueueDepth(client, key) {
   return Number(await client.send("EVAL", [
@@ -534,20 +604,6 @@ end
 if #redis.call('XPENDING', KEYS[1], ARGV[1], '-', '+', 1, ARGV[3]) == 0 then redis.call('XGROUP', 'DELCONSUMER', KEYS[1], ARGV[1], ARGV[3]) end
 return acknowledged
 `;
-var CLAIM_STREAM = `
-local window = redis.call('XPENDING', KEYS[1], ARGV[1], ARGV[4], '+', 10)
-local claimed = redis.call('XAUTOCLAIM', KEYS[1], ARGV[1], ARGV[2], ARGV[3], ARGV[4], 'COUNT', 1)
-for _, entry in ipairs(window) do
-  if entry[2] ~= ARGV[2] and #redis.call('XPENDING', KEYS[1], ARGV[1], '-', '+', 1, entry[2]) == 0 then redis.call('XGROUP', 'DELCONSUMER', KEYS[1], ARGV[1], entry[2]) end
-end
-if #redis.call('XPENDING', KEYS[1], ARGV[1], '-', '+', 1, ARGV[2]) == 0 then redis.call('XGROUP', 'DELCONSUMER', KEYS[1], ARGV[1], ARGV[2]) end
-return claimed
-`;
-var READ_STREAM = `
-local entries = redis.call('XREADGROUP', 'GROUP', ARGV[1], ARGV[2], 'COUNT', 1, 'STREAMS', KEYS[1], '>')
-if not entries and #redis.call('XPENDING', KEYS[1], ARGV[1], '-', '+', 1, ARGV[2]) == 0 then redis.call('XGROUP', 'DELCONSUMER', KEYS[1], ARGV[1], ARGV[2]) end
-return entries
-`;
 async function ensureStreamGroup(client, key) {
   await assertLegacyDrained(client, key);
   try {
@@ -557,17 +613,6 @@ async function ensureStreamGroup(client, key) {
       throw error;
   }
 }
-function readStreamEntry(value, owner) {
-  if (!Array.isArray(value) || typeof value[0] !== "string" || !Array.isArray(value[1]))
-    throw new Error("Invalid Redis stream entry response");
-  const fields = value[1];
-  let payload;
-  for (let index = 0;index < fields.length; index += 2) {
-    if (fields[index] === "payload" && typeof fields[index + 1] === "string")
-      payload = fields[index + 1];
-  }
-  return { id: value[0], owner, payload: payload ?? "" };
-}
 async function updateStreamReservation(client, key, reservation, action, controlKey) {
   return Number(await client.send("EVAL", [
     UPDATE_STREAM,
@@ -584,35 +629,6 @@ async function updateStreamReservation(client, key, reservation, action, control
     controlKey ? "1" : "0"
   ])) === 1;
 }
-async function reserveStreamJob(client, key, owner, cursor = "0-0") {
-  const claimed = await client.send("EVAL", [
-    CLAIM_STREAM,
-    "1",
-    streamQueueKey(key),
-    STREAM_GROUP,
-    owner,
-    String(readQueueVisibilityMs()),
-    cursor
-  ]);
-  if (!Array.isArray(claimed) || typeof claimed[0] !== "string" || !Array.isArray(claimed[1]))
-    throw new Error("Invalid Redis XAUTOCLAIM response");
-  const nextCursor = claimed[0];
-  if (claimed[1].length > 0)
-    return { reservation: readStreamEntry(claimed[1][0], owner), cursor: nextCursor };
-  const fresh = await client.send("EVAL", [
-    READ_STREAM,
-    "1",
-    streamQueueKey(key),
-    STREAM_GROUP,
-    owner
-  ]);
-  if (fresh === null)
-    return { reservation: null, cursor: nextCursor };
-  if (!Array.isArray(fresh) || !Array.isArray(fresh[0]) || !Array.isArray(fresh[0][1]))
-    throw new Error("Invalid Redis XREADGROUP response");
-  return { reservation: readStreamEntry(fresh[0][1][0], owner), cursor: nextCursor };
-}
-
 class RedisStreamsQueue {
   client;
   constructor(redisUrl) {
@@ -710,12 +726,6 @@ class RedisStreamsWorker {
       await ensureStreamGroup(this.client, key);
     this.initialized = true;
   }
-  async reserve(key) {
-    await promoteStreamRetries(this.client, key);
-    const result = await reserveStreamJob(this.client, key, this.owner, this.cursors.get(key));
-    this.cursors.set(key, result.cursor);
-    return result.reservation;
-  }
   async processNext() {
     if (this.processing)
       throw new Error("Queue worker already processing a job.");
@@ -732,13 +742,19 @@ class RedisStreamsWorker {
     await this.initialize();
     const deadline = performance.now() + this.timeoutSeconds * 1000;
     do {
-      for (const key of this.queueKeys) {
-        if (this.stopping)
-          return false;
-        const reservation = await this.reserve(key);
-        if (!reservation)
-          continue;
-        await this.handle(key, reservation);
+      if (this.stopping)
+        return false;
+      const polled = await pollStreamPriorities(this.client, this.queueKeys, this.owner, this.queueKeys.map((key) => this.cursors.get(key) ?? "0-0"));
+      this.queueKeys.forEach((key, index) => {
+        const cursor = polled.cursors[index];
+        if (cursor)
+          this.cursors.set(key, cursor);
+      });
+      if (polled.hit) {
+        const key = this.queueKeys[polled.hit.index];
+        if (!key)
+          throw new Error("Invalid Redis stream poll response");
+        await this.handle(key, polled.hit.reservation);
         return true;
       }
       if (performance.now() >= deadline || this.stopping)
@@ -1011,6 +1027,66 @@ for _, record in ipairs(redis.call('LRANGE', KEYS[2], 0, -1)) do
 end
 return reclaimed
 `;
+var POLL_LIST_PRIORITIES = `${SCRIPT_HEADER}
+local owner = ARGV[1]
+local visibility = ARGV[2]
+local reservationId = ARGV[3]
+local reclaim = ARGV[4] == '1'
+local function reclaimQueue(listKey, processingKey, leaseKey)
+  local err = checkType(listKey, 'list') or checkType(processingKey, 'list') or checkType(leaseKey, 'hash')
+  if err then return err end
+  local now = nowMs()
+  for _, record in ipairs(redis.call('LRANGE', processingKey, 0, -1)) do
+    local payload, field = record, record
+    local modern = false
+    local ok, reservation = pcall(cjson.decode, record)
+    if ok and type(reservation) == 'table' and reservation.strataReservation == 1 then
+      payload, field, modern = reservation.payload, reservation.id, true
+    end
+    local raw = redis.call('HGET', leaseKey, field)
+    local expired = true
+    if raw then
+      if modern then
+        local leaseOk, lease = pcall(cjson.decode, raw)
+        expired = not leaseOk or type(lease) ~= 'table' or not tonumber(lease.expiresAt) or tonumber(lease.expiresAt) <= now
+      else
+        local reservedAt = tonumber(raw)
+        expired = not reservedAt or now - reservedAt >= tonumber(visibility)
+      end
+    end
+    if expired then
+      redis.call('LPUSH', listKey, payload)
+      redis.call('LREM', processingKey, 1, record)
+      redis.call('HDEL', leaseKey, field)
+    end
+  end
+end
+local function reserveQueue(listKey, processingKey, leaseKey)
+  local err = checkType(listKey, 'list') or checkType(processingKey, 'list') or checkType(leaseKey, 'hash')
+  if err then return err end
+  local payload = redis.call('LINDEX', listKey, -1)
+  if not payload then return nil end
+  local record = cjson.encode({strataReservation=1, id=reservationId, owner=owner, payload=payload})
+  local lease = cjson.encode({owner=owner, expiresAt=nowMs()+tonumber(visibility)})
+  redis.call('LPUSH', processingKey, record)
+  redis.call('HSET', leaseKey, reservationId, lease)
+  redis.call('RPOP', listKey)
+  return record
+end
+local count = #KEYS / 3
+if reclaim then
+  for i = 1, count do
+    local err = reclaimQueue(KEYS[(i - 1) * 3 + 1], KEYS[(i - 1) * 3 + 2], KEYS[(i - 1) * 3 + 3])
+    if err then return err end
+  end
+end
+for i = 1, count do
+  local record = reserveQueue(KEYS[(i - 1) * 3 + 1], KEYS[(i - 1) * 3 + 2], KEYS[(i - 1) * 3 + 3])
+  if type(record) == 'string' then return {'1', tostring(i), record} end
+  if record then return record end
+end
+return {'0'}
+`;
 function queueInvalidKey(queueKey) {
   return `${queueKey}:invalid`;
 }
@@ -1045,6 +1121,41 @@ async function updateQueueReservation(client, queueKey, reservation, action) {
     reservation.payload
   ])) === 1;
 }
+async function pollListPriorities(client, queueKeys, owner, reservationId, reclaim) {
+  const keys = [];
+  for (const key of queueKeys) {
+    keys.push(key, queueProcessingKey(key), queueProcessingLeaseKey(key));
+  }
+  const raw = await client.send("EVAL", [
+    POLL_LIST_PRIORITIES,
+    String(keys.length),
+    ...keys,
+    owner,
+    String(readQueueVisibilityMs()),
+    reservationId,
+    reclaim ? "1" : "0"
+  ]);
+  if (!Array.isArray(raw))
+    throw new Error("Invalid Redis list poll response");
+  const flag = String(raw[0]);
+  if (flag === "0") {
+    if (raw.length !== 1)
+      throw new Error("Invalid Redis list poll response");
+    return null;
+  }
+  if (flag !== "1" || raw.length !== 3)
+    throw new Error("Invalid Redis list poll response");
+  const index = Number(raw[1]);
+  const record = raw[2];
+  if (!Number.isInteger(index) || index < 1 || index > queueKeys.length || typeof record !== "string") {
+    throw new Error("Invalid Redis list poll response");
+  }
+  const queueKey = queueKeys[index - 1];
+  if (!queueKey)
+    throw new Error("Invalid Redis list poll response");
+  const reservation = JSON.parse(record);
+  return { queueKey, reservation: { ...reservation, record } };
+}
 async function reclaimExpiredQueueReservations(client, queueKeys = QUEUE_KEYS) {
   let reclaimed = 0;
   for (const key of queueKeys) {
@@ -1105,14 +1216,14 @@ class QueueWorker {
   }
   async reserve() {
     const deadline = performance.now() + this.timeoutSeconds * 1000;
+    let reclaim = true;
     do {
-      for (const key of this.queueKeys) {
-        if (this.stopping)
-          return null;
-        const reservation = await reserveQueueJob(this.client, key, this.owner);
-        if (reservation)
-          return { queueKey: key, reservation };
-      }
+      if (this.stopping)
+        return null;
+      const reserved = await pollListPriorities(this.client, this.queueKeys, this.owner, crypto.randomUUID(), reclaim);
+      reclaim = false;
+      if (reserved)
+        return reserved;
       if (this.stopping || performance.now() >= deadline)
         return null;
       await Bun.sleep(Math.min(100, Math.max(1, deadline - performance.now())));
@@ -1122,7 +1233,6 @@ class QueueWorker {
   async processNext() {
     if (this.stopping)
       return false;
-    await reclaimExpiredQueueReservations(this.client, this.queueKeys);
     const reserved = await this.reserve();
     if (!reserved)
       return false;