bunqueue-client 0.1.8 → 0.2.0

package/dist/{ack-batcher.d.ts → types/sdk/typescript/src/ack-batcher.d.ts}

@@ -7,13 +7,13 @@
  * (or errored), so the worker keeps a job "active" — and its lock renewed —
  * until the server has confirmed the ack.
  */
-import type { Connection } from './connection.js';
+import type { Connection } from "./connection.js";
 export interface AckItem {
     id: string;
     token: string;
     result: unknown;
-    /** Called once the batch settles: `err` set on failure, undefined on ack. */
-    onSettled: (err?: unknown) => void;
+    /** `applied` is defined only after a successful, authoritative response. */
+    onSettled: (err?: unknown, applied?: boolean) => void;
 }
 export declare class AckBatcher {
     private readonly connection;

package/dist/{bunqueue → types/sdk/typescript/src/bunqueue}/aging.d.ts

@@ -4,8 +4,8 @@
  * old waiting jobs. Same semantics; the job scan goes over TCP (GetJobs on
  * the waiting and prioritized states) instead of the embedded manager.
  */
-import type { Queue } from '../queue.js';
-import type { PriorityAgingConfig } from './types.js';
+import type { Queue } from "../queue.js";
+import type { PriorityAgingConfig } from "./types.js";
 export declare class PriorityAger<T = unknown> {
     private timer;
     private readonly config;

package/dist/{bunqueue → types/sdk/typescript/src/bunqueue}/batch.d.ts

@@ -3,8 +3,8 @@
  * 1:1 port of src/client/bunqueue/batch.ts: accumulates jobs and processes
  * them in groups; flushes on size, on timeout, and on destroy (close).
  */
-import type { Processor } from '../worker-types.js';
-import type { BatchConfig } from './types.js';
+import type { Processor } from "../worker-types.js";
+import type { BatchConfig } from "./types.js";
 export declare class BatchAccumulator<T = unknown, R = unknown> {
     private readonly buffer;
     private timer;

package/dist/{bunqueue → types/sdk/typescript/src/bunqueue}/bunqueue-api.d.ts

@@ -3,11 +3,11 @@
  * breaker, TTL, DLQ, rate limit, events, control). Merged onto the Bunqueue
  * prototype by bunqueue.ts; split out to keep files small.
  */
-import type { Job } from '../job.js';
-import type { JobOptions } from '../types.js';
-import type { Bunqueue } from './bunqueue.js';
-import type { DlqFilter, DlqStats } from './dlq-rate-limit.js';
-import type { CircuitState, TriggerRule } from './types.js';
+import type { Job } from "../job.js";
+import type { JobOptions } from "../types.js";
+import type { Bunqueue } from "./bunqueue.js";
+import type { DlqFilter, DlqStats } from "./dlq-rate-limit.js";
+import type { CircuitState, TriggerRule } from "./types.js";
 type Raw = Record<string, unknown>;
 type Ctx = Bunqueue<any, any>;
 export declare const bunqueueApi: {

package/dist/{bunqueue → types/sdk/typescript/src/bunqueue}/bunqueue.d.ts

@@ -5,19 +5,19 @@
  * API (cron, DLQ, events, control, …) lives in bunqueue-api.ts and is merged
  * onto the prototype below.
  */
-import type { Job } from '../job.js';
-import { Queue } from '../queue.js';
-import type { JobOptions } from '../types.js';
-import { Worker } from '../worker.js';
-import { PriorityAger } from './aging.js';
-import { BatchAccumulator } from './batch.js';
-import { type BunqueueApi } from './bunqueue-api.js';
-import { CancellationManager } from './cancellation.js';
-import { WorkerCircuitBreaker } from './circuit-breaker.js';
-import { DlqRateLimitManager } from './dlq-rate-limit.js';
-import { TriggerManager } from './triggers.js';
-import { TtlChecker } from './ttl.js';
-import type { BunqueueMiddleware, BunqueueOptions } from './types.js';
+import type { Job } from "../job.js";
+import { Queue } from "../queue.js";
+import type { JobOptions } from "../types.js";
+import { Worker } from "../worker.js";
+import { PriorityAger } from "./aging.js";
+import { BatchAccumulator } from "./batch.js";
+import { type BunqueueApi } from "./bunqueue-api.js";
+import { CancellationManager } from "./cancellation.js";
+import { WorkerCircuitBreaker } from "./circuit-breaker.js";
+import { DlqRateLimitManager } from "./dlq-rate-limit.js";
+import { TriggerManager } from "./triggers.js";
+import { TtlChecker } from "./ttl.js";
+import type { BunqueueMiddleware, BunqueueOptions } from "./types.js";
 export declare class Bunqueue<T = unknown, R = unknown> {
     readonly name: string;
     readonly queue: Queue<T>;

package/dist/{bunqueue → types/sdk/typescript/src/bunqueue}/circuit-breaker.d.ts

@@ -2,8 +2,8 @@
  * Bunqueue Simple Mode — circuit breaker for worker protection.
  * 1:1 port of src/client/bunqueue/circuitBreaker.ts.
  */
-import type { WorkerBase } from '../worker-base.js';
-import type { CircuitBreakerConfig, CircuitState } from './types.js';
+import type { WorkerBase } from "../worker-base.js";
+import type { CircuitBreakerConfig, CircuitState } from "./types.js";
 export declare class WorkerCircuitBreaker {
     private state;
     private failures;

package/dist/{bunqueue → types/sdk/typescript/src/bunqueue}/dedup-debounce.d.ts

@@ -3,8 +3,8 @@
  * 1:1 port of src/client/bunqueue/dedupDebounce.ts, including the dedup id
  * derivation algorithm: `${name}:${JSON.stringify(data)}`.
  */
-import type { JobOptions } from '../types.js';
-import type { BunqueueDebounceConfig, BunqueueDeduplicationConfig } from './types.js';
+import type { JobOptions } from "../types.js";
+import type { BunqueueDebounceConfig, BunqueueDeduplicationConfig } from "./types.js";
 export declare class DedupDebounceMerger {
     private readonly dedup;
     private readonly debounce;

package/dist/{bunqueue → types/sdk/typescript/src/bunqueue}/dlq-rate-limit.d.ts

@@ -4,8 +4,8 @@
  * the DLQ filter and stats are computed client-side from the fetched entries
  * (the embedded original reads them in-process).
  */
-import type { Queue } from '../queue.js';
-import type { BunqueueDlqConfig } from './types.js';
+import type { Queue } from "../queue.js";
+import type { BunqueueDlqConfig } from "./types.js";
 type Raw = Record<string, unknown>;
 /** Filter for DLQ queries (mirrors the official DlqFilter). */
 export interface DlqFilter {

package/dist/{bunqueue → types/sdk/typescript/src/bunqueue}/rate-gate.d.ts

@@ -7,7 +7,7 @@
  * semantics as a gate awaited before each job runs: a job whose window is
  * full waits (holding its concurrency slot) until the window frees.
  */
-import type { RateLimiterOptions } from './types.js';
+import type { RateLimiterOptions } from "./types.js";
 export declare class RateGate {
     private readonly max;
     private readonly duration;

package/dist/{bunqueue → types/sdk/typescript/src/bunqueue}/retry.d.ts

@@ -2,7 +2,7 @@
  * Bunqueue Simple Mode — advanced in-process retry with backoff strategies.
  * 1:1 port of src/client/bunqueue/retry.ts (identical formulas).
  */
-import type { RetryConfig, RetryStrategy } from './types.js';
+import type { RetryConfig, RetryStrategy } from "./types.js";
 /** Calculate backoff delay based on strategy. */
 export declare function calculateBackoff(strategy: RetryStrategy, attempt: number, baseDelay: number, error: Error, config: RetryConfig): number;
 /** Execute a function with retry logic (the job stays active throughout). */

package/dist/{bunqueue → types/sdk/typescript/src/bunqueue}/triggers.d.ts

@@ -3,9 +3,9 @@
  * 1:1 port of src/client/bunqueue/triggers.ts: when a job completes/fails,
  * automatically create another job.
  */
-import type { Queue } from '../queue.js';
-import type { Worker } from '../worker.js';
-import type { TriggerRule } from './types.js';
+import type { Queue } from "../queue.js";
+import type { Worker } from "../worker.js";
+import type { TriggerRule } from "./types.js";
 export declare class TriggerManager<T = unknown, R = unknown> {
     private readonly rules;
     private active;

package/dist/{bunqueue → types/sdk/typescript/src/bunqueue}/ttl.d.ts

@@ -3,7 +3,7 @@
  * 1:1 port of src/client/bunqueue/ttl.ts: expire unprocessed jobs, checked
  * when the worker picks the job up. Resolution: perName -> defaultTtl -> 0.
  */
-import type { JobTtlConfig } from './types.js';
+import type { JobTtlConfig } from "./types.js";
 export declare class TtlChecker {
     private readonly config;
     constructor(config: JobTtlConfig);

package/dist/{bunqueue → types/sdk/typescript/src/bunqueue}/types.d.ts

@@ -3,10 +3,10 @@
  * 1:1 port of src/client/bunqueue/types.ts from the official client, minus
  * the embedded-mode options (this SDK is TCP-only).
  */
-import type { TlsOption } from '../connection.js';
-import type { Job } from '../job.js';
-import type { JobOptions } from '../types.js';
-import type { Processor } from '../worker-types.js';
+import type { TlsOption } from "../connection.js";
+import type { Job } from "../job.js";
+import type { JobOptions } from "../types.js";
+import type { Processor } from "../worker-types.js";
 /** Connection options accepted by Simple Mode (mirrors ConnectionOptions). */
 export interface BunqueueConnection {
     host?: string;

package/dist/types/sdk/typescript/src/canonical-transport/bun-sqlite-types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Declaration-only stand-in for Bun's `bun:sqlite` module in the published
+ * type graph. The embedded engine runs only under Bun; the portable build
+ * points engine declarations here so Node, Deno and Workers consumers never
+ * need Bun's global type declarations. Nothing imports this at runtime.
+ */
+export interface Statement {
+    run(...parameters: unknown[]): unknown;
+    get(...parameters: unknown[]): unknown;
+    all(...parameters: unknown[]): unknown[];
+    values(...parameters: unknown[]): unknown[][];
+    finalize(): void;
+}
+export interface Database {
+    prepare(sql: string): Statement;
+    query(sql: string): Statement;
+    run(sql: string, ...parameters: unknown[]): unknown;
+    exec(sql: string, ...parameters: unknown[]): unknown;
+    transaction<T extends (...parameters: never[]) => unknown>(run: T): T;
+    close(throwOnError?: boolean): void;
+}

package/dist/{connection-pool.d.ts → types/sdk/typescript/src/connection-pool.d.ts}

@@ -11,7 +11,7 @@
  * Lifecycle events from every member connection are re-emitted here.
  */
 import { EventEmitter } from 'node:events';
-import type { Command, ConnectionLike, ConnectionOptions, Response } from './connection-types.js';
+import type { Command, ConnectionLike, ConnectionOptions, Response } from "./connection-types.js";
 export declare class ConnectionPool extends EventEmitter implements ConnectionLike {
     private readonly connections;
     private cursor;

package/dist/{connection-types.d.ts → types/sdk/typescript/src/connection-types.d.ts}

@@ -1,5 +1,5 @@
 /** Connection option and message types. */
-import type { Observability } from './observability.js';
+import type { Observability } from "./observability.js";
 export type TlsOption = boolean | {
     caFile?: string;
     rejectUnauthorized?: boolean;

package/dist/{connection.d.ts → types/sdk/typescript/src/connection.d.ts}

@@ -1,19 +1,10 @@
-/**
- * TCP connection to a bunqueue server — cross-runtime (Node.js, Bun, Deno).
- *
- * Requests carry a `reqId` string; the server echoes it back, enabling
- * pipelining (many in-flight commands per socket). Uses only `node:`
- * builtins (net/tls), which Node, Bun and Deno all support.
- */
+/** Cross-runtime TCP connection with reqId-based request pipelining. */
 import { EventEmitter } from 'node:events';
-import type { Command, ConnectionOptions, Response, TlsOption } from './connection-types.js';
-export type { Command, ConnectionOptions, Response, TlsOption } from './connection-types.js';
+import type { Command, ConnectionOptions, Response, TlsOption } from "./connection-types.js";
+export type { Command, ConnectionOptions, Response, TlsOption } from "./connection-types.js";
 /**
- * A single pipelined TCP connection to a bunqueue server.
- *
- * Emits typed lifecycle events for observability: `connect`, `disconnect` and
- * `reconnect_scheduled` (payloads mirror the telemetry events). Attach a
- * telemetry sink via the `onTelemetry` option for per-command latency metrics.
+ * A pipelined connection with lifecycle events and an optional structured
+ * telemetry sink.
  */
 export declare class Connection extends EventEmitter {
     readonly host: string;
@@ -38,11 +29,7 @@ export declare class Connection extends EventEmitter {
     private readonly backpressure;
     constructor(options?: ConnectionOptions);
     get isConnected(): boolean;
-    /**
-     * Monotonic counter, incremented on every successful (re)connect. Consumers
-     * that hold per-connection server state (e.g. a Worker registration) compare
-     * it between operations and re-establish that state after a reconnect.
-     */
+    /** Successful-connect generation used to restore per-connection state. */
     get generation(): number;
     /** Open the socket (and authenticate) if not already connected. */
     connect(): Promise<void>;

package/dist/{errors.d.ts → types/sdk/typescript/src/errors.d.ts}

@@ -11,6 +11,9 @@ export declare class CommandTimeoutError extends BunqueueError {
 /** The server answered ok=false; message carries the server error. */
 export declare class CommandError extends BunqueueError {
 }
+/** A command cannot be encoded within the protocol's wire constraints. */
+export declare class SerializationError extends BunqueueError {
+}
 /** Authentication with the server failed. */
 export declare class AuthError extends BunqueueError {
 }

package/dist/types/sdk/typescript/src/flow-commit.d.ts

@@ -0,0 +1,5 @@
+import type { ConnectionLike } from "./connection-types.js";
+import type { AtomicFlowJobInput } from "./flow-plan.js";
+import type { JobRaw } from "./job.js";
+export declare function validateFlowSnapshots(jobs: AtomicFlowJobInput[], snapshots: unknown): Map<string, JobRaw>;
+export declare function commitFlow(connection: ConnectionLike, jobs: AtomicFlowJobInput[]): Promise<Map<string, JobRaw>>;

package/dist/types/sdk/typescript/src/flow-plan-legacy.d.ts

@@ -0,0 +1,13 @@
+import { type AtomicFlowJobInput, type FlowIdFactory } from "./flow-plan.js";
+import type { FlowStep } from "./flow-types.js";
+export interface ChainPlan {
+    jobs: AtomicFlowJobInput[];
+    ids: string[];
+}
+export interface FanInPlan {
+    jobs: AtomicFlowJobInput[];
+    parallelIds: string[];
+    finalId: string;
+}
+export declare function planChain<T>(steps: FlowStep<T>[], idFactory?: FlowIdFactory): ChainPlan;
+export declare function planBulkThen<T>(parallel: FlowStep<T>[], final: FlowStep<T>, idFactory?: FlowIdFactory): FanInPlan;

package/dist/types/sdk/typescript/src/flow-plan.d.ts

@@ -0,0 +1,29 @@
+import type { FlowJob, FlowOptions } from "./flow-types.js";
+import { type JobOptions } from "./types.js";
+export type FlowIdFactory = () => string;
+export interface AtomicFlowJobInput {
+    id: string;
+    queue: string;
+    input: Record<string, unknown>;
+}
+export interface PlannedFlowNode<T = unknown> {
+    id: string;
+    name: string;
+    queueName: string;
+    data: T | undefined;
+    children?: PlannedFlowNode<T>[];
+}
+export interface FlowPlan<T = unknown> {
+    jobs: AtomicFlowJobInput[];
+    roots: PlannedFlowNode<T>[];
+}
+interface FlowLinks {
+    parentId?: string;
+    dependsOn?: string[];
+    childrenIds?: string[];
+}
+export declare function flowData(name: string, data: unknown, internal?: Record<string, unknown>): Record<string, unknown>;
+export declare function flowInput(data: Record<string, unknown>, opts: JobOptions, links?: FlowLinks): Record<string, unknown>;
+export declare function allocateFlowId(opts: JobOptions, ids: Set<string>, idFactory: FlowIdFactory): string;
+export declare function planFlows<T>(flows: FlowJob<T>[], options?: FlowOptions, idFactory?: FlowIdFactory): FlowPlan<T>;
+export {};

package/dist/{flow-types.d.ts → types/sdk/typescript/src/flow-types.d.ts}

@@ -1,8 +1,8 @@
 /** FlowProducer types. */
-import type { Connection, TlsOption } from './connection.js';
-import type { Job } from './job.js';
-import type { Observability } from './observability.js';
-import type { JobOptions } from './types.js';
+import type { Connection, TlsOption } from "./connection.js";
+import type { Job } from "./job.js";
+import type { Observability } from "./observability.js";
+import type { JobOptions } from "./types.js";
 export interface FlowJob<T = unknown> {
     name: string;
     queueName: string;
@@ -10,6 +10,9 @@ export interface FlowJob<T = unknown> {
     opts?: JobOptions;
     children?: FlowJob<T>[];
 }
+export interface FlowOptions {
+    queuesOptions?: Record<string, Omit<Partial<JobOptions>, 'jobId'>>;
+}
 export interface JobNode<T = unknown> {
     job: Job<T>;
     children?: JobNode<T>[];

package/dist/{flow.d.ts → types/sdk/typescript/src/flow.d.ts}

@@ -1,16 +1,14 @@
 /**
- * FlowProducer: parent/children job trees, chains and fan-in flows.
- * Mirrors the official client's TCP flow logic (bottom-up creation,
- * UpdateParent fix-up, rollback via Cancel on failure).
+ * FlowProducer: atomic parent/children trees, chains and fan-in flows.
  */
-import { Connection } from './connection.js';
-import type { FlowJob, FlowProducerOptions, FlowStep, GetFlowOptions, JobNode } from './flow-types.js';
+import { Connection } from "./connection.js";
+import type { FlowJob, FlowOptions, FlowProducerOptions, FlowStep, GetFlowOptions, JobNode } from "./flow-types.js";
 export declare class FlowProducer {
     readonly connection: Connection;
     private readonly ownsConnection;
     constructor(opts?: FlowProducerOptions);
-    /** Add a flow tree. Children are created (and processed) BEFORE their parent. */
-    add<T = unknown>(flow: FlowJob<T>): Promise<JobNode<T>>;
+    /** Add a flow tree in one broker-side atomic commit. */
+    add<T = unknown>(flow: FlowJob<T>, options?: FlowOptions): Promise<JobNode<T>>;
     addBulk<T = unknown>(flows: FlowJob<T>[]): Promise<JobNode<T>[]>;
     /** Fetch a flow tree starting from a job id (recursive over childrenIds). */
     getFlow<T = unknown>(opts: GetFlowOptions): Promise<JobNode<T> | null>;
@@ -24,8 +22,6 @@ export declare class FlowProducer {
         finalId: string;
     }>;
     close(): void;
-    private addNode;
-    private pushWithParent;
+    private buildNode;
     private fetchNode;
-    private rollback;
 }

package/dist/{frame.d.ts → types/sdk/typescript/src/frame.d.ts}

@@ -2,7 +2,7 @@
  * Wire framing for the bunqueue TCP protocol: 4-byte big-endian length
  * prefix + msgpack payload. Runtime-neutral (plain Buffer operations).
  */
-export declare const PROTOCOL_VERSION = 2;
+export declare const PROTOCOL_VERSION = 3;
 export declare const MAX_FRAME_SIZE: number;
 /** Drop undefined-valued keys so the msgpack frame stays minimal. */
 export declare function compact<T extends Record<string, unknown>>(obj: T): T;

package/dist/types/sdk/typescript/src/index.d.ts

@@ -0,0 +1,10 @@
+/** Public API is sourced from the canonical client; the build supplies portable I/O. */
+export * from "../../../src/client/index.js";
+export { Connection } from "./connection.js";
+export { ConnectionPool } from "./connection-pool.js";
+export type { ConnectionLike } from "./connection-types.js";
+export { AuthError, BunqueueError, CommandError, CommandTimeoutError, ConnectionClosedError, SerializationError, } from "./errors.js";
+export { consoleLogger, noopLogger } from "./observability.js";
+export type { Logger, LogLevel, Observability, TelemetryEvent, TelemetryHandler, } from "./observability.js";
+export { MAX_FRAME_SIZE, PROTOCOL_VERSION } from "./frame.js";
+export declare const __version__ = "0.2.0";

package/dist/{job.d.ts → types/sdk/typescript/src/job.d.ts}

@@ -2,7 +2,7 @@
  * Job wrapper: read view over the server job record + per-job operations.
  * Mirrors the official TS client's Job surface (TCP mode).
  */
-import type { ConnectionLike } from './connection-types.js';
+import type { ConnectionLike } from "./connection-types.js";
 export type JobRaw = Record<string, unknown>;
 export type ProgressHook = (job: Job, progress: number) => void;
 export declare class Job<T = unknown> {
@@ -14,8 +14,9 @@ export declare class Job<T = unknown> {
     get id(): string;
     get queue(): string;
     get data(): T;
-    /** Job name (stored inside `data.name`, mirroring the official client). */
+    /** Job name, with compatibility for pre-name-field data envelopes. */
     get name(): string | undefined;
+    private topLevelName;
     get priority(): number;
     get attempts(): number;
     get maxAttempts(): number;
@@ -46,7 +47,7 @@ export declare class Job<T = unknown> {
     remove(): Promise<void>;
     discard(): Promise<void>;
     promote(): Promise<void>;
-    /** failed → waiting (BullMQ contract; MoveToWait over TCP). */
+    /** Move the job back to waiting, forwarding a Worker-owned lease when present. */
     retry(): Promise<void>;
     updateData(data: unknown): Promise<void>;
     changePriority(opts: {

package/dist/types/sdk/typescript/src/legacy.d.ts

@@ -0,0 +1,27 @@
+/**
+ * bunqueue-client — cross-runtime TypeScript SDK for bunqueue (TCP mode).
+ * Works on Node.js ≥20, Bun and Deno ≥2 (uses only node: builtins + msgpackr).
+ */
+export { Bunqueue } from "./bunqueue/bunqueue.js";
+export type { DlqFilter, DlqStats } from "./bunqueue/dlq-rate-limit.js";
+export type { BatchConfig, BatchProcessor, BunqueueConnection, BunqueueDebounceConfig, BunqueueDeduplicationConfig, BunqueueDlqConfig, BunqueueMiddleware, BunqueueOptions, CircuitBreakerConfig, CircuitState, JobTtlConfig, PriorityAgingConfig, RateLimiterOptions, RetryConfig, RetryStrategy, TriggerRule, } from "./bunqueue/types.js";
+export type { Command, ConnectionOptions, Response, TlsOption } from "./connection.js";
+export { Connection } from "./connection.js";
+export { ConnectionPool } from "./connection-pool.js";
+export type { ConnectionLike } from "./connection-types.js";
+export { AuthError, BunqueueError, CommandError, CommandTimeoutError, ConnectionClosedError, SerializationError, UnrecoverableError, } from "./errors.js";
+export { FlowProducer } from "./flow.js";
+export type { FlowJob, FlowOptions, FlowProducerOptions, FlowStep, GetFlowOptions, JobNode, } from "./flow-types.js";
+export { MAX_FRAME_SIZE, PROTOCOL_VERSION } from "./frame.js";
+export type { JobRaw } from "./job.js";
+export { Job } from "./job.js";
+export type { Logger, LogLevel, Observability, TelemetryErrorOperation, TelemetryEvent, TelemetryHandler, } from "./observability.js";
+export { consoleLogger, noopLogger } from "./observability.js";
+export type { BulkJobEntry, QueueOptions } from "./queue.js";
+export { Queue } from "./queue.js";
+export type { SchedulerOptions } from "./queue-admin.js";
+export type { BatchResponse, CountResponse, DataResponse, JobCountsResponse, JobResponse, JobsResponse, OkResponse, PausedResponse, ProgressResponse, PulledJobResponse, PulledJobsResponse, ResultResponse, StateResponse, WaitJobResponse, } from "./responses.js";
+export type { BackoffOptions, DeduplicationOptions, JobCounts, JobOptions, JobStateName, RepeatOptions, } from "./types.js";
+export { Worker } from "./worker.js";
+export type { AckBatchOptions, Processor, WorkerEventMap, WorkerOptions } from "./worker-types.js";
+export declare const __version__ = "0.2.0";

package/dist/{observability.d.ts → types/sdk/typescript/src/observability.d.ts}

@@ -19,6 +19,7 @@ export declare const noopLogger: Logger;
  */
 export declare function consoleLogger(min?: LogLevel): Logger;
 /** A single telemetry data point. A discriminated union keyed on `type`. */
+export type TelemetryErrorOperation = 'connect' | 'socket' | 'write' | 'serialization';
 export type TelemetryEvent = {
     type: 'command';
     cmd: string;
@@ -53,6 +54,12 @@ export type TelemetryEvent = {
     type: 'backpressure';
     inFlight: number;
     maxInFlight: number;
+} | {
+    type: 'error';
+    operation: TelemetryErrorOperation;
+    errorType: string;
+    message: string;
+    code?: string;
 };
 export type TelemetryHandler = (event: TelemetryEvent) => void;
 /** Lifecycle telemetry types that are ALSO emitted as EventEmitter events. */
@@ -91,5 +98,12 @@ export declare class Telemetry {
     reconnectScheduled(host: string, port: number, attempt: number, delayMs: number): void;
     auth(ok: boolean): void;
     backpressure(inFlight: number, maxInFlight: number): void;
+    /**
+     * Report transport failures without forwarding raw messages: those can
+     * contain remote-controlled text or application data in third-party errors.
+     */
+    error(operation: TelemetryErrorOperation, error: unknown): void;
+    capture<T>(operation: TelemetryErrorOperation, fn: () => T): T;
+    captureAsync<T>(operation: TelemetryErrorOperation, promise: Promise<T>): Promise<T>;
     private dispatch;
 }

package/dist/{queue-admin.d.ts → types/sdk/typescript/src/queue-admin.d.ts}

@@ -2,8 +2,8 @@
  * Queue admin surface: DLQ, stall/DLQ configs, rate limits, schedulers,
  * monitoring and webhooks. Merged onto Queue.prototype by queue.ts.
  */
-import type { Queue } from './queue.js';
-import { type JobOptions } from './types.js';
+import type { Queue } from "./queue.js";
+import { type JobOptions } from "./types.js";
 type Ctx = Queue<unknown>;
 type Raw = Record<string, unknown>;
 export interface SchedulerOptions {
@@ -24,8 +24,7 @@ export declare const adminMethods: {
     getDlqConfig(this: Ctx): Promise<Raw>;
     setStallConfig(this: Ctx, config: Raw): Promise<void>;
     getStallConfig(this: Ctx): Promise<Raw>;
-    /** `duration` accepted for signature parity; the TCP wire carries only `limit`. */
-    setGlobalRateLimit(this: Ctx, max: number, _duration?: number): Promise<void>;
+    setGlobalRateLimit(this: Ctx, max: number, duration?: number): Promise<void>;
     removeGlobalRateLimit(this: Ctx): Promise<void>;
     setGlobalConcurrency(this: Ctx, concurrency: number): Promise<void>;
     removeGlobalConcurrency(this: Ctx): Promise<void>;

package/dist/{queue-control.d.ts → types/sdk/typescript/src/queue-control.d.ts}

@@ -2,14 +2,15 @@
  * Queue control surface: pause/drain/clean, promotion, retry and per-job
  * mutations. Methods are merged onto Queue.prototype by queue.ts.
  */
-import type { Queue } from './queue.js';
-import type { JobStateName } from './types.js';
+import type { Queue } from "./queue.js";
+import type { JobStateName } from "./types.js";
 type Ctx = Queue<unknown>;
 export declare const controlMethods: {
     pause(this: Ctx): Promise<void>;
     resume(this: Ctx): Promise<void>;
     isPaused(this: Ctx): Promise<boolean>;
-    drain(this: Ctx): Promise<void>;
+    /** Remove all waiting/delayed jobs; returns how many were dropped. */
+    drain(this: Ctx): Promise<number>;
     obliterate(this: Ctx): Promise<void>;
     /** Remove old jobs; returns how many were removed. */
     clean(this: Ctx, graceMs: number, limit?: number, state?: JobStateName): Promise<number>;
@@ -33,9 +34,9 @@ export declare const controlMethods: {
         priority: number;
         lifo?: boolean;
     }): Promise<void>;
-    changeJobDelay(this: Ctx, id: string, delayMs: number): Promise<void>;
-    moveJobToWait(this: Ctx, id: string): Promise<void>;
-    moveJobToDelayed(this: Ctx, id: string, delayMs: number): Promise<void>;
+    changeJobDelay(this: Ctx, id: string, delayMs: number, token?: string): Promise<void>;
+    moveJobToWait(this: Ctx, id: string, token?: string): Promise<void>;
+    moveJobToDelayed(this: Ctx, id: string, delayMs: number, token?: string): Promise<void>;
     extendJobLock(this: Ctx, id: string, token: string, durationMs: number): Promise<void>;
     moveJobToCompleted(this: Ctx, id: string, returnValue: unknown, token?: string): Promise<void>;
     /**

package/dist/{queue-query.d.ts → types/sdk/typescript/src/queue-query.d.ts}

@@ -2,9 +2,9 @@
  * Queue query surface: job lookup, state, results, counts, logs, children.
  * Methods are merged onto Queue.prototype by queue.ts.
  */
-import { Job } from './job.js';
-import type { Queue } from './queue.js';
-import type { JobCounts } from './types.js';
+import { Job } from "./job.js";
+import type { Queue } from "./queue.js";
+import type { JobCounts } from "./types.js";
 type Ctx = Queue<unknown>;
 export declare const queryMethods: {
     getJob<T = unknown>(this: Ctx, id: string): Promise<Job<T> | null>;

package/dist/{queue.d.ts → types/sdk/typescript/src/queue.d.ts}

@@ -8,14 +8,14 @@
  * monitoring). Methods are merged onto the prototype; declaration merging
  * exposes them on the type.
  */
-import { Connection, type Response, type TlsOption } from './connection.js';
-import type { ConnectionLike } from './connection-types.js';
-import { Job } from './job.js';
-import type { Observability } from './observability.js';
-import { type QueueAdminApi } from './queue-admin.js';
-import { type QueueControlApi } from './queue-control.js';
-import { type QueueQueryApi } from './queue-query.js';
-import { type JobOptions } from './types.js';
+import { Connection, type Response, type TlsOption } from "./connection.js";
+import type { ConnectionLike } from "./connection-types.js";
+import { Job } from "./job.js";
+import type { Observability } from "./observability.js";
+import { type QueueAdminApi } from "./queue-admin.js";
+import { type QueueControlApi } from "./queue-control.js";
+import { type QueueQueryApi } from "./queue-query.js";
+import { type JobOptions } from "./types.js";
 export interface QueueOptions extends Observability {
     host?: string;
     port?: number;

package/dist/{responses.d.ts → types/sdk/typescript/src/responses.d.ts}

@@ -7,8 +7,8 @@
  * These narrow the loose transport `Response`; the runtime value is whatever
  * the server sent, so only assert the shape a given command actually returns.
  */
-import type { JobRaw } from './job.js';
-import type { JobCounts, JobStateName } from './types.js';
+import type { JobRaw } from "./job.js";
+import type { JobCounts, JobStateName } from "./types.js";
 interface Ok {
     ok: true;
     reqId?: string;

package/dist/types/sdk/typescript/src/serialization.d.ts

@@ -0,0 +1,10 @@
+/** Safe command serialization for the bunqueue wire protocol. */
+import type { Command } from "./connection-types.js";
+/**
+ * Encode and frame a command before it occupies an in-flight request slot.
+ *
+ * MessagePack may reject values such as cyclic objects. Normalize every such
+ * encoder failure to the public SDK error hierarchy; `frame()` already uses
+ * the same typed error for an oversized encoded body.
+ */
+export declare function serializeCommand(command: Command, reqId: string): Buffer;