Make videos on the computer you already own. FreeVideo runs MiniMax H3 in as little as 8 GB of VRAM and 16 GB of RAM, and adapts its acceleration path to your hardware.
import {copyName} from './editor_model.js';
import {generationSize} from './editor_generation.js';
// HTTP and scheduling live here; records and editing stay in the data modules.
const clockDefault = {now: () => Date.now(), setTimeout: (fn, ms) => setTimeout(fn, ms), clearTimeout: id => clearTimeout(id)};
const copy = value => structuredClone(value);
const memoryProjects = new Map();
const errorFor = response => Object.assign(new Error('editor_request'), {status: response.status});
// A failed save keeps the server's reason so the page can say what went wrong.
async function saveFailure(response) {
let body = null; try { body = await response.json(); } catch {}
return Object.assign(errorFor(response), body && typeof body === 'object' ? {reason: body.reason, response: body} : {});
}
const post = value => ({method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify(value)});
export const sourceKey = source => source ? `${source.kind}:${source.id}` : null;
import {chainRoute, createPoller, interpolate, capabilityPoints} from './chain_support.js';
export {chainRoute, createPoller, interpolate, capabilityPoints};
// Debounce from the first edit, rather than postponing indefinitely while dragging.
// Writes are serialized; a response supplies metadata to the next snapshot only.
const savedContent = record => JSON.stringify({...record, id: null, revision: 0});
const OUTBOX = 'fv-editor-outbox';
const operationId = () => globalThis.crypto?.randomUUID?.().replaceAll('-', '') || Array.from({length: 32}, () => Math.floor(Math.random() * 16).toString(16)).join('');
const lockName = session => OUTBOX + ':' + session;
function holdSession(session = operationId()) {
let release = () => {}; const owner = {session, held: !globalThis.navigator?.locks};
let ready = Promise.resolve();
if (globalThis.navigator?.locks) {
ready = new Promise(resolve => {
navigator.locks.request(lockName(session), () => { owner.held = true; resolve(); return new Promise(done => { release = done; }); });
});
}
return Object.assign(owner, {ready, dispose: () => ready.then(() => release())});
}
function outbox() {
const rows = [];
try {
for (let i = 0; i < localStorage.length; i++) {
const key = localStorage.key(i);
if (!key?.startsWith(OUTBOX + ':')) continue;
try { const entry = JSON.parse(localStorage.getItem(key)); if (entry?.session && entry.project) rows.push([key, entry]); } catch {}
}
// Preserve pending records written by the previous page version.
const legacy = JSON.parse(localStorage.getItem(OUTBOX) || '{}');
for (const [key, entry] of Object.entries(legacy)) if (entry?.project) rows.push([key, {...entry, legacy: true}]);
} catch {}
return rows;
}
function saveOutbox(session, entry) {
if (typeof localStorage === 'undefined') return false;
try {
if (entry) {
if (new TextEncoder().encode(JSON.stringify(entry.project)).length > 2 * 1024 * 1024) {
console.info('[FreeVideo editor] Record exceeds 2 MB; outbox skipped.'); return false;
}
localStorage.setItem(lockName(session), JSON.stringify(entry));
} else localStorage.removeItem(lockName(session));
return true;
} catch { console.info('[FreeVideo editor] Local outbox unavailable.'); return false; }
}
export function createSaveQueue({write, read, onSaved = () => {}, onConflict = () => {}, onCopied = () => {},
onMemory = () => {}, onError = () => {}, onStatus = () => {}, clock = clockDefault, delay = 600,
initial = null, getRecord = null, copySuffix = ' (copy)', session = null, create = null, attempt: resumedAttempt = null}) {
const owner = session || holdSession();
let pending = null, inFlight = null, timer = null, heartbeat = null, meta = null, retry = 0, disposed = false;
let memory = false, memoryNoticed = false, lastSaved = initial && copy(initial), failed = false, failure = null, copied = false, retained = false;
let createOperation = create || (initial?.id ? null : operationId());
let attempt = resumedAttempt && copy(resumedAttempt);
const localKey = owner.session;
function retain(record) {
if (!owner.held) { owner.ready.then(() => { if (!disposed && (pending || attempt || inFlight)) retain({...((getRecord?.() || pending) ?? record), ...(meta || {})}); }); return false; }
retained = saveOutbox(localKey, {session: localKey, id: record.id, project: copy(record), baseline: lastSaved, create: createOperation, attempt: copy(attempt), updated_at: clock.now()});
if (heartbeat === null && !disposed) heartbeat = clock.setTimeout(() => {
heartbeat = null;
if (pending || attempt || inFlight) retain({...((getRecord?.() || pending) ?? record), ...(meta || {})});
}, 10000);
return retained;
}
function schedule(ms) {
if (disposed || timer !== null) return;
timer = clock.setTimeout(() => { timer = null; drain(); }, ms);
}
async function drain() {
if (disposed || inFlight || (!pending && !attempt)) return inFlight;
if (!attempt) { attempt = {operation: operationId(), project: {...pending, ...(meta || {})}}; pending = null; }
const sent = attempt.project, body = copy(sent); failed = false;
if (!body.id) createOperation ||= operationId();
retain(pending || body);
inFlight = (async () => {
await owner.ready;
try {
if (disposed) return;
if (memory) { attempt = null; onSaved(body, true, localKey); return; }
const response = await write(body, createOperation, attempt.operation);
if (disposed) return;
if (response.status === 404) {
attempt = null; memory = true;
if (!memoryNoticed) { memoryNoticed = true; onMemory(); }
onSaved(body, true, localKey); return;
}
if (response.status === 409) {
const conflict = await response.json();
const remote = await read(body.id || conflict.id);
if (disposed) return;
if (!remote) throw errorFor(response);
const latest = copy(getRecord?.() || pending || sent);
if (lastSaved && savedContent(remote) === savedContent(lastSaved)) {
meta = {id: remote.id, revision: remote.revision};
} else {
meta = {id: null, revision: 0}; createOperation = operationId();
latest.name = copyName(latest.name, copySuffix);
onConflict({...latest, ...meta}, copySuffix);
copied = true;
}
attempt = null; pending = {...latest, ...meta}; retain(pending); retry = 0; return;
}
if (!response.ok) throw await saveFailure(response);
const saved = (await response.json()).project;
if (disposed) return;
attempt = null;
if (pending && savedContent(pending) === savedContent(sent)) pending = null;
meta = {id: saved.id, revision: saved.revision}; retry = 0; lastSaved = copy(saved);
onSaved(saved, false);
if (copied) { copied = false; onCopied(saved); }
if (pending) retain({...pending, ...meta});
else { saveOutbox(localKey, null); retained = false; clock.clearTimeout(heartbeat); heartbeat = null; }
} catch (error) {
failed = true; failure = error;
if (!disposed) {
retain({...(pending || sent), ...(meta || {})});
schedule(Math.min(30000, 1000 * 2 ** retry++)); onError(error);
}
}
})().finally(() => {
inFlight = null; onStatus();
if ((pending || attempt) && timer === null && !disposed && !failed) drain();
});
return inFlight;
}
return {
enqueue(record) { if (!disposed) { pending = copy(record); if (!record.id) createOperation ||= operationId(); retain({...pending, ...(meta || {})}); schedule(delay); } },
async flush() {
clock.clearTimeout(timer); timer = null;
if (inFlight) await inFlight;
clock.clearTimeout(timer); timer = null;
while ((pending || attempt) && !disposed) {
await drain();
if (failed) break;
if (inFlight) await inFlight;
clock.clearTimeout(timer); timer = null;
}
},
reset(record = null, recovery = null) {
pending = recovery ? copy(recovery.project) : null; attempt = recovery?.attempt ? copy(recovery.attempt) : null;
meta = null; retry = 0; copied = false; retained = false; lastSaved = copy(recovery ? recovery.baseline : record);
createOperation = recovery?.create || (record?.id ? null : operationId());
clock.clearTimeout(timer); timer = null; clock.clearTimeout(heartbeat); heartbeat = null;
if (pending || attempt) { retain(pending || attempt.project); schedule(delay); } else saveOutbox(localKey, null);
},
get recovery() { return {project: copy({...(pending || attempt?.project), ...(meta || {})}), baseline: copy(lastSaved), create: createOperation, attempt: copy(attempt)}; },
dispose({discard = false} = {}) { disposed = true; clock.clearTimeout(timer); timer = null; clock.clearTimeout(heartbeat); heartbeat = null; if (discard) saveOutbox(localKey, null); if (!session) owner.dispose(); },
get dirty() { return !!pending || !!attempt || !!inFlight; },
// Why the last write failed, while that failure still stands.
get failure() { return failed ? failure : null; },
get locallyRetained() { return retained; },
};
}
export function mediaURL(api, value) {
if (!value) return null;
if (/^(?:https?:|blob:|data:|\/)/.test(value)) return api.apiURL?.(value) || value;
const i = value.lastIndexOf('/');
const path = '/view?' + new URLSearchParams({filename: value.slice(i + 1), subfolder: value.slice(0, Math.max(0, i)), type: 'output'});
return api.apiURL?.(path) || path;
}
export function createEditorStore(api, {t = en => en, notify = () => {}, onGenerationReady = () => {}, onGenerationChecking = () => {}, clock = clockDefault, pollMs = 2000, standIn: injected = null} = {}) {
const sources = new Map(), sourceReads = new Map(), lineage = new Map(), lineageReads = new Map(), watchers = new Set(), pollers = new Set(), once = new Set();
let recovered = null, capabilityPoll = null;
// The length a new continuation starts with where the engine names one (a device that continues in short parts).
let continueSeconds = null;
// Whether a part that continues can be made as a preview first, once the engine has said so.
let continuationPreview = false;
let generationAvailable = false, generationGone = false, generationProbe = null, generationRetry = null, generationAttempts = 0, generationStalled = false, generationAsking = false;
let disposed = false; const uploads = new Set();
const session = holdSession();
let activeProject = null, sessionTimer = null, sessionWrites = Promise.resolve();
// A stalled lease request is cut off so opening, switching and closing never wait on it.
async function lease(body, extra = {}) {
const controller = new AbortController(), timer = clock.setTimeout(() => controller.abort(), 8000);
try { await json('/freevideo/editor/project/session', {...post(body), ...extra, signal: controller.signal}); }
finally { clock.clearTimeout(timer); }
}
function activateProject(id) {
clock.clearTimeout(sessionTimer); sessionTimer = null;
const previous = activeProject; activeProject = id;
sessionWrites = sessionWrites.catch(() => {}).then(async () => {
// A failed release must not skip registering the edit that is already open.
if (previous && previous !== id) await lease({id: previous, session: session.session, release: true}, {keepalive: true}).catch(() => {});
if (id) await lease({id, session: session.session});
});
if (id && !disposed) sessionTimer = clock.setTimeout(() => { activateProject(activeProject).catch(() => {}); }, 20000);
return sessionWrites;
}
const notice = (key, en, zh) => { if (!once.has(key)) { once.add(key); notify(t(en, zh)); } };
const request = (path, options) => api.fetchApi(path, options);
async function json(path, options, fallback = null) {
const response = await request(path, options);
if (response.status === 404) return fallback;
if (!response.ok) throw errorFor(response);
return response.json();
}
function cache(values) {
for (const [key, value] of Object.entries(values || {})) sources.set(key, value);
if (!disposed) for (const fn of watchers) fn();
}
async function load(query) {
// Finish the retained edit before allowing a different project to replace it.
if (recovered) return copy(recovered.project);
const value = await json('/freevideo/editor/project?' + new URLSearchParams(query));
if (value?.project) { cache(value.sources); return value.project; }
if (query.id) return copy(memoryProjects.get(query.id) || (query.id === 'memory' ? memoryProjects.get('memory') : null));
return copy([...memoryProjects.values()].find(record => record.tracks[0].clips[0]?.source?.id === query.work) || null);
}
// A list keeps how many damaged records the server left out of it.
function counted(value) {
const items = Array.isArray(value?.items) ? value.items : [];
const unreadable = Number.isSafeInteger(value?.unreadable) && value.unreadable > 0 ? value.unreadable : 0;
return Object.defineProperty(items, 'unreadable', {value: unreadable});
}
// lost: called once after three reads in a row fail; the watch then stops.
function watch(read, deliver, lost = null) {
let failures = 0, poller = null;
const stop = () => { poller?.dispose(); pollers.delete(poller); };
poller = createPoller(async () => { const value = await read(); failures = 0; return value; }, deliver, {clock, interval: pollMs,
onError: error => { if (lost && ++failures >= 3) { stop(); lost(error); } }});
pollers.add(poller);
return stop;
}
function generationAbsent() {
generationGone = true; generationRetry?.dispose();
generationAvailable = false;
if (!disposed) onGenerationReady(false);
}
function askGenerationAgain() {
const delay = [2000, 5000, 15000, 30000][generationAttempts++];
if (delay === undefined) { generationStalled = true; return; }
const timer = clock.setTimeout(() => { retry.dispose(); store.generationReady(); }, delay);
const retry = generationRetry = {dispose() { clock.clearTimeout(timer); pollers.delete(retry); if (generationRetry === retry) generationRetry = null; }};
pollers.add(retry);
}
// Optional adapter (or factory): startChain, owns, chain, chainAction, and
// optional restoreSources and generationAvailable/generationReady readiness
// hooks for a delayed test generator. Production callers provide none.
const standIn = typeof injected === 'function'
? injected({clock, sources, request: json, mediaURL: value => mediaURL(api, value)}) : injected;
const store = {
sources, cache,
activateProject,
get uploading() { return uploads.size > 0; },
async deleteProject(id) {
// A lease that could not be renewed must not stop the delete: the server checks the leases itself.
await sessionWrites.catch(() => {});
const response = await request('/freevideo/editor/project/delete', post({id, session: session.session}));
if (!response.ok) throw await saveFailure(response);
memoryProjects.delete(id);
if (activeProject === id) { activeProject = null; clock.clearTimeout(sessionTimer); sessionTimer = null; }
},
get continueSeconds() { return standIn ? standIn.continueSeconds ?? null : continueSeconds; },
get continuationPreview() { return standIn ? standIn.continuationPreview === true : continuationPreview; },
get generationAvailable() { return standIn ? standIn.generationAvailable ?? true : generationAvailable; },
// The server said for certain it cannot generate (not just a missed answer that is asked again).
get generationGone() { return !standIn && generationGone; },
// Every automatic check went unanswered: the page offers to check again. It stays so until an answer comes.
get generationStalled() { return !standIn && generationStalled && !generationAvailable && !generationGone; },
get generationChecking() { return !standIn && generationAsking; },
// Checks now and starts the automatic checks over; the page is told of every answer as before.
retryGeneration() {
if (standIn || generationAvailable || generationGone || disposed) return Promise.resolve(generationAvailable);
generationRetry?.dispose(); generationAttempts = 0;
return store.generationReady();
},
generationReady() {
if (standIn) return standIn.generationReady
? Promise.resolve(standIn.generationReady(ready => { if (!disposed) onGenerationReady(ready); }))
: Promise.resolve(true);
if (generationAvailable || generationGone || disposed) return Promise.resolve(generationAvailable);
// Generating stays off until the list of long videos answers in its
// expected shape. One bounded request at a time, shared by concurrent
// callers; a missing route is final, an error or timeout is asked again.
// Every answer is reported, so the page can stop waiting for the first.
return generationProbe ||= (async () => {
const controller = new AbortController();
let timer, finish, answer = null;
const timeout = new Promise(resolve => { finish = resolve; timer = clock.setTimeout(() => {
controller.abort(); resolve(null);
}, 5000); });
const probe = {dispose() { clock.clearTimeout(timer); controller.abort(); finish(null); pollers.delete(probe); }};
pollers.add(probe); generationAsking = true; if (!disposed) onGenerationChecking();
try {
// true: present; false: no such route; null: no usable answer.
answer = await Promise.race([Promise.resolve().then(() => request('/freevideo/chains', {signal: controller.signal}))
.then(async response => {
if (response.status === 404) return false;
if (!response.ok) return null;
const body = await response.json();
if (Number.isInteger(body?.continue_seconds) && body.continue_seconds > 0) continueSeconds = body.continue_seconds;
continuationPreview = body?.continuation_preview === true;
return Array.isArray(body?.chains) ? true : null;
})
.catch(() => null), timeout]);
} finally { probe.dispose(); generationProbe = null; generationAsking = false; }
if (disposed || generationGone) return false;
if (answer === false) generationAbsent();
else if (answer) { generationAvailable = true; onGenerationReady(true); }
else { askGenerationAgain(); onGenerationReady(false); }
return generationAvailable;
})();
},
async recoverOutbox() {
await session.ready;
for (const [key, entry] of outbox()) {
if (entry.session === session.session) continue;
const recover = async () => {
// Re-read after claiming; another recovering page may have finished.
if (!entry.legacy && localStorage.getItem(key) !== JSON.stringify(entry)) return;
const q = createSaveQueue({clock, initial: entry.baseline, create: entry.create, attempt: entry.attempt,
session: {session: entry.session || operationId(), held: true, ready: Promise.resolve()},
copySuffix: t(' (copy)', '(副本)'), read: id => store.load(id),
write: (record, create, operation) => request('/freevideo/editor/project', post({project: record, operation, ...(create ? {create} : {})})),
onSaved: (record, memory, local) => { if (memory) memoryProjects.set(local, copy(record)); try { localStorage.setItem('fv-editor-last', record.id || local); } catch {} },
onCopied: () => notice('conflict', 'This edit changed elsewhere. Your changes here were saved as a copy.', '这条剪辑在别处改过,这里的改动已存为副本')});
try {
q.enqueue(entry.project); await q.flush();
if (q.dirty) {
// Transfer the unresolved request and latest edit to this live
// session before releasing the abandoned session's lock.
const value = {...q.recovery, session: session.session, updated_at: clock.now()};
if (!saveOutbox(session.session, value)) return;
recovered = value;
if (!entry.legacy) localStorage.removeItem(key);
try { localStorage.setItem('fv-editor-last', value.project.id || session.session); } catch {}
}
if (entry.legacy && (!q.dirty || recovered)) {
const rows = JSON.parse(localStorage.getItem(OUTBOX) || '{}');
if (JSON.stringify(rows[key]) === JSON.stringify({...entry, legacy: undefined})) { delete rows[key]; localStorage.setItem(OUTBOX, JSON.stringify(rows)); }
}
} finally { q.dispose(); }
};
if (globalThis.navigator?.locks && entry.session) {
await navigator.locks.request(lockName(entry.session), {ifAvailable: true}, lock => lock ? recover() : undefined);
} else if (clock.now() - (entry.updated_at || 0) > 60000) await recover();
if (recovered) break;
}
}, load: id => load({id}), byWork: work => load({work}),
async projects() { return counted(await json('/freevideo/editor/projects', undefined, {items: []})); },
createSaveQueue(state, {onStatus = () => {}} = {}) {
const queue = createSaveQueue({clock, session, onStatus, initial: state.record, getRecord: () => state.record, copySuffix: t(' (copy)', '(副本)'), write: (record, create, operation) => { const options = post({project: record, operation, ...(create ? {create} : {})}); return request('/freevideo/editor/project', {...options, keepalive: new TextEncoder().encode(options.body).length < 60000}); },
read: id => store.load(id),
onSaved: (record, memory, local) => {
memoryProjects.set(record.id || local, copy({...state.record, id: record.id, revision: record.revision}));
state.adopt({id: record.id, revision: record.revision});
if (record.id && record.id !== activeProject) activateProject(record.id).catch(() => {});
try { localStorage.setItem('fv-editor-last', record.id || local); } catch {}
if (memory) memoryProjects.set(record.id || local, copy(state.record));
},
onConflict: (record, nameSuffix) => { state.adopt({id: null, revision: 0, nameSuffix}); },
onCopied: () => notice('conflict', 'This edit changed elsewhere. Your changes here were saved as a copy.', '这条剪辑在别处改过,这里的改动已存为副本'),
onMemory: () => notice('memory', 'Changes are kept in this page for now. Update and restart to save them.', '改动暂存在这个页面里,更新并重启后会保存。'),
// Automatic retries stay quiet; switching away while unsaved warns in editor.js.
onError: () => {}});
const reset = queue.reset;
queue.reset = record => { const entry = recovered; recovered = null; reset(record, entry); };
return queue;
},
async getSources(keys, {refresh = false} = {}) {
const missing = [...new Set(keys)].filter(key => refresh || !sources.has(key) || sources.get(key)._fallback);
if (!missing.length) return sources;
const signature = missing.slice().sort().join('\n');
if (!sourceReads.has(signature)) {
const query = new URLSearchParams(); missing.forEach(key => query.append('key', key));
sourceReads.set(signature, (async () => {
const value = await json('/freevideo/editor/sources?' + query, undefined, {sources: {}});
cache(value.sources);
standIn?.restoreSources?.(missing);
})().finally(() => sourceReads.delete(signature)));
}
await sourceReads.get(signature); return sources;
},
lineage(works) {
const unique = new Map(works.filter(work => work && typeof work.key === 'string' && work.reference && !lineage.has(work.key))
.map(work => [work.key, work]));
const entries = [...unique.values()];
if (!entries.length) return Promise.resolve(lineage);
const pending = entries.filter(work => !lineageReads.has(work.key));
for (let offset = 0; offset < pending.length; offset += 16) {
const batch = pending.slice(offset, offset + 16), keys = batch.map(work => work.key);
const task = (async () => {
try {
const value = await json('/freevideo/chain/lineage', post({works: batch.map(work => work.reference)}), {lineage: []});
batch.forEach((work, index) => {
const item = value?.lineage?.[index];
lineage.set(work.key, item && typeof item.known === 'boolean'
? {parts: item.parts, short: item.short, known: item.known}
: {parts: 1, short: false, known: false});
});
} catch {
for (const work of batch) lineage.set(work.key, {parts: 1, short: false, known: false});
/* Unknown history preserves the editor's existing preflight behavior. */
}
finally { for (const key of keys) lineageReads.delete(key); }
})();
for (const key of keys) lineageReads.set(key, task);
}
return Promise.all(entries.map(work => lineageReads.get(work.key)).filter(Boolean)).then(() => lineage);
},
knownLineage() { return Object.fromEntries(lineage); },
subscribeSources(fn) { watchers.add(fn); return () => watchers.delete(fn); },
async waveform(key, points = 200) {
return (await json('/freevideo/editor/waveform?' + new URLSearchParams({key, points}), undefined, {peaks: []})).peaks || [];
},
async works(before = null) {
const query = new URLSearchParams({limit: '24'}); if (before) query.set('before', before);
const value = await json('/freevideo/library?' + query, {cache: 'no-store'}, {items: [], next: null});
const fallback = {};
for (const row of value.items || []) if (row.video && row.id && !sources.has(`work:${row.id}`)) {
fallback[`work:${row.id}`] = {...row.geometry, _fallback: true, video: mediaURL(api, row.video), audio: mediaURL(api, row.video),
has_video: true, has_audio: row.has_audio !== false, path: row.video, missing: false,
thumbnail: api.apiURL?.('/freevideo/library/thumbnail?' + new URLSearchParams({id: row.id})) || '/freevideo/library/thumbnail?' + new URLSearchParams({id: row.id})};
}
if (Object.keys(fallback).length) cache(fallback);
return value;
},
async imports() { return counted(await json('/freevideo/editor/imports', undefined, {items: []})); },
watchImports(fn) { return watch(() => store.imports(), items => { fn(items); return true; }); },
upload(file, progress = () => {}) {
if (disposed) return Promise.reject(new Error('editor_closed'));
return new Promise((resolve, reject) => {
const xhr = new XMLHttpRequest();
const release = () => { uploads.delete(upload); xhr.onload = xhr.onerror = null; xhr.upload.onprogress = null; };
const upload = {xhr, release, reject}; uploads.add(upload);
xhr.open('POST', api.apiURL?.('/freevideo/editor/import') || '/freevideo/editor/import');
xhr.setRequestHeader('X-FreeVideo-Filename', encodeURIComponent(file.name));
xhr.setRequestHeader('Content-Type', 'application/octet-stream');
xhr.upload.onprogress = event => { if (event.lengthComputable) progress(event.loaded / event.total); };
xhr.onload = () => {
release();
if (xhr.status === 404) { notice('import', 'Import is unavailable until you restart after updating.', '更新后重启可导入素材。'); resolve(null); return; }
// The server's reason (a full disk) comes along, as with a failed save.
if (xhr.status < 200 || xhr.status >= 300) { let body = null; try { body = JSON.parse(xhr.responseText); } catch {} reject(Object.assign(errorFor(xhr), {reason: body?.reason})); return; }
try { resolve(JSON.parse(xhr.responseText).import); } catch (error) { reject(error); }
};
xhr.onerror = () => { release(); reject(new Error('import_failed')); };
try { xhr.send(file); } catch (error) { release(); reject(error); }
});
},
capabilities(options, onReady = () => {}) {
capabilityPoll?.dispose();
const size = generationSize(options);
const fallback = {maxSeconds: 15, maxFollowSeconds: 15, maxRequestFrames: null, estimate: () => null, generationSize: size};
if (disposed) return fallback;
const started = clock.now();
let active = true, timer = null;
const controller = new AbortController();
const poller = {dispose() {
active = false; clock.clearTimeout(timer); controller.abort(); pollers.delete(poller);
}};
capabilityPoll = poller; pollers.add(poller);
async function read() {
try {
const reply = await json('/freevideo/capabilities?' + new URLSearchParams(size), {signal: controller.signal});
if (!active || disposed) return;
if (reply?.status === 'computing') {
const seconds = Number(reply.retry_after_seconds);
const delay = clock.now() - started >= 60000 ? 10000
: Number.isFinite(seconds) && seconds > 0 ? Math.max(1000, Math.min(60000, seconds * 1000)) : 1000;
timer = clock.setTimeout(() => { timer = null; read(); }, delay);
return;
}
if (!reply || (reply.status && reply.status !== 'ready')) { poller.dispose(); return; }
// Advertised presets must not change the size we just asked
// about: both estimates and the final request use this size.
const value = capabilityPoints(reply, {...options, ...size});
const ready = {maxSeconds: value.maxSeconds, maxFollowSeconds: value.maxFollowSeconds, maxRequestFrames: value.maxRequestFrames,
sizes: reply.sizes, generationSize: size,
estimate: frames => interpolate(value.points, frames / 24)};
onReady(ready); poller.dispose();
} catch { if (active) poller.dispose(); }
}
// The first HTTP response can itself be slow. Editing starts with
// these limits; only the callback publishes a measured capability.
read(); return fallback;
},
// The longest single part this computer makes at a size other than the edit's; null when it cannot be told.
async requestFrames(size, settings) {
try {
for (let tries = 0; tries < 5 && !disposed; tries++) {
const reply = await json('/freevideo/capabilities?' + new URLSearchParams(size));
if (reply?.status !== 'computing') return !reply || (reply.status && reply.status !== 'ready') ? null
: capabilityPoints(reply, {...size, settings}).maxRequestFrames;
await new Promise(done => clock.setTimeout(done, 1000));
}
} catch { /* not known */ }
return null;
},
async startChain(payload) {
if (standIn) return standIn.startChain(payload);
if (!generationAvailable) return null;
const response = await request(chainRoute(), post(payload));
if (response.status === 404) {
generationAbsent();
notice('generate', 'Restart FreeVideo to generate.', '请重新启动 FreeVideo 后再生成。');
return null;
}
if (!response.ok) {
// The server's own sentence for a video with too many parts, or a continued part too short, is shown as it is.
const body = await response.json().catch(() => null);
if (['chain_too_long', 'chain_part_too_short', 'chain_short_parts'].includes(body?.code)) throw Object.assign(new Error(body.code), {code: body.code, said: [body.error, body.error_zh]});
throw Object.assign(new Error(typeof body?.error === 'string' ? body.error : body?.message || `HTTP ${response.status}`),
{status: response.status, reason: body?.reason || body?.code, response: body});
}
return (await response.json())?.chain || null;
},
async chain(id) { return standIn?.owns(id) ? standIn.chain(id) : (await json(chainRoute(id)))?.chain || null; },
watchChain(id, fn) { return watch(() => store.chain(id), fn); },
async chainAction(id, action) {
if (standIn?.owns(id)) return standIn.chainAction(id, action);
const payload = action === 'resume' && api.clientId ? {client_id: api.clientId} : {};
return (await json(chainRoute(id, action), post(payload)))?.chain || null;
},
async export(id, revision, options) {
const response = await request('/freevideo/editor/export', post({id, revision, ...(options && Object.keys(options).length ? {options} : {})}));
const value = await response.json().catch(() => null);
if (!response.ok && (response.status !== 404 || value?.reason || value?.code))
throw Object.assign(errorFor(response), {reason: value?.reason, code: value?.code, items: value?.items});
if (response.status === 404 || !value) { notice('export', 'To export, update FreeVideo and restart it.', '请更新 FreeVideo 并重新启动后再导出。'); return null; }
return value?.export || null;
},
watchExport(id, fn, lost) { return watch(async () => (await json('/freevideo/editor/export?' + new URLSearchParams({id})))?.export || null, fn, lost); },
cancelExport: id => json('/freevideo/editor/export/cancel', post({id})),
// One frame of the saved project, as the export draws it, kept as a picture in the image history; null where the server is older.
async saveFrame(id, revision, frame) {
const response = await request('/freevideo/editor/frame', post({id, revision, frame}));
const value = await response.json().catch(() => null);
if (!response.ok && (response.status !== 404 || value?.reason)) throw Object.assign(errorFor(response), {reason: value?.reason});
if (response.status === 404 || !value) { notice('frame', 'To save a frame, update FreeVideo and restart it.', '请更新 FreeVideo 并重新启动后再保存画面。'); return null; }
return value.picture || null;
},
// Subtitles from speech. What this computer can recognise; null where it cannot or the server is older.
async ears() { return (await json('/freevideo/editor/ears'))?.available || null; },
async startEars(id, revision) { return (await json('/freevideo/editor/ears', post({kind: 'transcribe', id, revision})))?.job || null; },
watchEars(id, fn, lost) { return watch(async () => (await json('/freevideo/editor/ears?' + new URLSearchParams({id})))?.job || null, fn, lost); },
cancelEars: id => json('/freevideo/editor/ears/cancel', post({id})),
// What recognising speech needs is downloaded on first use; null where the server has no such download.
earsPack: () => json('/freevideo/editor/subtitle-pack'),
installEars: () => json('/freevideo/editor/subtitle-pack', post({action: 'install', language: true})),
cancelEarsPack: () => json('/freevideo/editor/subtitle-pack', post({action: 'cancel'})),
watchEarsPack(fn, lost) { return watch(() => json('/freevideo/editor/subtitle-pack'), fn, lost); },
// Music for a stretch of the sound track. {available, ready}; null where the server is older.
musicInfo: () => json('/freevideo/editor/music'),
// body: {frames, text?} or {frames, style, mood}, optional seed. Refusals keep the server's reason.
async startMusic(body) {
const response = await request('/freevideo/editor/music', post(body));
const value = await response.json().catch(() => null);
if (!response.ok) throw Object.assign(errorFor(response), {reason: value?.reason || (response.status === 404 ? 'unsupported' : 'failed')});
return value?.job || null;
},
// A job the server no longer knows (it was restarted) reads as failed, so the planned piece does not wait forever.
watchMusic(id, fn, lost) {
return watch(async () => (await json('/freevideo/editor/music?' + new URLSearchParams({id}), undefined, {job: {id, state: 'failed', reason: 'missing'}}))?.job || null, fn, lost);
},
cancelMusic: id => json('/freevideo/editor/music/cancel', post({id})),
// The music model is downloaded on first use, with the download source chosen in Settings.
musicPack: () => json('/freevideo/editor/music-pack'),
// Speech spans of one source in seconds, for "Lower during speech": {spans}, {state: 'pending'} or {spans: null, reason}.
speech: key => json('/freevideo/editor/speech?' + new URLSearchParams({source: key})),
async installMusic() {
const response = await request('/freevideo/editor/music-pack', post({action: 'install'}));
const value = await response.json().catch(() => null);
// 507: not enough room on the disk; the state that comes back says how much is needed.
if (!response.ok && response.status !== 507) throw Object.assign(errorFor(response), {reason: value?.reason || 'failed'});
return value;
},
cancelMusicPack: () => json('/freevideo/editor/music-pack', post({action: 'cancel'})),
watchMusicPack(fn) { return watch(() => json('/freevideo/editor/music-pack'), fn); },
dispose() { disposed = true; activateProject(null).catch(() => {}); session.dispose(); for (const poller of pollers) poller.dispose(); pollers.clear(); watchers.clear();
for (const upload of [...uploads]) { upload.release(); upload.xhr.abort(); upload.reject(new Error('editor_closed')); } },
};
return store;
}