streamby-core 0.28.5 → 0.29.0

package/dist/services/jobQueue.d.ts

@@ -0,0 +1,5 @@
+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;

package/dist/services/jobQueue.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJob = createJob;
+exports.getJob = getJob;
+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 now = new Date();
+    const job = {
+        jobId,
+        jobType,
+        userId,
+        projectId,
+        status: 'pending',
+        stage: 'queued',
+        progress: 0,
+        payload,
+        createdAt: now,
+        updatedAt: now,
+    };
+    jobs.set(jobId, job);
+    return job;
+}
+function getJob(jobId) {
+    return jobs.get(jobId);
+}
+function updateJob(jobId, updates) {
+    const job = jobs.get(jobId);
+    if (!job)
+        return;
+    Object.assign(job, updates, { updatedAt: new Date() });
+    (0, wsHub_1.emitToUser)(job.userId, {
+        type: 'jobEvent',
+        data: {
+            jobId: job.jobId,
+            jobType: job.jobType,
+            assetId: job.assetId,
+            stage: job.stage,
+            progress: job.progress,
+            message: updates.stage,
+            error: job.error,
+        },
+    });
+}
+function failJob(jobId, error) {
+    updateJob(jobId, { status: 'failed', stage: 'failed', error });
+}

package/dist/services/mediaProcessor.d.ts

@@ -0,0 +1,19 @@
+import { StorageAdapter } from '../types';
+export declare function runIngestJob(jobId: string, fileId: string, projectId: string): Promise<void>;
+export declare function runTranscodeJob(jobId: string, fileId: string, projectId: string, options: {
+    codec?: string;
+    resolution?: string;
+    outputFormat?: string;
+    bitrate?: string;
+    audioCodec?: string;
+}, _adapter: StorageAdapter): Promise<void>;
+export declare function runThumbnailJob(jobId: string, fileId: string, projectId: string, options: {
+    timecode?: string;
+    resolution?: string;
+    strategy?: string;
+}): Promise<void>;
+export declare function runCaptionJob(jobId: string, fileId: string, projectId: string, options: {
+    sourceLanguage?: string;
+    outputFormat?: string;
+    provider?: string;
+}): Promise<void>;

package/dist/services/mediaProcessor.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runIngestJob = runIngestJob;
+exports.runTranscodeJob = runTranscodeJob;
+exports.runThumbnailJob = runThumbnailJob;
+exports.runCaptionJob = runCaptionJob;
+const mongodb_1 = require("mongodb");
+const connectionManager_1 = require("../adapters/database/connectionManager");
+const jobQueue_1 = require("./jobQueue");
+function getFilesCollection() {
+    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().collection('storage_files');
+}
+function getMetadataCollection() {
+    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().collection('media_metadata');
+}
+function getVersionsCollection() {
+    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().collection('asset_versions');
+}
+// Infer basic metadata from contentType without external binaries
+function inferMetadata(contentType, size) {
+    const meta = {};
+    if (contentType.startsWith('image/')) {
+        meta.category = 'images';
+    }
+    else if (contentType.startsWith('audio/')) {
+        meta.category = 'audios';
+    }
+    else if (contentType.startsWith('video/')) {
+        meta.category = 'videos';
+    }
+    else {
+        meta.category = '3d-models';
+    }
+    meta.size = size;
+    meta.codec = contentType.split('/')[1] ?? 'unknown';
+    return meta;
+}
+async function runIngestJob(jobId, fileId, projectId) {
+    (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10 });
+    try {
+        const filesCol = getFilesCollection();
+        if (!filesCol)
+            throw new Error('Storage database not available');
+        const fileDoc = await filesCol.findOne({ fileId, projectId });
+        if (!fileDoc)
+            throw new Error(`File ${fileId} not found in project ${projectId}`);
+        (0, jobQueue_1.updateJob)(jobId, { stage: 'extracting-metadata', progress: 40, assetId: fileId });
+        const metaCol = getMetadataCollection();
+        if (metaCol) {
+            const meta = inferMetadata(fileDoc.contentType ?? '', fileDoc.size ?? 0);
+            await metaCol.updateOne({ assetId: fileId, projectId }, {
+                $set: {
+                    assetId: fileId,
+                    projectId,
+                    codec: meta.codec,
+                    customTags: {},
+                    extractedAt: new Date(),
+                },
+            }, { upsert: true });
+        }
+        (0, jobQueue_1.updateJob)(jobId, { stage: 'creating-version', progress: 70 });
+        const versionsCol = getVersionsCollection();
+        if (versionsCol) {
+            const existing = await versionsCol.countDocuments({ assetId: fileId, projectId });
+            await versionsCol.insertOne({
+                _id: new mongodb_1.ObjectId(),
+                versionId: crypto.randomUUID(),
+                assetId: fileId,
+                projectId,
+                version: existing + 1,
+                storageKey: fileDoc.storageKey,
+                size: fileDoc.size ?? 0,
+                createdBy: fileDoc.uploadedBy,
+                createdAt: new Date(),
+            });
+        }
+        (0, jobQueue_1.updateJob)(jobId, { status: 'completed', stage: 'complete', progress: 100 });
+    }
+    catch (err) {
+        (0, jobQueue_1.failJob)(jobId, err.message);
+    }
+}
+async function runTranscodeJob(jobId, fileId, projectId, options, _adapter) {
+    (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'queued', progress: 5, assetId: fileId });
+    try {
+        const filesCol = getFilesCollection();
+        if (!filesCol)
+            throw new Error('Storage database not available');
+        const fileDoc = await filesCol.findOne({ fileId, projectId });
+        if (!fileDoc)
+            throw new Error(`File ${fileId} not found`);
+        if (!fileDoc.contentType?.startsWith('video/') && !fileDoc.contentType?.startsWith('audio/')) {
+            throw new Error('Transcode only supports video and audio files');
+        }
+        (0, jobQueue_1.updateJob)(jobId, { stage: 'transcoding', progress: 20 });
+        // Store the transcode request as a pending task — actual FFmpeg execution
+        // happens in the host environment (Nhexa-API worker). The job record is the
+        // handoff contract: the worker reads it, processes the file, and calls back
+        // to update progress via the job queue.
+        const metaCol = getMetadataCollection();
+        if (metaCol) {
+            await metaCol.updateOne({ assetId: fileId, projectId }, {
+                $set: {
+                    assetId: fileId,
+                    projectId,
+                    pendingTranscode: {
+                        codec: options.codec ?? 'h264',
+                        resolution: options.resolution ?? 'original',
+                        outputFormat: options.outputFormat ?? 'mp4',
+                        bitrate: options.bitrate,
+                        audioCodec: options.audioCodec ?? 'aac',
+                        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 runThumbnailJob(jobId, fileId, projectId, options) {
+    (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10, assetId: fileId });
+    try {
+        const filesCol = getFilesCollection();
+        if (!filesCol)
+            throw new Error('Storage database not available');
+        const fileDoc = await filesCol.findOne({ fileId, projectId });
+        if (!fileDoc)
+            throw new Error(`File ${fileId} not found`);
+        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 30 });
+        const metaCol = getMetadataCollection();
+        if (metaCol) {
+            await metaCol.updateOne({ assetId: fileId, projectId }, {
+                $set: {
+                    assetId: fileId,
+                    projectId,
+                    pendingThumbnail: {
+                        timecode: options.timecode ?? '00:00:01',
+                        resolution: options.resolution ?? '1280x720',
+                        strategy: options.strategy ?? 'timecode',
+                        requestedAt: new Date(),
+                    },
+                    customTags: {},
+                    extractedAt: new Date(),
+                },
+            }, { upsert: true });
+        }
+        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 40 });
+    }
+    catch (err) {
+        (0, jobQueue_1.failJob)(jobId, err.message);
+    }
+}
+async function runCaptionJob(jobId, fileId, projectId, options) {
+    (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10, assetId: fileId });
+    try {
+        const filesCol = getFilesCollection();
+        if (!filesCol)
+            throw new Error('Storage database not available');
+        const fileDoc = await filesCol.findOne({ fileId, projectId });
+        if (!fileDoc)
+            throw new Error(`File ${fileId} not found`);
+        if (!fileDoc.contentType?.startsWith('video/') && !fileDoc.contentType?.startsWith('audio/')) {
+            throw new Error('Captions only support video and audio files');
+        }
+        const metaCol = getMetadataCollection();
+        if (metaCol) {
+            await metaCol.updateOne({ assetId: fileId, projectId }, {
+                $set: {
+                    assetId: fileId,
+                    projectId,
+                    pendingCaption: {
+                        sourceLanguage: options.sourceLanguage ?? 'auto',
+                        outputFormat: options.outputFormat ?? 'srt',
+                        provider: options.provider ?? 'manual',
+                        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);
+    }
+}

package/dist/services/pipeline.js

@@ -4,6 +4,11 @@ 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;
@@ -130,18 +135,158 @@ async function executePipeline(nodeSchema, project, config) {
     }
     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) {
-        // transform/auth/custom logic per processNode.data.label — pass-through until defined
+        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 layer — chain from streamby out-right → filterNode in-filter → out-filter → ...
-    let filterNode = getTarget(nodes, edges, 'streamby', 'out-right');
-    while (filterNode) {
-        const cfg = filterNode.data?.filterConfig;
-        if (cfg)
-            payload = applyFilterConfig(payload, cfg);
-        filterNode = getTarget(nodes, edges, filterNode.id, 'out-filter');
+    // 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;
 }

package/dist/services/vfxProcessor.d.ts

@@ -0,0 +1,24 @@
+export declare function runRenderJob(jobId: string, fileId: string, projectId: string, options: {
+    renderer?: string;
+    renderFarmConnectionId?: string;
+    frameRange?: string;
+    resolution?: string;
+    samples?: number;
+    outputFormat?: string;
+}): Promise<void>;
+export declare function runFormatConvertJob(jobId: string, fileId: string, projectId: string, options: {
+    inputFormat?: string;
+    outputFormat?: string;
+    applyTransforms?: boolean;
+    embedTextures?: boolean;
+}): Promise<void>;
+export declare function runLodJob(jobId: string, fileId: string, projectId: string, options: {
+    levels?: number;
+    reductionRatios?: number[];
+    algorithm?: string;
+    outputFormat?: string;
+}): Promise<void>;
+export declare function resolveAssetDependencyGraph(projectId: string, rootAssetId: string, maxDepth?: number): Promise<{
+    nodes: any[];
+    edges: any[];
+}>;

package/dist/services/vfxProcessor.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRenderJob = runRenderJob;
+exports.runFormatConvertJob = runFormatConvertJob;
+exports.runLodJob = runLodJob;
+exports.resolveAssetDependencyGraph = resolveAssetDependencyGraph;
+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 runRenderJob(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-farm', progress: 20 });
+        // Store pending render task — picked up by the host render farm worker
+        await db.collection('media_metadata').updateOne({ assetId: fileId, projectId }, {
+            $set: {
+                assetId: fileId,
+                projectId,
+                pendingRender: {
+                    renderer: options.renderer ?? 'blender',
+                    renderFarmConnectionId: options.renderFarmConnectionId,
+                    frameRange: options.frameRange ?? '1-1',
+                    resolution: options.resolution ?? '1920x1080',
+                    samples: options.samples ?? 128,
+                    outputFormat: options.outputFormat ?? 'png',
+                    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 runFormatConvertJob(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-convert', progress: 25 });
+        await db.collection('media_metadata').updateOne({ assetId: fileId, projectId }, {
+            $set: {
+                assetId: fileId,
+                projectId,
+                pendingFormatConvert: {
+                    inputFormat: options.inputFormat ?? 'fbx',
+                    outputFormat: options.outputFormat ?? 'glb',
+                    applyTransforms: options.applyTransforms ?? true,
+                    embedTextures: options.embedTextures ?? true,
+                    requestedAt: new Date(),
+                },
+                customTags: {},
+                extractedAt: new Date(),
+            },
+        }, { upsert: true });
+        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 35 });
+    }
+    catch (err) {
+        (0, jobQueue_1.failJob)(jobId, err.message);
+    }
+}
+async function runLodJob(jobId, fileId, projectId, options) {
+    (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10, assetId: fileId });
+    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-lod', progress: 25 });
+        await db.collection('media_metadata').updateOne({ assetId: fileId, projectId }, {
+            $set: {
+                assetId: fileId,
+                projectId,
+                pendingLod: {
+                    levels: options.levels ?? 3,
+                    reductionRatios: options.reductionRatios ?? [0.5, 0.25, 0.1],
+                    algorithm: options.algorithm ?? 'quadric',
+                    outputFormat: options.outputFormat ?? 'glb',
+                    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 resolveAssetDependencyGraph(projectId, rootAssetId, maxDepth = 5) {
+    const db = getNosqlDb();
+    if (!db)
+        return { nodes: [], edges: [] };
+    const filesCol = db.collection('storage_files');
+    const visited = new Set();
+    const nodes = [];
+    const edges = [];
+    async function walk(assetId, depth) {
+        if (depth > maxDepth || visited.has(assetId))
+            return;
+        visited.add(assetId);
+        const file = await filesCol.findOne({ fileId: assetId, projectId });
+        nodes.push({
+            assetId,
+            type: file?.contentType ?? 'unknown',
+            resolved: !!file,
+        });
+        // Dependencies are stored as a `dependencies` array on the file document
+        const deps = file?.dependencies ?? [];
+        for (const depId of deps) {
+            edges.push({ from: assetId, to: depId, relationship: 'depends-on' });
+            await walk(depId, depth + 1);
+        }
+    }
+    await walk(rootAssetId, 0);
+    await db.collection('asset_dependency_graphs').updateOne({ rootAssetId, projectId }, { $set: { rootAssetId, projectId, nodes, edges, resolvedAt: new Date() } }, { upsert: true });
+    return { nodes, edges };
+}