videobook 0.3.0 → 0.3.2

package/dist/jobs/assess-media-probes.js

@@ -0,0 +1,94 @@
+import { join } from "node:path";
+import { probeVideo } from "../ffmpeg.js";
+import { logger } from "../logger.js";
+import { queue, registerJobHandler } from "../queue.js";
+import { invalidVideoProxyMetadata, probeStoredVideoFile, videoProxyAssessmentMatches, videoProxyMetadata, videoProxyValidationError, } from "../video-proxy.js";
+const PROXY_FILENAME = "proxy.mp4";
+export function scheduleVideoProxyAssessment(input) {
+    const jobId = `assess-video-proxy-${input.bookId}-${input.artifactId}-${input.proxyFile.objectHash}`;
+    void queue.enqueue(jobId, {
+        type: "assess_video_proxy",
+        bookId: input.bookId,
+        proxyAssetId: input.artifactId,
+        sourceFilename: input.sourceFile.name,
+        sourceHash: input.sourceFile.objectHash,
+        proxyHash: input.proxyFile.objectHash,
+        sourceProfile: input.sourceProfile,
+    }).catch((error) => {
+        logger.error("proxy-assessment-enqueue-failed", { assetId: input.artifactId, error });
+    });
+}
+export function scheduleMediaDurationBackfill(input) {
+    const jobId = `backfill-media-duration-${input.bookId}-${input.artifactId}-${input.mediaFile.objectHash}`;
+    void queue.enqueue(jobId, {
+        type: "backfill_media_duration",
+        bookId: input.bookId,
+        durationAssetId: input.artifactId,
+        mediaFilename: input.mediaFile.name,
+        mediaHash: input.mediaFile.objectHash,
+    }).catch((error) => {
+        logger.error("duration-backfill-enqueue-failed", { assetId: input.artifactId, error });
+    });
+}
+async function currentFile(engine, artifactId, name, objectHash) {
+    const manifest = await engine.files.manifest(artifactId);
+    if (!manifest.ok)
+        return null;
+    return manifest.value.files.find((file) => file.name === name && file.objectHash === objectHash) ?? null;
+}
+export async function assessStoredVideoProxy(engine, assetId, sourceFile, proxyFile, sourceProfile) {
+    let assessment;
+    try {
+        const proxy = await probeStoredVideoFile(engine, assetId, proxyFile.name);
+        const error = videoProxyValidationError(sourceProfile, proxy);
+        assessment = error
+            ? invalidVideoProxyMetadata(sourceFile, proxyFile, error)
+            : videoProxyMetadata(sourceFile, proxyFile, proxy);
+    }
+    catch (cause) {
+        const error = cause instanceof Error ? cause.message : String(cause);
+        assessment = invalidVideoProxyMetadata(sourceFile, proxyFile, error);
+    }
+    await engine.metadata.artifacts.write(assetId, "proxy", assessment);
+    return assessment.valid;
+}
+async function runVideoProxyAssessment(engine, payload) {
+    const { proxyAssetId } = payload;
+    const sourceFile = await currentFile(engine, proxyAssetId, payload.sourceFilename, payload.sourceHash);
+    const proxyFile = await currentFile(engine, proxyAssetId, PROXY_FILENAME, payload.proxyHash);
+    if (!sourceFile || !proxyFile)
+        return { skipped: true };
+    const existing = await engine.metadata.artifacts.read(proxyAssetId, "proxy");
+    if (existing.ok && videoProxyAssessmentMatches(existing.value, sourceFile, proxyFile)) {
+        return { skipped: true };
+    }
+    return {
+        valid: await assessStoredVideoProxy(engine, proxyAssetId, sourceFile, proxyFile, payload.sourceProfile),
+    };
+}
+async function runMediaDurationBackfill(engine, payload, signal) {
+    const { durationAssetId } = payload;
+    const metadata = await engine.metadata.artifacts.read(durationAssetId, "original");
+    if (!metadata.ok || typeof metadata.value.duration === "number")
+        return { skipped: true };
+    if (!await currentFile(engine, durationAssetId, payload.mediaFilename, payload.mediaHash)) {
+        return { skipped: true };
+    }
+    const dir = await engine.workspaces.resolveArtifact(durationAssetId);
+    if (!dir.ok)
+        throw new Error(`backfill_media_duration: ${dir.error.message}`);
+    const probe = await probeVideo(join(dir.value, payload.mediaFilename), { signal });
+    if (!Number.isFinite(probe.duration) || probe.duration <= 0)
+        return { skipped: true };
+    const written = await engine.metadata.artifacts.write(durationAssetId, "original", {
+        ...metadata.value,
+        duration: probe.duration,
+    });
+    if (!written.ok)
+        throw new Error(written.error.message);
+    return { duration: probe.duration };
+}
+export function registerAssessMediaProbeJobs(engine) {
+    registerJobHandler("assess_video_proxy", async (payload) => runVideoProxyAssessment(engine, payload));
+    registerJobHandler("backfill_media_duration", async (payload, { signal }) => runMediaDurationBackfill(engine, payload, signal));
+}

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

@@ -1,4 +1,3 @@
-import { withHarCapture } from "../har-capture.js";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { writeFile, unlink, readFile as readFsFile } from "node:fs/promises";
@@ -48,9 +47,7 @@ async function reclaimFailedCompletion(engine, task, ctx) {
     return lease.ownerId;
 }
 export function registerCompleteProviderTaskJob(engine) {
-    registerJobHandler("complete_kie_task", async (payload, ctx) => withHarCapture({
-        provider: String(payload.taskType).split("_")[0] ?? "unknown", endpoint: "generation.complete", input: payload,
-    }, async () => {
+    registerJobHandler("complete_kie_task", async (payload, ctx) => {
         const { taskId, taskType, assetId, bookId, meta, resultUrls, resultObject, } = payload;
         // Pattern C: inherit the provider lease via getOwner, abort if the row
         // already terminated, and register the lease so the wrapper's catch path
@@ -128,7 +125,7 @@ export function registerCompleteProviderTaskJob(engine) {
             clearInterval(heartbeat);
             await engine.jobs.locks.release(assetDir);
         }
-    }, globalThis.fetch, { providerTaskId: payload.taskId, model: payload.meta.model, runId: payload.meta.runId, attemptId: payload.meta.attemptId }));
+    });
 }
 async function mediaOutputs(taskType, taskId, urls) {
     if (taskType === MEDIA_TASK_TYPES.machgen)

package/dist/jobs/generate-media.js

@@ -1,4 +1,5 @@
-import { withHarCapture } from "../har-capture.js";
+import { withHarLocalFailure } from "../har-capture.js";
+import { generationHarEndpoint } from "../media/har-endpoint.js";
 import { withBookContext } from "../book-context.js";
 import { isSeedanceEdit } from "../media/seedance-edit.js";
 import { registerJobHandler } from "../queue.js";
@@ -21,24 +22,33 @@ async function replaceAudioMeta(engine, ref) {
     const input = await resolveRefInput(engine, "audio", ref);
     return { replaceAudioWith: { assetId: input.assetId, filename: input.filename } };
 }
+async function sourceAudioSeconds(engine, assetIds) {
+    for (const assetId of assetIds) {
+        const metadata = await engine.metadata.artifacts.read(assetId, "original");
+        const seconds = metadata.ok ? metadata.value.duration : undefined;
+        if (typeof seconds === "number" && Number.isFinite(seconds) && seconds > 0)
+            return seconds;
+    }
+    return undefined;
+}
 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 model = resolveModel(job.model);
+    if (model.entry.outputLength === "audio") {
+        const seconds = await sourceAudioSeconds(engine, refs.sourceAudioIds);
+        return seconds === undefined ? {} : { durationSeconds: seconds };
+    }
     const videoSeconds = await referenceVideoDuration(engine, refs.sourceVideoIds);
     if (videoSeconds !== undefined) {
-        return { inputDurationSeconds: videoSeconds, ...(isSeedanceEdit(job.model, job.mode) ? { durationSeconds: videoSeconds } : {}) };
+        const followsVideo = model.entry.outputLength === "video" || isSeedanceEdit(job.model, job.mode);
+        return { inputDurationSeconds: videoSeconds, ...(followsVideo ? { durationSeconds: videoSeconds } : {}) };
     }
-    if (resolveModel(job.model).provider !== "fal")
+    if (model.provider !== "fal")
         return {};
-    for (const assetId of refs.sourceAudioIds) {
-        const metadata = await engine.metadata.artifacts.read(assetId, "original");
-        const seconds = metadata.ok ? metadata.value.duration : undefined;
-        if (typeof seconds === "number" && Number.isFinite(seconds) && seconds > 0) {
-            return { inputDurationSeconds: seconds };
-        }
-    }
-    return {};
+    const seconds = await sourceAudioSeconds(engine, refs.sourceAudioIds);
+    return seconds === undefined ? {} : { inputDurationSeconds: seconds };
 }
 function generationMeta(job, model, refs) {
     return {
@@ -87,7 +97,7 @@ async function generateMedia(engine, job, ctx) {
 }
 export async function runGenerateMedia(engine, job, ctx) {
     return withBookContext({ bookId: job.bookId, engine, operation: "generate_media", artifactId: job.assetId,
-        attemptId: job.generationId ?? job.assetId, runId: job.runId, model: job.model }, () => withHarCapture({ provider: resolveModel(job.model).provider, endpoint: "generation.submit", input: job }, () => generateMedia(engine, job, ctx)));
+        attemptId: job.generationId ?? job.assetId, runId: job.runId, model: job.model }, () => withHarLocalFailure({ provider: resolveModel(job.model).provider, endpoint: generationHarEndpoint(resolveModel(job.model)), input: job }, () => generateMedia(engine, job, ctx)));
 }
 export function registerGenerateMediaJob(engine) {
     registerJobHandler("generate_media", (payload, ctx) => runGenerateMedia(engine, payload, ctx));

package/dist/jobs/image-subjects.js

@@ -4,6 +4,7 @@ import sharp from "sharp";
 import { KIE_RESULT_TIMEOUT_MS, kieProvider, parseResultUrls, waitForKieResult, } from "./_kie-poll.js";
 import { GROK_EXACT_MASK_ADAPTER_ID, imageEditAdapter, IMAGE_EDIT_ADAPTERS, } from "./_image-edit-adapter.js";
 import { DEFAULT_IMAGE_EDIT_MODEL_ID } from "../image-edit-models.js";
+import { requireApiKey } from "../api-key.js";
 import { compositeImageRegionEdit, imageRegionEditPrompt } from "../image-region-edit.js";
 import { IMAGE_SUBJECT_MAP_VERSION, applyGrokSegmentsToSubjects, composeImageSubjectRemoval, exactEditMaskIndexes, grokMaskIndex, parseGrokSegmentMapResult, persistSeedreamSubjectLayers, readImageSubjectMapRecord, resolveImageSubjectSource, writeCurrentImageSubjectAnalysisRecord, } from "../image-subject-map.js";
 import { enqueueSearchIndex } from "./enqueue-search-index.js";
@@ -534,6 +535,7 @@ export async function previewImageSubjectEditRequest(engine, payload, imageUrls)
         : adapter.buildSemanticRequest(input);
 }
 async function runAdapterImageSubjectEdit(engine, payload, adapter, route, prepared, sourceFilename, signal) {
+    requireApiKey(adapter.envKey);
     const stored = await readStoredImageSubjectEditTask(engine, payload.imageAssetId);
     const storedMatch = stored?.adapterId === adapter.id ? stored : null;
     let request = storedMatch?.request ?? null;

package/dist/jobs/kie-paygate.js

@@ -1,4 +1,4 @@
-import { withHarCapture } from "../har-capture.js";
+import { withHarLocalFailure } from "../har-capture.js";
 import { createKie } from "../usage-providers.js";
 import { submitMediaJob } from "../usage-providers.js";
 import { mintOtp } from "@apicity/cost";
@@ -177,8 +177,8 @@ async function submitQueuedKieTaskInner(engine, task) {
     return writeResult.value.task;
 }
 export async function submitKieTask(engine, ctx, args) {
-    return withHarCapture({ provider: "kie", endpoint: "generation.paygate", input: args.request }, () => submitKieTaskInner(engine, ctx, args));
+    return withHarLocalFailure({ provider: "kie", endpoint: "api.v1.jobs.createTask", input: args.request }, () => submitKieTaskInner(engine, ctx, args));
 }
 export async function submitQueuedKieTask(engine, task) {
-    return withHarCapture({ provider: "kie", endpoint: "generation.queued", input: task }, () => submitQueuedKieTaskInner(engine, task));
+    return withHarLocalFailure({ provider: "kie", endpoint: "api.v1.jobs.createTask", input: task }, () => submitQueuedKieTaskInner(engine, task));
 }

package/dist/jobs/register-all.js

@@ -38,6 +38,7 @@ import { registerLabelMusicSectionsJob } from "./label-music-sections.js";
 import { registerEditingMomentsJob } from "./analyze-editing-moments.js";
 import { registerExtractWaveformJob } from "./extract-waveform.js";
 import { registerExtractVideoPosterJob } from "./extract-video-poster.js";
+import { registerAssessMediaProbeJobs } from "./assess-media-probes.js";
 import { registerReplaceVideoAudioJob } from "./replace-video-audio.js";
 import { registerSpliceVideoJob } from "./splice-video.js";
 import { registerSmoothSceneConcatJob } from "./smooth-scene-concat.js";
@@ -109,6 +110,7 @@ export function registerAllJobHandlers(engine, books = bookManager) {
     registerExtractAudioJob(engine);
     registerExtractWaveformJob(engine);
     registerExtractVideoPosterJob(engine);
+    registerAssessMediaProbeJobs(engine);
     registerAnalyzeMusicJob(engine);
     registerPlanGoalJob(engine);
     registerAssembleGoalJob(engine);

package/dist/jobs/run-notebook.js

@@ -2609,6 +2609,21 @@ async function finishAwaitingNotebookCell(engine, input) {
         throw new Error(refreshed.error.message);
     return { outputArtifactId, document: refreshed.value };
 }
+function withFailedGenerationPlan(document, cellId, runId, error, updatedAt) {
+    return {
+        ...document,
+        generationPlans: (document.generationPlans ?? []).map((record) => record.cellId === cellId
+            && (record.status === "queued" || record.status === "awaiting-output")
+            && generationPlanClaimRunId(record.plan) === runId
+            ? {
+                ...record,
+                status: "failed",
+                updatedAt,
+                error: truncateGenerationError(error),
+            }
+            : record),
+    };
+}
 async function failAwaitingNotebookCell(engine, input, message) {
     const updatedAt = new Date().toISOString();
     const result = await mutateNotebook(engine, input.notebookId, "fail_notebook_provider_output", (document) => {
@@ -2628,7 +2643,7 @@ async function failAwaitingNotebookCell(engine, input, message) {
             : undefined) ?? cell.id;
         const current = executionState(document)[failTargetId]
             ?? executionState(document)[cell.id];
-        const withFailure = withExecution(document, failTargetId, {
+        const withFailure = withExecution(withFailedGenerationPlan(document, cell.id, input.runId, message, updatedAt), failTargetId, {
             fingerprint: current?.fingerprint
                 ?? notebookCellFingerprint(document, cell),
             status: "error",

package/dist/library-asset-projection.js

@@ -0,0 +1,141 @@
+import { computeArtifactStatus } from "videobook-engine";
+import { EMPTY_TAG_SUMMARY, matchesTagFilter, readAssetTagSummaries, } from "./asset-tags.js";
+import { assetDuration, assetMediaUrls, assetStreamProfile, findAssetMediaFile, groupByArtifactId, indexByArtifactId, PARTIAL_DOWNLOAD_RE, scheduleMissingVideoPoster, servedVideoProxyFile, } from "./asset-media-projection.js";
+function metadataNumber(meta, key) {
+    const value = meta?.[key];
+    return typeof value === "number" ? value : null;
+}
+function metadataString(meta, key) {
+    const value = meta?.[key];
+    return typeof value === "string" ? value : null;
+}
+function readJobIndexes(engine) {
+    const pending = engine.jobs.pending.findAll();
+    const failures = engine.jobs.failures.findAll();
+    const work = engine.jobs.artifactWork.list();
+    const streams = engine.streams.list();
+    return {
+        pending: indexByArtifactId(pending.ok ? pending.value : []),
+        failures: indexByArtifactId(failures.ok ? failures.value : []),
+        work: indexByArtifactId(work.ok ? work.value : []),
+        streams: groupByArtifactId(streams.ok ? streams.value : []),
+    };
+}
+async function readCandidate(engine, artifact, jobs, tags) {
+    const [manifest, metadata] = await Promise.all([
+        engine.files.manifest(artifact.artifactId, { includeDotfiles: true }),
+        engine.metadata.artifacts.read(artifact.artifactId, "original"),
+    ]);
+    const files = manifest.ok ? manifest.value.files : [];
+    const meta = metadata.ok ? metadata.value : null;
+    const mediaFile = findAssetMediaFile(files, artifact);
+    const work = jobs.work.get(artifact.artifactId) ?? null;
+    const status = computeArtifactStatus({
+        kind: artifact.kind,
+        fileNames: new Set(files.map((file) => file.name)),
+        primaryMediaName: mediaFile?.name ?? null,
+        hasOriginalMetadata: metadata.ok,
+        hasPartFile: files.some((file) => PARTIAL_DOWNLOAD_RE.test(file.name)),
+        lockData: engine.jobs.locks.get(artifact.path),
+        pendingTask: jobs.pending.get(artifact.artifactId) ?? null,
+        generationError: jobs.failures.get(artifact.artifactId) ?? null,
+        artifactRow: work
+            ? { status: work.status, meta: work.meta, deadlineAt: work.deadlineAt }
+            : null,
+    });
+    return {
+        id: artifact.artifactId,
+        artifact_id: artifact.artifactId,
+        ...(artifact.label ? { label: artifact.label } : {}),
+        type: artifact.kind,
+        created_at: new Date(artifact.createdAt).toISOString(),
+        status,
+        prompt: metadataString(meta, "prompt"),
+        object_hash: mediaFile?.objectHash ?? null,
+        tags,
+        source: {
+            artifact,
+            files,
+            meta,
+            mediaFile,
+            work,
+            streams: jobs.streams.get(artifact.artifactId) ?? [],
+        },
+    };
+}
+export async function readLibraryCandidates(engine, input) {
+    const artifacts = engine.artifacts.list({ sort: "newest" })
+        .filter((artifact) => input.kinds.has(artifact.kind));
+    const tagsByArtifact = readAssetTagSummaries(engine, artifacts.map((artifact) => artifact.artifactId));
+    const tagged = artifacts.filter((artifact) => matchesTagFilter(tagsByArtifact.get(artifact.artifactId), input.tags));
+    if (tagged.length === 0)
+        return [];
+    const jobs = readJobIndexes(engine);
+    return Promise.all(tagged.map((artifact) => readCandidate(engine, artifact, jobs, tagsByArtifact.get(artifact.artifactId) ?? EMPTY_TAG_SUMMARY)));
+}
+function libraryAssetWork(work) {
+    return work
+        ? {
+            status: work.status,
+            meta: work.meta,
+            ownerKind: work.ownerKind,
+            deadlineAt: work.deadlineAt,
+        }
+        : null;
+}
+function framesPerSecond(meta, frameRate) {
+    const metadataFps = Number(meta?.fps);
+    if (Number.isFinite(metadataFps) && metadataFps > 0)
+        return metadataFps;
+    if (!frameRate || frameRate.denominator <= 0)
+        return null;
+    const streamFps = frameRate.numerator / frameRate.denominator;
+    return Number.isFinite(streamFps) && streamFps > 0 ? streamFps : null;
+}
+export async function projectLibraryAsset(engine, bookId, candidate) {
+    const { artifact, files, meta, mediaFile, work, streams } = candidate.source;
+    const profile = assetStreamProfile(streams, meta);
+    const proxyMetadata = artifact.kind === "video" && files.some((file) => file.name === "proxy.mp4")
+        ? await engine.metadata.artifacts.read(artifact.artifactId, "proxy")
+        : { ok: false, error: { code: "NOT_FOUND", message: "no proxy" } };
+    const proxyFile = servedVideoProxyFile({
+        bookId,
+        artifact,
+        files,
+        mediaFile,
+        proxyMetadata,
+        work,
+        sourceProfile: profile.sourceProfile,
+    });
+    await scheduleMissingVideoPoster(engine, {
+        bookId,
+        artifact,
+        files,
+        mediaFile,
+        status: candidate.status,
+    });
+    return {
+        id: candidate.id,
+        artifact_id: candidate.artifact_id,
+        ...(candidate.label ? { label: candidate.label } : {}),
+        type: candidate.type,
+        created_at: candidate.created_at,
+        ...assetMediaUrls({ bookId, artifact, files, mediaFile, proxyFile }),
+        object_hash: candidate.object_hash,
+        status: candidate.status,
+        assetWork: libraryAssetWork(work),
+        width: metadataNumber(meta, "width"),
+        height: metadataNumber(meta, "height"),
+        origin: metadataString(meta, "origin"),
+        prompt: candidate.prompt,
+        duration: assetDuration({
+            bookId,
+            artifactId: artifact.artifactId,
+            meta,
+            mediaFile,
+            profile,
+        }),
+        fps: framesPerSecond(meta, profile.frameRate),
+        tags: candidate.tags,
+    };
+}

package/dist/lightning-defaults.js

@@ -1,12 +1,12 @@
 export const LIGHTNING_SCENE_MODEL = "kie:nano-banana-2-1";
-export const LIGHTNING_SCENE_ASPECT_RATIO = "16:9";
-export const LIGHTNING_SCENE_RESOLUTION = "2K";
+export const LIGHTNING_SCENE_ASPECT_RATIO = "9:16";
+export const LIGHTNING_SCENE_RESOLUTION = "4K";
 export const LIGHTNING_SCENE_OUTPUT_FORMAT = "jpg";
 export const LIGHTNING_SCENE_PROMPT_WORDS = 25;
 export const LIGHTNING_VIDEO_MODEL = "kie:bytedance/seedance-2-5";
-export const LIGHTNING_VIDEO_ASPECT_RATIO = "16:9";
+export const LIGHTNING_VIDEO_ASPECT_RATIO = "9:16";
 export const LIGHTNING_VIDEO_RESOLUTION = "1080p";
-export const LIGHTNING_VIDEO_DURATION_SECONDS = 13;
+export const LIGHTNING_VIDEO_DURATION_SECONDS = 12;
 export const LIGHTNING_VIDEO_OUTPUT_FORMAT = "mp4";
 export const LIGHTNING_VIDEO_GENERATE_AUDIO = true;
 export const LIGHTNING_VIDEO_PROMPT_WORDS = 60;

package/dist/media/catalog.js

@@ -22,7 +22,7 @@ const SEEDANCE_US_REFERENCE_MODES = [
 ];
 const XAI_MODES = [
     { id: "i2v", label: "Image to video", roles: ["first_frame"] },
-    { id: "r2v", label: "References", roles: ["image"] },
+    { id: "r2v", label: "References", roles: ["image"], defaults: { duration: 10 } },
     { id: "v2v", label: "Edit video", roles: ["video"], requireAny: ["video"] },
 ];
 const MACHGEN_FRAMES = { id: "i2v", label: "Frames", roles: ["first_frame", "last_frame"], requireAny: ["first_frame"] };
@@ -157,10 +157,11 @@ export const MODEL_ENTRIES = [
     },
     { id: "kie:grok-imagine/image-to-video", media: "video", operations: ["image_to_video"], guide: "grok_imagine" },
     { id: "kie:grok-imagine/text-to-video", media: "video", operations: ["text_to_video"], guide: "grok_imagine", defaults: { duration: 6, resolution: "480p" } },
+    { id: "kie:grok-imagine-video-1-5-preview", media: "video", operations: ["image_to_video"], title: "Grok Imagine Video 1.5 Preview (Kie)", guide: "grok_imagine", dialect: "natural_strip_frames" },
     { id: "kie:grok-imagine/extend", media: "video", operations: ["extend_video"], hidden: true },
     { id: "kie:grok-imagine/upscale", media: "video", operations: ["upscale_video"], hidden: true },
     { id: "kie:kling-3.0-omni/text-to-video", media: "video", operations: ["text_to_video"], guide: "kling30", dialect: "natural", defaults: { customize_multi_shots: false } },
-    { id: "kie:kling-3.0-omni/image-to-video", media: "video", operations: ["image_to_video"], guide: "kling30", dialect: "natural" },
+    { id: "kie:kling-3.0-omni/image-to-video", media: "video", operations: ["image_to_video"], guide: "kling30", dialect: "natural", defaults: { aspect_ratio: "auto" }, pinnedDefaults: ["aspect_ratio"] },
     { id: "kie:kling-3.0-omni/reference-to-video", media: "video", operations: ["reference_to_video"], guide: "kling30", dialect: "natural", defaults: { audio: false } },
     {
         id: "kie:kling-3.0-omni/transformation",
@@ -173,21 +174,26 @@ export const MODEL_ENTRIES = [
             { id: "v2v_refs", label: "Edit with references", roles: ["video", "image"], requireAny: ["video"] },
         ],
     },
-    { id: "kie:kling-3.0/motion-control", media: "video", operations: ["motion_control"], guide: "kling30", dialect: "natural", defaults: { mode: "720p" } },
+    { id: "kie:kling-3.0/motion-control", media: "video", operations: ["motion_control"], guide: "kling30", dialect: "natural", defaults: { mode: "720p" }, outputLength: "video" },
+    { id: "kie:kling-4.0/reference-to-video", media: "video", operations: ["reference_to_video"], dialect: "kling4" },
+    { id: "kie:kling-4.0/keyframe-to-video", media: "video", operations: ["image_to_video"], dialect: "kling4_keyframes", refs: { image: "keyframe_urls" } },
     { id: "kie:gemini-omni-video", media: "video", operations: ["image_to_video", "edit_video"], dialect: "natural_source_video", defaults: { duration: "8" }, modes: [{ id: "i2v", label: "Image to video", roles: ["image"] }, { id: "v2v", label: "Edit video", roles: ["video", "image"], requireAny: ["video"] }], refItem: { video: { start: 0, ends: 8 } }, aliases: { clip_start: "video_list.0.start", clip_end: "video_list.0.ends" } },
     { id: "kie:wan/3-0-video", media: "video", operations: ["text_to_video", "image_to_video", "reference_to_video"], dialect: "seedance", modes: SEEDANCE_MODES },
     { id: "kie:wan/3-0-video-prime", media: "video", operations: ["text_to_video", "image_to_video", "reference_to_video"], dialect: "seedance", modes: SEEDANCE_MODES },
     { id: "kie:happyhorse-1-1/text-to-video", media: "video", operations: ["text_to_video"] },
     { id: "kie:happyhorse-1-1/image-to-video", media: "video", operations: ["image_to_video"], dialect: "strip_frames" },
     { id: "kie:happyhorse-1-1/reference-to-video", media: "video", operations: ["reference_to_video"], dialect: "brackets" },
-    { id: "kie:happyhorse/video-edit", media: "video", operations: ["edit_video"], dialect: "happyhorse_edit" },
+    { id: "kie:happyhorse/video-edit", media: "video", operations: ["edit_video"], dialect: "happyhorse_edit", outputLength: "video" },
     { id: "kie:minimax-h3/text-to-video", media: "video", operations: ["text_to_video"] },
     { id: "kie:minimax-h3/image-to-video", media: "video", operations: ["image_to_video"], dialect: "strip_frames" },
     { id: "kie:minimax-h3/reference-to-video", media: "video", operations: ["reference_to_video"], dialect: "natural", rules: { refDurationMs: MiniMaxH3ReferenceClipDurationMs } },
-    { id: "kie:volcengine/video-to-video-lip-sync", media: "video", operations: ["lip_sync"] },
-    { id: "kie:omnihuman-1-5", media: "video", operations: ["image_to_video", "lip_sync"], dialect: "natural" },
+    { id: "kie:volcengine/video-to-video-lip-sync", media: "video", operations: ["lip_sync"], outputLength: "audio" },
+    { id: "kie:omnihuman-1-5", media: "video", operations: ["image_to_video", "lip_sync"], dialect: "natural", outputLength: "audio" },
+    { id: "kie:omnihuman-2-0", media: "video", operations: ["image_to_video", "lip_sync"], dialect: "natural", defaults: { enable_watermark: false }, outputLength: "audio" },
     { id: "kie:vidu-q4/image-to-video", media: "video", operations: ["image_to_video"], dialect: "natural_kinds" },
     { id: "kie:vidu-q4/reference-to-video", media: "video", operations: ["reference_to_video"], dialect: "natural_kinds" },
+    { id: "kie:pixverse-v6-max/text-to-video", media: "video", operations: ["text_to_video"], defaults: { quality: "1080p" } },
+    { id: "kie:pixverse-v6-max/image-to-video", media: "video", operations: ["image_to_video"], dialect: "strip_frames", defaults: { quality: "1080p" } },
     { id: "kie:veo3", media: "video", operations: ["text_to_video", "image_to_video"], title: "Veo 3 (Kie)" },
     { id: "kie:veo3_fast", media: "video", operations: ["text_to_video", "image_to_video"], title: "Veo 3 Fast (Kie)" },
     { id: "xai:grok-imagine-video", media: "video", operations: ["text_to_video", "image_to_video", "reference_to_video", "edit_video"], guide: "grok_imagine", title: "Grok Imagine Video (xAI)", dialect: "natural", refs: { first_frame: "image", audio: null }, modes: XAI_MODES },

package/dist/media/descriptor.js

@@ -1,9 +1,10 @@
 import { MODEL_DISPLAY } from "@apicity/cost";
 import { modelEntry } from "./catalog.js";
 import { parseModelId } from "./model-id.js";
+import { preferredDefaults } from "./preferred-defaults.js";
 import { claimedFields, resolveSlot } from "./ref-fields.js";
 import { wireSpec } from "./wire.js";
-import { enumValues, numberBounds, propertyAt, schemaTypes, stringMaxLength, toJsonSchema, } from "./json-schema.js";
+import { acceptsNoValue, enumValues, numberBounds, propertyAt, schemaTypes, stringMaxLength, toJsonSchema, } from "./json-schema.js";
 import { REF_ROLES, } from "./types.js";
 const PROMPT_CANDIDATES = ["prompt", "text", "instruction", "description"];
 const cache = new Map();
@@ -74,7 +75,7 @@ function resolveOptions(entry, input, excluded, fixed) {
     const defaults = entry.defaults ?? {};
     const options = [];
     for (const [name, schema] of Object.entries(input.properties ?? {})) {
-        if (excluded.has(name) || name in fixed)
+        if (excluded.has(name) || name in fixed || acceptsNoValue(schema))
             continue;
         options.push(optionSpec(name, name, schema, required.has(name), defaults));
     }
@@ -121,8 +122,10 @@ function build(entry) {
         excluded.add(top);
     if (promptTop)
         excluded.add(promptTop);
+    const preferred = preferredDefaults(entry, resolveOptions(entry, input, excluded, wire.fixed));
+    const tuned = { ...entry, defaults: { ...entry.defaults, ...preferred } };
     return {
-        entry,
+        entry: tuned,
         id: entry.id,
         provider: parsed.provider,
         apiId: parsed.apiId,
@@ -132,10 +135,18 @@ function build(entry) {
         promptField,
         promptRequired: promptTop !== undefined && promptField === promptTop && (input.required ?? []).includes(promptTop),
         slots,
-        options: resolveOptions(entry, input, excluded, wire.fixed),
+        options: resolveOptions(tuned, input, excluded, wire.fixed),
         modes: entry.modes ? [...entry.modes] : defaultModes(slots),
     };
 }
+export function resolveEntry(entry) {
+    const cached = cache.get(entry.id);
+    if (cached)
+        return cached;
+    const resolved = build(entry);
+    cache.set(entry.id, resolved);
+    return resolved;
+}
 export function resolveModel(model) {
     const cached = cache.get(model);
     if (cached)
@@ -143,9 +154,7 @@ export function resolveModel(model) {
     const entry = modelEntry(model);
     if (!entry)
         throw new UnknownModelError(model);
-    const resolved = build(entry);
-    cache.set(model, resolved);
-    return resolved;
+    return resolveEntry(entry);
 }
 export function tryResolveModel(model) {
     try {

package/dist/media/frontier-gaps.js

@@ -31,7 +31,6 @@ export const FRONTIER_CATALOG_GAPS = {
     "fal:bytedance.seedance2p0.imageToVideo": "This exact endpoint is not in the Videobook catalog.",
     "fal:blackforestlabs.flux3.imageToVideo": "This exact endpoint is not in the Videobook catalog.",
     "fal:xai.grokImagineVideo.v1p5.imageToVideo": "This exact endpoint is not in the Videobook catalog.",
-    "kie:grok-imagine-video-1-5-preview": "This exact endpoint is not in the Videobook catalog.",
     "xai:v1.videos.generations.imageToVideo": "The catalog uses grok-imagine-video, not the ranked 1.5 model id.",
     "fal:alibaba.happyHorse.v1p1.imageToVideo": "This exact endpoint is not in the Videobook catalog.",
     "fal:bytedance.seedance2p5.referenceToVideo": "This exact endpoint is not in the Videobook catalog.",

package/dist/media/har-endpoint.js

@@ -0,0 +1,25 @@
+import { isKieVeoModel } from "./wire.js";
+export function generationHarEndpoint(model) {
+    switch (model.provider) {
+        case "kie":
+            if (isKieVeoModel(model.apiId))
+                return "api.v1.veo.generate";
+            if (model.apiId === "suno/generate")
+                return "api.v1.generate";
+            if (model.apiId === "suno/sounds-generate")
+                return "api.v1.generate.sounds";
+            return "api.v1.jobs.createTask";
+        case "fal": return "v1.queue.submit";
+        case "xai": return "v1.videos.generations";
+        case "alibaba": return "api.v1.services.aigc.multimodalGeneration.generation";
+        case "machgen": return "api.v0.generate";
+        case "elevenlabs":
+            switch (model.apiId) {
+                case "sound-generation": return "v1.soundGeneration";
+                case "music": return "v1.music";
+                case "video-to-music": return "v1.music.videoToMusic";
+                case "text-to-speech": return "v1.textToSpeech";
+                default: throw new Error(`Unsupported ElevenLabs model ${model.apiId}`);
+            }
+    }
+}

package/dist/media/json-schema.js

@@ -43,6 +43,9 @@ export function isKeyframeItem(schema) {
         && branch.properties?.image_url !== undefined
         && branch.properties?.frame_index !== undefined);
 }
+export function acceptsNoValue(schema) {
+    return schema.not !== undefined && Object.keys(schema.not).length === 0;
+}
 export function isArraySchema(schema) {
     return branches(schema).some((branch) => branch.type === "array");
 }

package/dist/media/listing.js

@@ -1,7 +1,9 @@
 import { modelFrontierRankings } from "./frontier.js";
 import { PROVIDER_ENV_KEYS } from "./adapters/index.js";
 import { MODEL_ENTRIES } from "./catalog.js";
-import { resolveModel } from "./descriptor.js";
+import { resolveEntry } from "./descriptor.js";
+import { registerDiagnosticName } from "../diagnostics.js";
+import { logger } from "../logger.js";
 export function modelIsHidden(entry) {
     return entry.hidden === true && modelFrontierRankings(entry.id).length === 0;
 }
@@ -22,10 +24,30 @@ export function modelListing(model) {
         frontier: modelFrontierRankings(model.id),
     };
 }
+for (const entry of MODEL_ENTRIES)
+    registerDiagnosticName("model", entry.id);
+const unresolvableReported = new Set();
+function reportUnresolvable(entry, error) {
+    if (unresolvableReported.has(entry.id))
+        return;
+    unresolvableReported.add(entry.id);
+    logger.warn("model-unresolvable", { model: entry.id, error });
+}
+function resolveOrSkip(entry) {
+    try {
+        return [resolveEntry(entry)];
+    }
+    catch (error) {
+        reportUnresolvable(entry, error);
+        return [];
+    }
+}
+export function resolvableModels(entries) {
+    return entries.flatMap(resolveOrSkip);
+}
 export function listModels(filter = {}) {
-    return MODEL_ENTRIES
+    return resolvableModels(MODEL_ENTRIES
         .filter((entry) => filter.includeHidden || !modelIsHidden(entry))
         .filter((entry) => !filter.media || entry.media === filter.media)
-        .filter((entry) => !filter.operation || entry.operations.includes(filter.operation))
-        .map((entry) => resolveModel(entry.id));
+        .filter((entry) => !filter.operation || entry.operations.includes(filter.operation)));
 }