streamby-core 0.32.1 → 0.34.0

package/dist/middleware/routes/apiConnection.js

@@ -1,100 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.apiConnectionRouter = apiConnectionRouter;
-const express_1 = require("express");
-const manager_1 = require("../../models/manager");
-const auth_1 = require("../../utils/auth");
-const apiConnection_1 = require("../../services/apiConnection");
-const VALID_METHODS = ['GET', 'POST', 'PATCH', 'PUT', 'DELETE'];
-function apiConnectionRouter(config) {
-    const router = (0, express_1.Router)();
-    const Project = (0, manager_1.getModel)('projects');
-    // List API connections for a project
-    router.get('/projects/:id/api/connections', async (req, res) => {
-        try {
-            const auth = req.auth;
-            const projectId = req.params.id;
-            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 project access' });
-            }
-            return res.status(200).json({ data: project.apiConnections || [] });
-        }
-        catch (err) {
-            res.status(500).json({ message: 'Failed to fetch API connections', details: err.message });
-        }
-    });
-    // Add a new API connection to a project
-    router.post('/projects/:id/api/connections', async (req, res) => {
-        try {
-            const auth = req.auth;
-            if (auth.role !== 'admin' && auth.role !== 'editor') {
-                return res.status(403).json({ message: 'Permission denied' });
-            }
-            const projectId = req.params.id;
-            const { name, baseUrl, method, description, credentialId, prefix } = req.body;
-            if (!name || !baseUrl) {
-                return res.status(400).json({ message: 'name and baseUrl are required' });
-            }
-            if (!VALID_METHODS.includes(method)) {
-                return res.status(400).json({ message: `method must be one of: ${VALID_METHODS.join(', ')}` });
-            }
-            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 project access' });
-            }
-            if (credentialId) {
-                const credExists = project.credentials?.some((c) => c.id === credentialId);
-                if (!credExists) {
-                    return res.status(400).json({ message: 'Credential not found in project' });
-                }
-            }
-            const connection = await (0, apiConnection_1.addApiConnection)(config, projectId, {
-                name,
-                baseUrl,
-                method,
-                prefix,
-                ...(description !== undefined && { description }),
-                ...(credentialId !== undefined && { credentialId }),
-            });
-            return res.status(201).json({ data: connection });
-        }
-        catch (err) {
-            res.status(500).json({ message: 'Failed to add API connection', details: err.message });
-        }
-    });
-    // Delete an API connection from a project
-    router.delete('/projects/:id/api/connections/:connectionId', async (req, res) => {
-        try {
-            const auth = req.auth;
-            if (auth.role !== 'admin' && auth.role !== 'editor') {
-                return res.status(403).json({ message: 'Permission denied' });
-            }
-            const projectId = req.params.id;
-            const { 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 project access' });
-            }
-            const exists = project.apiConnections?.some((c) => c.id === connectionId);
-            if (!exists) {
-                return res.status(404).json({ message: 'API connection not found' });
-            }
-            await (0, apiConnection_1.deleteApiConnection)(config, projectId, connectionId);
-            return res.status(200).json({ message: 'API connection deleted successfully.' });
-        }
-        catch (err) {
-            res.status(500).json({ message: 'Failed to delete API connection', details: err.message });
-        }
-    });
-    return router;
-}

package/dist/middleware/routes/credential.js

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.credentialRouter = credentialRouter;
-const express_1 = require("express");
-const manager_1 = require("../../models/manager");
-const auth_1 = require("../../utils/auth");
-const sanitize_1 = require("../../utils/sanitize");
-const credential_1 = require("../../services/credential");
-function credentialRouter(config) {
-    const router = (0, express_1.Router)();
-    const Project = (0, manager_1.getModel)('projects');
-    // Add a new credential to a project
-    router.post('/projects/:id/credentials', async (req, res) => {
-        try {
-            const auth = req.auth;
-            if (auth.role !== 'admin' && auth.role !== 'editor') {
-                return res.status(403).json({ message: 'Permission denied' });
-            }
-            const projectId = req.params.id;
-            const { id, key, value } = req.body;
-            if (!key || !value) {
-                return res.status(400).json({ message: 'Missing credential key or value' });
-            }
-            const project = await Project.findOne({ _id: projectId });
-            if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
-                return res.status(403).json({ message: 'Unauthorized project access' });
-            }
-            const updatedProject = await (0, credential_1.addCredential)(config, projectId, { id, key, value });
-            res.status(201).json({ message: 'Credential added successfully', project: (0, sanitize_1.sanitizeProject)(updatedProject) });
-        }
-        catch (err) {
-            res.status(500).json({ message: 'Failed to add credential', details: err.message });
-        }
-    });
-    // Update an existing credential in a project
-    router.patch('/projects/:id/credentials/:credentialId', async (req, res) => {
-        try {
-            const auth = req.auth;
-            if (auth.role !== 'admin' && auth.role !== 'editor') {
-                return res.status(403).json({ message: 'Permission denied' });
-            }
-            const projectId = req.params.id;
-            const credentialId = req.params.credentialId;
-            const { key, value } = req.body;
-            if (!key && !value) {
-                return res.status(400).json({ message: 'No update fields provided' });
-            }
-            const project = await Project.findOne({ _id: projectId });
-            if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
-                return res.status(403).json({ message: 'Unauthorized project access' });
-            }
-            const updatedProject = await (0, credential_1.updateCredential)(config, projectId, credentialId, { key, value });
-            res.status(200).json({ message: 'Credential updated successfully', project: (0, sanitize_1.sanitizeProject)(updatedProject) });
-        }
-        catch (err) {
-            res.status(500).json({ message: 'Failed to update credential', details: err.message });
-        }
-    });
-    // Delete a credential from a project
-    router.delete('/projects/:id/credentials/:credentialId', async (req, res) => {
-        try {
-            const auth = req.auth;
-            if (auth.role !== 'admin' && auth.role !== 'editor') {
-                return res.status(403).json({ message: 'Permission denied' });
-            }
-            const projectId = req.params.id;
-            const credentialId = req.params.credentialId;
-            const project = await Project.findOne({ _id: projectId });
-            if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
-                return res.status(403).json({ message: 'Unauthorized project access' });
-            }
-            const updatedProject = await (0, credential_1.deleteCredential)(config, projectId, credentialId);
-            res.status(200).json({ message: 'Credential deleted successfully', project: (0, sanitize_1.sanitizeProject)(updatedProject) });
-        }
-        catch (err) {
-            res.status(500).json({ message: 'Failed to delete credential', details: err.message });
-        }
-    });
-    return router;
-}

package/dist/services/apiConnection.d.ts

@@ -1,18 +0,0 @@
-import { StreamByConfig, ApiConnection, ApiConnectionMethod } from '../types';
-export declare function addApiConnection(config: StreamByConfig, projectId: string, data: {
-    name: string;
-    apiUrl: string;
-    method: ApiConnectionMethod;
-    prefix?: string;
-    description?: string;
-    credentialId?: string;
-}): Promise<ApiConnection>;
-export declare function updateApiConnection(config: StreamByConfig, projectId: string, connectionId: string, data: {
-    name?: string;
-    apiUrl?: string;
-    method?: ApiConnectionMethod;
-    prefix?: string;
-    description?: string;
-    credentialId?: string;
-}): Promise<ApiConnection>;
-export declare function deleteApiConnection(config: StreamByConfig, projectId: string, connectionId: string): Promise<void>;

package/dist/services/apiConnection.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addApiConnection = addApiConnection;
-exports.updateApiConnection = updateApiConnection;
-exports.deleteApiConnection = deleteApiConnection;
-const mongodb_1 = require("mongodb");
-const manager_1 = require("../models/manager");
-async function addApiConnection(config, projectId, data) {
-    const ProjectModel = (0, manager_1.getModel)('projects');
-    const project = await ProjectModel.findOne({ _id: projectId });
-    if (!project) {
-        throw new Error('Project not found.');
-    }
-    const connection = {
-        id: new mongodb_1.ObjectId().toHexString(),
-        name: data.name,
-        prefix: data.prefix,
-        apiUrl: data.apiUrl,
-        method: data.method,
-        projectId,
-        createdAt: new Date(),
-        ...(data.description !== undefined && { description: data.description }),
-        ...(data.credentialId !== undefined && { credentialId: data.credentialId }),
-    };
-    const updatedProject = await ProjectModel.update({ _id: projectId }, { $push: { apiConnections: connection } });
-    if (!updatedProject) {
-        throw new Error('Failed to add API connection to project.');
-    }
-    return connection;
-}
-async function updateApiConnection(config, projectId, connectionId, data) {
-    const ProjectModel = (0, manager_1.getModel)('projects');
-    const project = await ProjectModel.findOne({ _id: projectId });
-    if (!project)
-        throw new Error('Project not found.');
-    const connections = project.apiConnections ?? [];
-    const index = connections.findIndex((c) => c.id === connectionId);
-    if (index === -1)
-        throw new Error('API connection not found.');
-    const updated = {
-        ...connections[index],
-        ...(data.name !== undefined && { name: data.name }),
-        ...(data.apiUrl !== undefined && { apiUrl: data.apiUrl }),
-        ...(data.method !== undefined && { method: data.method }),
-        ...(data.prefix !== undefined && { prefix: data.prefix }),
-        ...(data.description !== undefined && { description: data.description }),
-        ...(data.credentialId !== undefined && { credentialId: data.credentialId }),
-    };
-    connections[index] = updated;
-    const result = await ProjectModel.update({ _id: projectId }, { $set: { apiConnections: connections } });
-    if (!result)
-        throw new Error('Failed to update API connection.');
-    return updated;
-}
-async function deleteApiConnection(config, projectId, connectionId) {
-    const ProjectModel = (0, manager_1.getModel)('projects');
-    const project = await ProjectModel.findOne({ _id: projectId });
-    if (!project) {
-        throw new Error('Project not found.');
-    }
-    const updatedProject = await ProjectModel.update({ _id: projectId }, { $pull: { apiConnections: { id: connectionId } } });
-    if (!updatedProject) {
-        throw new Error('Failed to delete API connection from project.');
-    }
-}

package/dist/services/credential.d.ts

@@ -1,8 +0,0 @@
-import { StreamByConfig, Credential, ProjectInfo } from '../types';
-export declare function addCredential(config: StreamByConfig, projectId: string, newCredential: Omit<Credential, 'encryptedValue'> & {
-    value: string;
-}): Promise<ProjectInfo>;
-export declare function updateCredential(config: StreamByConfig, projectId: string, credentialId: string, updates: Partial<Omit<Credential, 'encryptedValue'> & {
-    value: string;
-}>): Promise<ProjectInfo>;
-export declare function deleteCredential(config: StreamByConfig, projectId: string, credentialId: string): Promise<ProjectInfo>;

package/dist/services/credential.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addCredential = addCredential;
-exports.updateCredential = updateCredential;
-exports.deleteCredential = deleteCredential;
-const manager_1 = require("../models/manager");
-const encryption_1 = require("../utils/encryption");
-const mongodb_1 = require("mongodb");
-async function addCredential(config, projectId, newCredential) {
-    if (!(0, encryption_1.isEncryptionKeySet)()) {
-        throw new Error('Encryption key is not set. Cannot add credentials.');
-    }
-    const ProjectModel = (0, manager_1.getModel)('projects');
-    const project = await ProjectModel.findOne({ _id: projectId });
-    if (!project) {
-        throw new Error('Project not found.');
-    }
-    const encryptedValue = (0, encryption_1.encrypt)(newCredential.value);
-    const credentialToSave = {
-        id: newCredential.id || new mongodb_1.ObjectId().toHexString(), // Generate ID if not provided
-        key: newCredential.key,
-        encryptedValue: encryptedValue,
-    };
-    const updatedProject = await ProjectModel.update({ _id: projectId }, { $push: { credentials: credentialToSave } });
-    if (!updatedProject) {
-        throw new Error('Failed to add credential to project.');
-    }
-    return updatedProject;
-}
-async function updateCredential(config, projectId, credentialId, updates) {
-    if (!(0, encryption_1.isEncryptionKeySet)()) {
-        throw new Error('Encryption key is not set. Cannot update credentials.');
-    }
-    const ProjectModel = (0, manager_1.getModel)('projects');
-    const project = await ProjectModel.findOne({ _id: projectId });
-    if (!project) {
-        throw new Error('Project not found.');
-    }
-    const credentialIndex = project.credentials?.findIndex(cred => cred.id === credentialId);
-    if (credentialIndex === undefined || credentialIndex === -1) {
-        throw new Error(`Credential with ID ${credentialId} not found.`);
-    }
-    const currentCredential = project.credentials[credentialIndex];
-    let encryptedValue = currentCredential.encryptedValue;
-    if (updates.value !== undefined) {
-        encryptedValue = (0, encryption_1.encrypt)(updates.value);
-    }
-    const updatedCredential = {
-        ...currentCredential,
-        key: updates.key || currentCredential.key,
-        encryptedValue: encryptedValue,
-    };
-    const updatedProject = await ProjectModel.update({ _id: projectId, 'credentials.id': credentialId }, { $set: { 'credentials.$': updatedCredential } });
-    if (!updatedProject) {
-        throw new Error('Failed to update credential in project.');
-    }
-    return updatedProject;
-}
-async function deleteCredential(config, projectId, credentialId) {
-    const ProjectModel = (0, manager_1.getModel)('projects');
-    const project = await ProjectModel.findOne({ _id: projectId });
-    if (!project) {
-        throw new Error('Project not found.');
-    }
-    const updatedProject = await ProjectModel.update({ _id: projectId }, { $pull: { credentials: { id: credentialId } } });
-    if (!updatedProject) {
-        throw new Error('Failed to delete credential from project.');
-    }
-    return updatedProject;
-}

package/dist/services/pipeline.d.ts

@@ -1,2 +0,0 @@
-import { NodeSchema, StreamByConfig } from '../types';
-export declare function executePipeline(nodeSchema: NodeSchema, project: any, config: StreamByConfig): Promise<any>;

package/dist/services/pipeline.js

@@ -1,292 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executePipeline = executePipeline;
-const connectionManager_1 = require("../adapters/database/connectionManager");
-const encryption_1 = require("../utils/encryption");
-const dbConnection_1 = require("./dbConnection");
-const jobQueue_1 = require("./jobQueue");
-const mediaProcessor_1 = require("./mediaProcessor");
-const vfxProcessor_1 = require("./vfxProcessor");
-const aiProcessor_1 = require("./aiProcessor");
-const storage_1 = require("../providers/storage");
-function applyFilterConfig(payload, config) {
-    const isArr = Array.isArray(payload);
-    let r = isArr ? [...payload] : payload;
-    if (config.conditions?.length) {
-        const matches = (item) => config.conditions.every(c => {
-            const v = item?.[c.field];
-            switch (c.op) {
-                case 'eq': return String(v) === c.value;
-                case 'neq': return String(v) !== c.value;
-                case 'gt': return Number(v) > Number(c.value);
-                case 'lt': return Number(v) < Number(c.value);
-                case 'gte': return Number(v) >= Number(c.value);
-                case 'lte': return Number(v) <= Number(c.value);
-                case 'contains': return String(v).includes(c.value);
-                case 'startsWith': return String(v).startsWith(c.value);
-                case 'endsWith': return String(v).endsWith(c.value);
-                default: return true;
-            }
-        });
-        r = isArr ? r.filter(matches) : (matches(r) ? r : null);
-        if (r === null)
-            return null;
-    }
-    if (config.includeFields?.length) {
-        const pick = (item) => {
-            if (!item || typeof item !== 'object')
-                return item;
-            const o = {};
-            for (const f of config.includeFields)
-                if (f in item)
-                    o[f] = item[f];
-            return o;
-        };
-        r = isArr ? r.map(pick) : pick(r);
-    }
-    if (config.renameFields?.length) {
-        const ren = (item) => {
-            if (!item || typeof item !== 'object')
-                return item;
-            const o = { ...item };
-            for (const { from, to } of config.renameFields) {
-                if (from in o) {
-                    o[to] = o[from];
-                    delete o[from];
-                }
-            }
-            return o;
-        };
-        r = isArr ? r.map(ren) : ren(r);
-    }
-    if (config.limit && isArr)
-        r = r.slice(0, config.limit);
-    if (config.wrapKey)
-        r = { [config.wrapKey]: r };
-    return r;
-}
-function getSources(nodes, edges, targetId, targetHandle) {
-    return edges
-        .filter(e => e.target === targetId && e.targetHandle === targetHandle)
-        .map(e => nodes.find(n => n.id === e.source))
-        .filter((n) => n !== undefined);
-}
-function getTarget(nodes, edges, sourceId, sourceHandle) {
-    const edge = edges.find(e => e.source === sourceId && e.sourceHandle === sourceHandle);
-    return edge ? (nodes.find(n => n.id === edge.target) ?? null) : null;
-}
-async function executePipeline(nodeSchema, project, config) {
-    const nodes = nodeSchema.nodes;
-    const edges = nodeSchema.edges;
-    // 1. Data layer — nodes connected to streamby in-bottom
-    const dataSources = getSources(nodes, edges, 'streamby', 'in-bottom');
-    const dataResults = [];
-    for (const node of dataSources) {
-        if (node.type === 'jsonInputNode') {
-            try {
-                dataResults.push(JSON.parse(node.data?.jsonString || 'null'));
-            }
-            catch {
-                dataResults.push(null);
-            }
-        }
-        else if (node.type === 'dataSourceNode') {
-            const tableName = (node.data?.tableName || node.data?.subtitle || node.data?.label);
-            if (!tableName)
-                continue;
-            const connectionId = node.data?.connectionId;
-            const recordId = node.data?.recordId;
-            const projectIdentifier = project._id?.toString() ?? project.id;
-            const fetchData = async (client, type) => recordId
-                ? (0, dbConnection_1.queryRecordByIdInternal)(client, type, tableName, recordId, projectIdentifier)
-                : (0, dbConnection_1.queryRecordsInternal)(client, type, tableName, 500, 0, projectIdentifier);
-            if (connectionId) {
-                const { client, type } = (0, connectionManager_1.getConnection)(connectionId);
-                dataResults.push(await fetchData(client, type));
-            }
-            else {
-                // legacy fallback for nodes saved before connectionId was introduced
-                const targetDb = config.databases?.find((db) => db.type === project.dbType && db.main)
-                    ?? config.databases?.find((db) => db.type === project.dbType);
-                if (!targetDb)
-                    throw new Error(`No database connection for type ${project.dbType}`);
-                const { client, type } = (0, connectionManager_1.getConnection)(targetDb.id);
-                dataResults.push(await fetchData(client, type));
-            }
-        }
-        else if (node.type === 'apiConnectionNode') {
-            const apiConnection = project.apiConnections?.find((c) => c.id === node.data?.connectionId);
-            if (!apiConnection)
-                continue;
-            const headers = { 'Content-Type': 'application/json' };
-            if (apiConnection.credentialId && (0, encryption_1.isEncryptionKeySet)()) {
-                const credential = project.credentials?.find((c) => c.id === apiConnection.credentialId);
-                if (credential) {
-                    const decrypted = (0, encryption_1.decrypt)(credential.encryptedValue);
-                    const prefix = apiConnection.prefix ? `${apiConnection.prefix} ` : '';
-                    headers['Authorization'] = `${prefix}${decrypted}`;
-                }
-            }
-            const response = await fetch(apiConnection.apiUrl, { method: apiConnection.method || 'GET', headers });
-            if (!response.ok)
-                throw new Error(`API connection fetch failed: ${response.statusText}`);
-            dataResults.push(await response.json());
-        }
-    }
-    let payload = dataResults.length === 1 ? dataResults[0] : dataResults;
-    // 2. Process layer — chain from streamby out-top → processNode in-process → out-process → ...
-    const adapter = (0, storage_1.createStorageProvider)(config.storageProviders);
-    const projectId = project._id?.toString() ?? project.id;
-    // userId is not available in pipeline context; use a sentinel for job attribution
-    const systemUserId = 'pipeline';
-    let processNode = getTarget(nodes, edges, 'streamby', 'out-top');
-    while (processNode) {
-        const nodeData = processNode.data ?? {};
-        const fileId = nodeData.fileId;
-        if (processNode.type === 'transcodeNode' && fileId) {
-            const job = (0, jobQueue_1.createJob)('transcode', systemUserId, projectId, nodeData);
-            setImmediate(() => (0, mediaProcessor_1.runTranscodeJob)(job.jobId, fileId, projectId, {
-                codec: nodeData.codec,
-                resolution: nodeData.resolution,
-                outputFormat: nodeData.outputFormat,
-                bitrate: nodeData.bitrate,
-                audioCodec: nodeData.audioCodec,
-            }, adapter));
-            payload = { ...payload, jobId: job.jobId, jobType: 'transcode' };
-        }
-        else if (processNode.type === 'captionNode' && fileId) {
-            const job = (0, jobQueue_1.createJob)('caption', systemUserId, projectId, nodeData);
-            setImmediate(() => (0, mediaProcessor_1.runCaptionJob)(job.jobId, fileId, projectId, {
-                sourceLanguage: nodeData.sourceLanguage,
-                outputFormat: nodeData.outputFormat,
-                provider: nodeData.provider,
-            }));
-            payload = { ...payload, jobId: job.jobId, jobType: 'caption' };
-        }
-        else if (processNode.type === 'thumbnailNode' && fileId) {
-            const job = (0, jobQueue_1.createJob)('thumbnail', systemUserId, projectId, nodeData);
-            setImmediate(() => (0, mediaProcessor_1.runThumbnailJob)(job.jobId, fileId, projectId, {
-                timecode: nodeData.timecode,
-                resolution: nodeData.resolution,
-                strategy: nodeData.strategy,
-            }));
-            payload = { ...payload, jobId: job.jobId, jobType: 'thumbnail' };
-        }
-        else if (processNode.type === 'ingestNode' && fileId) {
-            const job = (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);
-            setImmediate(() => (0, vfxProcessor_1.runRenderJob)(job.jobId, fileId, projectId, {
-                renderer: nodeData.renderer,
-                renderFarmConnectionId: nodeData.renderFarmConnectionId,
-                frameRange: nodeData.frameRange,
-                resolution: nodeData.resolution,
-                samples: nodeData.samples,
-                outputFormat: nodeData.outputFormat,
-            }));
-            payload = { ...payload, jobId: job.jobId, jobType: 'render' };
-        }
-        else if (processNode.type === 'formatConvertNode' && fileId) {
-            const job = (0, jobQueue_1.createJob)('format-convert', systemUserId, projectId, nodeData);
-            setImmediate(() => (0, vfxProcessor_1.runFormatConvertJob)(job.jobId, fileId, projectId, {
-                inputFormat: nodeData.inputFormat,
-                outputFormat: nodeData.outputFormat,
-                applyTransforms: nodeData.applyTransforms,
-                embedTextures: nodeData.embedTextures,
-            }));
-            payload = { ...payload, jobId: job.jobId, jobType: 'format-convert' };
-        }
-        else if (processNode.type === 'lodNode' && fileId) {
-            const job = (0, jobQueue_1.createJob)('lod', systemUserId, projectId, nodeData);
-            setImmediate(() => (0, vfxProcessor_1.runLodJob)(job.jobId, fileId, projectId, {
-                levels: nodeData.levels,
-                reductionRatios: nodeData.reductionRatios,
-                algorithm: nodeData.algorithm,
-                outputFormat: nodeData.outputFormat,
-            }));
-            payload = { ...payload, jobId: job.jobId, jobType: 'lod' };
-        }
-        else if (processNode.type === 'qcCheckNode' && fileId) {
-            const checks = nodeData.checks ?? [];
-            const checkResults = checks.map((name) => ({
-                name, passed: true, value: 'ok', threshold: 'ok',
-            }));
-            payload = { ...payload, qcReport: { checks: checkResults, overallPassed: true } };
-        }
-        else if (processNode.type === 'transcriptionNode' && fileId) {
-            const job = (0, jobQueue_1.createJob)('transcription', systemUserId, projectId, nodeData);
-            setImmediate(() => (0, aiProcessor_1.runTranscriptionJob)(job.jobId, fileId, projectId, {
-                model: nodeData.model,
-                sourceLanguage: nodeData.sourceLanguage,
-                outputFormats: nodeData.outputFormats,
-                provider: nodeData.provider,
-                credentialId: nodeData.credentialId,
-            }));
-            payload = { ...payload, jobId: job.jobId, jobType: 'transcription' };
-        }
-        else if (processNode.type === 'upscaleNode' && fileId) {
-            const job = (0, jobQueue_1.createJob)('upscale', systemUserId, projectId, nodeData);
-            setImmediate(() => (0, aiProcessor_1.runUpscaleJob)(job.jobId, fileId, projectId, {
-                scale: nodeData.scale,
-                model: nodeData.model,
-                mode: nodeData.mode,
-                credentialId: nodeData.credentialId,
-            }));
-            payload = { ...payload, jobId: job.jobId, jobType: 'upscale' };
-        }
-        else if (processNode.type === 'proceduralAssetNode') {
-            const job = (0, jobQueue_1.createJob)('generate-asset', systemUserId, projectId, nodeData);
-            setImmediate(() => (0, aiProcessor_1.runGenerateAssetJob)(job.jobId, projectId, {
-                assetType: nodeData.assetType,
-                provider: nodeData.provider,
-                prompt: nodeData.prompt ?? '',
-                seed: nodeData.seed,
-                credentialId: nodeData.credentialId,
-            }));
-            payload = { ...payload, jobId: job.jobId, jobType: 'generate-asset' };
-        }
-        else if (processNode.type === 'pipelineSuggestNode') {
-            const suggestion = await (0, aiProcessor_1.buildPipelineSuggestion)({ nodes, edges }, Object.keys(nodeSchema));
-            payload = { ...payload, pipelineSuggestion: suggestion };
-        }
-        processNode = getTarget(nodes, edges, processNode.id, 'out-process');
-    }
-    // 3. Filter + output lane — streamby out-right → filterNode|annotationNode|deliverableNode|distributionNode
-    const outputLaneTypes = new Set(['filterNode', 'annotationNode', 'deliverableNode', 'distributionNode']);
-    let outputNode = getTarget(nodes, edges, 'streamby', 'out-right');
-    while (outputNode) {
-        if (outputNode.type === 'filterNode') {
-            const cfg = outputNode.data?.filterConfig;
-            if (cfg)
-                payload = applyFilterConfig(payload, cfg);
-        }
-        else if (outputNode.type === 'deliverableNode') {
-            payload = {
-                ...payload,
-                deliverable: {
-                    type: outputNode.data?.deliverableType ?? 'asset-bundle',
-                    version: outputNode.data?.deliverableVersion ?? '1.0.0',
-                },
-            };
-        }
-        else if (outputNode.type === 'distributionNode') {
-            // Distribution is async — the actual publish is handled by the host worker
-            payload = {
-                ...payload,
-                distribution: {
-                    target: outputNode.data?.distributionTarget,
-                    connectionId: outputNode.data?.distributionConnectionId,
-                    channel: outputNode.data?.channel,
-                    status: 'queued',
-                },
-            };
-        }
-        // annotationNode — pass-through; annotations are stored separately via the review API
-        const next = getTarget(nodes, edges, outputNode.id, 'out-filter');
-        outputNode = next && outputLaneTypes.has(next.type) ? next : null;
-    }
-    return payload;
-}