@spooled/sdk 1.0.39 → 1.1.0

package/dist/{index-Lgo8JxCV.d.ts → index-D_MpLQYY.d.ts}

@@ -107,11 +107,11 @@ declare const DEFAULT_CONFIG: {
         successThreshold: number;
         timeout: number;
     };
-    readonly userAgent: "@spooled/sdk-nodejs/1.0.39";
+    readonly userAgent: "@spooled/sdk-nodejs/1.1.0";
     readonly autoRefreshToken: true;
 };
 /** SDK version */
-declare const SDK_VERSION = "1.0.39";
+declare const SDK_VERSION = "1.1.0";
 /** API version prefix */
 declare const API_VERSION = "v1";
 /**
@@ -231,7 +231,7 @@ declare function createCircuitBreaker(config: CircuitBreakerConfig): CircuitBrea
  */
 
 /** HTTP methods */
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
 /** Query parameters type */
 type QueryParams = Record<string, string | number | boolean | undefined>;
 /** Request options for HTTP client */
@@ -340,23 +340,23 @@ declare class HttpClient {
     /**
      * Make a GET request
      */
-    get<T>(path: string, options?: Omit<HttpRequestOptions, 'method' | 'body'>): Promise<T>;
+    get<T>(path: string, options?: Omit<HttpRequestOptions, "method" | "body">): Promise<T>;
     /**
      * Make a POST request
      */
-    post<T>(path: string, body?: unknown, options?: Omit<HttpRequestOptions, 'method' | 'body'>): Promise<T>;
+    post<T>(path: string, body?: unknown, options?: Omit<HttpRequestOptions, "method" | "body">): Promise<T>;
     /**
      * Make a PUT request
      */
-    put<T>(path: string, body?: unknown, options?: Omit<HttpRequestOptions, 'method' | 'body'>): Promise<T>;
+    put<T>(path: string, body?: unknown, options?: Omit<HttpRequestOptions, "method" | "body">): Promise<T>;
     /**
      * Make a PATCH request
      */
-    patch<T>(path: string, body?: unknown, options?: Omit<HttpRequestOptions, 'method' | 'body'>): Promise<T>;
+    patch<T>(path: string, body?: unknown, options?: Omit<HttpRequestOptions, "method" | "body">): Promise<T>;
     /**
      * Make a DELETE request
      */
-    delete<T = void>(path: string, options?: Omit<HttpRequestOptions, 'method' | 'body'>): Promise<T>;
+    delete<T = void>(path: string, options?: Omit<HttpRequestOptions, "method" | "body">): Promise<T>;
 }
 /**
  * Create an HTTP client instance
@@ -377,7 +377,7 @@ interface LoginParams {
 interface LoginResponse {
     accessToken: string;
     refreshToken: string;
-    tokenType: 'Bearer';
+    tokenType: "Bearer";
     expiresIn: number;
     refreshExpiresIn: number;
 }
@@ -388,7 +388,7 @@ interface RefreshTokenParams {
 /** Token refresh response */
 interface RefreshTokenResponse {
     accessToken: string;
-    tokenType: 'Bearer';
+    tokenType: "Bearer";
     expiresIn: number;
 }
 /** Current user info response */
@@ -484,21 +484,21 @@ interface JsonObject {
 /** JSON array type */
 type JsonArray = JsonValue[];
 /** Job status enum values */
-type JobStatus = 'pending' | 'scheduled' | 'processing' | 'completed' | 'failed' | 'deadletter' | 'cancelled';
+type JobStatus = "pending" | "scheduled" | "processing" | "completed" | "failed" | "deadletter" | "cancelled";
 /** Worker status enum values */
-type WorkerStatus = 'healthy' | 'degraded' | 'offline' | 'draining';
+type WorkerStatus = "healthy" | "degraded" | "offline" | "draining";
 /** Workflow status enum values */
-type WorkflowStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+type WorkflowStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
 /** Plan tier enum values */
-type PlanTier = 'free' | 'starter' | 'pro' | 'enterprise';
+type PlanTier = "free" | "starter" | "pro" | "enterprise";
 /** Schedule run status */
-type ScheduleRunStatus = 'pending' | 'running' | 'completed' | 'failed';
+type ScheduleRunStatus = "pending" | "running" | "completed" | "failed";
 /** Webhook delivery status */
-type WebhookDeliveryStatus = 'pending' | 'success' | 'failed';
+type WebhookDeliveryStatus = "pending" | "success" | "failed";
 /** Webhook event types */
-type WebhookEventType = 'job.created' | 'job.started' | 'job.completed' | 'job.failed' | 'job.cancelled' | 'queue.paused' | 'queue.resumed' | 'worker.registered' | 'worker.deregistered' | 'schedule.triggered';
+type WebhookEventType = "job.created" | "job.started" | "job.completed" | "job.failed" | "job.cancelled" | "queue.paused" | "queue.resumed" | "worker.registered" | "worker.deregistered" | "schedule.triggered";
 /** Dependency mode for workflows */
-type DependencyMode = 'all' | 'any';
+type DependencyMode = "all" | "any";
 /** Pagination parameters */
 interface PaginationParams {
     /** Maximum number of results */
@@ -511,7 +511,7 @@ interface ListParams extends PaginationParams {
     /** Field to order by */
     orderBy?: string;
     /** Sort direction */
-    orderDir?: 'asc' | 'desc';
+    orderDir?: "asc" | "desc";
 }
 /** Paginated response wrapper */
 interface PaginatedResponse<T> {
@@ -976,15 +976,21 @@ interface Worker {
     id: string;
     organizationId: string;
     queueName: string;
+    /** Multi-queue membership when present (detail response). */
+    queueNames?: string[];
     hostname: string;
-    workerType?: string;
+    /** Serialized as explicit null by the backend when not set. */
+    workerType?: string | null;
     maxConcurrency: number;
     currentJobs: number;
     status: WorkerStatus;
     lastHeartbeat: string;
     metadata: JsonObject;
-    version?: string;
+    /** Serialized as explicit null by the backend when not set. */
+    version?: string | null;
     registeredAt: string;
+    /** Last row update (detail response). */
+    updatedAt?: string;
 }
 /** Worker summary for list responses */
 interface WorkerSummary {
@@ -1000,6 +1006,18 @@ interface WorkerSummary {
 interface RegisterWorkerParams {
     /** Queue name to process */
     queueName: string;
+    /**
+     * Stable worker identifier (1-128 chars, `[A-Za-z0-9._-]`).
+     *
+     * Supplying one makes registration an upsert, so a restarting worker reuses
+     * a single row and re-registering an id you already own is not charged
+     * against the plan worker cap. Omit it and the server mints a UUID, which
+     * means every restart leaves the old row occupying the cap until the
+     * stale-worker reaper clears it (~2 minutes) — enough for a crash-looping
+     * worker on a tight plan to 429 itself out of registering. An id owned by a
+     * different organization is rejected with HTTP 409.
+     */
+    workerId?: string;
     /** Worker hostname */
     hostname: string;
     /** Worker type identifier */
@@ -1323,7 +1341,7 @@ interface WorkflowJob {
     /** Queue name */
     queueName: string;
     /** Current job status */
-    status: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'cancelled' | 'deadletter';
+    status: "pending" | "queued" | "running" | "completed" | "failed" | "cancelled" | "deadletter";
     /** Job payload */
     payload: JsonObject;
     /** Job result (if completed) */
@@ -1479,9 +1497,24 @@ interface OutgoingWebhook {
     url: string;
     events: WebhookEventType[];
     enabled: boolean;
+    /**
+     * Consecutive failed deliveries.
+     *
+     * Counted once per DELIVERY, not once per retry attempt, so for the same
+     * real-world failures this is roughly 5x smaller than a per-attempt count.
+     * A successful delivery resets it to 0, including a successful manual retry
+     * via `retryDelivery()`. At 20 the webhook is disabled automatically.
+     */
     failureCount: number;
     lastTriggeredAt?: string;
-    lastStatus?: 'success' | 'failed';
+    /**
+     * Outcome of the most recent delivery.
+     *
+     * `"auto_disabled"` means 20 consecutive failed deliveries disabled the
+     * webhook: `enabled` is now false and no further events are delivered until
+     * it is re-enabled with `update(id, { enabled: true })`.
+     */
+    lastStatus?: "success" | "failed" | "auto_disabled";
     createdAt: string;
     updatedAt: string;
 }
@@ -1498,12 +1531,34 @@ interface CreateOutgoingWebhookParams {
     /** Whether enabled (default: true) */
     enabled?: boolean;
 }
-/** Parameters for updating an outgoing webhook */
+/**
+ * Parameters for updating an outgoing webhook.
+ *
+ * Every field is optional and only the fields you send are changed.
+ */
 interface UpdateOutgoingWebhookParams {
     name?: string;
     url?: string;
     events?: WebhookEventType[];
-    secret?: string;
+    /**
+     * HMAC secret used to sign deliveries.
+     *
+     * Omit the field to keep the current secret, pass a string to replace it, or
+     * pass `null` to CLEAR it. Clearing is destructive: deliveries then go out
+     * unsigned, with no `X-Spooled-Signature` header, and the old secret cannot
+     * be recovered. Client code that reserialises an unchanged webhook must send
+     * `undefined` (or drop the key) rather than `null`, or it will wipe a live
+     * secret.
+     */
+    secret?: string | null;
+    /**
+     * Whether the webhook receives events.
+     *
+     * Setting this to `true` is the recovery path for a webhook that was
+     * auto-disabled after 20 consecutive failed deliveries. Re-enabling is
+     * charged against the plan webhook cap, so it can fail with HTTP 429
+     * `QUOTA_EXCEEDED` even though no webhook is being created.
+     */
     enabled?: boolean;
 }
 /** Response for webhook test */
@@ -1513,7 +1568,15 @@ interface TestWebhookResponse {
     responseTimeMs: number;
     error?: string;
 }
-/** Webhook delivery record */
+/**
+ * Webhook delivery record.
+ *
+ * Delivery history is retained, not permanent: rows are removed by the
+ * per-organization retention sweep using the plan's history retention window
+ * (free 1 day, starter 7, pro 30, enterprise 90). Only the newest 100
+ * deliveries per webhook are readable through the API in any case, so copy
+ * anything you need as a durable audit record into your own store.
+ */
 interface OutgoingWebhookDelivery {
     id: string;
     webhookId: string;
@@ -1587,6 +1650,12 @@ interface ApiKeySummary {
     rateLimit?: number;
     isActive: boolean;
     createdAt: string;
+    /**
+     * Coarse last-use timestamp, written at most once per key per 5 minutes
+     * rather than on every request. Treat it as "used recently", not as a live
+     * signal: it can lag actual use by up to 5 minutes, so it cannot answer
+     * "is this key in use right now" and idle-key checks must allow for the lag.
+     */
     lastUsed?: string;
     expiresAt?: string;
 }
@@ -1756,7 +1825,7 @@ interface UsageItem {
 interface UsageWarning {
     resource: string;
     message: string;
-    severity: 'warning' | 'critical' | string;
+    severity: "warning" | "critical" | string;
 }
 /** Organization member */
 interface OrganizationMember {
@@ -2043,7 +2112,7 @@ interface AdminListOrganizationsParams {
     limit?: number;
     offset?: number;
     sortBy?: string;
-    sortOrder?: 'asc' | 'desc' | string;
+    sortOrder?: "asc" | "desc" | string;
 }
 interface AdminUsageStats {
     jobsToday: number;
@@ -2193,7 +2262,7 @@ interface IngestGitHubWebhookOptions {
     /** Optional org-scoped webhook token (X-Webhook-Token) */
     webhookToken?: string;
     /** Optional X-Forwarded-Proto override (production servers may require https) */
-    forwardedProto?: 'https' | 'http' | string;
+    forwardedProto?: "https" | "http" | string;
     /** Provide a precomputed X-Hub-Signature-256 header value (sha256=<hex>) */
     signature?: string;
     /** If provided, the SDK will compute the signature for you */
@@ -2203,7 +2272,7 @@ interface IngestStripeWebhookOptions {
     /** Optional org-scoped webhook token (X-Webhook-Token) */
     webhookToken?: string;
     /** Optional X-Forwarded-Proto override */
-    forwardedProto?: 'https' | 'http' | string;
+    forwardedProto?: "https" | "http" | string;
     /** Provide a precomputed Stripe-Signature header */
     signature?: string;
     /** If provided, the SDK will compute the signature for you */
@@ -2271,7 +2340,7 @@ interface RealtimeEventBase {
 }
 /** Job created event */
 interface JobCreatedEvent extends RealtimeEventBase {
-    type: 'job.created';
+    type: "job.created";
     data: {
         jobId: string;
         queueName: string;
@@ -2280,7 +2349,7 @@ interface JobCreatedEvent extends RealtimeEventBase {
 }
 /** Job started event */
 interface JobStartedEvent extends RealtimeEventBase {
-    type: 'job.started';
+    type: "job.started";
     data: {
         jobId: string;
         queueName: string;
@@ -2289,7 +2358,7 @@ interface JobStartedEvent extends RealtimeEventBase {
 }
 /** Job completed event */
 interface JobCompletedEvent extends RealtimeEventBase {
-    type: 'job.completed';
+    type: "job.completed";
     data: {
         jobId: string;
         queueName: string;
@@ -2299,7 +2368,7 @@ interface JobCompletedEvent extends RealtimeEventBase {
 }
 /** Job failed event */
 interface JobFailedEvent extends RealtimeEventBase {
-    type: 'job.failed';
+    type: "job.failed";
     data: {
         jobId: string;
         queueName: string;
@@ -2310,7 +2379,7 @@ interface JobFailedEvent extends RealtimeEventBase {
 }
 /** Job progress event */
 interface JobProgressEvent extends RealtimeEventBase {
-    type: 'job.progress';
+    type: "job.progress";
     data: {
         jobId: string;
         queueName: string;
@@ -2320,7 +2389,7 @@ interface JobProgressEvent extends RealtimeEventBase {
 }
 /** Job status changed event */
 interface JobStatusChangedEvent extends RealtimeEventBase {
-    type: 'job.status_changed';
+    type: "job.status_changed";
     data: {
         jobId: string;
         queueName: string;
@@ -2330,7 +2399,7 @@ interface JobStatusChangedEvent extends RealtimeEventBase {
 }
 /** Queue stats update event (backend `QueueStats`) */
 interface QueueStatsEvent extends RealtimeEventBase {
-    type: 'queue.stats';
+    type: "queue.stats";
     data: {
         queueName: string;
         pending: number;
@@ -2341,7 +2410,7 @@ interface QueueStatsEvent extends RealtimeEventBase {
 }
 /** Worker heartbeat event (backend `WorkerHeartbeat`) */
 interface WorkerHeartbeatEvent extends RealtimeEventBase {
-    type: 'worker.heartbeat';
+    type: "worker.heartbeat";
     data: {
         workerId: string;
         status: string;
@@ -2350,7 +2419,7 @@ interface WorkerHeartbeatEvent extends RealtimeEventBase {
 }
 /** Queue paused event */
 interface QueuePausedEvent extends RealtimeEventBase {
-    type: 'queue.paused';
+    type: "queue.paused";
     data: {
         queueName: string;
         reason?: string;
@@ -2358,14 +2427,14 @@ interface QueuePausedEvent extends RealtimeEventBase {
 }
 /** Queue resumed event */
 interface QueueResumedEvent extends RealtimeEventBase {
-    type: 'queue.resumed';
+    type: "queue.resumed";
     data: {
         queueName: string;
     };
 }
 /** Worker registered event */
 interface WorkerRegisteredEvent extends RealtimeEventBase {
-    type: 'worker.registered';
+    type: "worker.registered";
     data: {
         workerId: string;
         queueName: string;
@@ -2374,7 +2443,7 @@ interface WorkerRegisteredEvent extends RealtimeEventBase {
 }
 /** Worker deregistered event */
 interface WorkerDeregisteredEvent extends RealtimeEventBase {
-    type: 'worker.deregistered';
+    type: "worker.deregistered";
     data: {
         workerId: string;
         queueName: string;
@@ -2382,7 +2451,7 @@ interface WorkerDeregisteredEvent extends RealtimeEventBase {
 }
 /** Schedule triggered event */
 interface ScheduleTriggeredEvent extends RealtimeEventBase {
-    type: 'schedule.triggered';
+    type: "schedule.triggered";
     data: {
         scheduleId: string;
         jobId: string;
@@ -2390,7 +2459,7 @@ interface ScheduleTriggeredEvent extends RealtimeEventBase {
 }
 /** Heartbeat event (for connection keep-alive) */
 interface HeartbeatEvent extends RealtimeEventBase {
-    type: 'heartbeat';
+    type: "heartbeat";
     data: {
         serverTime: string;
     };
@@ -2398,13 +2467,13 @@ interface HeartbeatEvent extends RealtimeEventBase {
 /** All realtime event types */
 type RealtimeEvent = JobCreatedEvent | JobStartedEvent | JobCompletedEvent | JobFailedEvent | JobProgressEvent | JobStatusChangedEvent | QueueStatsEvent | QueuePausedEvent | QueueResumedEvent | WorkerRegisteredEvent | WorkerDeregisteredEvent | WorkerHeartbeatEvent | ScheduleTriggeredEvent | HeartbeatEvent;
 /** Event type names */
-type RealtimeEventType = RealtimeEvent['type'];
+type RealtimeEventType = RealtimeEvent["type"];
 /** Extract event data type from event type name */
 type RealtimeEventData<T extends RealtimeEventType> = Extract<RealtimeEvent, {
     type: T;
-}>['data'];
+}>["data"];
 /** Connection state */
-type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
+type ConnectionState = "disconnected" | "connecting" | "connected" | "reconnecting";
 /** Realtime connection options */
 interface RealtimeConnectionOptions {
     /** Base URL for the REST API (e.g., https://api.spooled.cloud) - used for SSE */
@@ -2452,7 +2521,7 @@ interface SpooledRealtimeOptions {
      * - WebSocket uses push/pubsub in the backend
      * - SSE job/queue endpoints poll the database periodically
      */
-    type?: 'websocket' | 'sse';
+    type?: "websocket" | "sse";
     /** Auto-reconnect on disconnect (default: true) */
     autoReconnect?: boolean;
     /** Maximum reconnect attempts (default: 10) */
@@ -2788,6 +2857,8 @@ interface GrpcClientOptions {
     credentials?: grpc.ChannelCredentials;
     /** Channel options */
     channelOptions?: grpc.ChannelOptions;
+    /** Deadline for unary gRPC calls in milliseconds. Streams are not bounded unless explicitly configured. */
+    timeout?: number;
 }
 /** @deprecated Use GrpcEnqueueRequest */
 type GrpcEnqueueJobParams = GrpcEnqueueRequest & {
@@ -2922,21 +2993,25 @@ declare function createJobStream(call: grpc.ClientReadableStream<GrpcJob>, optio
  */
 
 type UnaryCallback<T> = (error: grpc.ServiceError | null, response: T) => void;
+type UnaryMethod<TReq, TRes> = {
+    (request: TReq, metadata: grpc.Metadata, callback: UnaryCallback<TRes>): void;
+    (request: TReq, metadata: grpc.Metadata, options: grpc.CallOptions, callback: UnaryCallback<TRes>): void;
+};
 interface QueueServiceClient extends grpc.Client {
-    Enqueue(request: GrpcEnqueueRequest, metadata: grpc.Metadata, callback: UnaryCallback<GrpcEnqueueResponse>): void;
-    Dequeue(request: GrpcDequeueRequest, metadata: grpc.Metadata, callback: UnaryCallback<GrpcDequeueResponse>): void;
-    Complete(request: GrpcCompleteRequest, metadata: grpc.Metadata, callback: UnaryCallback<GrpcCompleteResponse>): void;
-    Fail(request: GrpcFailRequest, metadata: grpc.Metadata, callback: UnaryCallback<GrpcFailResponse>): void;
-    RenewLease(request: GrpcRenewLeaseRequest, metadata: grpc.Metadata, callback: UnaryCallback<GrpcRenewLeaseResponse>): void;
-    GetJob(request: GrpcGetJobRequest, metadata: grpc.Metadata, callback: UnaryCallback<GrpcGetJobResponse>): void;
-    GetQueueStats(request: GrpcGetQueueStatsRequest, metadata: grpc.Metadata, callback: UnaryCallback<GrpcGetQueueStatsResponse>): void;
+    Enqueue: UnaryMethod<GrpcEnqueueRequest, GrpcEnqueueResponse>;
+    Dequeue: UnaryMethod<GrpcDequeueRequest, GrpcDequeueResponse>;
+    Complete: UnaryMethod<GrpcCompleteRequest, GrpcCompleteResponse>;
+    Fail: UnaryMethod<GrpcFailRequest, GrpcFailResponse>;
+    RenewLease: UnaryMethod<GrpcRenewLeaseRequest, GrpcRenewLeaseResponse>;
+    GetJob: UnaryMethod<GrpcGetJobRequest, GrpcGetJobResponse>;
+    GetQueueStats: UnaryMethod<GrpcGetQueueStatsRequest, GrpcGetQueueStatsResponse>;
     StreamJobs(request: GrpcStreamJobsRequest, metadata: grpc.Metadata): grpc.ClientReadableStream<GrpcJob>;
     ProcessJobs(metadata: grpc.Metadata): grpc.ClientDuplexStream<GrpcProcessRequest, GrpcProcessResponse>;
 }
 interface WorkerServiceClient extends grpc.Client {
-    Register(request: GrpcRegisterWorkerRequest, metadata: grpc.Metadata, callback: UnaryCallback<GrpcRegisterWorkerResponse>): void;
-    Heartbeat(request: GrpcHeartbeatRequest, metadata: grpc.Metadata, callback: UnaryCallback<GrpcHeartbeatResponse>): void;
-    Deregister(request: GrpcDeregisterRequest, metadata: grpc.Metadata, callback: UnaryCallback<GrpcDeregisterResponse>): void;
+    Register: UnaryMethod<GrpcRegisterWorkerRequest, GrpcRegisterWorkerResponse>;
+    Heartbeat: UnaryMethod<GrpcHeartbeatRequest, GrpcHeartbeatResponse>;
+    Deregister: UnaryMethod<GrpcDeregisterRequest, GrpcDeregisterResponse>;
 }
 /**
  * Queue operations for the gRPC client
@@ -2944,7 +3019,8 @@ interface WorkerServiceClient extends grpc.Client {
 declare class GrpcQueueOperations {
     private readonly client;
     private readonly metadata;
-    constructor(client: QueueServiceClient, metadata: grpc.Metadata);
+    private readonly timeoutMs?;
+    constructor(client: QueueServiceClient, metadata: grpc.Metadata, timeoutMs?: number | undefined);
     /**
      * Enqueue a new job
      */
@@ -3018,7 +3094,8 @@ declare class GrpcQueueOperations {
 declare class GrpcWorkerOperations {
     private readonly client;
     private readonly metadata;
-    constructor(client: WorkerServiceClient, metadata: grpc.Metadata);
+    private readonly timeoutMs?;
+    constructor(client: WorkerServiceClient, metadata: grpc.Metadata, timeoutMs?: number | undefined);
     /**
      * Register a new worker
      */
@@ -3278,6 +3355,16 @@ declare function createClient(options: SpooledClientConfig): SpooledClient;
 interface SpooledWorkerOptions {
     /** Queue name to process */
     queueName: string;
+    /**
+     * Stable worker identifier (1-128 chars, `[A-Za-z0-9._-]`).
+     *
+     * Set this on any worker that restarts or redeploys: registration becomes an
+     * upsert, so the process reuses one row instead of leaving the previous
+     * registration to occupy the plan worker cap until the stale-worker reaper
+     * clears it (~2 minutes). Omit it and the server mints a UUID on every
+     * start. An id owned by a different organization is rejected with HTTP 409.
+     */
+    workerId?: string;
     /** Worker hostname (default: auto-detected) */
     hostname?: string;
     /** Worker type identifier */
@@ -3300,7 +3387,7 @@ interface SpooledWorkerOptions {
     shutdownTimeout?: number;
 }
 /** Worker state */
-type WorkerState = 'idle' | 'starting' | 'running' | 'stopping' | 'stopped' | 'error';
+type WorkerState = "idle" | "starting" | "running" | "stopping" | "stopped" | "error";
 /** Job context passed to handlers */
 interface JobContext {
     /** Job ID */
@@ -3315,10 +3402,10 @@ interface JobContext {
     maxRetries: number;
     /** Abort signal for graceful shutdown */
     signal: AbortSignal;
-    /** Update job progress (0-100) */
+    /** Log local job progress (0-100); backend progress persistence is not yet available. */
     progress: (percent: number, message?: string) => Promise<void>;
     /** Log a message */
-    log: (level: 'debug' | 'info' | 'warn' | 'error', message: string, meta?: unknown) => void;
+    log: (level: "debug" | "info" | "warn" | "error", message: string, meta?: unknown) => void;
 }
 /** Job handler function */
 type JobHandler = (context: JobContext) => Promise<JsonObject | void>;
@@ -3329,7 +3416,7 @@ interface JobResult {
     error?: string;
 }
 /** Worker event types */
-type WorkerEvent = 'started' | 'stopped' | 'error' | 'job:claimed' | 'job:started' | 'job:completed' | 'job:failed' | 'job:timeout';
+type WorkerEvent = "started" | "stopped" | "error" | "job:claimed" | "job:started" | "job:completed" | "job:failed" | "job:timeout";
 /** Worker event data types */
 interface WorkerEventData {
     started: {
@@ -3343,26 +3430,26 @@ interface WorkerEventData {
     error: {
         error: Error;
     };
-    'job:claimed': {
+    "job:claimed": {
         jobId: string;
         queueName: string;
     };
-    'job:started': {
+    "job:started": {
         jobId: string;
         queueName: string;
     };
-    'job:completed': {
+    "job:completed": {
         jobId: string;
         queueName: string;
         result?: JsonObject;
     };
-    'job:failed': {
+    "job:failed": {
         jobId: string;
         queueName: string;
         error: string;
         willRetry: boolean;
     };
-    'job:timeout': {
+    "job:timeout": {
         jobId: string;
         queueName: string;
     };
@@ -3408,6 +3495,11 @@ type EventHandler<E extends WorkerEvent> = (data: WorkerEventData[E]) => void;
  */
 declare class SpooledWorker {
     private readonly client;
+    /**
+     * Options with every defaultable field filled in. `workerId` stays optional:
+     * there is no sensible default for it, and omitting it is what makes the
+     * server mint a UUID.
+     */
     private readonly options;
     private readonly debug;
     private state;