@gravito/stream 2.0.1 → 2.1.0

package/dist/consumer/PollingStrategy.d.ts

@@ -0,0 +1,42 @@
+import type { Job } from '../Job';
+import type { QueueManager } from '../QueueManager';
+import type { ConsumerStrategy } from './ConsumerStrategy';
+/**
+ * PollingStrategy implements pull-based job consumption.
+ *
+ * Continuously polls queues at adaptive intervals, backing off when empty
+ * and resetting when jobs are found.
+ *
+ * Characteristics:
+ * - Simple and reliable
+ * - Predictable polling intervals
+ * - Higher latency and resource usage vs reactive
+ * - No external dependencies (works with any driver)
+ *
+ * @public
+ */
+export declare class PollingStrategy implements ConsumerStrategy {
+    private queueManager;
+    private queues;
+    private connectionName;
+    private options;
+    private running;
+    constructor(queueManager: QueueManager, queues: string[], connectionName: string, options: {
+        minPollInterval: number;
+        maxPollInterval: number;
+        backoffMultiplier: number;
+        batchSize: number;
+        useBlocking: boolean;
+        blockingTimeout: number;
+        concurrency: number;
+        stats: {
+            active: number;
+        };
+        debug: boolean;
+        log: (message: string, data?: unknown) => void;
+    });
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    fetchJobs(): Promise<Job[]>;
+}

package/dist/consumer/ReactiveStrategy.d.ts

@@ -0,0 +1,41 @@
+import type { Job } from '../Job';
+import type { QueueManager } from '../QueueManager';
+import type { ConsumerStrategy } from './ConsumerStrategy';
+/**
+ * ReactiveStrategy implements push-based job consumption.
+ *
+ * Listens for queue notifications and pulls jobs reactively when they arrive.
+ * Implements drain-loop pattern with optional polling fallback.
+ *
+ * Characteristics:
+ * - Low latency (immediate job pickup)
+ * - Efficient resource usage (no continuous polling)
+ * - Requires driver support for onNotify()
+ * - Includes polling fallback to prevent starvation
+ *
+ * @public
+ */
+export declare class ReactiveStrategy implements ConsumerStrategy {
+    private queueManager;
+    private queues;
+    private connectionName;
+    private options;
+    private running;
+    private lastNotificationTime;
+    private fallbackPollingTimer;
+    constructor(queueManager: QueueManager, queues: string[], connectionName: string, options: {
+        concurrency: number;
+        batchSize: number;
+        stats: {
+            active: number;
+        };
+        reactivePollingFallback: number;
+        debug: boolean;
+        log: (message: string, data?: unknown) => void;
+    });
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    fetchJobs(): Promise<Job[]>;
+    private startFallbackPolling;
+}

package/dist/consumer/StreamingConsumer.d.ts

@@ -0,0 +1,88 @@
+import { EventEmitter } from 'node:events';
+import type { ConsumerOptions } from '../Consumer';
+import type { QueueManager } from '../QueueManager';
+import type { ConsumerStats } from './types';
+/**
+ * StreamingConsumer 是 Consumer 管線的核心實作。
+ *
+ * 組合以下元件，提供高效能、可測試的 job 消費管線：
+ * - JobSourceGenerator：抓取 job 的 Async Generator
+ * - ConcurrencyGate：Promise-based Semaphore，取代 busy-wait
+ * - GroupSequencer：確保相同 groupId 的 job 依序執行
+ * - JobExecutor：完整的 job 執行生命週期
+ * - HeartbeatManager：定時心跳與監控日誌
+ *
+ * 主管線採用 `for await...of` 模式，
+ * 完全消除原始 Consumer 中的 `setTimeout(50)` busy-wait。
+ *
+ * @example
+ * ```typescript
+ * const streaming = new StreamingConsumer(queueManager, options)
+ * streaming.on('job:processed', (payload) => console.log('Done:', payload.job.id))
+ *
+ * await streaming.start()
+ * ```
+ */
+export declare class StreamingConsumer extends EventEmitter {
+    private readonly queueManager;
+    private readonly options;
+    private running;
+    private stopRequested;
+    private readonly workerId;
+    private readonly stats;
+    private gate;
+    private sequencer;
+    private heartbeat;
+    private abortController;
+    constructor(queueManager: QueueManager, options: ConsumerOptions);
+    /**
+     * 啟動主消費管線。
+     *
+     * 初始化所有元件，然後進入 `for await...of` 管線迴圈：
+     * 1. 從 jobSourceGenerator 取得 FetchResult
+     * 2. 對每個 job，acquire ConcurrencyGate
+     * 3. 透過 GroupSequencer 確保 group 序列
+     * 4. 由 JobExecutor 執行 job
+     * 5. release ConcurrencyGate
+     *
+     * @throws {Error} 如果 consumer 已在執行中
+     */
+    start(): Promise<void>;
+    /**
+     * 請求優雅停止。
+     *
+     * 設定 stopRequested 旗標，並中止 generator，
+     * 等待目前執行中的 job 完成後停止。
+     *
+     * @returns 等待完全停止的 Promise
+     */
+    requestStop(): Promise<void>;
+    /**
+     * 檢查是否仍有 job 在執行中。
+     */
+    isActive(): boolean;
+    /**
+     * 取得目前的統計資料快照。
+     */
+    getStats(): ConsumerStats;
+    /**
+     * 重置統計計數器。
+     */
+    resetStats(): void;
+    /**
+     * Consumer 是否正在執行中。
+     */
+    isRunning(): boolean;
+    /**
+     * 等待所有正在執行的 job 完成。
+     */
+    private waitForAllJobsToComplete;
+    /**
+     * 清理所有資源。
+     */
+    private cleanup;
+    /**
+     * 輸出 debug 日誌（僅在 debug=true 時）。
+     */
+    private log;
+}

package/dist/consumer/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Consumer 管線模組 - 重新導出所有公開類型與類別。
+ *
+ * 供測試及進階使用者直接引用各個子元件。
+ */
+export { ConcurrencyGate } from './ConcurrencyGate';
+export { GroupSequencer } from './GroupSequencer';
+export type { HeartbeatManagerOptions } from './HeartbeatManager';
+export { HeartbeatManager } from './HeartbeatManager';
+export { JobExecutor } from './JobExecutor';
+export { jobSourceGenerator } from './JobSourceGenerator';
+export { StreamingConsumer } from './StreamingConsumer';
+export type { ConsumerStats, ExecutionResult, ExecutorOptions, FetchResult, JobSourceOptions, StopSignal, } from './types';

package/dist/consumer/types.d.ts

@@ -0,0 +1,102 @@
+import type { Job } from '../Job';
+/**
+ * 從佇列抓取 job 的結果。
+ *
+ * JobSourceGenerator 每次 yield 一個 FetchResult，
+ * 包含本輪抓取的所有 job，以及是否使用阻塞式等待的資訊。
+ */
+export interface FetchResult {
+    /** 本次抓取到的 job 列表（可能為空） */
+    jobs: Job[];
+    /**
+     * 是否使用了阻塞式 pop（如 BLPOP）。
+     * 若為 true，代表已在 driver 層等待，不需額外 backoff。
+     */
+    didBlock: boolean;
+}
+/**
+ * JobSourceGenerator 的選項設定。
+ */
+export interface JobSourceOptions {
+    /** 要消費的佇列名稱列表 */
+    queues: string[];
+    /** 連線名稱，不指定時使用預設連線 */
+    connection?: string;
+    /** 每次嘗試抓取的 job 數量，大於 1 時使用批次抓取 */
+    batchSize: number;
+    /** 是否使用阻塞式 pop */
+    useBlocking: boolean;
+    /** 阻塞式 pop 的逾時秒數 */
+    blockingTimeout: number;
+    /** 佇列為空時是否持續存活 */
+    keepAlive: boolean;
+    /** 最小輪詢間隔（毫秒） */
+    minPollInterval: number;
+    /** 最大輪詢間隔（毫秒） */
+    maxPollInterval: number;
+    /** 自適應退避乘數 */
+    backoffMultiplier: number;
+    /** Rate limit 設定，key 為佇列名稱 */
+    rateLimits?: Record<string, {
+        max: number;
+        duration: number;
+    }>;
+    /** 並發容量 getter，讓 generator 知道可以抓多少 job */
+    getCapacity: () => number;
+}
+/**
+ * JobExecutor 執行選項。
+ */
+export interface ExecutorOptions {
+    /** debug 模式，會輸出詳細 log */
+    debug: boolean;
+    /** Worker ID，用於 log 識別 */
+    workerId: string;
+    /** Worker 選項（maxAttempts 等） */
+    workerOptions?: {
+        maxAttempts?: number;
+    };
+    /** 監控設定 */
+    monitor?: boolean | {
+        interval?: number;
+        extraInfo?: Record<string, unknown>;
+        prefix?: string;
+    };
+    /** 最大請求數量，達到後自動停止 */
+    maxRequests?: number;
+    /** 外部事件回呼 */
+    onEvent?: (event: string, payload: unknown) => void;
+}
+/**
+ * JobExecutor 執行一個 job 後的結果。
+ */
+export interface ExecutionResult {
+    /** job 是否成功完成 */
+    success: boolean;
+    /** 執行耗時（毫秒） */
+    duration: number;
+    /** 是否因達到 maxRequests 而需要停止 consumer */
+    shouldStop: boolean;
+    /** 如果失敗，包含錯誤資訊 */
+    error?: Error;
+}
+/**
+ * Consumer 執行統計資訊。
+ */
+export interface ConsumerStats {
+    /** 已成功處理的 job 數量 */
+    processed: number;
+    /** 失敗（含重試失敗）的 job 數量 */
+    failed: number;
+    /** 重試的 job 數量 */
+    retried: number;
+    /** 目前正在執行的 job 數量 */
+    active: number;
+}
+/**
+ * 停止訊號，用於 AbortController 整合。
+ */
+export interface StopSignal {
+    /** 是否已發出停止訊號 */
+    readonly aborted: boolean;
+}

package/dist/drivers/BinaryJobFrame.d.ts

@@ -0,0 +1,78 @@
+import type { SerializedJob } from '../types';
+/**
+ * BinaryJobFrame - Gravito Job 的二進制幀格式
+ *
+ * 幀結構（Frame Format）：
+ *   Magic(2B) + Version(1B) + Flags(1B) + MetaLen(2B Big-Endian) + Metadata(CBOR) + Payload
+ *
+ * - Magic：固定為 [0x47, 0x4A]（"GJ" = Gravito Job）
+ * - Version：目前為 0x01
+ * - Flags：位元旗標，目前定義：
+ *     Bit 0 (HAS_CLASS_NAME)：是否包含 className 欄位
+ *     Bit 1 (HAS_GROUP_ID)：是否包含 groupId 欄位
+ *     Bit 2 (HAS_DELAY)：是否包含 delaySeconds 欄位
+ *     Bit 3 (HAS_PRIORITY)：是否包含 priority 欄位
+ *     Bit 4 (HAS_ERROR)：是否包含 error / failedAt 欄位
+ * - MetaLen：Metadata CBOR 資料的長度（2 bytes Big-Endian，最大 65535 bytes）
+ * - Metadata：以 CBOR 或 JSON 編碼的 metadata 物件（id, createdAt, attempts 等）
+ * - Payload：原始 Uint8Array 資料（job.data）
+ *
+ * @module BinaryJobFrame
+ */
+/** Magic bytes，標識 Gravito Job 二進制幀 */
+export declare const MAGIC: readonly [71, 74];
+/** 幀格式版本號 */
+export declare const VERSION = 1;
+/** 幀 header 的固定大小（Magic 2B + Version 1B + Flags 1B + MetaLen 2B = 6 bytes） */
+export declare const HEADER_SIZE = 6;
+/** Flags 位元定義 */
+export declare const Flags: {
+    /** 包含 className 欄位 */
+    readonly HAS_CLASS_NAME: 1;
+    /** 包含 groupId 欄位 */
+    readonly HAS_GROUP_ID: 2;
+    /** 包含 delaySeconds 欄位 */
+    readonly HAS_DELAY: 4;
+    /** 包含 priority 欄位 */
+    readonly HAS_PRIORITY: 8;
+    /** 包含 error / failedAt 欄位 */
+    readonly HAS_ERROR: 16;
+};
+/**
+ * Metadata 短鍵映射（節省序列化空間）
+ * 完整鍵名 → 短鍵名
+ */
+export declare const META_KEY_MAP: Record<string, string>;
+/**
+ * 短鍵反向映射（反序列化用）
+ * 短鍵名 → 完整鍵名
+ */
+export declare const META_KEY_REVERSE_MAP: Record<string, string>;
+/**
+ * 判斷給定的資料是否為 Gravito Job 二進制幀
+ *
+ * 透過 Magic byte 嗅探識別：檢查前 2 bytes 是否為 [0x47, 0x4A]
+ *
+ * @param data - 要檢查的資料（Uint8Array 或 Buffer）
+ * @returns 如果是 Gravito Job 幀則回傳 true
+ */
+export declare function isGravitoJobFrame(data: Uint8Array | Buffer): boolean;
+/**
+ * 將 SerializedJob 編碼為二進制幀格式
+ *
+ * 僅適用於 type === 'binary' 且 data 為 Uint8Array 的 Job。
+ *
+ * @param job - 要編碼的 SerializedJob（必須是 binary type）
+ * @returns 編碼後的 Uint8Array
+ * @throws {TypeError} 如果 job.data 不是 Uint8Array
+ * @throws {Error} 如果 metadata 長度超過 65535 bytes
+ */
+export declare function encodeBinaryJobFrame(job: SerializedJob): Uint8Array;
+/**
+ * 將二進制幀解碼為 SerializedJob
+ *
+ * @param data - 要解碼的二進制幀（Uint8Array 或 Buffer）
+ * @returns 解碼後的 SerializedJob，data 為 Uint8Array
+ * @throws {Error} 如果資料格式無效
+ */
+export declare function decodeBinaryJobFrame(data: Uint8Array | Buffer): SerializedJob;

package/dist/drivers/BullMQDriver.d.ts

@@ -0,0 +1,186 @@
+import type { JobPushOptions, QueueStats, SerializedJob, TopicOptions } from '../types';
+import type { QueueDriver } from './QueueDriver';
+/**
+ * Bull Queue client interface (compatible with bullmq package).
+ */
+export interface BullQueueClient {
+    add(name: string, data: any, options?: any): Promise<any>;
+    getJob(id: string): Promise<any | null>;
+    count(): Promise<number>;
+    process(handler: (job: any) => Promise<void>): void;
+    on(event: string, handler: (...args: any[]) => void): void;
+    off(event: string, handler: (...args: any[]) => void): void;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    clean(grace: number, limit?: number, type?: string): Promise<number>;
+    close(): Promise<void>;
+    getJobCounts(types?: string[]): Promise<Record<string, number>>;
+    getDelayedCount(): Promise<number>;
+    getFailedCount(): Promise<number>;
+    getActiveCount(): Promise<number>;
+    [key: string]: any;
+}
+export interface BullWorkerClient {
+    [key: string]: any;
+}
+/**
+ * Bull Queue driver configuration.
+ */
+export interface BullMQDriverConfig {
+    /**
+     * Bull Queue instance (from bullmq package).
+     */
+    queue: BullQueueClient;
+    /**
+     * Optional Bull Worker instance for processing jobs.
+     */
+    worker?: BullWorkerClient;
+    /**
+     * Connection options (host, port, etc. for Redis).
+     */
+    connection?: {
+        host?: string;
+        port?: number;
+        password?: string;
+        db?: number;
+        [key: string]: any;
+    };
+    /**
+     * Default number of concurrent workers (default: 1).
+     */
+    concurrency?: number;
+    /**
+     * Key prefix for namespacing queues (default: 'gravito:').
+     */
+    prefix?: string;
+    /**
+     * Enable debug logging.
+     */
+    debug?: boolean;
+}
+/**
+ * Bull Queue driver implementation.
+ *
+ * Provides high-performance, persistent job queuing using Bull Queue (backed by Redis).
+ * Supports priority, delays, retries, and group-based FIFO processing.
+ *
+ * @public
+ * @example
+ * ```typescript
+ * import { Queue } from 'bullmq'
+ * import Redis from 'ioredis'
+ *
+ * const redis = new Redis()
+ * const queue = new Queue('gravito-events', { connection: redis })
+ * const driver = new BullMQDriver({ queue })
+ * ```
+ */
+export declare class BullMQDriver implements QueueDriver {
+    private queue;
+    private prefix;
+    private debug;
+    private queueMap;
+    constructor(config: BullMQDriverConfig);
+    /**
+     * Get or create a queue for the given queue name.
+     */
+    private getQueue;
+    /**
+     * Build Job Options from JobPushOptions.
+     */
+    private buildJobOptions;
+    /**
+     * Create Bull job data from SerializedJob.
+     */
+    private createBullJobData;
+    /**
+     * Pushes a job to Bull Queue.
+     */
+    push(queue: string, job: SerializedJob, options?: JobPushOptions): Promise<void>;
+    /**
+     * Pops a job from Bull Queue.
+     * Note: Bull Queue typically uses Workers, not manual pop.
+     * This is a fallback implementation.
+     */
+    pop(queue: string): Promise<SerializedJob | null>;
+    /**
+     * Returns the size of the queue.
+     */
+    size(queue: string): Promise<number>;
+    /**
+     * Clears the queue.
+     */
+    clear(queue: string): Promise<void>;
+    /**
+     * Marks a job as failed (moves to failed list).
+     */
+    fail(queue: string, job: SerializedJob): Promise<void>;
+    /**
+     * Returns detailed statistics for the queue.
+     */
+    stats(queue: string): Promise<QueueStats>;
+    /**
+     * Retrieves failed jobs from the Dead Letter Queue.
+     */
+    getFailed(queue: string, _start?: number, _end?: number): Promise<SerializedJob[]>;
+    /**
+     * Retries failed jobs.
+     */
+    retryFailed(queue: string, _count?: number): Promise<number>;
+    /**
+     * Clears the Dead Letter Queue.
+     */
+    clearFailed(queue: string): Promise<void>;
+    /**
+     * Creates a new queue/topic.
+     */
+    createTopic(_topic: string, _options?: TopicOptions): Promise<void>;
+    /**
+     * Deletes a queue/topic.
+     */
+    deleteTopic(topic: string): Promise<void>;
+    /**
+     * Pushes multiple jobs in batch.
+     */
+    pushMany(queue: string, jobs: SerializedJob[]): Promise<void>;
+    /**
+     * Pops multiple jobs in batch.
+     */
+    popMany(_queue: string, _count: number): Promise<SerializedJob[]>;
+    /**
+     * Reports worker heartbeat.
+     */
+    reportHeartbeat(workerInfo: {
+        id: string;
+        status: string;
+        hostname: string;
+        pid: number;
+        uptime: number;
+        last_ping: string;
+        queues: string[];
+        metrics?: Record<string, any>;
+        [key: string]: any;
+    }, _prefix?: string): Promise<void>;
+    /**
+     * Publishes a log message.
+     */
+    publishLog(logPayload: {
+        level: string;
+        message: string;
+        workerId: string;
+        jobId?: string;
+        timestamp: string;
+        [key: string]: any;
+    }, _prefix?: string): Promise<void>;
+    /**
+     * Checks rate limit for a queue.
+     */
+    checkRateLimit(_queue: string, _config: {
+        max: number;
+        duration: number;
+    }): Promise<boolean>;
+    /**
+     * Retrieves all queue names.
+     */
+    getQueues(): Promise<string[]>;
+}

package/dist/drivers/DatabaseDriver.d.ts

@@ -0,0 +1,131 @@
+import type { QueueStats, SerializedJob } from '../types';
+import type { QueueDriver } from './QueueDriver';
+/**
+ * Generic database service interface.
+ *
+ * Adapts any SQL database client (e.g., pg, mysql2, sqlite3) for use with the DatabaseDriver.
+ * Users must provide an implementation of this interface that wraps their specific DB library.
+ */
+export interface DatabaseService {
+    /**
+     * Execute a raw SQL query.
+     *
+     * @param sql - The SQL query string with placeholders (e.g., $1, ?).
+     * @param bindings - The values to bind to the placeholders.
+     * @returns The query result (rows or metadata).
+     */
+    execute<T = unknown>(sql: string, bindings?: unknown[]): Promise<T[] | T>;
+    /**
+     * Execute multiple queries within a single transaction.
+     *
+     * @param callback - A function that receives a transaction-scoped service instance.
+     * @returns The result of the callback.
+     */
+    transaction<T>(callback: (tx: DatabaseService) => Promise<T>): Promise<T>;
+}
+/**
+ * Configuration options for the DatabaseDriver.
+ */
+export interface DatabaseDriverConfig {
+    /**
+     * The name of the table used to store jobs.
+     * @default 'jobs'
+     */
+    table?: string;
+    /**
+     * The database service adapter instance.
+     */
+    dbService?: DatabaseService;
+}
+/**
+ * Database-backed queue driver.
+ *
+ * Persists jobs in a SQL database table. Supports delayed jobs, reservation (locking),
+ * and reliable delivery. Compatible with PostgreSQL (SKIP LOCKED), MySQL, and SQLite.
+ *
+ * @public
+ * @example
+ * ```typescript
+ * const driver = new DatabaseDriver({
+ *   dbService: myDbAdapter,
+ *   table: 'queue_jobs'
+ * });
+ * ```
+ */
+export declare class DatabaseDriver implements QueueDriver {
+    private tableName;
+    private dbService;
+    constructor(config: DatabaseDriverConfig);
+    /**
+     * Pushes a job to the database queue.
+     *
+     * Inserts a new row into the jobs table.
+     *
+     * @param queue - The queue name.
+     * @param job - The serialized job.
+     */
+    push(queue: string, job: SerializedJob): Promise<void>;
+    /**
+     * Pops the next available job from the queue.
+     *
+     * Uses transactional locking (SELECT ... FOR UPDATE SKIP LOCKED if supported) to ensure
+     * atomic reservation of jobs by workers.
+     *
+     * @param queue - The queue name.
+     * @returns The job or `null`.
+     */
+    pop(queue: string): Promise<SerializedJob | null>;
+    /**
+     * Pops multiple jobs from the queue in a single transaction.
+     *
+     * @param queue - The queue name.
+     * @param count - Max jobs to pop.
+     */
+    popMany(queue: string, count: number): Promise<SerializedJob[]>;
+    /**
+     * Retrieves queue statistics by querying the table.
+     *
+     * @param queue - The queue name.
+     */
+    stats(queue: string): Promise<QueueStats>;
+    /**
+     * Returns the count of pending jobs.
+     *
+     * @param queue - The queue name.
+     */
+    size(queue: string): Promise<number>;
+    /**
+     * Clears the queue by deleting all rows for the queue.
+     *
+     * @param queue - The queue name.
+     */
+    clear(queue: string): Promise<void>;
+    /**
+     * Pops a job using a polling loop (Blocking simulation).
+     *
+     * @param queue - The queue name.
+     * @param timeout - Timeout in seconds.
+     */
+    popBlocking(queue: string, timeout: number): Promise<SerializedJob | null>;
+    /**
+     * Pushes multiple jobs using a transaction.
+     *
+     * @param queue - The queue name.
+     * @param jobs - Array of jobs.
+     */
+    pushMany(queue: string, jobs: SerializedJob[]): Promise<void>;
+    /**
+     * Marks a job as permanently failed by moving it to the DLQ (separate logical queue in DB).
+     *
+     * @param queue - The queue name.
+     * @param job - The failed job.
+     */
+    fail(queue: string, job: SerializedJob): Promise<void>;
+    /**
+     * Deletes a job row from the database (completion).
+     *
+     * @param _queue - The queue name (unused).
+     * @param job - The job to complete.
+     */
+    complete(_queue: string, job: SerializedJob): Promise<void>;
+}

package/dist/drivers/GrpcDriver.d.ts

@@ -0,0 +1,16 @@
+import type { GrpcDriverConfig, JobPushOptions, QueueStats, SerializedJob } from '../types';
+import type { QueueDriver } from './QueueDriver';
+export type { GrpcDriverConfig } from '../types';
+export declare class GrpcDriver implements QueueDriver {
+    private client;
+    constructor(config: GrpcDriverConfig);
+    private getCredentials;
+    push(queue: string, job: SerializedJob, options?: JobPushOptions): Promise<void>;
+    pop(queue: string): Promise<SerializedJob | null>;
+    size(queue: string): Promise<number>;
+    clear(queue: string): Promise<void>;
+    acknowledge(messageId: string): Promise<void>;
+    stats(queue: string): Promise<QueueStats>;
+    private toProtoJob;
+    private fromProtoJob;
+}