Formerly KrillinAI, VideoTranslation and Dubbing Tool for 120+ Languages. Open-source AI workspace for creators, powered by Codex. Video downloader, video translation, create videos, images, audios, and edits with Agents in one place. For your Social Media like YouTube, TikTok, Instagram, etc.
TypeScript agent-skillscodex-clideskop-appdubbingimage-generationlocalizationskillsttsvideo-editingvideo-generationvideo-transcriptionvideo-translation
import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import {
createDefaultCreatorServicesConfig,
videoGenerationModelIds,
type CreatorJson
} from '@opencreator/protocol';
import { afterEach, describe, expect, it, vi } from 'vitest';
import { createCreatorStageRunner } from '../../src/creator/stage-runner.js';
import { createCreatorRepository } from '../../src/creator/repository.js';
import {
CreatorServiceError,
createCreatorService
} from '../../src/creator/service.js';
import { createCreatorPresetRegistry } from '../../src/creator/presets/catalog.js';
import {
assertCreatorPresetStageRequirement
} from '../../src/creator/presets/requirements.js';
import type {
CompiledCreatorPreset
} from '../../src/creator/presets/types.js';
import { createDefaultCreatorTemplateRegistry } from '../../src/creator/templates/registry.js';
import { openRuntimeDatabase } from '../../src/storage/database.js';
let tempDir = '';
afterEach(() => {
if (tempDir) rmSync(tempDir, { recursive: true, force: true });
tempDir = '';
});
function setup() {
tempDir = mkdtempSync(join(tmpdir(), 'creator-service-'));
const db = openRuntimeDatabase(join(tempDir, 'app.sqlite'));
const repository = createCreatorRepository(db);
const service = createCreatorService({
repository,
templates: createDefaultCreatorTemplateRegistry()
});
return { db, repository, service };
}
describe('creator service', () => {
it('registers and deduplicates manually uploaded article images', () => {
const { db, service } = setup();
const job = service.createJob({
projectId: 'project_1',
templateId: 'wechat-article',
state: {}
});
const first = service.registerArticleImage(job.id, {
expectedRevision: job.revision,
path: join(tempDir, 'article-image.png'),
fileName: '配图.png',
mimeType: 'image/png',
size: 256,
sha256: '1234567890abcdef',
lastModified: null,
format: 'png'
});
const second = service.registerArticleImage(job.id, {
expectedRevision: first.job.revision,
path: join(tempDir, 'duplicate.png'),
fileName: '配图.png',
mimeType: 'image/png',
size: 256,
sha256: '1234567890abcdef',
lastModified: null,
format: 'png'
});
expect(first.artifact).toMatchObject({
kind: 'article_image',
metadata: {
fileName: 'article-upload-1234567890ab.png',
originalFileName: '配图.png',
source: 'local-upload'
}
});
expect(first.job.state.manualArticleImageArtifactIds).toEqual([first.artifact.id]);
expect(second.deduplicated).toBe(true);
expect(second.job.artifacts.filter(artifact => artifact.kind === 'article_image')).toHaveLength(1);
db.close();
});
it('registers and deduplicates source documents for WeChat article jobs', () => {
const { db, service } = setup();
const job = service.createJob({
projectId: 'project_1',
templateId: 'wechat-article',
state: {}
});
const first = service.registerSourceDocument(job.id, {
expectedRevision: job.revision,
path: join(tempDir, 'source.pdf'),
fileName: 'source.pdf',
mimeType: 'application/pdf',
size: 128,
sha256: 'same-document',
lastModified: null
});
const second = service.registerSourceDocument(job.id, {
expectedRevision: first.job.revision,
path: join(tempDir, 'duplicate.pdf'),
fileName: 'source.pdf',
mimeType: 'application/pdf',
size: 128,
sha256: 'same-document',
lastModified: null
});
expect(first.deduplicated).toBe(false);
expect(second.deduplicated).toBe(true);
expect(second.job.state.sourceDocumentArtifactIds).toEqual([first.artifact.id]);
expect(second.job.artifacts.filter(artifact => artifact.kind === 'source_document')).toHaveLength(1);
db.close();
});
it('rejects a source document when links and documents already total 10', () => {
const { db, service } = setup();
const sourceLinks = Array.from({ length: 9 }, (_, index) => ({
id: `source-${index}`,
url: `https://example.com/${index}`,
kind: 'webpage' as const,
label: `Source ${index}`
}));
const job = service.createJob({
projectId: 'project_1',
templateId: 'wechat-article',
state: { sourceLinks }
});
const tenth = service.registerSourceDocument(job.id, {
expectedRevision: job.revision,
path: join(tempDir, 'tenth.pdf'),
fileName: 'tenth.pdf',
mimeType: 'application/pdf',
size: 128,
sha256: 'tenth-document',
lastModified: null
});
expect(() => service.registerSourceDocument(job.id, {
expectedRevision: tenth.job.revision,
path: join(tempDir, 'eleventh.pdf'),
fileName: 'eleventh.pdf',
mimeType: 'application/pdf',
size: 128,
sha256: 'eleventh-document',
lastModified: null
})).toThrowError(expect.objectContaining<Partial<CreatorServiceError>>({
code: 'creator_source_limit_exceeded'
}));
db.close();
});
it('creates a draft preset job with resolved editable state and no stage run', async () => {
const config = createDefaultCreatorServicesConfig();
const { db, service } = setupPresetService([
preset({
module: 'image-generation',
id: 'ecommerce-product',
runtimeTemplate: { id: 'image-generation', version: 2 },
defaults: {
prompt: '中文商品主图',
size: '1536x1024',
quality: 'medium',
candidateCount: 2
},
defaultsByLocale: {
'en-US': { prompt: 'English product image' }
},
requirements: { service: 'image', capabilities: ['text-to-image'] }
})
], config);
const job = await service.createJob({
projectId: 'project_preset',
preset: {
module: 'image-generation',
id: 'ecommerce-product',
version: 1
},
locale: 'en-US',
creationKey: 'preset-create-1'
});
expect(job).toMatchObject({
templateId: 'image-generation',
templateVersion: 2,
status: 'draft',
state: {
prompt: 'English product image',
provider: 'codex-native',
size: '1536x1024',
quality: 'medium',
candidateCount: 2
},
presetOrigin: {
module: 'image-generation',
id: 'ecommerce-product',
version: 1,
locale: 'en-US',
title: 'Preset title',
contentHash: 'a'.repeat(64)
},
stages: []
});
expect(job.activities[0]?.details).toMatchObject({
requirementService: 'image',
requirementCapabilities: ['text-to-image']
});
expect(JSON.stringify(job)).not.toContain('apiKey');
db.close();
});
it('inherits the configured image provider for provider-agnostic image presets', async () => {
const config = createDefaultCreatorServicesConfig();
config.image.provider = 'codex-native';
const { db, service } = setupPresetService([
preset({
module: 'image-generation',
id: 'reference-image-preset',
runtimeTemplate: { id: 'image-generation', version: 2 },
defaults: {
prompt: 'Transform the uploaded portrait',
size: '1024x1536',
quality: 'high',
candidateCount: 1
}
})
], config);
const job = await service.createJob({
projectId: 'project_preset',
preset: {
module: 'image-generation',
id: 'reference-image-preset',
version: 1
},
locale: 'zh-CN',
creationKey: 'preset-create-codex-default'
});
expect(job.state).toMatchObject({
provider: 'codex-native',
candidateCount: 1
});
expect(job.presetOrigin?.id).toBe('reference-image-preset');
db.close();
});
it('replays only an identical resolved preset creation fingerprint', async () => {
const config = createDefaultCreatorServicesConfig();
config.video.seedance.model = videoGenerationModelIds.seedance[0];
const { db, service } = setupPresetService([
preset({
module: 'video-generation',
id: 'product-ad',
runtimeTemplate: { id: 'video-generation', version: 1 },
defaults: {
prompt: '中文广告',
size: '1280x720',
duration: 5
},
defaultsByLocale: {
'en-US': { prompt: 'English advertisement' }
}
})
], config);
const request = {
projectId: 'project_preset',
preset: {
module: 'video-generation' as const,
id: 'product-ad',
version: 1
},
locale: 'zh-CN' as const,
creationKey: 'preset-idempotency'
};
const created = await service.createJob(request);
const replayed = await service.createJob(request);
expect(replayed.id).toBe(created.id);
await expect(service.createJob({
...request,
locale: 'en-US'
})).rejects.toMatchObject({ code: 'creator_idempotency_key_reused' });
config.video.seedance.model = videoGenerationModelIds.seedance[1];
await expect(service.createJob(request)).rejects.toMatchObject({
code: 'creator_idempotency_key_reused'
});
expect(service.listJobs('project_preset')).toHaveLength(1);
db.close();
});
it('keeps edited preset state and avoids the executor when requirements are missing', async () => {
const config = createDefaultCreatorServicesConfig();
config.image.provider = 'jimeng';
config.image.jimeng.apiKey = 'configured-jimeng-key';
const { db, repository, service, templates } = setupPresetService([
preset({
module: 'image-generation',
id: 'paid-image',
runtimeTemplate: { id: 'image-generation', version: 2 },
defaults: {
prompt: 'Initial prompt',
size: '1536x1024',
quality: 'medium',
candidateCount: 2
},
requirements: { service: 'image', capabilities: ['reference-image'] }
})
], config);
const created = await service.createJob({
projectId: 'project_preset',
preset: {
module: 'image-generation',
id: 'paid-image',
version: 1
},
locale: 'zh-CN',
creationKey: 'preset-requirement'
});
const edited = service.applyAction(created.id, {
action: 'update-settings',
expectedRevision: created.revision,
input: {
patch: { prompt: 'Edited before execution' },
objectId: 'prompt'
}
}).job;
const run = vi.fn(async () => ({ outputs: [] }));
const runner = createCreatorStageRunner({
repository,
templates,
executors: [{ id: 'image', run }],
workRoot: join(tempDir, 'jobs'),
beforeRun(job, stageId) {
assertCreatorPresetStageRequirement({ job, stageId, services: config });
}
});
const stage = await runner.run(edited.id, 'generate');
const waiting = service.getJob(edited.id)!;
expect(stage).toMatchObject({
status: 'failed',
errorCode: 'creator_preset_requirement_missing'
});
expect(waiting).toMatchObject({
status: 'needs_input',
state: {
prompt: 'Edited before execution',
needsInput: {
code: 'creator_preset_requirement_missing',
deepLink: '#/settings?tab=ai-services§ion=image'
}
}
});
expect(run).not.toHaveBeenCalled();
await runner.close();
db.close();
});
it('does not let a preset pin the configured TTS model', async () => {
const config = createDefaultCreatorServicesConfig();
config.tts.provider = 'aliyun';
config.tts.aliyun.apiKey = 'configured-aliyun-key';
config.tts.aliyun.model = 'configured-default-model';
const { db, repository, service, templates } = setupPresetService([
preset({
module: 'smart-dubbing',
id: 'required-voice-model',
runtimeTemplate: { id: 'smart-dubbing', version: 1 },
defaults: {
text: 'A required voice model',
style: 'natural',
speed: 1,
format: 'mp3'
},
requirements: {
service: 'tts',
capabilities: ['speech-generation']
}
})
], config);
const created = await service.createJob({
projectId: 'project_preset',
preset: {
module: 'smart-dubbing',
id: 'required-voice-model',
version: 1
},
locale: 'en-US',
creationKey: 'preset-required-tts-model'
});
expect(created.state).toMatchObject({
ttsProvider: 'aliyun',
ttsModel: 'configured-default-model'
});
const edited = service.applyAction(created.id, {
action: 'update-settings',
expectedRevision: created.revision,
input: {
patch: { ttsModel: 'tampered-tts-model' },
objectId: 'ttsModel'
}
}).job;
const run = vi.fn(async () => ({ outputs: [] }));
const runner = createCreatorStageRunner({
repository,
templates,
executors: [{ id: 'smart-dubbing', run }],
workRoot: join(tempDir, 'jobs'),
beforeRun(job, stageId) {
assertCreatorPresetStageRequirement({ job, stageId, services: config });
}
});
const stage = await runner.run(edited.id, 'tts');
expect(stage).toMatchObject({
status: 'succeeded'
});
expect(run).toHaveBeenCalledOnce();
await runner.close();
db.close();
});
it('deletes inactive jobs and rejects jobs with an active stage', () => {
const { db, service } = setup();
const inactive = service.createJob({
projectId: 'project_1',
templateId: 'cover',
state: { prompt: '待删除封面' }
});
service.deleteJob(inactive.id);
expect(service.getJob(inactive.id)).toBeUndefined();
expect((db.prepare('SELECT COUNT(*) AS count FROM creator_activities WHERE job_id = ?')
.get(inactive.id) as { count: number }).count).toBe(0);
expect(() => service.deleteJob(inactive.id)).toThrowError(
expect.objectContaining<Partial<CreatorServiceError>>({ code: 'creator_job_not_found' })
);
const active = service.createJob({
projectId: 'project_1',
templateId: 'cover',
state: { prompt: '生成中的封面' }
});
service.applyAction(active.id, {
actor: 'user',
action: 'run-stage',
expectedRevision: active.revision,
input: { stageId: 'generate' }
});
expect(() => service.deleteJob(active.id)).toThrowError(
expect.objectContaining<Partial<CreatorServiceError>>({
code: 'creator_job_has_active_run'
})
);
expect(service.getJob(active.id)).toBeDefined();
db.close();
});
it('rejects a stale expectedRevision without overwriting state', () => {
const { db, service } = setup();
const job = service.createJob({
projectId: 'project_1',
templateId: 'video-translation',
state: { targetLanguage: 'en' }
});
const updated = service.applyAction(job.id, {
actor: 'user',
action: 'update-settings',
expectedRevision: 0,
input: { patch: { targetLanguage: 'ja' } }
});
expect(() => service.applyAction(job.id, {
actor: 'agent',
action: 'update-settings',
expectedRevision: 0,
input: { patch: { targetLanguage: 'fr' } }
})).toThrowError(expect.objectContaining<Partial<CreatorServiceError>>({
code: 'creator_revision_conflict',
latestRevision: 1
}));
expect(service.getJob(job.id)?.state.targetLanguage).toBe('ja');
expect(updated.job.revision).toBe(1);
db.close();
});
it('coalesces draft edits and preserves semantic actions', () => {
const { db, service } = setup();
const job = service.createJob({
projectId: 'project_1',
templateId: 'video-translation',
state: {
dubbing: true,
composeVideo: true,
videoFormat: 'horizontal'
}
});
const first = service.applyAction(job.id, {
actor: 'user',
action: 'update-settings',
expectedRevision: 0,
input: { patch: { verticalTitle: 'A' }, activityMode: 'draft', objectId: 'title' }
});
const second = service.applyAction(job.id, {
actor: 'user',
action: 'update-settings',
expectedRevision: first.job.revision,
input: { patch: { verticalTitle: 'AB' }, activityMode: 'draft', objectId: 'title' }
});
service.applyAction(job.id, {
actor: 'user',
action: 'update-settings',
expectedRevision: second.job.revision,
input: { patch: { verticalTitle: 'AB' }, activityMode: 'semantic', objectId: 'title' }
});
const activities = service.getJob(job.id)!.activities;
expect(activities.map(activity => activity.action)).toEqual([
'create-job',
'update-settings:draft',
'update-settings'
]);
expect(activities[1]?.revision).toBe(2);
db.close();
});
it('persists UI-only state without exposing it as creator activity', () => {
const { db, service } = setup();
const job = service.createJob({
projectId: 'project_1',
templateId: 'cover',
state: {}
});
const uiOnly = service.applyAction(job.id, {
actor: 'user',
action: 'update-settings',
expectedRevision: 0,
input: {
patch: {
currentStep: 1,
furthestStep: 1,
workspacePhase: 'configure'
},
activityMode: 'draft',
objectId: 'currentStep,furthestStep,workspacePhase'
}
});
expect(uiOnly.job.revision).toBe(1);
expect(uiOnly.job.state.currentStep).toBe(1);
expect(uiOnly.job.activities.map(activity => activity.action)).toEqual(['create-job']);
const mixed = service.applyAction(job.id, {
actor: 'user',
action: 'update-settings',
expectedRevision: uiOnly.job.revision,
input: {
patch: {
prompt: '高对比电影感人物封面',
currentStep: 2,
workspacePhase: 'result'
},
activityMode: 'draft',
objectId: 'currentStep,prompt,workspacePhase'
}
});
expect(mixed.job.activities.at(-1)).toMatchObject({
action: 'update-settings:draft',
details: { objectId: 'prompt' }
});
db.close();
});
it('records the structured stage id for run-stage activity', () => {
const { db, service } = setup();
const job = service.createJob({
projectId: 'project_1',
templateId: 'cover',
state: { prompt: '电影感人物封面' }
});
const started = service.applyAction(job.id, {
actor: 'user',
action: 'run-stage',
expectedRevision: 0,
input: { stageId: 'generate' }
});
expect(started.job.activities.at(-1)).toMatchObject({
action: 'run-stage',
details: { stageId: 'generate' }
});
db.close();
});
it('rejects missing or empty setting patches without advancing revision or activity', () => {
const { db, service } = setup();
const job = service.createJob({
projectId: 'project_1',
templateId: 'video-translation',
state: { targetLanguage: 'en' }
});
const invalidInputs: Array<Record<string, import('@opencreator/protocol').CreatorJson>> = [
{ objectId: 'targetLanguage' },
{ patch: {} }
];
for (const input of invalidInputs) {
expect(() => service.applyAction(job.id, {
actor: 'agent',
action: 'update-settings',
expectedRevision: 0,
input
})).toThrowError(expect.objectContaining<Partial<CreatorServiceError>>({
code: 'creator_action_input_invalid'
}));
const unchanged = service.getJob(job.id)!;
expect(unchanged.revision).toBe(0);
expect(unchanged.state.targetLanguage).toBe('en');
expect(unchanged.activities).toHaveLength(1);
}
db.close();
});
it('persists a structured subtitle style patch and records its object id', () => {
const { db, service } = setup();
const job = service.createJob({
projectId: 'project_1',
templateId: 'video-translation',
state: {}
});
const response = service.applyAction(job.id, {
actor: 'agent',
action: 'update-settings',
expectedRevision: 0,
input: {
patch: {
subtitleStyle: { primaryColor: '#F6C453' }
},
objectId: 'subtitleStyle'
}
});
expect(response.job.revision).toBe(1);
expect(response.job.state.subtitleStyle).toMatchObject({
fontPreset: 'sans',
fontWeight: 'bold',
fontSize: 'medium',
primaryColor: '#F6C453',
secondaryColor: '#D1D5DB',
outlineColor: '#000000',
outlineWidth: 2.5,
shadow: {
enabled: true,
opacity: 0.6,
offsetX: 1.5,
offsetY: 1.5,
blur: 0.5
}
});
expect(response.job.activities.at(-1)?.details.objectId).toBe('subtitleStyle');
db.close();
});
it('clears a persisted configuration request when a stage can start', () => {
const { db, service } = setup();
const job = service.createJob({
projectId: 'project_1',
templateId: 'video-translation',
state: {
sourceUrl: 'https://www.youtube.com/watch?v=test'
}
});
const waiting = service.setNeedsInput(job.id, {
code: 'creator_llm_config_missing',
message: '请先完成文本翻译模型配置'
});
const started = service.applyAction(job.id, {
actor: 'user',
action: 'run-stage',
expectedRevision: waiting.revision,
input: { stageId: 'subtitle' }
});
expect(started.job.status).toBe('running');
expect(started.job.state).not.toHaveProperty('needsInput');
db.close();
});
it('clears an obsolete TTS request when dubbing is turned off', () => {
const { db, repository, service } = setup();
const job = service.createJob({
projectId: 'project_1',
templateId: 'video-translation',
state: {
sourceUrl: 'https://www.youtube.com/watch?v=test',
dubbing: true
}
});
repository.createStageRun({
jobId: job.id,
stageId: 'subtitle',
executor: 'krillinai',
status: 'succeeded',
progress: { workflow: true }
});
const waiting = service.setNeedsInput(job.id, {
code: 'creator_tts_config_missing',
message: '请先完成目标语言配音服务配置'
});
const updated = service.applyAction(job.id, {
actor: 'user',
action: 'update-settings',
expectedRevision: waiting.revision,
input: { patch: { dubbing: false } }
});
expect(updated.job.status).toBe('completed');
expect(updated.job.state.dubbing).toBe(false);
expect(updated.job.state).not.toHaveProperty('needsInput');
db.close();
});
it.each([
['target_subtitle', '采访.片段.srt'],
['vertical_subtitle', '采访.片段.srt'],
['target_subtitle', '采访.片段.opencreator-bilingual-v1.opencreator-bilingual-v2.srt']
] as const)('keeps subtitle names bounded and previous files intact across repeated edits of %s from %s', (kind, fileName) => {
const { db, repository, service } = setup();
try {
const job = service.createJob({ projectId: 'project_1', templateId: 'video-translation', state: {} });
const path = join(tempDir, fileName);
writeFileSync(path, '1\n00:00:00,000 --> 00:00:01,000\nOriginal\n');
let subtitle = repository.insertArtifact({ jobId: job.id, kind, status: 'completed', path,
sourceArtifactIds: [], metadata: { fileName, resultVersion: 1 } });
repository.updateJob({ id: job.id, status: 'completed', revision: 0, state: {
...job.state, resultVersion: 1, latestResultVersion: 1,
resultSnapshots: [{ version: 1, createdAt: subtitle.createdAt, action: 'stage-succeeded', stageId: 'subtitle',
description: 'Initial subtitles', artifactRefs: { [kind]: [subtitle.id] },
changedArtifactIds: [subtitle.id], staleArtifactIds: [], state: {} }]
} });
let current = service.getJob(job.id)!;
const savedFiles = new Map([[path, readFileSync(path, 'utf8')]]);
const label = kind === 'target_subtitle' ? 'horizontal' : 'vertical';
for (const [index, preserveResultVersion] of [false, true, false].entries()) {
const response = service.applyAction(job.id, { actor: 'user', action: 'edit-subtitle', expectedRevision: current.revision,
input: { artifactId: subtitle.id, baseResultVersion: current.state.resultVersion!, preserveResultVersion,
cues: [{ id: 1, start: '00:00:00,000', end: '00:00:01,000', text: `Translation ${index}`,
...(kind === 'target_subtitle' ? { sourceText: `Source ${index}` } : {}) }] }
});
current = response.job;
subtitle = current.artifacts.filter(artifact => artifact.kind === kind).at(-1)!;
const resultVersion = index === 2 ? 3 : 2;
const editSuffix = index === 1 ? '-edit2' : '';
expect(subtitle.metadata.fileName).toBe(`采访.片段.opencreator-${label}-v${resultVersion}${editSuffix}.srt`);
for (const [savedPath, content] of savedFiles) expect(readFileSync(savedPath, 'utf8')).toBe(content);
const editedArtifacts = current.artifacts.filter(artifact => !savedFiles.has(artifact.path!));
for (const artifact of editedArtifacts) {
const content = readFileSync(artifact.path!, 'utf8');
expect(content).toContain(artifact.kind === 'source_subtitle' ? `Source ${index}` : `Translation ${index}`);
if (artifact.kind === 'target_subtitle') expect(content).not.toContain(`Source ${index}`);
if (artifact.kind === 'source_subtitle') expect(content).not.toContain(`Translation ${index}`);
if (artifact.kind === 'bilingual_subtitle') expect(content).toContain(`Source ${index}`);
savedFiles.set(artifact.path!, content);
}
}
} finally {
db.close();
}
});
it('stales subtitle-dependent outputs without invalidating source video or other versions', () => {
const { db, repository, service } = setup();
const job = service.createJob({
projectId: 'project_1',
templateId: 'video-translation',
state: {}
});
const subtitleV1 = repository.insertArtifact({
jobId: job.id,
kind: 'target_subtitle',
status: 'completed',
path: join(tempDir, 'v1.srt'),
scopeKey: null,
inputFingerprint: null,
sha256: null,
sourceArtifactIds: [],
metadata: { resultVersion: 1 }
});
const audioV1 = repository.insertArtifact({
jobId: job.id,
kind: 'dubbed_audio',
status: 'completed',
path: join(tempDir, 'v1.mp3'),
scopeKey: null,
inputFingerprint: null,
sha256: null,
sourceArtifactIds: [subtitleV1.id],
metadata: { resultVersion: 1 }
});
const subtitleV2 = repository.insertArtifact({
jobId: job.id,
kind: 'target_subtitle',
status: 'completed',
path: join(tempDir, 'v2.srt'),
scopeKey: null,
inputFingerprint: null,
sha256: null,
sourceArtifactIds: [],
metadata: { resultVersion: 2 }
});
const sourceVideo = repository.insertArtifact({
jobId: job.id,
kind: 'source_video',
status: 'completed',
path: join(tempDir, 'source.mp4'),
sourceArtifactIds: [subtitleV2.id],
metadata: { resultVersion: 2 }
});
const audioV2 = repository.insertArtifact({
jobId: job.id,
kind: 'dubbed_audio',
status: 'completed',
path: join(tempDir, 'v2.mp3'),
scopeKey: null,
inputFingerprint: null,
sha256: null,
sourceArtifactIds: [subtitleV2.id],
metadata: { resultVersion: 2 }
});
const videoV2 = repository.insertArtifact({
jobId: job.id,
kind: 'horizontal_video',
status: 'completed',
path: join(tempDir, 'v2.mp4'),
scopeKey: null,
inputFingerprint: null,
sha256: null,
sourceArtifactIds: [audioV2.id, subtitleV2.id],
metadata: { resultVersion: 2 }
});
repository.updateJob({
id: job.id,
status: 'completed',
revision: 0,
state: {
...job.state,
resultVersion: 2,
latestResultVersion: 2,
subtitlePosition: 'top',
resultSnapshots: [{
version: 1,
createdAt: '2026-09-03T00:00:00.000Z',
action: 'stage-succeeded',
stageId: 'tts',
description: '生成项目 V1',
artifactRefs: {
target_subtitle: [subtitleV1.id],
dubbed_audio: [audioV1.id]
},
changedArtifactIds: [subtitleV1.id, audioV1.id],
staleArtifactIds: [],
state: {}
}, {
version: 2,
createdAt: '2026-09-03T01:00:00.000Z',
action: 'stage-succeeded',
stageId: 'render-horizontal',
description: '生成项目 V2',
artifactRefs: {
source_video: [sourceVideo.id],
target_subtitle: [subtitleV2.id],
dubbed_audio: [audioV2.id],
horizontal_video: [videoV2.id]
},
changedArtifactIds: [subtitleV2.id, audioV2.id, videoV2.id],
staleArtifactIds: [],
state: { subtitlePosition: 'top' }
}]
}
});
const response = service.applyAction(job.id, {
actor: 'user',
action: 'edit-subtitle',
expectedRevision: 0,
input: {
artifactId: subtitleV2.id,
cues: [{
id: 1,
start: '00:00:00,000',
end: '00:00:01,000',
text: '修改后的字幕',
sourceText: 'Original subtitle'
}],
baseResultVersion: 2,
preserveResultVersion: true
}
});
const artifacts = service.getJob(job.id)!.artifacts;
expect(artifacts.find(item => item.id === sourceVideo.id)?.status).toBe('completed');
expect(artifacts.find(item => item.id === audioV1.id)?.status).toBe('completed');
expect(artifacts.find(item => item.id === audioV2.id)?.status).toBe('stale');
expect(artifacts.find(item => item.id === videoV2.id)?.status).toBe('stale');
const editedSubtitle = response.job.artifacts
.filter(item => item.kind === 'target_subtitle')
.at(-1)!;
expect(editedSubtitle.path).not.toBe(subtitleV2.path);
expect(readFileSync(editedSubtitle.path!, 'utf8')).toContain('修改后的字幕');
const editedBilingual = response.job.artifacts
.filter(item => item.kind === 'bilingual_subtitle')
.at(-1)!;
expect(readFileSync(editedBilingual.path!, 'utf8')).toContain(
'修改后的字幕\nOriginal subtitle'
);
const editedSource = response.job.artifacts.filter(item => item.kind === 'source_subtitle').at(-1)!;
expect(readFileSync(editedSource.path!, 'utf8')).toContain('Original subtitle');
expect(editedSource.metadata.cues).toMatchObject([{ text: 'Original subtitle' }]);
expect(editedSubtitle.version).toBe(3);
expect(editedSubtitle.metadata.resultVersion).toBe(2);
expect(response.job.state.resultVersion).toBe(2);
expect(response.job.state.latestResultVersion).toBe(2);
expect(response.job.state.resultSnapshots).toMatchObject([
{
version: 1,
artifactRefs: {
target_subtitle: [subtitleV1.id],
dubbed_audio: [audioV1.id]
},
staleArtifactIds: []
},
{
version: 2,
artifactRefs: {
source_video: [sourceVideo.id],
target_subtitle: [editedSubtitle.id],
bilingual_subtitle: [editedBilingual.id],
source_subtitle: [editedSource.id],
dubbed_audio: [audioV2.id],
horizontal_video: [videoV2.id]
},
staleArtifactIds: [audioV2.id, videoV2.id]
}
]);
db.close();
});
it('writes an editable vertical subtitle artifact and invalidates only its vertical video', () => {
const { db, repository, service } = setup();
const job = service.createJob({
projectId: 'project_1',
templateId: 'video-translation',
state: {
composeVideo: true,
videoFormat: 'all'
}
});
const horizontal = repository.insertArtifact({
jobId: job.id,
kind: 'horizontal_video',
status: 'completed',
path: join(tempDir, 'horizontal.mp4'),
scopeKey: null,
inputFingerprint: null,
sha256: null,
sourceArtifactIds: [],
metadata: { resultVersion: 1 }
});
const verticalSubtitle = repository.insertArtifact({
jobId: job.id,
kind: 'vertical_subtitle',
status: 'completed',
path: join(tempDir, 'vertical.srt'),
scopeKey: null,
inputFingerprint: null,
sha256: null,
sourceArtifactIds: [],
metadata: { resultVersion: 1 }
});
const verticalVideo = repository.insertArtifact({
jobId: job.id,
kind: 'vertical_video',
status: 'completed',
path: join(tempDir, 'vertical.mp4'),
scopeKey: null,
inputFingerprint: null,
sha256: null,
sourceArtifactIds: [verticalSubtitle.id],
metadata: { resultVersion: 1 }
});
repository.updateJob({
id: job.id,
status: 'completed',
revision: 0,
state: {
...job.state,
resultVersion: 1,
latestResultVersion: 1,
resultSnapshots: [{
version: 1,
createdAt: '2026-09-03T00:00:00.000Z',
action: 'stage-succeeded',
stageId: 'render-vertical',
description: '生成项目 V1',
artifactRefs: {
horizontal_video: [horizontal.id],
vertical_subtitle: [verticalSubtitle.id],
vertical_video: [verticalVideo.id]
},
changedArtifactIds: [horizontal.id, verticalSubtitle.id, verticalVideo.id],
staleArtifactIds: [],
state: {
composeVideo: true,
videoFormat: 'all'
}
}]
}
});
const response = service.applyAction(job.id, {
actor: 'user',
action: 'edit-subtitle',
expectedRevision: 0,
input: {
artifactId: verticalSubtitle.id,
cues: [{
id: 1,
start: '00:00:00,000',
end: '00:00:01,000',
text: '修改后的竖屏字幕'
}],
baseResultVersion: 1,
preserveResultVersion: true
}
});
const editedVertical = response.job.artifacts
.filter(item => item.kind === 'vertical_subtitle')
.at(-1)!;
expect(readFileSync(editedVertical.path!, 'utf8')).toContain('修改后的竖屏字幕');
expect(response.job.artifacts.find(item => item.id === horizontal.id)?.status).toBe('completed');
expect(response.job.artifacts.find(item => item.id === verticalVideo.id)?.status).toBe('stale');
expect(response.job.state.resultVersion).toBe(1);
expect(response.job.state.latestResultVersion).toBe(1);
expect(response.job.state.resultSnapshots).toMatchObject([{
version: 1,
artifactRefs: {
horizontal_video: [horizontal.id],
vertical_subtitle: [editedVertical.id],
vertical_video: [verticalVideo.id]
},
staleArtifactIds: [verticalVideo.id]
}]);
db.close();
});
it('commits a settings-only project version from the selected base snapshot', () => {
const { db, repository, service } = setup();
const job = service.createJob({
projectId: 'project_1',
templateId: 'video-translation',
state: {
composeVideo: false,
videoFormat: 'horizontal'
}
});
const subtitle = repository.insertArtifact({
jobId: job.id,
kind: 'target_subtitle',
status: 'completed',
path: join(tempDir, 'subtitle-v1.srt'),
scopeKey: null,
inputFingerprint: null,
sha256: null,
sourceArtifactIds: [],
metadata: { resultVersion: 1 }
});
const video = repository.insertArtifact({
jobId: job.id,
kind: 'horizontal_video',
status: 'completed',
path: join(tempDir, 'video-v1.mp4'),
scopeKey: null,
inputFingerprint: null,
sha256: null,
sourceArtifactIds: [subtitle.id],
metadata: { resultVersion: 1 }
});
repository.updateJob({
id: job.id,
status: 'completed',
revision: 0,
state: {
...job.state,
resultVersion: 1,
latestResultVersion: 1,
resultSnapshots: [{
version: 1,
createdAt: '2026-08-30T00:00:00.000Z',
action: 'stage-succeeded',
stageId: 'render-horizontal',
description: '合成横屏视频',
artifactRefs: {
target_subtitle: [subtitle.id],
horizontal_video: [video.id]
},
changedArtifactIds: [subtitle.id, video.id],
staleArtifactIds: [],
state: {
composeVideo: true,
videoFormat: 'horizontal'
}
}]
}
});
const response = service.applyAction(job.id, {
actor: 'user',
action: 'commit-version',
expectedRevision: 0,
input: { baseResultVersion: 1 }
});
expect(response.job.state.resultVersion).toBe(2);
expect(response.job.state.resultSnapshots).toMatchObject([
{ version: 1 },
{
version: 2,
action: 'commit-version',
artifactRefs: {
target_subtitle: [subtitle.id]
},
state: {
composeVideo: false,
videoFormat: 'horizontal'
}
}
]);
expect(response.job.state.resultSnapshots).not.toMatchObject([
{},
{ artifactRefs: { horizontal_video: expect.anything() } }
]);
db.close();
});
});
function setupPresetService(
presets: CompiledCreatorPreset[],
config = createDefaultCreatorServicesConfig()
) {
tempDir = mkdtempSync(join(tmpdir(), 'creator-service-preset-'));
const db = openRuntimeDatabase(join(tempDir, 'app.sqlite'));
const repository = createCreatorRepository(db);
const templates = createDefaultCreatorTemplateRegistry();
const service = createCreatorService({
repository,
templates,
presets: createCreatorPresetRegistry({
catalog: { schemaVersion: 1, presets },
catalogHash: 'f'.repeat(64)
}),
creatorServicesConfig: {
async read() {
return structuredClone(config);
}
}
});
return { db, repository, service, templates };
}
function preset(input: {
module: CompiledCreatorPreset['module'];
id: string;
runtimeTemplate: CompiledCreatorPreset['runtimeTemplate'];
defaults: Record<string, CreatorJson>;
defaultsByLocale?: CompiledCreatorPreset['defaultsByLocale'];
requirements?: CompiledCreatorPreset['requirements'];
}): CompiledCreatorPreset {
return {
schemaVersion: 1,
module: input.module,
id: input.id,
version: 1,
runtimeTemplate: input.runtimeTemplate,
status: 'published',
featured: true,
sortOrder: 10,
title: {
'zh-CN': 'Preset title',
'en-US': 'Preset title'
},
description: {
'zh-CN': 'Preset description',
'en-US': 'Preset description'
},
tags: ['test'],
defaults: input.defaults,
...(input.defaultsByLocale === undefined
? {}
: { defaultsByLocale: input.defaultsByLocale }),
...(input.requirements === undefined
? {}
: { requirements: input.requirements }),
cover: {
source: `${input.module}/${input.id}/1/cover.webp`,
asset: `assets/${'b'.repeat(64)}.webp`,
sha256: 'b'.repeat(64),
mime: 'image/webp',
width: 1280,
height: 720,
size: 1024
},
contentHash: 'a'.repeat(64)
};
}