streamby-core 0.28.5 → 0.29.0

package/dist/middleware/routes/renderFarm.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderFarmRouter = renderFarmRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const jobQueue_1 = require("../../services/jobQueue");
+const vfxProcessor_1 = require("../../services/vfxProcessor");
+const crypto_1 = __importDefault(require("crypto"));
+function renderFarmRouter(_config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // ─── Render Farm Connections ─────────────────────────────────────────────────
+    router.get('/projects/:projectId/render-farm-connections', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            res.json({ connections: project.renderFarmConnections ?? [] });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/render-farm-connections', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { name, provider, apiUrl, credentialId, description } = req.body;
+            if (!name || !provider || !apiUrl) {
+                return res.status(400).json({ message: 'name, provider and apiUrl are required' });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const connection = {
+                id: crypto_1.default.randomUUID(),
+                name,
+                provider,
+                apiUrl,
+                credentialId,
+                description,
+                projectId,
+                createdAt: new Date(),
+            };
+            await Project.update({ _id: projectId }, { $push: { renderFarmConnections: connection } });
+            res.status(201).json({ connection });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.delete('/projects/:projectId/render-farm-connections/:connectionId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connectionId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            await Project.update({ _id: projectId }, { $pull: { renderFarmConnections: { id: connectionId } } });
+            res.json({ message: 'Connection deleted' });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // ─── VFX Jobs ────────────────────────────────────────────────────────────────
+    router.post('/projects/:projectId/jobs/render', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, renderer, renderFarmConnectionId, frameRange, resolution, samples, outputFormat } = req.body;
+            if (!fileId)
+                return res.status(400).json({ message: 'fileId is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('render', auth.userId, projectId, { fileId, renderer, renderFarmConnectionId, frameRange, resolution, samples, outputFormat });
+            setImmediate(() => (0, vfxProcessor_1.runRenderJob)(job.jobId, fileId, projectId, { renderer, renderFarmConnectionId, frameRange, resolution, samples, outputFormat }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/jobs/format-convert', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, inputFormat, outputFormat, applyTransforms, embedTextures } = req.body;
+            if (!fileId)
+                return res.status(400).json({ message: 'fileId is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('format-convert', auth.userId, projectId, { fileId, inputFormat, outputFormat, applyTransforms, embedTextures });
+            setImmediate(() => (0, vfxProcessor_1.runFormatConvertJob)(job.jobId, fileId, projectId, { inputFormat, outputFormat, applyTransforms, embedTextures }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/jobs/lod', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, levels, reductionRatios, algorithm, outputFormat } = req.body;
+            if (!fileId)
+                return res.status(400).json({ message: 'fileId is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('lod', auth.userId, projectId, { fileId, levels, reductionRatios, algorithm, outputFormat });
+            setImmediate(() => (0, vfxProcessor_1.runLodJob)(job.jobId, fileId, projectId, { levels, reductionRatios, algorithm, outputFormat }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // ─── Asset Dependency Graph ──────────────────────────────────────────────────
+    router.get('/projects/:projectId/assets/:fileId/dependency-graph', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, fileId } = req.params;
+            const maxDepth = Number(req.query.maxDepth ?? 5);
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const graph = await (0, vfxProcessor_1.resolveAssetDependencyGraph)(projectId, fileId, maxDepth);
+            res.json({ graph });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}

package/dist/middleware/routes/review.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import { StreamByConfig } from '../../types';
+export declare function reviewRouter(_config: StreamByConfig): Router;

package/dist/middleware/routes/review.js

@@ -0,0 +1,240 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reviewRouter = reviewRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const wsHub_1 = require("../../services/wsHub");
+const connectionManager_1 = require("../../adapters/database/connectionManager");
+const crypto_1 = __importDefault(require("crypto"));
+function getDb() {
+    const ids = (0, connectionManager_1.getConnectedIds)().filter(id => (0, connectionManager_1.getConnection)(id).type === 'nosql');
+    if (!ids.length)
+        return null;
+    return (0, connectionManager_1.getConnection)(ids[0]).client.db();
+}
+function broadcastReviewUpdate(review, project) {
+    const members = project.members ?? [];
+    for (const m of members) {
+        (0, wsHub_1.emitToUser)(m.userId, { type: 'reviewEvent', data: review });
+    }
+}
+function reviewRouter(_config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // GET /projects/:projectId/reviews
+    router.get('/projects/:projectId/reviews', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const reviews = await db.collection('review_sessions')
+                .find({ projectId })
+                .sort({ createdAt: -1 })
+                .toArray();
+            res.json({ reviews });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/reviews
+    router.post('/projects/:projectId/reviews', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { assetId, assetVersionId, requiredApprovers, deadline } = req.body;
+            if (!assetId || !assetVersionId) {
+                return res.status(400).json({ message: 'assetId and assetVersionId are required' });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const now = new Date();
+            const review = {
+                id: crypto_1.default.randomUUID(),
+                projectId,
+                assetId,
+                assetVersionId,
+                status: 'open',
+                requiredApprovers: requiredApprovers ?? 1,
+                approvals: [],
+                deadline: deadline ? new Date(deadline) : undefined,
+                createdAt: now,
+                updatedAt: now,
+            };
+            await db.collection('review_sessions').insertOne({ ...review });
+            broadcastReviewUpdate(review, project);
+            res.status(201).json({ review });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // GET /projects/:projectId/reviews/:reviewId
+    router.get('/projects/:projectId/reviews/:reviewId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, reviewId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const review = await db.collection('review_sessions').findOne({ id: reviewId, projectId });
+            if (!review)
+                return res.status(404).json({ message: 'Review not found' });
+            res.json({ review });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/reviews/:reviewId/decision
+    router.post('/projects/:projectId/reviews/:reviewId/decision', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, reviewId } = req.params;
+            const { decision, comment } = req.body;
+            if (decision !== 'approve' && decision !== 'reject') {
+                return res.status(400).json({ message: 'decision must be approve or reject' });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const col = db.collection('review_sessions');
+            const review = await col.findOne({ id: reviewId, projectId });
+            if (!review)
+                return res.status(404).json({ message: 'Review not found' });
+            if (review.status !== 'open')
+                return res.status(409).json({ message: `Review is already ${review.status}` });
+            // Remove any prior decision from this user, then add the new one
+            const approvals = (review.approvals ?? []).filter(a => a.userId !== auth.userId);
+            approvals.push({
+                userId: auth.userId,
+                username: auth.username ?? auth.userId,
+                decision,
+                comment,
+                at: new Date(),
+            });
+            const approveCount = approvals.filter(a => a.decision === 'approve').length;
+            const hasRejection = approvals.some(a => a.decision === 'reject');
+            let status = 'open';
+            if (hasRejection)
+                status = 'rejected';
+            else if (approveCount >= review.requiredApprovers)
+                status = 'approved';
+            const updatedAt = new Date();
+            await col.updateOne({ id: reviewId, projectId }, { $set: { approvals, status, updatedAt } });
+            const updated = { ...review, approvals, status, updatedAt };
+            broadcastReviewUpdate(updated, project);
+            res.json({ review: updated });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // ─── Annotations ─────────────────────────────────────────────────────────────
+    router.get('/projects/:projectId/assets/:assetId/versions/:versionId/annotations', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, assetId, versionId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const annotations = await db.collection('annotations')
+                .find({ assetId, assetVersionId: versionId, projectId })
+                .sort({ createdAt: 1 })
+                .toArray();
+            res.json({ annotations });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/assets/:assetId/versions/:versionId/annotations', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, assetId, versionId } = req.params;
+            const { type, timecode, position3d, regionRect, text } = req.body;
+            if (!type || !text)
+                return res.status(400).json({ message: 'type and text are required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const annotation = {
+                id: crypto_1.default.randomUUID(),
+                assetId,
+                assetVersionId: versionId,
+                projectId,
+                authorId: auth.userId,
+                authorUsername: auth.username ?? auth.userId,
+                type,
+                timecode,
+                position3d,
+                regionRect,
+                text,
+                resolved: false,
+                createdAt: new Date(),
+            };
+            await db.collection('annotations').insertOne({ ...annotation });
+            res.status(201).json({ annotation });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.patch('/projects/:projectId/assets/:assetId/versions/:versionId/annotations/:annotationId/resolve', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, assetId, versionId, annotationId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            await db.collection('annotations').updateOne({ id: annotationId, assetId, assetVersionId: versionId, projectId }, { $set: { resolved: true, resolvedBy: auth.userId } });
+            res.json({ message: 'Annotation resolved' });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}

package/dist/middleware/routes/rights.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import { StreamByConfig } from '../../types';
+export declare function rightsRouter(_config: StreamByConfig): Router;

package/dist/middleware/routes/rights.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rightsRouter = rightsRouter;
+const express_1 = require("express");
+const auth_1 = require("../../utils/auth");
+const connectionManager_1 = require("../../adapters/database/connectionManager");
+const manager_1 = require("../../models/manager");
+function getDb() {
+    const ids = (0, connectionManager_1.getConnectedIds)().filter(id => (0, connectionManager_1.getConnection)(id).type === 'nosql');
+    if (!ids.length)
+        return null;
+    return (0, connectionManager_1.getConnection)(ids[0]).client.db();
+}
+function rightsRouter(_config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // GET /projects/:projectId/assets/:assetId/rights
+    router.get('/projects/:projectId/assets/:assetId/rights', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, assetId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const rights = await db.collection('asset_rights').findOne({ assetId, projectId });
+            res.json({ rights: rights ?? null });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // PUT /projects/:projectId/assets/:assetId/rights  (upsert)
+    router.put('/projects/:projectId/assets/:assetId/rights', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, assetId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const { rightsHolder, licenseType, licenseUrl, territory, expiresAt, usageRestrictions, notes } = req.body;
+            const now = new Date();
+            const payload = {
+                assetId,
+                projectId,
+                licenseType: licenseType ?? 'unknown',
+                updatedBy: auth.userId,
+                updatedAt: now,
+            };
+            if (rightsHolder !== undefined)
+                payload.rightsHolder = rightsHolder;
+            if (licenseUrl !== undefined)
+                payload.licenseUrl = licenseUrl;
+            if (territory !== undefined)
+                payload.territory = territory;
+            if (expiresAt !== undefined)
+                payload.expiresAt = expiresAt ? new Date(expiresAt) : null;
+            if (usageRestrictions !== undefined)
+                payload.usageRestrictions = usageRestrictions;
+            if (notes !== undefined)
+                payload.notes = notes;
+            await db.collection('asset_rights').updateOne({ assetId, projectId }, { $set: payload }, { upsert: true });
+            const rights = await db.collection('asset_rights').findOne({ assetId, projectId });
+            res.json({ rights });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}

package/dist/models/Model.js

@@ -45,11 +45,11 @@ class Model {
                     // Handle members filter for SQL projects
                     const userId = processedFilter.members.$elemMatch.userId;
                     const schema = this.schema || 'streamby'; // Default to 'streamby' if schema not provided
-                    const query = `
-            SELECT p.*, pm."userId" as memberUserId, pm.role as memberRole, pm.status as memberStatus, pm.archived as memberArchived
-            FROM "${schema}"."projects" p
-            JOIN "${schema}"."project_members" pm ON p.id = pm."projectId"
-            WHERE pm."userId" = $1
+                    const query = `
+            SELECT p.*, pm."userId" as memberUserId, pm.role as memberRole, pm.status as memberStatus, pm.archived as memberArchived
+            FROM "${schema}"."projects" p
+            JOIN "${schema}"."project_members" pm ON p.id = pm."projectId"
+            WHERE pm."userId" = $1
           `;
                     const result = await connection.query(query, [userId]);
                     sqlResults = result.rows.map(row => ({
@@ -219,10 +219,10 @@ class Model {
         else {
             const matchKey = value.id !== undefined ? 'id' : Object.keys(value)[0];
             const matchVal = String(value[matchKey]);
-            await connection.query(`UPDATE ${tbl} SET "${field}" = (
-          SELECT COALESCE(jsonb_agg(elem), '[]'::jsonb)
-          FROM jsonb_array_elements("${field}") elem
-          WHERE elem->>'${matchKey}' != $1
+            await connection.query(`UPDATE ${tbl} SET "${field}" = (
+          SELECT COALESCE(jsonb_agg(elem), '[]'::jsonb)
+          FROM jsonb_array_elements("${field}") elem
+          WHERE elem->>'${matchKey}' != $1
         ) WHERE id = $2`, [matchVal, id]);
         }
     }

package/dist/services/aiProcessor.d.ts

@@ -0,0 +1,25 @@
+import { PipelineSuggestion } from '../types';
+export declare function runTranscriptionJob(jobId: string, fileId: string, projectId: string, options: {
+    model?: string;
+    sourceLanguage?: string;
+    outputFormats?: string[];
+    provider?: string;
+    credentialId?: string;
+}): Promise<void>;
+export declare function runUpscaleJob(jobId: string, fileId: string, projectId: string, options: {
+    scale?: number;
+    model?: string;
+    mode?: 'images' | 'video';
+    credentialId?: string;
+}): Promise<void>;
+export declare function runGenerateAssetJob(jobId: string, projectId: string, options: {
+    assetType?: 'mesh' | 'texture' | 'audio';
+    provider?: string;
+    prompt: string;
+    seed?: number;
+    credentialId?: string;
+}): Promise<void>;
+export declare function buildPipelineSuggestion(nodeSchema: {
+    nodes: any[];
+    edges: any[];
+}, availableNodeTypes: string[]): Promise<PipelineSuggestion>;

package/dist/services/aiProcessor.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTranscriptionJob = runTranscriptionJob;
+exports.runUpscaleJob = runUpscaleJob;
+exports.runGenerateAssetJob = runGenerateAssetJob;
+exports.buildPipelineSuggestion = buildPipelineSuggestion;
+const connectionManager_1 = require("../adapters/database/connectionManager");
+const jobQueue_1 = require("./jobQueue");
+function getNosqlDb() {
+    const ids = (0, connectionManager_1.getConnectedIds)().filter(id => (0, connectionManager_1.getConnection)(id).type === 'nosql');
+    if (!ids.length)
+        return null;
+    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 });
+    try {
+        const db = getNosqlDb();
+        if (!db)
+            throw new Error('Storage database not available');
+        const fileDoc = await db.collection('storage_files').findOne({ fileId, projectId });
+        if (!fileDoc)
+            throw new Error(`File ${fileId} not found`);
+        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 db.collection('media_metadata').updateOne({ assetId: fileId, projectId }, {
+            $set: {
+                assetId: fileId,
+                projectId,
+                pendingTranscription: {
+                    model: options.model ?? 'whisper-1',
+                    sourceLanguage: options.sourceLanguage ?? 'auto',
+                    outputFormats: options.outputFormats ?? ['srt', 'vtt'],
+                    provider: options.provider ?? 'openai',
+                    credentialId: options.credentialId,
+                    requestedAt: new Date(),
+                },
+                customTags: {},
+                extractedAt: new Date(),
+            },
+        }, { upsert: true });
+        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 30 });
+    }
+    catch (err) {
+        (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 });
+    try {
+        const db = getNosqlDb();
+        if (!db)
+            throw new Error('Storage database not available');
+        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 db.collection('media_metadata').updateOne({ assetId: fileId, projectId }, {
+            $set: {
+                assetId: fileId,
+                projectId,
+                pendingUpscale: {
+                    scale: options.scale ?? 4,
+                    model: options.model ?? 'real-esrgan',
+                    mode: options.mode ?? 'images',
+                    credentialId: options.credentialId,
+                    requestedAt: new Date(),
+                },
+                customTags: {},
+                extractedAt: new Date(),
+            },
+        }, { upsert: true });
+        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 30 });
+    }
+    catch (err) {
+        (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 });
+    try {
+        const db = getNosqlDb();
+        if (!db)
+            throw new Error('Storage database not available');
+        await db.collection('generative_jobs').insertOne({
+            jobId,
+            projectId,
+            assetType: options.assetType ?? 'mesh',
+            provider: options.provider ?? 'meshy',
+            prompt: options.prompt,
+            seed: options.seed,
+            credentialId: options.credentialId,
+            status: 'pending',
+            requestedAt: new Date(),
+        });
+        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 20 });
+    }
+    catch (err) {
+        (0, jobQueue_1.failJob)(jobId, err.message);
+    }
+}
+async function buildPipelineSuggestion(nodeSchema, availableNodeTypes) {
+    const presentTypes = new Set(nodeSchema.nodes.map((n) => n.type));
+    // Heuristic rules — replaced by LLM call in the host environment
+    const suggestions = [];
+    const edgeSuggestions = [];
+    const hasVideo = nodeSchema.nodes.some((n) => ['ingestNode', 'transcodeNode'].includes(n.type));
+    if (hasVideo && !presentTypes.has('captionNode') && availableNodeTypes.includes('captionNode')) {
+        suggestions.push({ type: 'captionNode', label: 'Captions', position: { x: 600, y: 100 } });
+    }
+    if (hasVideo && !presentTypes.has('thumbnailNode') && availableNodeTypes.includes('thumbnailNode')) {
+        suggestions.push({ type: 'thumbnailNode', label: 'Thumbnail', position: { x: 600, y: 250 } });
+    }
+    if (!presentTypes.has('qcCheckNode') && availableNodeTypes.includes('qcCheckNode')) {
+        suggestions.push({ type: 'qcCheckNode', label: 'QC Check', position: { x: 400, y: -150 } });
+    }
+    const rationale = suggestions.length > 0
+        ? `Detected ${suggestions.map(s => s.label).join(', ')} as missing steps for a complete pipeline.`
+        : 'Pipeline looks complete for the current asset types.';
+    return { rationale, nodesToAdd: suggestions, edgesToAdd: edgeSuggestions };
+}