bunqueue 2.8.0 → 2.8.2

package/dist/infrastructure/scheduler/cronScheduler.js

@@ -125,6 +125,9 @@ export class CronScheduler {
         const existing = this.cronJobs.get(cron.name);
         if (existing) {
             cron.executions = existing.cron.executions;
+            // Reset per-name overlap tracking on upsert: the redefined cron starts
+            // fresh and must not be blocked by the previous definition's last fire (H10)
+            this.lastFiredAt.delete(cron.name);
         }
         // Handle immediately option: set nextRun to now so it fires on next tick
         // Only on first creation, not on upsert (otherwise it overrides skipMissedOnRestart)
@@ -150,6 +153,9 @@ export class CronScheduler {
             return false;
         // Just remove from map - heap entry becomes stale (lazy deletion)
         this.cronJobs.delete(name);
+        // Clear per-name overlap tracking so a future cron re-added with the same
+        // name isn't blocked by this cron's stale last-fire timestamp (fixes H10)
+        this.lastFiredAt.delete(name);
         // Reschedule in case removed cron was the next timer target
         if (this.started) {
             this.scheduleNext();
@@ -262,13 +268,17 @@ export class CronScheduler {
                 // Calculate new state BEFORE pushing job
                 const newExecutions = cron.executions + 1;
                 const executionTime = Date.now();
+                // The slot this fire was scheduled for (anchor for fixed-rate intervals)
+                const scheduledRun = cron.nextRun;
                 let newNextRun;
                 if (cron.schedule) {
                     const expanded = expandCronShortcut(cron.schedule);
                     newNextRun = getNextCronRun(expanded, executionTime, cron.timezone ?? undefined);
                 }
                 else if (cron.repeatEvery) {
-                    newNextRun = getNextIntervalRun(cron.repeatEvery, executionTime);
+                    // Fixed-rate: anchor to the scheduled slot, not wall-clock now, so a
+                    // slow/late job does not cumulatively drift the schedule forward (M4)
+                    newNextRun = getNextIntervalRun(cron.repeatEvery, scheduledRun);
                 }
                 else {
                     newNextRun = executionTime;
@@ -352,11 +362,19 @@ export class CronScheduler {
         }
         // preventOverlap: auto-set uniqueKey to block pushes while previous job is active
         const effectiveUniqueKey = cron.uniqueKey ?? (cron.preventOverlap ? `cron:${cron.name}` : undefined);
+        const opts = cron.jobOptions;
         await this.pushJob(cron.queue, {
             data: cron.data,
             priority: cron.priority,
             uniqueKey: effectiveUniqueKey,
             dedup: cron.dedup ?? undefined,
+            maxAttempts: opts?.maxAttempts,
+            backoff: opts?.backoff,
+            timeout: opts?.timeout,
+            delay: opts?.delay,
+            stallTimeout: opts?.stallTimeout,
+            removeOnComplete: opts?.removeOnComplete,
+            removeOnFail: opts?.removeOnFail,
         });
         this.lastFiredAt.set(cron.name, now);
         this.dashboardEmit?.('cron:fired', { name: cron.name, queue: cron.queue });
@@ -391,4 +409,3 @@ export class CronScheduler {
         };
     }
 }
-//# sourceMappingURL=cronScheduler.js.map

package/dist/infrastructure/scheduler/index.d.ts

@@ -3,4 +3,3 @@
  */
 export * from './cronParser';
 export * from './cronScheduler';
-//# sourceMappingURL=index.d.ts.map

package/dist/infrastructure/scheduler/index.js

@@ -3,4 +3,3 @@
  */
 export * from './cronParser';
 export * from './cronScheduler';
-//# sourceMappingURL=index.js.map

package/dist/infrastructure/server/handler.d.ts

@@ -10,4 +10,3 @@ export type { HandlerContext } from './types';
  * Main command handler - routes to specific handlers
  */
 export declare function handleCommand(cmd: Command, ctx: HandlerContext): Promise<Response>;
-//# sourceMappingURL=handler.d.ts.map

package/dist/infrastructure/server/handler.js

@@ -73,4 +73,3 @@ export async function handleCommand(cmd, ctx) {
         return resp.error(message, reqId);
     }
 }
-//# sourceMappingURL=handler.js.map

package/dist/infrastructure/server/handlerRoutes.d.ts

@@ -24,4 +24,3 @@ export declare function routeConfigCommand(cmd: Command, ctx: HandlerContext, re
 export declare function routeMonitoringCommand(cmd: Command, ctx: HandlerContext, reqId?: string): Response | null;
 /** Route dashboard commands */
 export declare function routeDashboardCommand(cmd: Command, ctx: HandlerContext, reqId?: string): Response | null;
-//# sourceMappingURL=handlerRoutes.d.ts.map

package/dist/infrastructure/server/handlerRoutes.js

@@ -252,4 +252,3 @@ export function routeDashboardCommand(cmd, ctx, reqId) {
             return null;
     }
 }
-//# sourceMappingURL=handlerRoutes.js.map

package/dist/infrastructure/server/handlers/advanced.d.ts

@@ -89,7 +89,13 @@ export declare function handleGetDlqConfig(cmd: Extract<Command, {
 export declare function handleChangeDelay(cmd: Extract<Command, {
     cmd: 'ChangeDelay';
 }>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle MoveToWait command - promote a delayed job to waiting */
+/** Handle MoveToWait command - move a job back to waiting.
+ *  Dispatch by state to match embedded branching in jobMove.ts.
+ *  - active  -> moveActiveToWait
+ *  - delayed -> promote
+ *  - failed  -> retryDlq
+ *  - waiting / prioritized -> already there, no-op success
+ */
 export declare function handleMoveToWait(cmd: Extract<Command, {
     cmd: 'MoveToWait';
 }>, ctx: HandlerContext, reqId?: string): Promise<Response>;
@@ -113,4 +119,3 @@ export declare function handleRemoveChildDependency(cmd: Extract<Command, {
 export declare function handleRemoveUnprocessedChildren(cmd: Extract<Command, {
     cmd: 'RemoveUnprocessedChildren';
 }>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-//# sourceMappingURL=advanced.d.ts.map

package/dist/infrastructure/server/handlers/advanced.js

@@ -16,7 +16,7 @@ export async function handleUpdate(cmd, ctx, reqId) {
 }
 /** Handle ChangePriority command */
 export async function handleChangePriority(cmd, ctx, reqId) {
-    const success = await ctx.queueManager.changePriority(jobId(cmd.id), cmd.priority);
+    const success = await ctx.queueManager.changePriority(jobId(cmd.id), cmd.priority, cmd.lifo);
     if (success) {
         ctx.queueManager.emitDashboardEvent('job:priority-changed', {
             jobId: cmd.id,
@@ -44,14 +44,20 @@ export async function handleUpdateParent(cmd, ctx, reqId) {
 }
 /** Handle MoveToDelayed command */
 export async function handleMoveToDelayed(cmd, ctx, reqId) {
-    const success = await ctx.queueManager.moveToDelayed(jobId(cmd.id), cmd.delay);
+    const id = jobId(cmd.id);
+    const success = await ctx.queueManager.moveToDelayed(id, cmd.delay);
     if (success) {
         ctx.queueManager.emitDashboardEvent('job:moved-to-delayed', {
             jobId: cmd.id,
             delay: cmd.delay,
         });
+        return resp.ok(undefined, reqId);
+    }
+    const state = await ctx.queueManager.getJobState(id);
+    if (state === 'unknown') {
+        return resp.error('Job not found', reqId);
     }
-    return success ? resp.ok(undefined, reqId) : resp.error('Job not found or not active', reqId);
+    return resp.error(`Job is not active (current state: ${state})`, reqId);
 }
 /** Handle Discard command - move to DLQ */
 export async function handleDiscard(cmd, ctx, reqId) {
@@ -98,15 +104,15 @@ export function handleListQueues(_cmd, ctx, reqId) {
 }
 /** Handle Clean command */
 export function handleClean(cmd, ctx, reqId) {
-    const count = ctx.queueManager.clean(cmd.queue, cmd.grace, cmd.state, cmd.limit);
-    if (count > 0) {
+    const ids = ctx.queueManager.clean(cmd.queue, cmd.grace, cmd.state, cmd.limit);
+    if (ids.length > 0) {
         ctx.queueManager.emitDashboardEvent('queue:cleaned', {
             queue: cmd.queue,
             state: cmd.state,
-            count,
+            count: ids.length,
         });
     }
-    return { ok: true, count, reqId };
+    return { ok: true, count: ids.length, ids, reqId };
 }
 /** Handle Count command */
 export function handleCount(cmd, ctx, reqId) {
@@ -183,10 +189,35 @@ export async function handleChangeDelay(cmd, ctx, reqId) {
         ? resp.ok(undefined, reqId)
         : resp.error('Job not found or cannot change delay', reqId);
 }
-/** Handle MoveToWait command - promote a delayed job to waiting */
+/** Handle MoveToWait command - move a job back to waiting.
+ *  Dispatch by state to match embedded branching in jobMove.ts.
+ *  - active  -> moveActiveToWait
+ *  - delayed -> promote
+ *  - failed  -> retryDlq
+ *  - waiting / prioritized -> already there, no-op success
+ */
 export async function handleMoveToWait(cmd, ctx, reqId) {
-    const success = await ctx.queueManager.promote(jobId(cmd.id));
-    return success ? resp.ok(undefined, reqId) : resp.error('Job not found or not delayed', reqId);
+    const id = jobId(cmd.id);
+    const state = await ctx.queueManager.getJobState(id);
+    if (state === 'active') {
+        const ok = await ctx.queueManager.moveActiveToWait(id);
+        return ok ? resp.ok(undefined, reqId) : resp.error('Job not found or not active', reqId);
+    }
+    if (state === 'delayed') {
+        const ok = await ctx.queueManager.promote(id);
+        return ok ? resp.ok(undefined, reqId) : resp.error('Job not found or not delayed', reqId);
+    }
+    if (state === 'failed') {
+        const job = await ctx.queueManager.getJob(id);
+        if (!job)
+            return resp.error('Job not found', reqId);
+        const count = ctx.queueManager.retryDlq(job.queue, id);
+        return count > 0 ? resp.ok(undefined, reqId) : resp.error('Failed job not in DLQ', reqId);
+    }
+    if (state === 'waiting' || state === 'prioritized') {
+        return resp.ok(undefined, reqId);
+    }
+    return resp.error(`Cannot move job from state '${state}' to waiting`, reqId);
 }
 /** Handle PromoteJobs command - promote all delayed jobs in a queue */
 export async function handlePromoteJobs(cmd, ctx, reqId) {
@@ -241,4 +272,3 @@ export async function handleRemoveUnprocessedChildren(cmd, ctx, reqId) {
         return resp.error(err instanceof Error ? err.message : String(err), reqId);
     }
 }
-//# sourceMappingURL=advanced.js.map

package/dist/infrastructure/server/handlers/core.d.ts

@@ -33,4 +33,3 @@ export declare function handleAckBatch(cmd: Extract<Command, {
 export declare function handleFail(cmd: Extract<Command, {
     cmd: 'FAIL';
 }>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-//# sourceMappingURL=core.d.ts.map

package/dist/infrastructure/server/handlers/core.js

@@ -60,6 +60,14 @@ export async function handlePush(cmd, ctx, reqId) {
             removeDependencyOnFailure: cmd.removeDependencyOnFailure,
             ignoreDependencyOnFailure: cmd.ignoreDependencyOnFailure,
             continueParentOnFailure: cmd.continueParentOnFailure,
+            stallTimeout: cmd.stallTimeout,
+            stackTraceLimit: cmd.stackTraceLimit,
+            keepLogs: cmd.keepLogs,
+            sizeLimit: cmd.sizeLimit,
+            dedup: cmd.dedup,
+            debounceId: cmd.debounceId,
+            debounceTtl: cmd.debounceTtl,
+            timestamp: cmd.timestamp,
         });
         return resp.ok(job.id, reqId);
     }
@@ -190,4 +198,3 @@ export async function handleFail(cmd, ctx, reqId) {
         return resp.error(err instanceof Error ? err.message : String(err), reqId);
     }
 }
-//# sourceMappingURL=core.js.map

package/dist/infrastructure/server/handlers/cron.d.ts

@@ -21,4 +21,3 @@ export declare function handleCronDelete(cmd: Extract<Command, {
 export declare function handleCronList(_cmd: Extract<Command, {
     cmd: 'CronList';
 }>, ctx: HandlerContext, reqId?: string): Response;
-//# sourceMappingURL=cron.d.ts.map

package/dist/infrastructure/server/handlers/cron.js

@@ -22,6 +22,7 @@ export function handleCron(cmd, ctx, reqId) {
             immediately: cmd.immediately,
             skipIfNoWorker: cmd.skipIfNoWorker,
             preventOverlap: cmd.preventOverlap,
+            jobOptions: cmd.jobOptions,
         });
         ctx.queueManager.emitDashboardEvent(existing ? 'cron:updated' : 'cron:created', {
             name: cron.name,
@@ -93,4 +94,3 @@ export function handleCronList(_cmd, ctx, reqId) {
         reqId,
     };
 }
-//# sourceMappingURL=cron.js.map

package/dist/infrastructure/server/handlers/dashboard.d.ts

@@ -18,4 +18,3 @@ export declare function handleDashboardQueues(_cmd: Extract<Command, {
 export declare function handleDashboardQueue(cmd: Extract<Command, {
     cmd: 'DashboardQueue';
 }>, ctx: HandlerContext, reqId?: string): Response;
-//# sourceMappingURL=dashboard.d.ts.map

package/dist/infrastructure/server/handlers/dashboard.js

@@ -80,6 +80,7 @@ export function handleDashboardQueues(_cmd, ctx, reqId) {
         return {
             name,
             waiting: stats?.waiting ?? 0,
+            prioritized: stats?.prioritized ?? 0,
             delayed: stats?.delayed ?? 0,
             active: stats?.active ?? 0,
             dlq: stats?.dlq ?? 0,
@@ -132,4 +133,3 @@ function jobSummary(j) {
         progress: j.progress,
     };
 }
-//# sourceMappingURL=dashboard.js.map

package/dist/infrastructure/server/handlers/dlq.d.ts

@@ -21,4 +21,3 @@ export declare function handlePurgeDlq(cmd: Extract<Command, {
 export declare function handleRetryCompleted(cmd: Extract<Command, {
     cmd: 'RetryCompleted';
 }>, ctx: HandlerContext, reqId?: string): Response;
-//# sourceMappingURL=dlq.d.ts.map

package/dist/infrastructure/server/handlers/dlq.js

@@ -35,4 +35,3 @@ export function handleRetryCompleted(cmd, ctx, reqId) {
     const count = ctx.queueManager.retryCompleted(cmd.queue, jid);
     return { ok: true, count, reqId };
 }
-//# sourceMappingURL=dlq.js.map

package/dist/infrastructure/server/handlers/index.d.ts

@@ -5,4 +5,3 @@ export * from './core';
 export * from './query';
 export * from './management';
 export * from './dashboard';
-//# sourceMappingURL=index.d.ts.map

package/dist/infrastructure/server/handlers/index.js

@@ -5,4 +5,3 @@ export * from './core';
 export * from './query';
 export * from './management';
 export * from './dashboard';
-//# sourceMappingURL=index.js.map

package/dist/infrastructure/server/handlers/management.d.ts

@@ -16,7 +16,7 @@ export declare function handleProgress(cmd: Extract<Command, {
 /** Handle GetProgress command */
 export declare function handleGetProgress(cmd: Extract<Command, {
     cmd: 'GetProgress';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
 /** Handle Pause command */
 export declare function handlePause(cmd: Extract<Command, {
     cmd: 'Pause';
@@ -37,4 +37,3 @@ export declare function handleStorageStatus(_cmd: Extract<Command, {
 }>, ctx: HandlerContext, reqId?: string): Response;
 /** Handle Metrics command */
 export declare function handleMetrics(ctx: HandlerContext, reqId?: string): Response;
-//# sourceMappingURL=management.d.ts.map

package/dist/infrastructure/server/handlers/management.js

@@ -15,20 +15,35 @@ export async function handleCancel(cmd, ctx, reqId) {
 }
 /** Handle Progress command */
 export async function handleProgress(cmd, ctx, reqId) {
-    const success = await ctx.queueManager.updateProgress(jobId(cmd.id), cmd.progress, cmd.message);
-    return success ? resp.ok(undefined, reqId) : resp.error('Job not found or not active', reqId);
+    const id = jobId(cmd.id);
+    const success = await ctx.queueManager.updateProgress(id, cmd.progress, cmd.message);
+    if (success)
+        return resp.ok(undefined, reqId);
+    // Disambiguate "not found" from "not active" so callers can act on the
+    // distinction (e.g. retry on transient state vs surface a missing-ID error).
+    const state = await ctx.queueManager.getJobState(id);
+    if (state === 'unknown') {
+        return resp.error('Job not found', reqId);
+    }
+    return resp.error(`Job is not active (current state: ${state})`, reqId);
 }
 /** Handle GetProgress command */
-export function handleGetProgress(cmd, ctx, reqId) {
-    const progress = ctx.queueManager.getProgress(jobId(cmd.id));
-    if (!progress)
-        return resp.error('Job not found or not active', reqId);
-    return {
-        ok: true,
-        progress: progress.progress,
-        message: progress.message,
-        reqId,
-    };
+export async function handleGetProgress(cmd, ctx, reqId) {
+    const id = jobId(cmd.id);
+    const progress = ctx.queueManager.getProgress(id);
+    if (progress) {
+        return {
+            ok: true,
+            progress: progress.progress,
+            message: progress.message,
+            reqId,
+        };
+    }
+    const state = await ctx.queueManager.getJobState(id);
+    if (state === 'unknown') {
+        return resp.error('Job not found', reqId);
+    }
+    return resp.error(`Job is not active (current state: ${state})`, reqId);
 }
 /** Handle Pause command */
 export function handlePause(cmd, ctx, reqId) {
@@ -82,4 +97,3 @@ export function handleMetrics(ctx, reqId) {
         activeConnections: 0,
     }, reqId);
 }
-//# sourceMappingURL=management.js.map

package/dist/infrastructure/server/handlers/monitoring.d.ts

@@ -28,4 +28,3 @@ export declare function handleExtendLock(cmd: ExtendLockCommand, ctx: HandlerCon
 export declare function handleExtendLocks(cmd: ExtendLocksCommand, ctx: HandlerContext, reqId?: string): Promise<Response>;
 export declare function handleSetWebhookEnabled(cmd: SetWebhookEnabledCommand, ctx: HandlerContext, reqId?: string): Response;
 export declare function handleCompactMemory(_cmd: CompactMemoryCommand, ctx: HandlerContext, reqId?: string): Response;
-//# sourceMappingURL=monitoring.d.ts.map

package/dist/infrastructure/server/handlers/monitoring.js

@@ -208,4 +208,3 @@ export function handleCompactMemory(_cmd, ctx, reqId) {
     ctx.queueManager.compactMemory();
     return resp.ok(undefined, reqId);
 }
-//# sourceMappingURL=monitoring.js.map

package/dist/infrastructure/server/handlers/query.d.ts

@@ -37,4 +37,3 @@ export declare function handleGetJobs(cmd: Extract<Command, {
 export declare function handleGetChildrenValues(cmd: Extract<Command, {
     cmd: 'GetChildrenValues';
 }>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-//# sourceMappingURL=query.d.ts.map

package/dist/infrastructure/server/handlers/query.js

@@ -77,4 +77,3 @@ export async function handleGetChildrenValues(cmd, ctx, reqId) {
         return resp.data({ values: {} }, reqId);
     }
 }
-//# sourceMappingURL=query.js.map

package/dist/infrastructure/server/http.d.ts

@@ -26,4 +26,3 @@ export declare function createHttpServer(queueManager: QueueManager, config: Htt
     stop(): void;
 };
 export type HttpServer = ReturnType<typeof createHttpServer>;
-//# sourceMappingURL=http.d.ts.map

package/dist/infrastructure/server/http.js

@@ -261,4 +261,3 @@ async function routeRequest(req, path, ctx, corsOrigins) {
         return result;
     return jsonResponse({ ok: false, error: 'Not found' }, 404, corsOrigins);
 }
-//# sourceMappingURL=http.js.map

package/dist/infrastructure/server/httpEndpoints.d.ts

@@ -25,4 +25,3 @@ export declare function dashboardQueuesEndpoint(queueManager: QueueManager, limi
 export declare function dashboardQueueDetailEndpoint(queueManager: QueueManager, queue: string, includeJobs: boolean, corsOrigins?: Set<string>): Response;
 /** Metrics endpoint */
 export declare function metricsEndpoint(queueManager: QueueManager, corsOrigins?: Set<string>): Response;
-//# sourceMappingURL=httpEndpoints.d.ts.map

package/dist/infrastructure/server/httpEndpoints.js

@@ -307,4 +307,3 @@ export function metricsEndpoint(queueManager, corsOrigins) {
         },
     }, 200, corsOrigins);
 }
-//# sourceMappingURL=httpEndpoints.js.map

package/dist/infrastructure/server/httpRouteJobs.d.ts

@@ -7,4 +7,3 @@ type Cors = Set<string>;
 /** Route /jobs/* requests. Returns Response or null if no match. */
 export declare function routeJobRoutes(req: Request, path: string, method: string, ctx: HandlerContext, cors: Cors): Promise<Response | null>;
 export {};
-//# sourceMappingURL=httpRouteJobs.d.ts.map

package/dist/infrastructure/server/httpRouteJobs.js

@@ -268,4 +268,3 @@ export async function routeJobRoutes(req, path, method, ctx, cors) {
         return mgmt;
     return routeJobAdvanced(req, path, method, ctx, cors);
 }
-//# sourceMappingURL=httpRouteJobs.js.map

package/dist/infrastructure/server/httpRouteQueueConfig.d.ts

@@ -5,4 +5,3 @@
 import type { HandlerContext } from './types';
 /** Route queue config/admin requests. Returns Response or null if no match. */
 export declare function routeQueueConfigRoutes(req: Request, path: string, method: string, ctx: HandlerContext, cors: Set<string>): Promise<Response | null>;
-//# sourceMappingURL=httpRouteQueueConfig.d.ts.map

package/dist/infrastructure/server/httpRouteQueueConfig.js

@@ -128,4 +128,3 @@ export async function routeQueueConfigRoutes(req, path, method, ctx, cors) {
     }
     return null;
 }
-//# sourceMappingURL=httpRouteQueueConfig.js.map

package/dist/infrastructure/server/httpRouteQueues.d.ts

@@ -5,4 +5,3 @@
 import type { HandlerContext } from './types';
 /** Route /queues/* requests. Returns Response or null if no match. */
 export declare function routeQueueRoutes(req: Request, path: string, method: string, ctx: HandlerContext, cors: Set<string>): Promise<Response | null>;
-//# sourceMappingURL=httpRouteQueues.d.ts.map

package/dist/infrastructure/server/httpRouteQueues.js

@@ -264,4 +264,3 @@ export async function routeQueueRoutes(req, path, method, ctx, cors) {
     }
     return null;
 }
-//# sourceMappingURL=httpRouteQueues.js.map

package/dist/infrastructure/server/httpRouteResources.d.ts

@@ -5,4 +5,3 @@
 import type { HandlerContext } from './types';
 /** Route cron, webhook, worker, and monitoring requests. Returns Response or null. */
 export declare function routeResourceRoutes(req: Request, path: string, method: string, ctx: HandlerContext, cors: Set<string>): Promise<Response | null>;
-//# sourceMappingURL=httpRouteResources.d.ts.map

package/dist/infrastructure/server/httpRouteResources.js

@@ -170,4 +170,3 @@ export async function routeResourceRoutes(req, path, method, ctx, cors) {
     }
     return null;
 }
-//# sourceMappingURL=httpRouteResources.js.map

package/dist/infrastructure/server/index.d.ts

@@ -5,4 +5,3 @@ export * from './protocol';
 export * from './handler';
 export * from './tcp';
 export * from './http';
-//# sourceMappingURL=index.d.ts.map

package/dist/infrastructure/server/index.js

@@ -5,4 +5,3 @@ export * from './protocol';
 export * from './handler';
 export * from './tcp';
 export * from './http';
-//# sourceMappingURL=index.js.map

package/dist/infrastructure/server/protocol.d.ts

@@ -60,9 +60,12 @@ export declare class FrameParser {
      * @throws {FrameSizeError} if frame length exceeds maxFrameSize
      */
     addData(data: Uint8Array): Uint8Array[];
+    /** Number of bytes currently buffered awaiting a complete frame. */
+    get bufferedBytes(): number;
+    /** True while a partial (incomplete) frame is buffered. */
+    get hasPartialFrame(): boolean;
     /** Clear the internal buffer */
     clear(): void;
     /** Create a framed message */
     static frame(data: Uint8Array): Uint8Array;
 }
-//# sourceMappingURL=protocol.d.ts.map

package/dist/infrastructure/server/protocol.js

@@ -174,14 +174,21 @@ export class FrameParser {
                 (this.buffer[2] << 8) |
                 this.buffer[3]) >>>
                 0;
-            // Validate frame size to prevent memory exhaustion DoS
+            // Validate frame size to prevent memory exhaustion DoS. A single frame's
+            // declared length can never exceed maxFrameSize (64MB), so the partial
+            // buffer is bounded by maxFrameSize regardless of how it is segmented
+            // across TCP reads. Slowloris (a connection that declares a large frame
+            // then never completes it) is handled at the transport layer by an idle
+            // read timeout in the server, NOT by dropping legal large partial frames.
             if (length > this.maxFrameSize) {
                 // Clear buffer to prevent further processing of malicious data
                 this.buffer = new Uint8Array(0);
                 throw new FrameSizeError(length, this.maxFrameSize);
             }
             if (this.buffer.length < 4 + length) {
-                // Not enough data
+                // Not enough data for this (legal, < maxFrameSize) frame yet. Keep the
+                // partial bytes buffered until the rest of the frame arrives across
+                // subsequent TCP segments.
                 break;
             }
             // Extract frame
@@ -190,6 +197,14 @@ export class FrameParser {
         }
         return frames;
     }
+    /** Number of bytes currently buffered awaiting a complete frame. */
+    get bufferedBytes() {
+        return this.buffer.length;
+    }
+    /** True while a partial (incomplete) frame is buffered. */
+    get hasPartialFrame() {
+        return this.buffer.length > 0;
+    }
     /** Clear the internal buffer */
     clear() {
         this.buffer = new Uint8Array(0);
@@ -206,4 +221,3 @@ export class FrameParser {
         return frame;
     }
 }
-//# sourceMappingURL=protocol.js.map

package/dist/infrastructure/server/rateLimiter.d.ts

@@ -31,4 +31,3 @@ export declare class ProtocolRateLimiter {
 export declare function getRateLimiter(config?: Partial<RateLimiterConfig>): ProtocolRateLimiter;
 /** Stop and cleanup global rate limiter */
 export declare function stopRateLimiter(): void;
-//# sourceMappingURL=rateLimiter.d.ts.map

package/dist/infrastructure/server/rateLimiter.js

@@ -135,4 +135,3 @@ export function stopRateLimiter() {
         globalRateLimiter = null;
     }
 }
-//# sourceMappingURL=rateLimiter.js.map

package/dist/infrastructure/server/socketWriteQueue.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Per-socket write queue
+ * =================================================================
+ * Bun's `socket.write()` may write FEWER bytes than provided when the kernel
+ * send buffer is full (backpressure). The unwritten tail is NOT retained by
+ * Bun — the caller is responsible for buffering it and resending once the
+ * socket fires `drain`. Ignoring the short count silently drops response
+ * bytes, corrupting the length-prefixed frame protocol.
+ *
+ * This helper buffers any unwritten tail per-socket and preserves ordering:
+ * while a pending tail exists, all subsequent writes are appended to the queue
+ * (never written ahead of older bytes), and the queue is flushed in order from
+ * the `drain` handler.
+ */
+import type { Socket } from 'bun';
+/** Minimal write surface a socket must expose for the queue. */
+interface WritableSocket {
+    write(data: Uint8Array): number;
+}
+/** Per-socket pending write state. Stored on `socket.data`. */
+export declare class SocketWriteQueue {
+    /** Buffered chunks waiting to be (re)written, in order. */
+    private pending;
+    /** Byte offset into pending[0] already written by a short write. */
+    private offset;
+    /** Total queued bytes (for bounds / observability). */
+    private queuedBytes;
+    /** Max queued bytes before the queue reports over-budget (0 = unbounded). */
+    private readonly maxBytes;
+    /**
+     * @param maxBytes Soft cap on buffered bytes. When `bytesQueued` exceeds this,
+     *   `isOverBudget` becomes true and the owner should drop the connection
+     *   (bounds write-side memory for a client that stopped reading). 0 disables.
+     */
+    constructor(maxBytes?: number);
+    /**
+     * True once the buffered byte count exceeds the configured cap. The owner is
+     * expected to terminate the connection and `clear()` the queue.
+     */
+    get isOverBudget(): boolean;
+    /**
+     * Enqueue `data` for delivery on `socket`, preserving order.
+     * Returns false if the socket appears closed (write threw / returned < 0).
+     */
+    write(socket: WritableSocket, data: Uint8Array): boolean;
+    /**
+     * Flush as much of the pending queue as the socket accepts.
+     * Call from the socket's `drain` handler. Stops at the first short write,
+     * leaving the remainder queued for the next drain.
+     */
+    flush(socket: WritableSocket): void;
+    /** Number of bytes still buffered awaiting drain. */
+    get bytesQueued(): number;
+    /** Whether there is unwritten data awaiting drain. */
+    get hasPending(): boolean;
+    /** Drop all buffered data (e.g. on close). */
+    clear(): void;
+}
+/**
+ * Convenience: write through a socket whose `data` carries a `writeQueue`.
+ * Keeps call sites in tcp.ts terse and consistent.
+ */
+export declare function queuedWrite<T extends {
+    writeQueue: SocketWriteQueue;
+}>(socket: Socket<T>, data: Uint8Array): void;
+export {};