streamby-core 0.38.0 → 0.40.0

package/dist/services/jobQueue.js

@@ -5,16 +5,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createJob = createJob;
 exports.getJob = getJob;
+exports.listJobs = listJobs;
+exports.notify = notify;
 exports.updateJob = updateJob;
 exports.failJob = failJob;
 const crypto_1 = __importDefault(require("crypto"));
 const wsHub_1 = require("./wsHub");
-const jobs = new Map();
-function createJob(jobType, userId, projectId, payload) {
-    const jobId = crypto_1.default.randomUUID();
+const jobStore_1 = require("./jobStore");
+// Jobs, kept in the main database (see jobStore): they survive restarts and every instance
+// sees them. Each change is sent to whoever started the job (a `jobEvent`).
+async function createJob(jobType, userId, projectId, payload, extra = {}) {
     const now = new Date();
     const job = {
-        jobId,
+        jobId: crypto_1.default.randomUUID(),
         jobType,
         userId,
         projectId,
@@ -24,31 +27,40 @@ function createJob(jobType, userId, projectId, payload) {
         payload,
         createdAt: now,
         updatedAt: now,
+        ...extra,
     };
-    jobs.set(jobId, job);
-    return job;
+    const saved = await (0, jobStore_1.jobStore)().insert(job);
+    notify(saved);
+    return saved;
+}
+async function getJob(jobId) {
+    return (0, jobStore_1.jobStore)().get(jobId);
 }
-function getJob(jobId) {
-    return jobs.get(jobId);
+async function listJobs(projectId, assetId) {
+    return (0, jobStore_1.jobStore)().list({ projectId, assetId });
 }
-function updateJob(jobId, updates) {
-    const job = jobs.get(jobId);
-    if (!job)
-        return;
-    Object.assign(job, updates, { updatedAt: new Date() });
+function notify(job) {
     (0, wsHub_1.emitToUser)(job.userId, {
         type: 'jobEvent',
         data: {
             jobId: job.jobId,
             jobType: job.jobType,
+            projectId: job.projectId,
             assetId: job.assetId,
+            status: job.status,
             stage: job.stage,
             progress: job.progress,
-            message: updates.stage,
+            message: job.stage,
             error: job.error,
         },
     });
 }
-function failJob(jobId, error) {
-    updateJob(jobId, { status: 'failed', stage: 'failed', error });
+async function updateJob(jobId, updates) {
+    const job = await (0, jobStore_1.jobStore)().update(jobId, { ...updates, updatedAt: new Date() });
+    if (job)
+        notify(job);
+    return job;
+}
+async function failJob(jobId, error) {
+    return updateJob(jobId, { status: 'failed', stage: 'failed', error });
 }

package/dist/services/jobStore.d.ts

@@ -0,0 +1,27 @@
+import { JobRecord, StreamByConfig } from '../types';
+export interface JobStore {
+    insert(job: JobRecord): Promise<JobRecord>;
+    get(jobId: string): Promise<JobRecord | null>;
+    list(filter: {
+        projectId: string;
+        assetId?: string;
+        limit?: number;
+    }): Promise<JobRecord[]>;
+    update(jobId: string, patch: Partial<JobRecord>): Promise<JobRecord | null>;
+    /**
+     * Changes a job only if it's still in one of `statuses` (any, if none), and, if given, its
+     * lease ended by `leaseEndedBy` and its callback hash is `callbackHash`.
+     */
+    claim(jobId: string, statuses: JobRecord['status'][], patch: Partial<JobRecord>, only?: ClaimConditions): Promise<JobRecord | null>;
+    /** Worker jobs to look at now: queued and due, or dispatched with their lease ended. */
+    due(now: Date, limit: number): Promise<JobRecord[]>;
+    /** A deleted project's jobs. */
+    deleteProject(projectId: string): Promise<void>;
+}
+export interface ClaimConditions {
+    leaseEndedBy?: Date;
+    callbackHash?: string;
+}
+/** The router's main database, where jobs are kept. */
+export declare const setJobStoreDatabase: (config: StreamByConfig) => void;
+export declare function jobStore(): JobStore;

package/dist/services/jobStore.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setJobStoreDatabase = void 0;
+exports.jobStore = jobStore;
+const connectionManager_1 = require("../adapters/database/connectionManager");
+const JSON_FIELDS = new Set(['payload', 'report', 'result', 'worker', 'profile', 'upload']);
+// ── PostgreSQL ──
+const sqlStore = (pool) => {
+    const table = 'streamby.jobs';
+    const fromRow = (row) => {
+        if (!row)
+            return null;
+        const { id, ...job } = row;
+        return { ...job, jobId: id };
+    };
+    const toColumns = (patch) => {
+        const entries = Object.entries(patch).filter(([key, value]) => key !== 'jobId' && value !== undefined);
+        return {
+            names: entries.map(([key]) => `"${key}"`),
+            values: entries.map(([key, value]) => (JSON_FIELDS.has(key) && value !== null ? JSON.stringify(value) : value)),
+        };
+    };
+    return {
+        async insert(job) {
+            const { names, values } = toColumns(job);
+            const placeholders = values.map((_, i) => `$${i + 2}`);
+            const { rows } = await pool.query(`INSERT INTO ${table} (id, ${names.join(', ')}) VALUES ($1, ${placeholders.join(', ')}) RETURNING *`, [job.jobId, ...values]);
+            return fromRow(rows[0]);
+        },
+        async get(jobId) {
+            const { rows } = await pool.query(`SELECT * FROM ${table} WHERE id = $1`, [jobId]);
+            return fromRow(rows[0]);
+        },
+        async list({ projectId, assetId, limit = 100 }) {
+            const { rows } = await pool.query(`SELECT * FROM ${table} WHERE "projectId" = $1 ${assetId ? 'AND "assetId" = $3' : ''} ORDER BY "createdAt" DESC LIMIT $2`, assetId ? [projectId, limit, assetId] : [projectId, limit]);
+            return rows.map(row => fromRow(row));
+        },
+        async update(jobId, patch) {
+            return this.claim(jobId, [], patch);
+        },
+        async claim(jobId, statuses, patch, only = {}) {
+            const { names, values } = toColumns(patch);
+            const sets = names.map((name, i) => `${name} = $${i + 2}`).join(', ');
+            const params = [jobId, ...values];
+            let where = 'id = $1';
+            if (statuses.length) {
+                params.push(statuses);
+                where += ` AND status = ANY($${params.length})`;
+            }
+            if (only.leaseEndedBy) {
+                params.push(only.leaseEndedBy);
+                where += ` AND ("leaseUntil" IS NULL OR "leaseUntil" <= $${params.length})`;
+            }
+            if (only.callbackHash) {
+                params.push(only.callbackHash);
+                where += ` AND "callbackHash" = $${params.length}`;
+            }
+            const { rows } = await pool.query(`UPDATE ${table} SET ${sets} WHERE ${where} RETURNING *`, params);
+            return fromRow(rows[0]);
+        },
+        async due(now, limit) {
+            const { rows } = await pool.query(`SELECT * FROM ${table}
+          WHERE worker IS NOT NULL AND (
+            (status = 'pending' AND ("nextAttemptAt" IS NULL OR "nextAttemptAt" <= $1))
+            OR (status = 'processing' AND "leaseUntil" <= $1))
+          ORDER BY "createdAt" LIMIT $2`, [now, limit]);
+            return rows.map(row => fromRow(row));
+        },
+        async deleteProject(projectId) {
+            await pool.query(`DELETE FROM ${table} WHERE "projectId" = $1`, [projectId]);
+        },
+    };
+};
+// ── MongoDB ──
+const mongoStore = (client) => {
+    const col = () => client.db().collection('jobs');
+    const fromDoc = (doc) => {
+        if (!doc)
+            return null;
+        const { _id, ...job } = doc;
+        return job;
+    };
+    const clean = (patch) => Object.fromEntries(Object.entries(patch).filter(([, value]) => value !== undefined));
+    return {
+        async insert(job) {
+            await col().insertOne({ ...clean(job) });
+            return job;
+        },
+        async get(jobId) {
+            return fromDoc(await col().findOne({ jobId }));
+        },
+        async list({ projectId, assetId, limit = 100 }) {
+            const docs = await col().find({ projectId, ...(assetId ? { assetId } : {}) }).sort({ createdAt: -1 }).limit(limit).toArray();
+            return docs.map(doc => fromDoc(doc));
+        },
+        async update(jobId, patch) {
+            return this.claim(jobId, [], patch);
+        },
+        async claim(jobId, statuses, patch, only = {}) {
+            const filter = { jobId };
+            if (statuses.length)
+                filter.status = { $in: statuses };
+            if (only.leaseEndedBy)
+                filter.$or = [{ leaseUntil: null }, { leaseUntil: { $exists: false } }, { leaseUntil: { $lte: only.leaseEndedBy } }];
+            if (only.callbackHash)
+                filter.callbackHash = only.callbackHash;
+            return fromDoc(await col().findOneAndUpdate(filter, { $set: clean(patch) }, { returnDocument: 'after' }));
+        },
+        async due(now, limit) {
+            const docs = await col().find({
+                worker: { $ne: null },
+                $or: [
+                    { status: 'pending', $or: [{ nextAttemptAt: null }, { nextAttemptAt: { $lte: now } }] },
+                    { status: 'processing', leaseUntil: { $lte: now } },
+                ],
+            }).sort({ createdAt: 1 }).limit(limit).toArray();
+            return docs.map(doc => fromDoc(doc));
+        },
+        async deleteProject(projectId) {
+            await col().deleteMany({ projectId });
+        },
+    };
+};
+// ── In memory (no main database) ──
+const memoryStore = () => {
+    const jobs = new Map();
+    const copy = (job) => (job ? { ...job } : null);
+    return {
+        async insert(job) { jobs.set(job.jobId, { ...job }); return { ...job }; },
+        async get(jobId) { return copy(jobs.get(jobId)); },
+        async list({ projectId, assetId, limit = 100 }) {
+            return [...jobs.values()]
+                .filter(job => job.projectId === projectId && (!assetId || job.assetId === assetId))
+                .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
+                .slice(0, limit)
+                .map(job => ({ ...job }));
+        },
+        async update(jobId, patch) { return this.claim(jobId, [], patch); },
+        async claim(jobId, statuses, patch, only = {}) {
+            const job = jobs.get(jobId);
+            if (!job || (statuses.length && !statuses.includes(job.status)))
+                return null;
+            if (only.leaseEndedBy && job.leaseUntil && new Date(job.leaseUntil) > only.leaseEndedBy)
+                return null;
+            if (only.callbackHash && job.callbackHash !== only.callbackHash)
+                return null;
+            Object.assign(job, Object.fromEntries(Object.entries(patch).filter(([, value]) => value !== undefined)));
+            return { ...job };
+        },
+        async due(now, limit) {
+            return [...jobs.values()]
+                .filter(job => job.worker && ((job.status === 'pending' && (!job.nextAttemptAt || new Date(job.nextAttemptAt) <= now))
+                || (job.status === 'processing' && job.leaseUntil && new Date(job.leaseUntil) <= now)))
+                .slice(0, limit)
+                .map(job => ({ ...job }));
+        },
+        async deleteProject(projectId) {
+            for (const [id, job] of jobs)
+                if (job.projectId === projectId)
+                    jobs.delete(id);
+        },
+    };
+};
+let mainDbId;
+let memory;
+/** The router's main database, where jobs are kept. */
+const setJobStoreDatabase = (config) => {
+    mainDbId = config.databases?.find(db => db.main)?.id;
+};
+exports.setJobStoreDatabase = setJobStoreDatabase;
+function jobStore() {
+    if (mainDbId && (0, connectionManager_1.getConnectedIds)().includes(mainDbId)) {
+        const entry = (0, connectionManager_1.getConnection)(mainDbId);
+        return entry.type === 'sql' ? sqlStore(entry.client) : mongoStore(entry.client);
+    }
+    return (memory ?? (memory = memoryStore()));
+}

package/dist/services/mediaProcessor.js

@@ -45,7 +45,7 @@ function inferMetadata(contentType, size) {
     return meta;
 }
 async function runIngestJob(jobId, fileId, projectId) {
-    (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10 });
+    await (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10 });
     try {
         const filesCol = getFilesCollection();
         if (!filesCol)
@@ -53,7 +53,7 @@ async function runIngestJob(jobId, fileId, projectId) {
         const fileDoc = await filesCol.findOne({ fileId, projectId });
         if (!fileDoc)
             throw new Error(`File ${fileId} not found in project ${projectId}`);
-        (0, jobQueue_1.updateJob)(jobId, { stage: 'extracting-metadata', progress: 40, assetId: fileId });
+        await (0, jobQueue_1.updateJob)(jobId, { stage: 'extracting-metadata', progress: 40, assetId: fileId });
         const metaCol = getMetadataCollection();
         if (metaCol) {
             const meta = inferMetadata(fileDoc.contentType ?? '', fileDoc.size ?? 0);
@@ -67,7 +67,7 @@ async function runIngestJob(jobId, fileId, projectId) {
                 },
             }, { upsert: true });
         }
-        (0, jobQueue_1.updateJob)(jobId, { stage: 'creating-version', progress: 70 });
+        await (0, jobQueue_1.updateJob)(jobId, { stage: 'creating-version', progress: 70 });
         const versionsCol = getVersionsCollection();
         // Its upload already recorded the version it's in; only an asset from before versions
         // were kept gets one here.
@@ -85,14 +85,14 @@ async function runIngestJob(jobId, fileId, projectId) {
                 createdAt: new Date(),
             });
         }
-        (0, jobQueue_1.updateJob)(jobId, { status: 'completed', stage: 'complete', progress: 100 });
+        await (0, jobQueue_1.updateJob)(jobId, { status: 'completed', stage: 'complete', progress: 100 });
     }
     catch (err) {
-        (0, jobQueue_1.failJob)(jobId, err.message);
+        await (0, jobQueue_1.failJob)(jobId, err.message);
     }
 }
 async function runTranscodeJob(jobId, fileId, projectId, options, _adapter) {
-    (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'queued', progress: 5, assetId: fileId });
+    await (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'queued', progress: 5, assetId: fileId });
     try {
         const filesCol = getFilesCollection();
         if (!filesCol)
@@ -103,7 +103,7 @@ async function runTranscodeJob(jobId, fileId, projectId, options, _adapter) {
         if (!fileDoc.contentType?.startsWith('video/') && !fileDoc.contentType?.startsWith('audio/')) {
             throw new Error('Transcode only supports video and audio files');
         }
-        (0, jobQueue_1.updateJob)(jobId, { stage: 'transcoding', progress: 20 });
+        await (0, jobQueue_1.updateJob)(jobId, { stage: 'transcoding', progress: 20 });
         // Store the transcode request as a pending task — actual FFmpeg execution
         // happens in the host environment (Nhexa-API worker). The job record is the
         // handoff contract: the worker reads it, processes the file, and calls back
@@ -127,14 +127,14 @@ async function runTranscodeJob(jobId, fileId, projectId, options, _adapter) {
                 },
             }, { upsert: true });
         }
-        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 30 });
+        await (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 30 });
     }
     catch (err) {
-        (0, jobQueue_1.failJob)(jobId, err.message);
+        await (0, jobQueue_1.failJob)(jobId, err.message);
     }
 }
 async function runThumbnailJob(jobId, fileId, projectId, options) {
-    (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10, assetId: fileId });
+    await (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10, assetId: fileId });
     try {
         const filesCol = getFilesCollection();
         if (!filesCol)
@@ -142,7 +142,7 @@ async function runThumbnailJob(jobId, fileId, projectId, options) {
         const fileDoc = await filesCol.findOne({ fileId, projectId });
         if (!fileDoc)
             throw new Error(`File ${fileId} not found`);
-        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 30 });
+        await (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 30 });
         const metaCol = getMetadataCollection();
         if (metaCol) {
             await metaCol.updateOne({ assetId: fileId, projectId }, {
@@ -160,14 +160,14 @@ async function runThumbnailJob(jobId, fileId, projectId, options) {
                 },
             }, { upsert: true });
         }
-        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 40 });
+        await (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 40 });
     }
     catch (err) {
-        (0, jobQueue_1.failJob)(jobId, err.message);
+        await (0, jobQueue_1.failJob)(jobId, err.message);
     }
 }
 async function runCaptionJob(jobId, fileId, projectId, options) {
-    (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10, assetId: fileId });
+    await (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10, assetId: fileId });
     try {
         const filesCol = getFilesCollection();
         if (!filesCol)
@@ -195,9 +195,9 @@ async function runCaptionJob(jobId, fileId, projectId, options) {
                 },
             }, { upsert: true });
         }
-        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 30 });
+        await (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 30 });
     }
     catch (err) {
-        (0, jobQueue_1.failJob)(jobId, err.message);
+        await (0, jobQueue_1.failJob)(jobId, err.message);
     }
 }

package/dist/services/vfxProcessor.js

@@ -13,7 +13,7 @@ function getNosqlDb() {
     return (0, connectionManager_1.getConnection)(ids[0]).client.db();
 }
 async function runRenderJob(jobId, fileId, projectId, options) {
-    (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10, assetId: fileId });
+    await (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10, assetId: fileId });
     try {
         const db = getNosqlDb();
         if (!db)
@@ -21,7 +21,7 @@ async function runRenderJob(jobId, fileId, projectId, options) {
         const fileDoc = await db.collection('storage_files').findOne({ fileId, projectId });
         if (!fileDoc)
             throw new Error(`File ${fileId} not found`);
-        (0, jobQueue_1.updateJob)(jobId, { stage: 'queued-farm', progress: 20 });
+        await (0, jobQueue_1.updateJob)(jobId, { stage: 'queued-farm', progress: 20 });
         // Store pending render task — picked up by the host render farm worker
         await db.collection('media_metadata').updateOne({ assetId: fileId, projectId }, {
             $set: {
@@ -40,14 +40,14 @@ async function runRenderJob(jobId, fileId, projectId, options) {
                 extractedAt: new Date(),
             },
         }, { upsert: true });
-        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 30 });
+        await (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 30 });
     }
     catch (err) {
-        (0, jobQueue_1.failJob)(jobId, err.message);
+        await (0, jobQueue_1.failJob)(jobId, err.message);
     }
 }
 async function runFormatConvertJob(jobId, fileId, projectId, options) {
-    (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10, assetId: fileId });
+    await (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10, assetId: fileId });
     try {
         const db = getNosqlDb();
         if (!db)
@@ -55,7 +55,7 @@ async function runFormatConvertJob(jobId, fileId, projectId, options) {
         const fileDoc = await db.collection('storage_files').findOne({ fileId, projectId });
         if (!fileDoc)
             throw new Error(`File ${fileId} not found`);
-        (0, jobQueue_1.updateJob)(jobId, { stage: 'queued-convert', progress: 25 });
+        await (0, jobQueue_1.updateJob)(jobId, { stage: 'queued-convert', progress: 25 });
         await db.collection('media_metadata').updateOne({ assetId: fileId, projectId }, {
             $set: {
                 assetId: fileId,
@@ -71,14 +71,14 @@ async function runFormatConvertJob(jobId, fileId, projectId, options) {
                 extractedAt: new Date(),
             },
         }, { upsert: true });
-        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 35 });
+        await (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 35 });
     }
     catch (err) {
-        (0, jobQueue_1.failJob)(jobId, err.message);
+        await (0, jobQueue_1.failJob)(jobId, err.message);
     }
 }
 async function runLodJob(jobId, fileId, projectId, options) {
-    (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10, assetId: fileId });
+    await (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10, assetId: fileId });
     try {
         const db = getNosqlDb();
         if (!db)
@@ -86,7 +86,7 @@ async function runLodJob(jobId, fileId, projectId, options) {
         const fileDoc = await db.collection('storage_files').findOne({ fileId, projectId });
         if (!fileDoc)
             throw new Error(`File ${fileId} not found`);
-        (0, jobQueue_1.updateJob)(jobId, { stage: 'queued-lod', progress: 25 });
+        await (0, jobQueue_1.updateJob)(jobId, { stage: 'queued-lod', progress: 25 });
         await db.collection('media_metadata').updateOne({ assetId: fileId, projectId }, {
             $set: {
                 assetId: fileId,
@@ -102,10 +102,10 @@ async function runLodJob(jobId, fileId, projectId, options) {
                 extractedAt: new Date(),
             },
         }, { upsert: true });
-        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 30 });
+        await (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 30 });
     }
     catch (err) {
-        (0, jobQueue_1.failJob)(jobId, err.message);
+        await (0, jobQueue_1.failJob)(jobId, err.message);
     }
 }
 async function resolveAssetDependencyGraph(projectId, rootAssetId, maxDepth = 5) {

package/dist/services/workerJobs.d.ts

@@ -0,0 +1,73 @@
+import { Auth, JobRecord, StorageAdapter, StreamByConfig, WorkerRef, WorkerResultMode } from '../types';
+export declare const WORKER_CALLBACK_PATH = "/worker-jobs";
+type RouterConfig = StreamByConfig & {
+    adapter?: StorageAdapter;
+};
+export interface WorkerJobRequest {
+    assetId: unknown;
+    versionId?: unknown;
+    worker: unknown;
+    kind: unknown;
+    profile?: unknown;
+    resultMode?: unknown;
+}
+/** Asks a worker to process an asset, as `auth`: the job, pending, to be sent right away. */
+export declare function enqueueWorkerJob(project: any, request: WorkerJobRequest, auth: Auth, config: RouterConfig, callbackBase: string): Promise<JobRecord>;
+/** Runs the workers set to process, by themselves, an asset of their categories marked as a deliverable. */
+export declare function enqueueAutomaticJobs(project: any, assetId: string, versionId: string | null, auth: Auth, config: RouterConfig, callbackBase: string): Promise<JobRecord[]>;
+/** A failed worker job, back in line. */
+export declare function retryWorkerJob(jobId: string, config: RouterConfig): Promise<JobRecord | null>;
+/**
+ * Sends a pending job (or one its worker didn't finish in time) to its worker. Of several
+ * instances, only the one that claims it does.
+ */
+export declare function dispatchJob(jobId: string, config: RouterConfig): Promise<void>;
+/** Looks, now and then, for jobs to send (again). Every instance does; claiming keeps them from doubling. */
+export declare function startWorkerSweeper(config: RouterConfig): () => void;
+/** The job a callback is about, if its token is this attempt's and the job is in progress. */
+export declare function authorizeCallback(jobId: string, authorization: string | undefined): Promise<JobRecord>;
+export declare function reportProgress(job: JobRecord, body: any): Promise<JobRecord | null>;
+/** Where the worker uploads its result: a key of its own until the job completes. */
+export declare function resultUploadUrl(job: JobRecord, body: any, config: RouterConfig): Promise<{
+    url: string;
+    method: string;
+    headers: {
+        'Content-Type': any;
+    };
+    expiresAt: string;
+}>;
+/** The worker's result, kept: a new version of the asset, or a new asset derived from it. */
+export declare function completeJob(job: JobRecord, body: any, config: RouterConfig): Promise<JobRecord>;
+/** The worker couldn't do it: sent again if it says it may work later (and attempts are left), or failed. */
+export declare function failWorkerJob(job: JobRecord, body: any, config: RouterConfig): Promise<JobRecord | null>;
+/** What's shown of a job: never its callback token's hash, nor its upload's key. */
+export declare const publicJob: ({ callbackHash: _hash, upload: _upload, payload, ...job }: JobRecord) => {
+    payload: Record<string, any>;
+    jobId: string;
+    jobType: import("../types").JobType;
+    userId: string;
+    projectId: string;
+    assetId?: string;
+    status: import("../types").JobStatus;
+    stage: string;
+    progress: number;
+    error?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    worker?: WorkerRef | null;
+    kind?: string | null;
+    profile?: Record<string, unknown> | null;
+    versionId?: string | null;
+    resultMode?: WorkerResultMode | null;
+    attempts?: number;
+    maxAttempts?: number;
+    nextAttemptAt?: Date | null;
+    leaseUntil?: Date | null;
+    report?: Record<string, unknown> | null;
+    result?: {
+        assetId: string;
+        versionId: string;
+        mode: WorkerResultMode;
+    } | null;
+};
+export {};