streamby-core 0.39.0 → 0.41.0

package/dist/services/aiProcessor.js

@@ -13,7 +13,7 @@ function getNosqlDb() {
     return (0, connectionManager_1.getConnection)(ids[0]).client.db();
 }
 async function runTranscriptionJob(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)
@@ -24,7 +24,7 @@ async function runTranscriptionJob(jobId, fileId, projectId, options) {
         if (!fileDoc.contentType?.startsWith('video/') && !fileDoc.contentType?.startsWith('audio/')) {
             throw new Error('Transcription only supports video and audio files');
         }
-        (0, jobQueue_1.updateJob)(jobId, { stage: 'queued-provider', progress: 20 });
+        await (0, jobQueue_1.updateJob)(jobId, { stage: 'queued-provider', progress: 20 });
         await db.collection('media_metadata').updateOne({ assetId: fileId, projectId }, {
             $set: {
                 assetId: fileId,
@@ -41,14 +41,14 @@ async function runTranscriptionJob(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 runUpscaleJob(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)
@@ -56,7 +56,7 @@ async function runUpscaleJob(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-upscale', progress: 20 });
+        await (0, jobQueue_1.updateJob)(jobId, { stage: 'queued-upscale', progress: 20 });
         await db.collection('media_metadata').updateOne({ assetId: fileId, projectId }, {
             $set: {
                 assetId: fileId,
@@ -72,14 +72,14 @@ async function runUpscaleJob(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 runGenerateAssetJob(jobId, projectId, options) {
-    (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'queued-generation', progress: 10 });
+    await (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'queued-generation', progress: 10 });
     try {
         const db = getNosqlDb();
         if (!db)
@@ -95,10 +95,10 @@ async function runGenerateAssetJob(jobId, projectId, options) {
             status: 'pending',
             requestedAt: new Date(),
         });
-        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 20 });
+        await (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 20 });
     }
     catch (err) {
-        (0, jobQueue_1.failJob)(jobId, err.message);
+        await (0, jobQueue_1.failJob)(jobId, err.message);
     }
 }
 async function buildPipelineSuggestion(nodeSchema, availableNodeTypes) {

package/dist/services/apiTokenPermissions.js

@@ -74,10 +74,10 @@ const RULES = [
     // Rights.
     rule('read', `${P}/assets/[^/]+/rights`, 'rights:read'),
     rule(['PUT'], `${P}/assets/[^/]+/rights`, 'rights:write'),
-    // Connections (API, database, storage, distribution, render farm): the project's settings.
-    rule('read', `${P}/(connections|get-connection|distribution-connections|render-farm-connections)(/.+)?`, 'project:read'),
-    rule('write', `${P}/(connections|distribution-connections|render-farm-connections)(/.+)?`, 'project:update'),
-    rule('delete', `${P}/(connections|distribution-connections|render-farm-connections)/.+`, 'project:update'),
+    // Connections (API, database, storage, distribution, workers): the project's settings.
+    rule('read', `${P}/(connections|get-connection|distribution-connections|workers)(/.+)?`, 'project:read'),
+    rule('write', `${P}/(connections|distribution-connections|workers)(/.+)?`, 'project:update'),
+    rule('delete', `${P}/(connections|distribution-connections|workers)/.+`, 'project:update'),
     // Production.
     rule('read', `${P}/production/.+`, 'production:read'),
     rule('write', `${P}/production/.+`, 'production:write'),
@@ -92,7 +92,8 @@ const RULES = [
     rule(['POST'], `${P}/exports`, 'exports:write'),
     rule(['PATCH', 'DELETE'], `${P}/exports/[^/]+`, 'exports:write'),
     // Jobs: transcoding, rendering, AI, publishing a deliverable.
-    rule(['POST'], `${P}/(jobs/[^/]+|pipeline-suggest|deliverables/[^/]+/publish)`, 'jobs:run'),
+    rule('read', `${P}/jobs`, 'jobs:read'),
+    rule(['POST'], `${P}/(jobs/[^/]+(/retry)?|pipeline-suggest|deliverables/[^/]+/publish)`, 'jobs:run'),
 ];
 /** The rule for a request made with an API token, or undefined: not reachable with one. */
 function routeRuleFor(method, path) {

package/dist/services/auth.d.ts

@@ -6,5 +6,7 @@ export declare const isPublicRoute: (method: string, path: string) => boolean;
 export declare const scopeReachesProject: (scope: Auth["apiToken"], projectId: string) => boolean;
 /** Whether a token has a permission (a request without a token: always). */
 export declare const tokenAllows: (scope: Auth["apiToken"], permission: ApiTokenPermission) => boolean;
+/** Whether an app (an OAuth request) may make this request's method on its path. */
+export declare const oauthMayDelete: (method: string, path: string) => boolean;
 export declare const enforceApiTokenScope: (req: Request, res: Response, next: NextFunction) => void | Response<any, Record<string, any>>;
 export declare const authenticate: (config: StreamByConfig) => (req: Request, res: Response, next: NextFunction) => Promise<void | Response<any, Record<string, any>>>;

package/dist/services/auth.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.authenticate = exports.enforceApiTokenScope = exports.tokenAllows = exports.scopeReachesProject = exports.isPublicRoute = void 0;
+exports.authenticate = exports.enforceApiTokenScope = exports.oauthMayDelete = exports.tokenAllows = exports.scopeReachesProject = exports.isPublicRoute = void 0;
 const auth_1 = require("../utils/auth");
 const apiTokenPermissions_1 = require("./apiTokenPermissions");
+const oauthTokens_1 = require("./oauthTokens");
 // The one route open without a session: a project's public export, read
 // (GET /:projectId/export/:exportName, see routes/export). Exactly that path -- not any path
 // that has an "export" segment somewhere.
@@ -33,13 +34,29 @@ exports.scopeReachesProject = scopeReachesProject;
 /** Whether a token has a permission (a request without a token: always). */
 const tokenAllows = (scope, permission) => !scope || scope.permissions.includes(permission);
 exports.tokenAllows = tokenAllows;
+// ── OAuth apps ──
+// An app the user signed in to was approved to make and change things, never to delete them:
+// its permissions come from its scopes, and some of those (project:update, workflow:write,
+// exports:write) also reach routes that delete (a connection, a worker, an integration, a
+// pipeline, an export). So an app's DELETE is refused, whatever its route's permission.
+// The one DELETE it may make is taking a deliverable's mark off: that forgets the mark only
+// (the asset, its versions and its files stay, and it can be marked again), and it's the
+// counterpart of marking one, which assets:write already allows.
+const OAUTH_DELETE_ALLOWED = new RegExp(`^/projects/[^/]+/deliverables/[^/]+/?$`);
+/** Whether an app (an OAuth request) may make this request's method on its path. */
+const oauthMayDelete = (method, path) => method.toUpperCase() !== 'DELETE' || OAUTH_DELETE_ALLOWED.test(path);
+exports.oauthMayDelete = oauthMayDelete;
 const enforceApiTokenScope = (req, res, next) => {
-    const scope = req.auth?.apiToken;
+    const auth = req.auth;
+    const scope = auth?.apiToken;
     if (!scope)
         return next();
     // The MCP server handles a token itself: its tools call the routes here, each one checked.
     if (req.path === '/mcp')
         return next();
+    if (auth?.oauth && !(0, exports.oauthMayDelete)(req.method, req.path)) {
+        return res.status(403).json({ error: 'An app connected with OAuth can\'t delete' });
+    }
     const rule = (0, apiTokenPermissions_1.routeRuleFor)(req.method, req.path);
     if (!rule || (rule.userTokenOnly && scope.kind !== 'user')) {
         return res.status(403).json({ error: 'Not available with an API token' });
@@ -53,25 +70,34 @@ const enforceApiTokenScope = (req, res, next) => {
     next();
 };
 exports.enforceApiTokenScope = enforceApiTokenScope;
+const hasBearer = (req) => /^Bearer\s+\S/i.test(req.headers.authorization ?? '');
 const authenticate = (config) => async (req, res, next) => {
     if ((0, exports.isPublicRoute)(req.method, req.path)) {
         return next();
     }
+    // A client without a valid token is told where to sign in (RFC 9728), when StreamBy is set
+    // up as an OAuth resource.
+    const unauthorized = () => {
+        if (config.oauth)
+            res.setHeader('WWW-Authenticate', (0, oauthTokens_1.wwwAuthenticate)(config.oauth, hasBearer(req)));
+        return res.status(401).json({ error: 'Unauthorized' });
+    };
     try {
         const auth = await config.authProvider(req);
-        if (!auth || !auth.userId || !auth.role) {
-            return res.status(401).json({ error: 'Unauthorized' });
-        }
+        if (!auth || !auth.userId || !auth.role)
+            return unauthorized();
         // A project token's principal is only ever a project's token (see utils/auth).
-        if ((0, auth_1.isProjectTokenPrincipal)(auth.userId) && auth.apiToken?.kind !== 'project') {
-            return res.status(401).json({ error: 'Unauthorized' });
-        }
+        if ((0, auth_1.isProjectTokenPrincipal)(auth.userId) && auth.apiToken?.kind !== 'project')
+            return unauthorized();
+        // An app acting for the user reaches only what its scopes grant: never without them.
+        if (auth.oauth && auth.apiToken?.kind !== 'user')
+            return unauthorized();
         req.auth = auth;
         next();
     }
     catch (error) {
-        console.error('Authentication failed:', error);
-        return res.status(401).json({ error: 'Unauthorized' });
+        console.error('Authentication failed:', error instanceof Error ? error.message : error);
+        return unauthorized();
     }
 };
 exports.authenticate = authenticate;

package/dist/services/executor.js

@@ -216,7 +216,7 @@ async function executeExport(nodeSchema, project, config, { public: isPublic = t
         if (isPublic && JOB_NODES.has(processNode.type))
             throw notPublic(processNode);
         if (processNode.type === 'transcodeNode' && fileId) {
-            const job = (0, jobQueue_1.createJob)('transcode', systemUserId, projectId, nodeData);
+            const job = await (0, jobQueue_1.createJob)('transcode', systemUserId, projectId, nodeData);
             setImmediate(() => (0, mediaProcessor_1.runTranscodeJob)(job.jobId, fileId, projectId, {
                 codec: nodeData.codec,
                 resolution: nodeData.resolution,
@@ -227,7 +227,7 @@ async function executeExport(nodeSchema, project, config, { public: isPublic = t
             payload = { ...payload, jobId: job.jobId, jobType: 'transcode' };
         }
         else if (processNode.type === 'captionNode' && fileId) {
-            const job = (0, jobQueue_1.createJob)('caption', systemUserId, projectId, nodeData);
+            const job = await (0, jobQueue_1.createJob)('caption', systemUserId, projectId, nodeData);
             setImmediate(() => (0, mediaProcessor_1.runCaptionJob)(job.jobId, fileId, projectId, {
                 sourceLanguage: nodeData.sourceLanguage,
                 outputFormat: nodeData.outputFormat,
@@ -236,7 +236,7 @@ async function executeExport(nodeSchema, project, config, { public: isPublic = t
             payload = { ...payload, jobId: job.jobId, jobType: 'caption' };
         }
         else if (processNode.type === 'thumbnailNode' && fileId) {
-            const job = (0, jobQueue_1.createJob)('thumbnail', systemUserId, projectId, nodeData);
+            const job = await (0, jobQueue_1.createJob)('thumbnail', systemUserId, projectId, nodeData);
             setImmediate(() => (0, mediaProcessor_1.runThumbnailJob)(job.jobId, fileId, projectId, {
                 timecode: nodeData.timecode,
                 resolution: nodeData.resolution,
@@ -256,12 +256,12 @@ async function executeExport(nodeSchema, project, config, { public: isPublic = t
             if ('error' in storageResolved) {
                 throw new NodeExecutionError(processNode.id, processNode.type, `Node '${processNode.id}' (${processNode.type}): ${storageResolved.error}`);
             }
-            const job = (0, jobQueue_1.createJob)('ingest', systemUserId, projectId, nodeData);
+            const job = await (0, jobQueue_1.createJob)('ingest', systemUserId, projectId, nodeData);
             setImmediate(() => (0, mediaProcessor_1.runIngestJob)(job.jobId, fileId, projectId));
             payload = { ...payload, jobId: job.jobId, jobType: 'ingest' };
         }
         else if (processNode.type === 'renderJobNode' && fileId) {
-            const job = (0, jobQueue_1.createJob)('render', systemUserId, projectId, nodeData);
+            const job = await (0, jobQueue_1.createJob)('render', systemUserId, projectId, nodeData);
             setImmediate(() => (0, vfxProcessor_1.runRenderJob)(job.jobId, fileId, projectId, {
                 renderer: nodeData.renderer,
                 renderFarmConnectionId: nodeData.renderFarmConnectionId,
@@ -273,7 +273,7 @@ async function executeExport(nodeSchema, project, config, { public: isPublic = t
             payload = { ...payload, jobId: job.jobId, jobType: 'render' };
         }
         else if (processNode.type === 'formatConvertNode' && fileId) {
-            const job = (0, jobQueue_1.createJob)('format-convert', systemUserId, projectId, nodeData);
+            const job = await (0, jobQueue_1.createJob)('format-convert', systemUserId, projectId, nodeData);
             setImmediate(() => (0, vfxProcessor_1.runFormatConvertJob)(job.jobId, fileId, projectId, {
                 inputFormat: nodeData.inputFormat,
                 outputFormat: nodeData.outputFormat,
@@ -283,7 +283,7 @@ async function executeExport(nodeSchema, project, config, { public: isPublic = t
             payload = { ...payload, jobId: job.jobId, jobType: 'format-convert' };
         }
         else if (processNode.type === 'lodNode' && fileId) {
-            const job = (0, jobQueue_1.createJob)('lod', systemUserId, projectId, nodeData);
+            const job = await (0, jobQueue_1.createJob)('lod', systemUserId, projectId, nodeData);
             setImmediate(() => (0, vfxProcessor_1.runLodJob)(job.jobId, fileId, projectId, {
                 levels: nodeData.levels,
                 reductionRatios: nodeData.reductionRatios,
@@ -300,7 +300,7 @@ async function executeExport(nodeSchema, project, config, { public: isPublic = t
             payload = { ...payload, qcReport: { checks: checkResults, overallPassed: true } };
         }
         else if (processNode.type === 'transcriptionNode' && fileId) {
-            const job = (0, jobQueue_1.createJob)('transcription', systemUserId, projectId, nodeData);
+            const job = await (0, jobQueue_1.createJob)('transcription', systemUserId, projectId, nodeData);
             setImmediate(() => (0, aiProcessor_1.runTranscriptionJob)(job.jobId, fileId, projectId, {
                 model: nodeData.model,
                 sourceLanguage: nodeData.sourceLanguage,
@@ -311,7 +311,7 @@ async function executeExport(nodeSchema, project, config, { public: isPublic = t
             payload = { ...payload, jobId: job.jobId, jobType: 'transcription' };
         }
         else if (processNode.type === 'upscaleNode' && fileId) {
-            const job = (0, jobQueue_1.createJob)('upscale', systemUserId, projectId, nodeData);
+            const job = await (0, jobQueue_1.createJob)('upscale', systemUserId, projectId, nodeData);
             setImmediate(() => (0, aiProcessor_1.runUpscaleJob)(job.jobId, fileId, projectId, {
                 scale: nodeData.scale,
                 model: nodeData.model,
@@ -321,7 +321,7 @@ async function executeExport(nodeSchema, project, config, { public: isPublic = t
             payload = { ...payload, jobId: job.jobId, jobType: 'upscale' };
         }
         else if (processNode.type === 'proceduralAssetNode') {
-            const job = (0, jobQueue_1.createJob)('generate-asset', systemUserId, projectId, nodeData);
+            const job = await (0, jobQueue_1.createJob)('generate-asset', systemUserId, projectId, nodeData);
             setImmediate(() => (0, aiProcessor_1.runGenerateAssetJob)(job.jobId, projectId, {
                 assetType: nodeData.assetType,
                 provider: nodeData.provider,

package/dist/services/jobQueue.d.ts

@@ -1,5 +1,7 @@
 import { JobRecord, JobType } from '../types';
-export declare function createJob(jobType: JobType, userId: string, projectId: string, payload: Record<string, any>): JobRecord;
-export declare function getJob(jobId: string): JobRecord | undefined;
-export declare function updateJob(jobId: string, updates: Partial<Pick<JobRecord, 'status' | 'stage' | 'progress' | 'assetId' | 'error'>>): void;
-export declare function failJob(jobId: string, error: string): void;
+export declare function createJob(jobType: JobType, userId: string, projectId: string, payload: Record<string, any>, extra?: Partial<JobRecord>): Promise<JobRecord>;
+export declare function getJob(jobId: string): Promise<JobRecord | null>;
+export declare function listJobs(projectId: string, assetId?: string): Promise<JobRecord[]>;
+export declare function notify(job: JobRecord): void;
+export declare function updateJob(jobId: string, updates: Partial<JobRecord>): Promise<JobRecord | null>;
+export declare function failJob(jobId: string, error: string): Promise<JobRecord | null>;

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()));
+}