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 { copyFile, link, lstat, mkdir, realpath, rename, writeFile } from 'node:fs/promises';
import { normalizeVideoSourceUrl, publicErrorCodeFromFailure, videoSourceIdentity, normalizeCreatorLanguage } from '@opencreator/protocol';
import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
import type {
CreatorArtifact,
CreatorJson,
CreatorServicesConfig
} from '@opencreator/protocol';
import type { CreatorServicesConfigStore } from '../../creator-services/config-store.js';
import type {
CreatorExecutor,
CreatorExecutorInput,
CreatorExecutorOutput,
CreatorExecutorResult
} from '../executor.js';
import { CreatorExecutorError } from '../executor.js';
import { publicFactsFromFailure } from '../public-error-facts.js';
import { creatorSubtitleStyleSchema } from '../presets/module-schemas.js';
import { validateMediaFile } from '../validators/media.js';
import { formatSrtTimestamp, validateSrtFile } from '../validators/srt.js';
import {
KrillinCliError,
resolveKrillinCliSource,
runKrillinCli,
type KrillinResultArtifact
} from './cli-runner.js';
import type { KrillinDependencyLoader } from './dependency-loader.js';
import { preflightKrillinDependencies } from './dependency-preflight.js';
import { createKrillinCliExecutionPlan } from './execution-plan.js';
import { readKrillinRuntimeManifest, resolveInside } from './manifest.js';
import type { YtDlpRuntime } from '../yt-dlp/runtime.js';
import { assessKrillinTranscription } from './transcription-language.js';
import { translationResumeStage } from './translation-resume.js';
export function createKrillinExecutor(input: {
resourceRoot: string;
jobsRoot: string;
dependencyLoader: KrillinDependencyLoader;
configStore: Pick<CreatorServicesConfigStore, 'read'>;
getYtDlpRuntime?(sourceUrl?: string): YtDlpRuntime | undefined;
verificationCachePath?: string;
ensureRuntimeReady?(): Promise<void>;
getCodexLlmConfig?(): { baseUrl: string; apiKey: string; model: string } | undefined;
}): CreatorExecutor {
return {
id: 'krillinai',
async run(stageInput): Promise<CreatorExecutorResult> {
let stage = filterObsoleteSourceVideo(stageInput);
await input.ensureRuntimeReady?.();
const configured = await input.configStore.read();
const preflight = preflightKrillinDependencies(input.resourceRoot, configured, {
cachePath: input.verificationCachePath
});
const ffprobe = executablePath(input.resourceRoot, /(?:^|\/)ffprobe(?:\.exe)?$/i);
const options = buildKrillinStageOptions(stage);
const llmOverride = preflight.config.llm.source === 'codex' ? input.getCodexLlmConfig?.() : undefined;
stage = translationResumeStage(stage, options, preflight.config, llmOverride);
await mkdir(stage.workdir, { recursive: true });
const materializedArtifacts = await writeArtifactIndex(input.jobsRoot, stage);
let artifacts: KrillinResultArtifact[];
let captionFallbackProgress: Record<string, CreatorJson> = {};
let transcriptionMetadata: Record<string, CreatorJson> | undefined;
try {
const attempts = createKrillinCliExecutionPlan(
resolveKrillinStageContract(stage).stageType,
{
sourceUrl: stringValue(options.sourceUrl),
mediaSource: resolveKrillinCliSource(materializedArtifacts, { ...options, captionSource: 'whisper' })
},
options
);
let completed: KrillinResultArtifact[] | undefined;
let deferredFailure: KrillinCliError | undefined;
for (const attempt of attempts) {
const attemptStage: CreatorExecutorInput = {
...stage,
reportProgress(progress) {
if (progress.providerStatus === 'failed' && attempt.continueOnErrorCodes !== undefined) return;
stage.reportProgress({ ...progress, ...captionFallbackProgress });
}
};
try {
if (requiresTranscriptionDependency(stage.stageRun.stageId, attempt.options)) {
if (!stage.inputArtifacts.some(artifact => artifact.kind === 'source_subtitle' || artifact.kind === 'target_subtitle')) {
const assessment = assessKrillinTranscription(preflight.config, stringValue(attempt.options.originLanguage) ?? 'en');
if (assessment.support === 'unsupported') throw new CreatorExecutorError('creator_transcription_language_unsupported',
`${assessment.provider} / ${assessment.model} does not support ${assessment.productLanguage}. Change the speech recognition service or import source subtitles.`);
if (assessment.capability.timestamps === 'none') throw new CreatorExecutorError('creator_transcription_timestamps_unavailable',
'Select a speech recognition service that returns subtitle timestamps.');
transcriptionMetadata = { provider: assessment.provider, model: assessment.model, executionModel: assessment.executionModel,
productLanguage: assessment.productLanguage, backendLanguage: assessment.backendLanguage,
profileVersion: assessment.capability.profileVersion, languageSupport: assessment.support };
}
await ensureKrillinTranscriptionDependency(
input.dependencyLoader,
preflight.config,
attemptStage,
typeof captionFallbackProgress.captionFallbackMessage === 'string'
? captionFallbackProgress.captionFallbackMessage
: undefined
);
}
completed = await runKrillinCli({
resourceRoot: input.resourceRoot,
jobsRoot: input.jobsRoot,
dependencyRoot: input.dependencyLoader.root,
manifest: preflight.manifest,
stage: attemptStage,
config: preflight.config,
artifacts: materializedArtifacts,
source: attempt.source,
options: attempt.options,
ytDlpRuntime: input.getYtDlpRuntime?.(stringValue(attempt.options.sourceUrl)),
llmOverride
});
break;
} catch (error) {
if (
error instanceof KrillinCliError
&& attempt.continueOnErrorCodes?.includes(error.code)
&& !stage.signal.aborted
) {
deferredFailure = error;
const message = error.code === 'platform_caption_invalid'
? 'Platform subtitle parsing failed. Switched to speech transcription.'
: 'No usable platform subtitles were found. Switched to speech transcription.';
captionFallbackProgress = {
captionSource: 'whisper',
captionFallbackCode: error.code,
captionFallbackMessage: message
};
stage.reportProgress({
...captionFallbackProgress,
phase: 'fallback_to_transcription',
providerStatus: 'running',
percent: 25,
message
});
continue;
}
if (deferredFailure !== undefined) {
throw combineKrillinFallbackFailures(deferredFailure, error);
}
throw error;
}
}
if (completed === undefined) {
throw new CreatorExecutorError(
'krillin_stage_failed',
'KrillinAI exhausted the subtitle execution plan'
);
}
artifacts = completed;
} catch (error) {
if (!(error instanceof KrillinCliError)) throw error;
const normalized = normalizeKrillinFailure({
code: error.code,
kind: error.kind,
message: error.message
});
throw CreatorExecutorError.from(normalized.code, error, normalized.message);
}
const relevantArtifacts = stage.job.templateId === 'auto-clip'
&& stage.stageRun.stageId === 'subtitle'
? artifacts.filter(artifact => artifact.kind === 'target_subtitle')
: artifacts;
const outputs = await validateResultArtifacts({
stage,
jobsRoot: input.jobsRoot,
artifacts: relevantArtifacts,
ffprobe
});
if (transcriptionMetadata) for (const output of outputs) output.metadata = { ...output.metadata, transcription: transcriptionMetadata };
return {
outputs: stage === stageInput ? outputs : outputs.map(output => ({
...output,
sourceArtifactIds: output.sourceArtifactIds ?? stage.inputArtifacts.map(artifact => artifact.id)
})),
progress: {
...stage.stageRun.progress,
...captionFallbackProgress,
krillinMode: 'cli',
providerStatus: 'succeeded',
percent: 100,
completedOutputKinds: outputs.map(output => output.kind)
}
};
}
};
}
function filterObsoleteSourceVideo(input: CreatorExecutorInput): CreatorExecutorInput {
const sourceUrl = stringValue(input.job.state.sourceUrl);
if (input.job.templateId !== 'video-translation' || input.job.state.sourceType === 'file' || !sourceUrl) {
return input;
}
const inputArtifacts = input.inputArtifacts.filter(artifact => {
if (artifact.kind !== 'source_video') return true;
const snapshot = artifact.metadata?.settingsSnapshot;
return snapshot !== null && typeof snapshot === 'object' && !Array.isArray(snapshot)
&& snapshot.sourceType !== 'file' && typeof snapshot.sourceUrl === 'string'
&& videoSourceIdentity(snapshot.sourceUrl) !== null
&& videoSourceIdentity(snapshot.sourceUrl) === videoSourceIdentity(sourceUrl);
});
return inputArtifacts.length === input.inputArtifacts.length ? input : { ...input, inputArtifacts };
}
function requiresTranscriptionDependency(
stageId: string,
options: Record<string, unknown>
): boolean {
return stageId === 'subtitle' && options.captionSource !== 'platform';
}
async function ensureKrillinTranscriptionDependency(
loader: KrillinDependencyLoader,
config: CreatorServicesConfig,
stage: CreatorExecutorInput,
fallbackMessage?: string
): Promise<void> {
if (stage.job.templateId === 'video-translation' && (
stage.stageRun.stageId === 'subtitle'
? stage.inputArtifacts.some(artifact => artifact.kind === 'source_subtitle' || artifact.kind === 'target_subtitle')
: typeof stage.job.state.importedSourceSubtitleId === 'string' || typeof stage.job.state.importedTargetSubtitleId === 'string'
)) return;
await loader.ensure({
config,
signal: stage.signal,
reportProgress(progress) {
stage.reportProgress({ ...stage.stageRun.progress, ...progress,
...(fallbackMessage && typeof progress.message === 'string'
? { message: `${fallbackMessage}。${progress.message}` }
: {})
});
}
});
}
export function normalizeKrillinFailure(error: { code?: string; kind?: string; message?: string } | undefined): {
code: string;
message: string;
} {
const message = error?.message ?? 'KrillinAI stage failed';
if (/^prepare_(?:media|audio_fallback)_failed$/.test(error?.code ?? '') && /\[Douyin(?:\+[^\]]+)?\]/i.test(message)) {
if (/Douyin request signature is required/i.test(message)) return { code: 'platform_request_signature_required', message };
if (/fresh cookies|Douyin browser identity was rejected/i.test(message)) return { code: 'platform_session_required', message };
}
if (error?.code !== undefined && [
'audio_no_speech', 'audio_transcription_empty', 'audio_transcription_invalid_response',
'audio_transcription_timestamps_missing', 'audio_transcription_api_failed'
].includes(error.code)) {
return { code: error.code, message };
}
if (
error?.code === 'subtitle_style_load_failed'
|| error?.code === 'default_subtitle_style_load_failed'
|| /(?:fontconfig|fontconfig error|could not load font|failed to find.*font|subtitle style)/i.test(message)
) {
return { code: 'creator_subtitle_style_unsupported', message };
}
if (/OpenAI.*(?:杞綍|转录|transcri)|(?:杞綍|转录|transcri).*OpenAI/i.test(message)) {
return { code: 'creator_transcription_config_missing', message };
}
if (error?.code === 'usage' || error?.kind === 'usage') {
if (/(?:TTS|閰嶉煶|配音|语音合成)/i.test(message)) {
return { code: 'creator_tts_config_missing', message };
}
if (/(?:LLM|澶фā鍨媩鏂囨湰缈昏瘧|大模型|文本翻译)/i.test(message)) {
return { code: 'creator_llm_config_missing', message };
}
}
return { code: error?.kind === 'usage' ? 'usage' : error?.code ?? 'krillin_stage_failed', message };
}
export function buildKrillinStageOptions(input: CreatorExecutorInput): Record<string, unknown> {
const state = input.job.state;
return compactObject({
sourceType: state.sourceType,
sourceUrl: state.sourceType !== 'subtitle' && typeof state.sourceUrl === 'string' ? normalizeVideoSourceUrl(state.sourceUrl) : undefined,
originLanguage: normalizeKrillinLanguage(
typeof state.sourceLanguage === 'string' ? state.sourceLanguage : undefined
),
targetLanguage: normalizeKrillinLanguage(
typeof state.targetLanguage === 'string' ? state.targetLanguage : undefined
),
captionSource: state.preferPlatformCaptions === false ? 'whisper' : 'any',
sourceOnly: input.job.templateId === 'stickman-video'
&& input.stageRun.stageId === 'source-transcript',
prepareVideo: input.job.templateId !== 'video-translation',
audioOnly: input.job.templateId === 'video-translation',
bilingual: input.stageRun.stageId === 'subtitles' || state.bilingual === true,
bilingualTop: state.subtitlePosition !== 'bottom',
ttsProvider: typeof state.ttsProvider === 'string' ? state.ttsProvider : undefined,
ttsModel: typeof state.ttsModel === 'string' ? state.ttsModel : undefined,
voiceCode: typeof state.voiceCode === 'string' ? state.voiceCode : undefined,
verticalTitle: typeof state.verticalTitle === 'string' ? state.verticalTitle : undefined,
verticalSubtitle: typeof state.verticalSubtitle === 'string' ? state.verticalSubtitle : undefined,
dubbed: state.dubbing === true || state.dubbed === true,
subtitleStyle: buildKrillinSubtitleStyle(state.subtitleStyle ?? (
input.job.templateId === 'video-translation' ? compactObject({
fontPreset: state.subtitleFont ?? 'sans',
fontWeight: state.subtitleWeight,
fontSize: state.subtitleSize,
primaryColor: state.subtitleColor,
secondaryColor: state.subtitleSecondaryColor,
outlineColor: state.subtitleOutlineColor,
outlineWidth: state.subtitleOutlineWidth,
shadow: compactObject({
enabled: state.subtitleShadowEnabled,
color: state.subtitleShadowColor,
opacity: state.subtitleShadowOpacity,
offsetX: state.subtitleShadowOffsetX,
offsetY: state.subtitleShadowOffsetY,
blur: state.subtitleShadowBlur
})
}) as CreatorJson : undefined
))
});
}
export function normalizeKrillinLanguage(value: string | undefined): string | undefined {
return value?.trim() ? normalizeCreatorLanguage(value) : undefined;
}
function combineKrillinFallbackFailures(platformFailure: KrillinCliError, fallbackFailure: unknown): Error {
const fallbackMessage = fallbackFailure instanceof Error
? fallbackFailure.message
: 'Unknown audio transcription failure';
const message = `Platform captions failed: ${platformFailure.message}; audio transcription fallback failed: ${fallbackMessage}`;
if (fallbackFailure instanceof KrillinCliError) {
return new KrillinCliError(
fallbackFailure.code,
message,
fallbackFailure.kind,
fallbackFailure.retryable,
{ cause: fallbackFailure }
);
}
if (fallbackFailure instanceof CreatorExecutorError) {
return new CreatorExecutorError(fallbackFailure.code, message, {},
fallbackFailure.publicFacts, { cause: fallbackFailure });
}
return new CreatorExecutorError(publicErrorCodeFromFailure(fallbackFailure) ?? 'krillin_stage_failed',
message, {}, publicFactsFromFailure(fallbackFailure), { cause: fallbackFailure });
}
export function buildKrillinSubtitleStyle(value: CreatorJson | undefined): Record<string, unknown> | undefined {
if (value === null || typeof value !== 'object' || Array.isArray(value)) return undefined;
if (Object.keys(value).length === 0) return undefined;
const parsed = creatorSubtitleStyleSchema.safeParse(value);
if (!parsed.success) {
throw new CreatorExecutorError(
'creator_subtitle_style_unsupported',
`Unsupported subtitle style: ${parsed.error.issues.map(issue => issue.message).join('; ')}`
);
}
const style = parsed.data;
const fontName = `${subtitleFontFamily(style.fontPreset)} ${subtitleWeightName(style.fontWeight)}`;
const bold = style.fontWeight === 'bold';
const backColor = assBackColor(style.shadow.color, style.shadow.opacity);
const shadow = style.shadow.enabled
? Math.max(Math.abs(style.shadow.offsetX), Math.abs(style.shadow.offsetY))
: 0;
const overrideTags = style.shadow.enabled
? `\\xshad${formatAssNumber(style.shadow.offsetX)}\\yshad${formatAssNumber(style.shadow.offsetY)}\\blur${formatAssNumber(style.shadow.blur)}`
: '';
const sizes = subtitleFontSizes(style.fontSize);
const createStyle = (
name: 'Major' | 'Minor',
fontSize: number,
primaryColor: string,
marginV: number
) => ({
name,
font_name: fontName,
font_size: fontSize,
primary_color: primaryColor,
secondary_color: primaryColor,
outline_color: style.outlineColor,
back_color: backColor,
bold,
italic: false,
underline: false,
strike_out: false,
scale_x: 100,
scale_y: 100,
spacing: 0,
angle: 0,
border_style: 1,
outline: style.outlineWidth,
shadow,
alignment: 2,
margin_l: 10,
margin_r: 10,
margin_v: marginV,
encoding: 1,
override_tags: overrideTags
});
return {
version: 1,
horizontal: {
major: createStyle('Major', sizes.horizontalMajor, style.primaryColor, 20),
minor: createStyle('Minor', sizes.horizontalMinor, style.secondaryColor, 30)
},
vertical: {
major: createStyle('Major', sizes.verticalMajor, style.primaryColor, 101),
minor: createStyle('Minor', sizes.verticalMinor, style.secondaryColor, 92)
}
};
}
function subtitleFontFamily(preset: 'system' | 'sans' | 'serif' | 'rounded'): string {
if (preset === 'serif') return 'OpenCreator Serif';
if (preset === 'rounded') return 'OpenCreator Rounded';
return 'OpenCreator Sans';
}
function subtitleWeightName(weight: 'regular' | 'medium' | 'bold'): string {
if (weight === 'medium') return 'Medium';
if (weight === 'bold') return 'Bold';
return 'Regular';
}
function subtitleFontSizes(size: 'small' | 'medium' | 'large'): {
horizontalMajor: number;
horizontalMinor: number;
verticalMajor: number;
verticalMinor: number;
} {
if (size === 'small') {
return { horizontalMajor: 14, horizontalMinor: 10, verticalMajor: 12, verticalMinor: 7 };
}
if (size === 'large') {
return { horizontalMajor: 22, horizontalMinor: 15, verticalMajor: 18, verticalMinor: 11 };
}
return { horizontalMajor: 18, horizontalMinor: 12, verticalMajor: 15, verticalMinor: 9 };
}
function assBackColor(color: string, opacity: number): string {
const hex = color.slice(1).toUpperCase();
const alpha = Math.round(255 * (1 - opacity)).toString(16).padStart(2, '0').toUpperCase();
return `&H${alpha}${hex.slice(4, 6)}${hex.slice(2, 4)}${hex.slice(0, 2)}`;
}
function formatAssNumber(value: number): string {
return Number.isInteger(value) ? String(value) : String(Number(value.toFixed(3)));
}
async function writeArtifactIndex(
jobsRoot: string,
input: CreatorExecutorInput
): Promise<Array<{ id: string; kind: string; path: string }>> {
const jobRoot = resolve(jobsRoot, input.job.id);
await mkdir(jobRoot, { recursive: true });
const entries: Array<{ id: string; kind: string; relativePath: string; path: string }> = [];
for (const artifact of input.inputArtifacts) {
if (artifact.path === null) continue;
const path = await materializeArtifact(jobRoot, artifact);
entries.push({
id: artifact.id,
kind: krillinInputKind(input, artifact.kind),
relativePath: relative(jobRoot, path).replaceAll('\\', '/'),
path
});
}
const target = join(jobRoot, 'artifact-index.json');
const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
await writeFile(temporary, `${JSON.stringify({
artifacts: entries.map(({ path: _path, ...entry }) => entry)
}, null, 2)}\n`, { mode: 0o600 });
await rename(temporary, target);
return entries.map(({ id, kind, path }) => ({ id, kind, path }));
}
async function materializeArtifact(jobRoot: string, artifact: CreatorArtifact): Promise<string> {
const source = await realpath(artifact.path!);
const sourceStat = await lstat(source);
if (!sourceStat.isFile() || sourceStat.isSymbolicLink()) {
throw new CreatorExecutorError('creator_artifact_invalid', `Artifact ${artifact.id} is not a regular file`);
}
if (isInside(jobRoot, source)) return source;
const destination = join(jobRoot, 'imports', artifact.id, basename(source));
await mkdir(dirname(destination), { recursive: true });
try {
await link(source, destination);
} catch (error) {
if ((error as NodeJS.ErrnoException).code !== 'EEXIST') await copyFile(source, destination);
}
const actual = await realpath(destination);
if (!isInside(jobRoot, actual)) {
throw new CreatorExecutorError('creator_artifact_path_escape', `Artifact ${artifact.id} escaped the Job root`);
}
return actual;
}
export async function validateResultArtifacts(input: {
stage: CreatorExecutorInput;
jobsRoot: string;
artifacts: KrillinResultArtifact[];
ffprobe: string;
}): Promise<CreatorExecutorOutput[]> {
const contract = resolveKrillinStageContract(input.stage);
const outputs: CreatorExecutorOutput[] = [];
const jobRoot = await realpath(resolve(input.jobsRoot, input.stage.job.id));
for (const artifact of input.artifacts) {
if (!contract.allowedOutputKinds.has(artifact.kind)) {
throw new CreatorExecutorError('krillin_output_mismatch', `KrillinAI returned undeclared output ${artifact.kind}`);
}
const outputKind = contract.outputAliases[artifact.kind];
if (outputKind === undefined) continue;
const path = await realpath(resolve(input.jobsRoot, artifact.relativePath));
if (!isInside(jobRoot, path)) {
throw new CreatorExecutorError('krillin_output_escape', 'KrillinAI output escapes the current Job root');
}
let metadata: Record<string, CreatorJson> = {
...artifact.metadata,
fileName: basename(path),
settingsSnapshot: input.stage.job.state,
sha256: artifact.sha256 ?? null,
bytes: artifact.size ?? null
};
if (outputKind.includes('subtitle')) {
const cues = await validateSrtFile(path, {
allowOverlaps: outputKind === 'vertical_subtitle'
});
metadata = {
...metadata,
cueCount: cues.length,
cues: cues.map(cue => ({
id: cue.index,
start: formatSrtTimestamp(cue.startMs),
end: formatSrtTimestamp(cue.endMs),
text: cue.text
}))
};
} else {
metadata = { ...metadata, ...(await validateMediaFile(path, input.ffprobe)) };
}
outputs.push({ kind: outputKind, status: 'completed', path, metadata,
...(outputKind === 'source_video' && input.stage.stageRun.stageId !== 'subtitle' ? { sourceArtifactIds: [] } : {})
});
}
for (const required of contract.requiredOutputKinds) {
if (required === 'source_subtitle' && input.stage.inputArtifacts.some(artifact => artifact.kind === 'target_subtitle')) continue;
if (!outputs.some(output => output.kind === required)) {
throw new CreatorExecutorError('krillin_output_missing', `KrillinAI did not produce ${required}`);
}
}
return outputs;
}
function executablePath(resourceRoot: string, pattern: RegExp): string {
const manifest = readKrillinRuntimeManifest(resourceRoot);
const resource = manifest.resources.find(candidate => candidate.kind === 'executable' && pattern.test(candidate.path));
if (resource === undefined) throw new CreatorExecutorError('dependency_not_packaged', `Missing runtime executable: ${pattern}`);
return resolveInside(resourceRoot, resource.path);
}
export type KrillinStageContract = {
stageType: 'subtitle' | 'tts' | 'render-horizontal' | 'render-vertical';
allowedOutputKinds: Set<string>;
outputAliases: Record<string, string | undefined>;
requiredOutputKinds: string[];
};
export function resolveKrillinStageContract(
input: Pick<CreatorExecutorInput, 'job' | 'stageRun'>
): KrillinStageContract {
const stageId = input.stageRun.stageId;
if (input.job.templateId === 'stickman-video') {
if (stageId === 'source-transcript') return {
stageType: 'subtitle',
allowedOutputKinds: new Set(['source_video', 'source_subtitle', 'target_subtitle', 'bilingual_subtitle', 'vertical_subtitle']),
outputAliases: { source_subtitle: 'source_subtitle' },
requiredOutputKinds: ['source_subtitle']
};
if (stageId === 'narration') return {
stageType: 'tts',
allowedOutputKinds: new Set(['dubbed_audio', 'dubbed_video', 'narration_audio']),
outputAliases: { dubbed_audio: 'narration_audio', narration_audio: 'narration_audio' },
requiredOutputKinds: ['narration_audio']
};
if (stageId === 'subtitles') return {
stageType: 'subtitle',
allowedOutputKinds: new Set(['source_video', 'source_subtitle', 'target_subtitle', 'bilingual_subtitle', 'vertical_subtitle']),
outputAliases: { bilingual_subtitle: 'bilingual_subtitle' },
requiredOutputKinds: ['bilingual_subtitle']
};
if (stageId === 'bilingual-render') return {
stageType: 'render-horizontal',
allowedOutputKinds: new Set(['horizontal_video', 'bilingual_video']),
outputAliases: { horizontal_video: 'bilingual_video', bilingual_video: 'bilingual_video' },
requiredOutputKinds: ['bilingual_video']
};
}
if (input.job.templateId === 'auto-clip' && stageId === 'subtitle') {
return {
stageType: 'subtitle',
allowedOutputKinds: new Set(['target_subtitle']),
outputAliases: { target_subtitle: 'target_subtitle' },
requiredOutputKinds: ['target_subtitle']
};
}
if (stageId === 'subtitle' || stageId === 'tts' || stageId === 'render-horizontal' || stageId === 'render-vertical') {
const expected = expectedOutputKinds(stageId);
return {
stageType: stageId,
allowedOutputKinds: expected,
outputAliases: Object.fromEntries([...expected].map(kind => [kind, kind])),
requiredOutputKinds: requiredOutputKinds(stageId, input.job.templateId)
};
}
throw new CreatorExecutorError('creator_stage_not_supported', `Unsupported KrillinAI stage ${stageId}`);
}
function krillinInputKind(input: CreatorExecutorInput, kind: string): string {
if (input.job.templateId !== 'stickman-video') return kind;
if (input.stageRun.stageId === 'narration' && kind === 'narration_subtitle') {
return 'target_subtitle';
}
if (
(input.stageRun.stageId === 'subtitles' || input.stageRun.stageId === 'bilingual-render')
&& kind === 'clean_video'
) {
return 'source_video';
}
return kind;
}
function expectedOutputKinds(stageId: string): Set<string> {
if (stageId === 'subtitle') return new Set([
'source_video',
'source_subtitle',
'target_subtitle',
'bilingual_subtitle',
'vertical_subtitle'
]);
if (stageId === 'tts') return new Set(['source_video', 'dubbed_audio', 'dubbed_video']);
if (stageId === 'render-horizontal') return new Set(['source_video', 'horizontal_video']);
if (stageId === 'render-vertical') return new Set(['source_video', 'vertical_video']);
return new Set();
}
function requiredOutputKinds(stageId: string, templateId?: string): string[] {
if (stageId === 'subtitle' && templateId === 'auto-clip') {
return ['target_subtitle'];
}
if (stageId === 'subtitle') {
return [...(templateId === 'video-translation' ? [] : ['source_video']), 'source_subtitle', 'target_subtitle', 'vertical_subtitle'];
}
if (stageId === 'tts') return ['dubbed_audio'];
if (stageId === 'render-horizontal') return ['horizontal_video'];
if (stageId === 'render-vertical') return ['vertical_video'];
return [];
}
function isInside(root: string, path: string): boolean {
const rel = relative(resolve(root), resolve(path));
return rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
}
function compactObject(value: Record<string, unknown>): Record<string, unknown> {
return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
}
function stringValue(value: unknown): string | undefined {
return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
}
function nonEmptyString(value: CreatorJson | undefined): string | undefined {
return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
}
function finiteNumber(value: CreatorJson | undefined): number | undefined {
return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
}