videobook 0.2.2 → 0.2.4

package/CHANGELOG.md

@@ -6,6 +6,65 @@ and the package uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.4] - 2026-10-23
+
+### Added
+
+- Image and video model pickers show frontier rankings from the offline
+  `@apicity/cost` snapshot, with rank, Elo and price for the selected operation.
+  Other models follow in their existing order; unconfigured providers are
+  marked unavailable. Saved selections and default models stay unchanged.
+
+- MachGen as a video provider, with six models: MiniMax H3, Seedance
+  2.5, Seedance 2.0, Wan 3.0 and HappyHorse 1.1 for text, frame and
+  reference video, and Grok Imagine Video 1.5 for image-to-video. Each
+  model offers its own resolutions, durations and aspect ratios, and
+  cost estimates come from the `@apicity/cost` MachGen per-second rates.
+  Wan 3.0 always sends MachGen's documented adaptive, 30 fps, with-audio
+  config. Generations run as provider tasks: Videobook polls MachGen and
+  downloads the finished video with the API key.
+- `MACHGEN_API_KEY` is a managed key. `videobook config`, 1Password
+  resolution and the provider keys panel include it. Without it, MachGen
+  generations stop with "MACHGEN_API_KEY environment variable is not set"
+  before an asset is created, and pending MachGen tasks wait unpolled.
+- Seedance 2.5 Draft Complete (`kie:bytedance/seedance-2-5-draft`)
+  renders the 1080p final of a 480p Seedance 2.5 draft from the draft's
+  Kie task id. A draft rendered in the same book supplies the billed
+  seconds and reference video seconds for the estimate. The Kie Seedance
+  2.5 model gains the matching `draft` option.
+
+### Changed
+
+- Upgrade all application `@apicity/*` dependencies to 0.17.0 and add
+  `@apicity/machgen`.
+- Kie Seedance 2.5 estimates use the 2026-10-22 rates, for example
+  $0.79 per second at 1080p without a reference video, up from $0.57.
+
+## [0.2.3] - 2026-10-21
+
+### Added
+
+- Fal FLUX 3 Max text-to-video, image-to-video, and keyframes-to-video,
+  with generated audio and resolution-tiered per-second cost estimates.
+- Bria Fibo 2 text-to-image with structured VGL prompts, and Fibo 2 Edit
+  for one to four reference images, including the image editor.
+- H3 Max Reframe Video, which outpaints a source video to a target aspect
+  ratio at 480p, 768p, or 1080p while keeping its audio and timing.
+  Priced from fal's historical average because the request does not fix
+  the billed duration.
+
+### Changed
+
+- Upgrade all application `@apicity/*` dependencies to 0.16.3.
+- Windows x64 is supported. The release check runs the pack-and-install
+  smoke on Windows and blocks the release when it fails. Stopping
+  `videobook serve` from another process still ends it without a clean
+  shutdown, because Windows has no SIGTERM, and the next start replaces
+  the lock file.
+- Dynamic fal requests are priced from fal's historical average when
+  `FAL_ADMIN_API_KEY` is set. Without the key, and for the two Seedance
+  formula gaps, the estimate stays at the local $0.
+
 ## [0.2.2] - 2026-10-21
 
 ### Added

package/README.md

@@ -12,8 +12,8 @@ graph, and every change is recorded as a revision. This package installs one
 ## Requirements
 
 - Node.js 22 or newer.
-- macOS (Apple Silicon or Intel) or Linux (x64 or arm64). Windows is not
-  supported yet; see the platform notes.
+- macOS (Apple Silicon or Intel), Linux (x64 or arm64), or Windows x64.
+  See the platform notes.
 - About 800 MB of disk. Installing downloads the ffmpeg and yt-dlp binaries
   from GitHub, and the first video render downloads Chrome Headless Shell
   (about 150 MB) into `~/.cache/videobook/remotion`.
@@ -121,8 +121,9 @@ Caches live in `~/.cache/videobook`. Other settings: `PORT`,
 ## Provider keys
 
 The keys are `OPENAI_API_KEY`, `KIE_API_KEY`, `XAI_API_KEY`, `FAL_API_KEY`,
+`FAL_ADMIN_API_KEY`,
 `DASHSCOPE_API_KEY`, `ELEVENLABS_API_KEY`, `KIMI_CODING_API_KEY`,
-`X_CLIENT_ID` and `X_CLIENT_SECRET`, `DROPBOX_CLIENT_ID` and
+`MACHGEN_API_KEY`, `X_CLIENT_ID` and `X_CLIENT_SECRET`, `DROPBOX_CLIENT_ID` and
 `DROPBOX_CLIENT_SECRET`, and the `B2_*` storage settings. The server starts
 without any of them; tools that need one report which.
 
@@ -133,7 +134,8 @@ A key can come from four places. The first one that has it wins:
    Settings in the web UI.
 3. A 1Password secret reference in `.env`, such as
    `op://Private/FAL_API_KEY/password`.
-4. A 1Password vault whose items are named after the keys.
+4. A 1Password vault: every item named like an environment variable fills
+   that variable, whether or not videobook lists it as a key.
 
 `videobook config` lists every key with its source and masks secret values.
 `config get`, `config set` and `config unset` work on one key and edit
@@ -177,12 +179,10 @@ come from 1Password are read-only in Settings.
 - macOS on Intel works, but ONNX Runtime has no Intel Mac build, so semantic
   search is unavailable there.
 - Linux x64 and arm64 are supported.
-- Windows is not supported yet. Every native dependency has a Windows x64
-  build, but the release smoke test has not passed on Windows. Windows has no
-  SIGTERM, so stopping `videobook serve` from another process ends it without
-  a clean shutdown, and the next start replaces the lock file it leaves. The
-  Release check workflow runs the smoke test on Windows for every release tag
-  without blocking the release.
+- Windows x64 is supported. Windows has no SIGTERM, so stopping
+  `videobook serve` from another process ends it without a clean shutdown,
+  and the next start replaces the lock file it leaves. The Release check
+  workflow runs the pack-and-install smoke on Windows for every release tag.
 
 ## Security
 

package/dist/book-manager.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { lstat, mkdir, readdir, rename, rm } from "node:fs/promises";
+import { cp, lstat, mkdir, readdir, rename, rm } from "node:fs/promises";
 import { join, relative, resolve, sep } from "node:path";
 import { performance } from "node:perf_hooks";
 import { BOOK_SLUG_ERROR, normalizeBookSlug } from "videobook-engine/book-slug";
@@ -8,6 +8,43 @@ import { createEngine, err, isUuidV7, ok, } from "videobook-engine";
 function engineError(code, message) {
     return { code, message };
 }
+const MOVE_ATTEMPTS = 8;
+const RETRYABLE_MOVE_CODES = new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
+function systemCode(cause) {
+    if (!cause || typeof cause !== "object" || !("code" in cause))
+        return undefined;
+    const code = cause.code;
+    return typeof code === "string" ? code : undefined;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// Windows denies renaming a directory while Defender, or a Dolt file that just
+// closed, still holds a handle. Retry, then copy and drop the staging tree.
+async function moveDirectory(source, destination) {
+    let last;
+    for (let attempt = 0; attempt < MOVE_ATTEMPTS; attempt += 1) {
+        try {
+            await rename(source, destination);
+            return;
+        }
+        catch (cause) {
+            last = cause;
+            if (!RETRYABLE_MOVE_CODES.has(systemCode(cause) ?? ""))
+                throw cause;
+            if (attempt < MOVE_ATTEMPTS - 1)
+                await delay(50 * 2 ** attempt);
+        }
+    }
+    try {
+        await cp(source, destination, { recursive: true });
+    }
+    catch {
+        await rm(destination, { recursive: true, force: true }).catch(() => undefined);
+        throw last;
+    }
+    await rm(source, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }).catch(() => undefined);
+}
 function isInside(parent, candidate) {
     const path = relative(parent, candidate);
     return path !== "" && !path.startsWith(`..${sep}`) && path !== "..";
@@ -114,8 +151,9 @@ export class BookManager {
             const created = temporaryEngine.book.get();
             temporaryEngine.close();
             temporaryEngine = null;
+            await delay(0);
             const destination = this.bookRoot(created.bookId);
-            await rename(temporaryRoot, destination);
+            await moveDirectory(temporaryRoot, destination);
             finalRoot = destination;
             const engine = this.createEngine(finalRoot);
             finalEngine = engine;

package/dist/command-reference.js

@@ -1,4 +1,6 @@
-import { listModels } from "./media/listing.js";
+import { FRONTIER } from "@apicity/cost";
+import { FRONTIER_CATALOG_GAPS } from "./media/frontier-gaps.js";
+import { listModels, modelIsHidden } from "./media/listing.js";
 import { buildWorkspaceActionCatalog } from "./workspace-action-catalog.js";
 import { WORKSPACE_ACTION_SURFACES } from "./workspace-action-surfaces.js";
 function oneLine(value) {
@@ -80,12 +82,24 @@ export function renderGenerationModels() {
     const rows = models.map((model) => {
         const refs = model.slots.map((slot) => `${slot.role} ${slot.min}-${slot.max ?? "n"}`).join(", ") || "none";
         const modes = model.modes.length > 1 ? model.modes.map((mode) => mode.id).join(", ") : "";
-        return `| \`${escapeTable(model.id)}\` | ${escapeTable(model.title)} | ${model.media} | ${model.entry.operations.join(", ")} | ${escapeTable(refs)} | ${modes} | ${model.entry.hidden ? "hidden" : "visible"} |`;
+        return `| \`${escapeTable(model.id)}\` | ${escapeTable(model.title)} | ${model.media} | ${model.entry.operations.join(", ")} | ${escapeTable(refs)} | ${modes} | ${modelIsHidden(model.entry) ? "hidden" : "visible"} |`;
     });
+    const gaps = Object.entries(FRONTIER_CATALOG_GAPS).map(([endpoint, reason]) => `| ${escapeTable(endpoint)} | ${escapeTable(reason)} |`).join("\n");
+    const unmapped = [...new Set(Object.values(FRONTIER).flatMap((snapshot) => snapshot.entries.filter((entry) => entry.endpoints.length === 0).map((entry) => entry.model)))];
     return `# Generation Models
 
 Generated by \`npm run docs:commands\` from the media catalog (\`server/src/media/catalog.ts\`). Call \`generate_image\`, \`generate_video\` or \`generate_audio\` with one of these model ids; \`list_generation_models\` returns the same list with every option, enum, range and default read from the apicity schemas.
 
+Image and video pickers rank exact catalog endpoints using the committed top-10 snapshots in @apicity/cost 0.17.0, originally sourced from Artificial Analysis. No leaderboard is fetched at runtime. Rankings are per operation: t2i, i2i, t2v, i2v, v2v, and r2v (derived from the text/image-to-video boards). Each ranked option shows rank, Elo, and a bundled price label; prices are indicative ranges, not a quote for the selected settings.
+
+Configured frontier models appear first; other models retain their existing order in a separate group. Providers without credentials are marked unavailable. Saved selections and defaults stay unchanged. Catalog variants on a frontier board are included even if previously hidden; non-frontier hidden variants remain hidden. A model version or lite variant never inherits another endpoint's score.
+
+Top-10 coverage policy: every registry endpoint must map exactly to a catalog entry or appear in the known gaps below. Models with no provider endpoint in the registry: ${unmapped.join(", ")}. Catalog gaps do not imply provider API support is missing; adding those endpoints is separate work.
+
+| Known endpoint gap | Reason |
+| --- | --- |
+${gaps}
+
 - Models: ${models.length}
 
 | Model | Title | Media | Operations | Refs | Modes | Picker |

package/dist/env-secrets.js

@@ -6,9 +6,10 @@
  *      them into the environment BEFORE Node starts (npm run dev:server).
  *   2. A plain `.env` file, loaded here with dotenv semantics: never override
  *      a var that is already set, so op-injected values always win.
- *   3. op:// references left in the environment or `.env`, plus the vault
- *      named by VIDEOBOOK_OP_VAULT, resolved through the 1Password CLI by
- *      resolveOnePassword() before a server starts.
+ *   3. op:// references left in the environment or `.env`, plus every
+ *      env-named item in the vault named by VIDEOBOOK_OP_VAULT, resolved
+ *      through the 1Password CLI by resolveOnePassword() before a server
+ *      starts.
  *
  * A managed key that was already set before `.env` loaded, or that 1Password
  * resolved, is therefore "1password" — externally managed and read-only,
@@ -35,8 +36,10 @@ export const MANAGED_ENV_KEYS = [
     "DROPBOX_CLIENT_SECRET",
     "KIMI_CODING_API_KEY",
     "FAL_API_KEY",
+    "FAL_ADMIN_API_KEY",
     "DASHSCOPE_API_KEY",
     "ELEVENLABS_API_KEY",
+    "MACHGEN_API_KEY",
     "B2_ACCESS_KEY_ID",
     "B2_SECRET_ACCESS_KEY",
     "B2_REGION",
@@ -124,7 +127,7 @@ export function createSecretStore(options = {}) {
         if (resolution)
             return resolution;
         loadDotenv();
-        const resolved = resolveOnePasswordEnv(processEnv, MANAGED_ENV_KEYS);
+        const resolved = resolveOnePasswordEnv(processEnv);
         for (const key of [...resolved.fromReferences, ...resolved.fromVault])
             fromOnePassword.add(key);
         resolution = resolved;

package/dist/image-edit-models.js

@@ -18,6 +18,7 @@ const EDIT_MODELS = [
     { catalogModel: "fal:fal-ai/nano-banana-2/edit", label: "Nano Banana 2" },
     { catalogModel: "fal:alibaba/qwen-image-3/edit", label: "Qwen 3.0 Edit" },
     { catalogModel: "fal:fal-ai/wan/v2.7/edit", label: "Wan 2.7 Edit" },
+    { catalogModel: "fal:bria/fibo-2/edit", label: "Fibo 2 Edit" },
 ];
 function imageSlotMax(model) {
     return model.slots.find((slot) => slot.role === "image")?.max ?? null;

package/dist/jobs/complete-provider-task.js

@@ -6,6 +6,7 @@ import { registerJobHandler } from "../queue.js";
 import { runFfmpeg } from "../ffmpeg.js";
 import { completeMediaGeneration, providerResultUrls } from "../media/complete.js";
 import { MEDIA_TASK_TYPES } from "../media/adapters/types.js";
+import { downloadMachGenVideo } from "../media/adapters/machgen.js";
 import { legacyMediaForTaskType, legacyMediaMeta } from "../media/legacy-task-types.js";
 const LOCK_DURATION_MS = 300_000;
 const TASK_TYPES_BY_COMPLETION_FAMILY = {
@@ -109,7 +110,7 @@ export function registerCompleteProviderTaskJob(engine) {
                         assetDir,
                         bookId,
                         meta: legacyMediaMeta(taskType, meta),
-                        outputs: urls.map((url) => ({ url })),
+                        outputs: await mediaOutputs(taskType, taskId, urls),
                     });
                     break;
                 default: {
@@ -126,6 +127,11 @@ export function registerCompleteProviderTaskJob(engine) {
         }
     });
 }
+async function mediaOutputs(taskType, taskId, urls) {
+    if (taskType === MEDIA_TASK_TYPES.machgen)
+        return [await downloadMachGenVideo(taskId, urls[0])];
+    return urls.map((url) => ({ url }));
+}
 async function completeIsolateVocals(engine, assetId, meta, resultUrls) {
     const vocalsUrl = resultUrls[0];
     if (!vocalsUrl)

package/dist/jobs/generate-media.js

@@ -7,6 +7,7 @@ import { resolveModel } from "../media/descriptor.js";
 import { buildWireRequest } from "../media/request.js";
 import { applyPromptDialect } from "../media/prompt-dialects.js";
 import { checkSeedanceEditSource, checkInsertVideoTiming, checkRefDurations, resolveRefInput, uploadRefs } from "../media/refs.js";
+import { seedanceDraftCostHints } from "../media/seedance-draft.js";
 import { adapterFor } from "../media/adapters/index.js";
 import { completeMediaGeneration } from "../media/complete.js";
 function storedPayload(model, request) {
@@ -19,6 +20,9 @@ async function replaceAudioMeta(engine, ref) {
     return { replaceAudioWith: { assetId: input.assetId, filename: input.filename } };
 }
 export async function generationSourceCostHints(engine, refs, job) {
+    const draftHints = await seedanceDraftCostHints(engine, job.model, job.options ?? {});
+    if (Object.keys(draftHints).length > 0)
+        return draftHints;
     const videoSeconds = await referenceVideoDuration(engine, refs.sourceVideoIds);
     if (videoSeconds !== undefined) {
         return { inputDurationSeconds: videoSeconds, ...(isSeedanceEdit(job.model, job.mode) ? { durationSeconds: videoSeconds } : {}) };

package/dist/jobs/render-project.js

@@ -24,7 +24,10 @@ import { isKeywordPlacementCacheValid, keywordPlacementFingerprint, readKeywordP
 import { resolveKeywordPlacements } from "../remotion/keyword-placement.js";
 import { aliveRenderTrack } from "../alive-captions/track.js";
 const LOCK_DURATION_MS = 1_800_000; // 30 min for renders
-const CLAIM_WAIT_MS = 30_000;
+// All three orientations lock the same source workspace. A subtitle render
+// of one orientation outlives the old 30s wait, so the others failed and the
+// queue then marked the playable source as media-failed.
+const CLAIM_WAIT_MS = 15 * 60_000;
 // Lazy subtitle-language resolution: serve the cached translated sidecar when
 // it matches the current transcript, translate-and-cache when it doesn't, and
 // fall back to the original-language transcript on any translation failure —
@@ -62,6 +65,76 @@ async function resolveSubtitleSegments(engine, assetId, raw, subtitleLanguage, s
         return sourceSegments;
     }
 }
+function preserveArtifactState(error) {
+    const preserved = error instanceof Error ? error : new Error(String(error));
+    Object.assign(preserved, { preserveArtifactState: true });
+    return preserved;
+}
+async function sourceVideoIsPlayable(engine, assetId) {
+    const manifest = await engine.files.manifest(assetId);
+    if (!manifest.ok)
+        return false;
+    return findVideoFile(manifest.value.files) !== null;
+}
+async function clearRenderError(engine, assetId) {
+    const cleared = await engine.jobs.failures.clear(assetId);
+    if (cleared.ok && cleared.value)
+        return;
+    // A reaped render lease marks the view failed without writing a
+    // generation-error row, and clear() then no-ops. Write a row so the same
+    // clear can restore the playable source.
+    const view = engine.jobs.artifactWork.read(assetId);
+    if (!view.ok || view.value?.status !== "error")
+        return;
+    const written = await engine.jobs.failures.write(assetId, {
+        message: "Retrying subtitle render",
+    });
+    if (!written.ok)
+        return;
+    await engine.jobs.failures.clear(assetId);
+}
+/** A failed subtitle render must not leave a playable source stuck in error. */
+export async function clearRenderErrorIfPlayable(engine, assetId) {
+    if (!(await sourceVideoIsPlayable(engine, assetId)))
+        return false;
+    const view = engine.jobs.artifactWork.read(assetId);
+    if (view.ok && view.value?.status === "error") {
+        await clearRenderError(engine, assetId);
+    }
+    return true;
+}
+/** Drop a queued render view when this attempt never took the lease. */
+export async function releaseQueuedRenderIfPlayable(engine, assetId) {
+    if (!(await sourceVideoIsPlayable(engine, assetId)))
+        return;
+    const view = engine.jobs.artifactWork.read(assetId);
+    if (!view.ok || view.value?.status !== "pending")
+        return;
+    const owner = engine.jobs.artifactWork.begin(assetId, {
+        kind: "render",
+        ownerKind: "job",
+        durationMs: 5_000,
+    });
+    if (!owner)
+        return;
+    engine.jobs.artifactWork.complete(assetId, owner.ownerId);
+    // complete() does not remove a generation-error row, and that row alone
+    // still reports the playable source as failed.
+    await clearRenderError(engine, assetId);
+}
+export async function preservePlayableRenderSources(engine, assetIds, markAssetFailureHandled, error) {
+    const playable = await Promise.all(assetIds.map(async (assetId) => {
+        const kept = await clearRenderErrorIfPlayable(engine, assetId);
+        if (kept)
+            await releaseQueuedRenderIfPlayable(engine, assetId);
+        return kept;
+    }));
+    if (playable.some(Boolean)) {
+        markAssetFailureHandled();
+        throw preserveArtifactState(error);
+    }
+    throw error instanceof Error ? error : new Error(String(error));
+}
 function abortRace(signal) {
     return new Promise((_, reject) => {
         const fail = () => {
@@ -76,13 +149,39 @@ function abortRace(signal) {
 }
 export function registerRenderProjectJob(engine) {
     registerJobHandler("render_project", async (payload, ctx) => {
-        ctx.signal.throwIfAborted();
         const { orientation, assets, subtitlesEnabled, subtitleLanguage = "original", highlightStyle, position, fontSize, textColor, highlightColor, audioFadeIn, audioFadeOut, audioVolume, osgImagePath: payloadOsgImagePath, osgAssetId, osgPosition, osgSize, osgScale, osgOpacity, osgStartSeconds, osgEndSeconds, osgTailSeconds, keywordGraphicsEnabled = false, keywordGraphicsMaxCount = DEFAULT_KEYWORD_GRAPHICS_MAX_COUNT, keywordGraphicsLingerSeconds = DEFAULT_KEYWORD_GRAPHICS_LINGER_SECONDS, keywordGraphicsKeywords = null, backgroundMode, strokeWidth, strokeColor, shadowBlur, shadowOpacity, } = payload;
-        const bundleDir = await Promise.race([
-            getSharedBundleLocation(),
-            abortRace(ctx.signal),
-        ]);
-        ctx.signal.throwIfAborted();
+        let bundleDir;
+        let osgImagePath = payloadOsgImagePath;
+        let osgCopyName = null;
+        let osgCopyPath = null;
+        try {
+            ctx.signal.throwIfAborted();
+            bundleDir = await Promise.race([
+                getSharedBundleLocation(),
+                abortRace(ctx.signal),
+            ]);
+            ctx.signal.throwIfAborted();
+            if (!osgImagePath && osgAssetId) {
+                const resolved = await resolveOsgImagePath(engine, osgAssetId);
+                if (resolved.ok) {
+                    osgImagePath = resolved.path;
+                }
+                else {
+                    logger.warn("overlay-skipped", { assetId: osgAssetId, error: resolved.error });
+                }
+            }
+            if (osgImagePath) {
+                osgCopyName = `osg-project-${Date.now()}${basename(osgImagePath).replace(/^[^.]*/, "")}`;
+                osgCopyPath = join(bundleDir, osgCopyName);
+                await copyFile(resolve(osgImagePath), osgCopyPath);
+            }
+        }
+        catch (error) {
+            const assetIds = Array.isArray(assets)
+                ? assets.flatMap((asset) => (asset && typeof asset.assetId === "string" ? [asset.assetId] : []))
+                : [];
+            return preservePlayableRenderSources(engine, assetIds, () => ctx.markAssetFailureHandled(), error);
+        }
         const targetWidth = orientation === "portrait" ? PORTRAIT_WIDTH : orientation === "square" ? SQUARE_WIDTH : LANDSCAPE_WIDTH;
         const targetHeight = orientation === "portrait" ? PORTRAIT_HEIGHT : orientation === "square" ? SQUARE_HEIGHT : LANDSCAPE_HEIGHT;
         const outputFilename = orientation === "portrait"
@@ -90,36 +189,18 @@ export function registerRenderProjectJob(engine) {
             : orientation === "square"
                 ? "square.mp4"
                 : "landscape.mp4";
-        // The stored-settings path (set_video_overlay → lazy render) carries only
-        // osgAssetId; resolve it to a file at run time so the overlay actually
-        // renders — and so the path survives file moves between enqueue and run.
-        let osgImagePath = payloadOsgImagePath;
-        if (!osgImagePath && osgAssetId) {
-            const resolved = await resolveOsgImagePath(engine, osgAssetId);
-            if (resolved.ok) {
-                osgImagePath = resolved.path;
-            }
-            else {
-                logger.warn("overlay-skipped", { assetId: osgAssetId, error: resolved.error });
-            }
-        }
-        // Copy OSG image into bundle dir once if provided
-        let osgCopyName = null;
-        let osgCopyPath = null;
-        if (osgImagePath) {
-            osgCopyName = `osg-project-${Date.now()}${basename(osgImagePath).replace(/^[^.]*/, "")}`;
-            osgCopyPath = join(bundleDir, osgCopyName);
-            await copyFile(resolve(osgImagePath), osgCopyPath);
-        }
         const rendered = [];
         const failed = [];
         try {
             for (const asset of assets) {
+                const playable = await clearRenderErrorIfPlayable(engine, asset.assetId);
                 try {
                     ctx.signal.throwIfAborted();
                     const claim = await claimLockedLease(engine, asset.assetId, asset.assetDir, "render", { durationMs: LOCK_DURATION_MS, data: { state: `rendering-${orientation}` } }, { durationMs: LOCK_DURATION_MS, waitForActiveMs: CLAIM_WAIT_MS, meta: { orientation } });
                     if (!claim.ok) {
                         failed.push({ assetId: asset.assetId, error: claim.reason });
+                        if (playable)
+                            await releaseQueuedRenderIfPlayable(engine, asset.assetId);
                         continue;
                     }
                     const lease = { ownerId: claim.ownerId };
@@ -350,8 +431,9 @@ export function registerRenderProjectJob(engine) {
                     }
                     finally {
                         clearInterval(heartbeat);
-                        if (renderSucceeded) {
+                        if (renderSucceeded || playable) {
                             await engine.jobs.artifactWork.complete(asset.assetId, lease.ownerId);
+                            await clearRenderError(engine, asset.assetId);
                         }
                         else {
                             await engine.jobs.artifactWork.fail(asset.assetId, lease.ownerId, {
@@ -362,8 +444,13 @@ export function registerRenderProjectJob(engine) {
                     }
                 }
                 catch (err) {
-                    if (ctx.signal.aborted)
+                    if (ctx.signal.aborted) {
+                        if (playable) {
+                            ctx.markAssetFailureHandled();
+                            throw preserveArtifactState(err);
+                        }
                         throw err;
+                    }
                     failed.push({ assetId: asset.assetId, error: err instanceof Error ? err.message : String(err) });
                 }
             }
@@ -373,7 +460,13 @@ export function registerRenderProjectJob(engine) {
                 await unlink(osgCopyPath).catch(() => { });
         }
         if (rendered.length === 0 && failed.length > 0) {
-            throw new Error(`Render failed: ${failed.map((f) => `${f.assetId}: ${f.error}`).join("; ")}`);
+            const error = new Error(`Render failed: ${failed.map((f) => `${f.assetId}: ${f.error}`).join("; ")}`);
+            const playable = await Promise.all(failed.map((entry) => clearRenderErrorIfPlayable(engine, entry.assetId)));
+            if (playable.some(Boolean)) {
+                ctx.markAssetFailureHandled();
+                throw preserveArtifactState(error);
+            }
+            throw error;
         }
         return { success: failed.length === 0, rendered, failed };
     });

package/dist/media/adapters/index.js

@@ -2,6 +2,7 @@ import { alibabaAdapterFor } from "./alibaba.js";
 import { elevenLabsAdapter } from "./elevenlabs.js";
 import { falAdapter } from "./fal.js";
 import { kieAdapter } from "./kie.js";
+import { machgenAdapter } from "./machgen.js";
 import { xaiAdapter } from "./xai.js";
 export function adapterFor(model) {
     switch (model.provider) {
@@ -15,6 +16,8 @@ export function adapterFor(model) {
             return alibabaAdapterFor(model.apiId);
         case "elevenlabs":
             return elevenLabsAdapter;
+        case "machgen":
+            return machgenAdapter;
     }
 }
 export const PROVIDER_ENV_KEYS = {
@@ -23,4 +26,5 @@ export const PROVIDER_ENV_KEYS = {
     xai: "XAI_API_KEY",
     alibaba: "DASHSCOPE_API_KEY",
     elevenlabs: "ELEVENLABS_API_KEY",
+    machgen: "MACHGEN_API_KEY",
 };

package/dist/media/adapters/machgen.js

@@ -0,0 +1,48 @@
+import { createMachGen } from "../../usage-providers.js";
+import { requireApiKey } from "../../api-key.js";
+import { uploadAssetFile } from "../../upload.js";
+import { providerEndpoints } from "../endpoints.js";
+import { nonEmpty, record, writePendingTask } from "./pending.js";
+import { MEDIA_TASK_TYPES } from "./types.js";
+const ASSET_DOWNLOAD_TIMEOUT_MS = 10 * 60_000;
+export function machgenProvider(timeout = 60_000, baseURL = providerEndpoints().machgenBaseURL) {
+    return createMachGen({
+        apiKey: requireApiKey("MACHGEN_API_KEY"),
+        timeout,
+        ...(baseURL ? { baseURL } : {}),
+    });
+}
+function costHints(request, hints) {
+    const seconds = record(request.video_config)?.duration_secs;
+    return {
+        ...(typeof seconds === "number" && seconds > 0 ? { durationSeconds: seconds } : {}),
+        ...hints,
+    };
+}
+async function submit(request, context) {
+    const hints = costHints(request, context.costHints);
+    if (Object.keys(hints).length > 0) {
+        const written = await context.engine.metadata.artifacts.write(context.assetId, "generation-cost-hints", hints);
+        if (!written.ok)
+            throw new Error(written.error.message);
+    }
+    const response = await machgenProvider().api.v0.generate(request, context.ctx.signal);
+    const taskId = nonEmpty(response.task_id);
+    if (!taskId)
+        throw new Error("MachGen accepted the request without a task id");
+    await writePendingTask(context, taskId, MEDIA_TASK_TYPES.machgen, { machgenModel: context.model.apiId });
+    return { kind: "pending", taskId };
+}
+export async function downloadMachGenVideo(taskId, url) {
+    const bytes = Buffer.from(await machgenProvider(ASSET_DOWNLOAD_TIMEOUT_MS).api.v0.assets(taskId));
+    if (bytes.length === 0)
+        throw new Error(`MachGen task ${taskId} returned an empty video`);
+    return { bytes, extension: "mp4", ...(url ? { url } : {}) };
+}
+export const machgenAdapter = {
+    provider: "machgen",
+    envKey: "MACHGEN_API_KEY",
+    upload: uploadAssetFile,
+    uploadUrl: async (url) => url,
+    submit,
+};

package/dist/media/adapters/types.js

@@ -2,4 +2,5 @@ export const MEDIA_TASK_TYPES = {
     kie: "media_kie",
     fal: "fal_media",
     xai: "xai_media",
+    machgen: "machgen_media",
 };