videobook 0.0.0-stage → 0.1.0

package/dist/http-byte-range.js

@@ -0,0 +1,31 @@
+export function parseHttpByteRange(value, size) {
+    if (!Number.isSafeInteger(size) || size < 1)
+        return { ok: false };
+    const match = value.trim().match(/^bytes=(\d*)-(\d*)$/u);
+    if (!match || (!match[1] && !match[2]))
+        return { ok: false };
+    if (!match[1]) {
+        const suffixLength = Number(match[2]);
+        if (!Number.isSafeInteger(suffixLength) || suffixLength < 1) {
+            return { ok: false };
+        }
+        return {
+            ok: true,
+            end: size - 1,
+            start: Math.max(0, size - suffixLength),
+        };
+    }
+    const start = Number(match[1]);
+    const requestedEnd = match[2] ? Number(match[2]) : size - 1;
+    if (!Number.isSafeInteger(start)
+        || !Number.isSafeInteger(requestedEnd)
+        || start >= size
+        || requestedEnd < start) {
+        return { ok: false };
+    }
+    return {
+        ok: true,
+        end: Math.min(requestedEnd, size - 1),
+        start,
+    };
+}

package/dist/image-compress.js

@@ -0,0 +1,77 @@
+import sharp from "sharp";
+const JPEG_REENCODE_THRESHOLD_BYTES = 3 * 1024 * 1024;
+// External image-gen APIs reject or silently degrade sub-300px inputs. Keep both
+// dimensions at or above this floor by upscaling small images to JPEG.
+const MIN_IMAGE_DIMENSION = 300;
+const REENCODABLE_FORMATS = new Set(["jpeg", "png", "webp", "bmp", "tiff", "avif"]);
+function replaceExtension(filename, newExt) {
+    const dot = filename.lastIndexOf(".");
+    return dot === -1 ? `${filename}.${newExt}` : `${filename.slice(0, dot)}.${newExt}`;
+}
+// Re-encode raster images larger than the threshold to high-quality JPEG at
+// the source resolution. Uploads to free hosts and Alibaba/Kie worker fetches
+// are more reliable with smaller payloads, and wan i2v has a ~10 MB base-64
+// cap (≈7 MB raw). Returns the input unchanged for non-images, small files,
+// or cases where re-encoding would not shrink the payload.
+export async function maybeReencodeImage(data, filename) {
+    if (data.byteLength <= JPEG_REENCODE_THRESHOLD_BYTES) {
+        return { data, filename };
+    }
+    let format;
+    try {
+        const meta = await sharp(data).metadata();
+        format = meta.format;
+    }
+    catch {
+        return { data, filename };
+    }
+    if (!format || !REENCODABLE_FORMATS.has(format)) {
+        return { data, filename };
+    }
+    const reencoded = await sharp(data)
+        .rotate()
+        .flatten({ background: "#ffffff" })
+        .jpeg({ quality: 92, mozjpeg: true, progressive: true, chromaSubsampling: "4:2:0" })
+        .toBuffer();
+    if (reencoded.byteLength >= data.byteLength) {
+        return { data, filename };
+    }
+    return { data: new Uint8Array(reencoded), filename: replaceExtension(filename, "jpg") };
+}
+// Upscale raster images whose shortest side is below MIN_IMAGE_DIMENSION so that
+// both dimensions are at least MIN_IMAGE_DIMENSION, preserving aspect ratio.
+// Output is always JPEG. Returns the input unchanged for non-raster formats or
+// images that already meet the floor.
+export async function maybeUpscaleSmallImage(data, filename) {
+    let format;
+    let width;
+    let height;
+    try {
+        const meta = await sharp(data).metadata();
+        format = meta.format;
+        width = meta.width;
+        height = meta.height;
+    }
+    catch {
+        return { data, filename };
+    }
+    if (!format || !REENCODABLE_FORMATS.has(format))
+        return { data, filename };
+    if (!width || !height)
+        return { data, filename };
+    if (width >= MIN_IMAGE_DIMENSION && height >= MIN_IMAGE_DIMENSION) {
+        return { data, filename };
+    }
+    const resized = await sharp(data)
+        .rotate()
+        .flatten({ background: "#ffffff" })
+        .resize({
+        width: MIN_IMAGE_DIMENSION,
+        height: MIN_IMAGE_DIMENSION,
+        fit: "outside",
+        withoutEnlargement: false,
+    })
+        .jpeg({ quality: 92, mozjpeg: true, progressive: true, chromaSubsampling: "4:2:0" })
+        .toBuffer();
+    return { data: new Uint8Array(resized), filename: replaceExtension(filename, "jpg") };
+}

package/dist/image-edit-default.js

@@ -0,0 +1 @@
+export const DEFAULT_IMAGE_EDIT_MODEL_ID = "nano-banana-2-1";

package/dist/image-edit-models.js

@@ -0,0 +1,41 @@
+import { resolveModel } from "./media/descriptor.js";
+import { DEFAULT_IMAGE_EDIT_MODEL_ID } from "./image-edit-default.js";
+export { DEFAULT_IMAGE_EDIT_MODEL_ID } from "./image-edit-default.js";
+const STANDARD_IMAGE_EDIT_CAPABILITIES = {
+    semantic: true,
+    regionReplace: true,
+    wholeImage: true,
+    exactMask: false,
+};
+const EDIT_MODELS = [
+    { catalogModel: `kie:${DEFAULT_IMAGE_EDIT_MODEL_ID}`, label: "Nano Banana 2.1 Edit" },
+    { catalogModel: "kie:seedream/5-pro-image-to-image", label: "Seedream 5 Pro" },
+    { catalogModel: "kie:gpt-image-2-5-flare-image-to-image", label: "GPT Image 2.5 Flare" },
+    { catalogModel: "kie:gpt-image-2-5-sunburst-image-to-image", label: "GPT Image 2.5 Sunburst" },
+    { catalogModel: "kie:gpt-image-2-image-to-image", label: "GPT Image 2" },
+    { catalogModel: "fal:fal-ai/nano-banana-pro/edit", label: "Nano Banana Pro" },
+    { 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" },
+];
+function imageSlotMax(model) {
+    return model.slots.find((slot) => slot.role === "image")?.max ?? null;
+}
+function editModelInfo(entry) {
+    const model = resolveModel(entry.catalogModel);
+    const provider = model.provider === "fal" ? "fal" : "kie";
+    return {
+        id: model.apiId,
+        catalogModel: model.id,
+        label: entry.label,
+        provider,
+        envKey: provider === "fal" ? "FAL_API_KEY" : "KIE_API_KEY",
+        maxInputImages: imageSlotMax(model),
+        capabilities: STANDARD_IMAGE_EDIT_CAPABILITIES,
+    };
+}
+export const IMAGE_EDIT_MODELS = EDIT_MODELS.map(editModelInfo);
+export const IMAGE_EDIT_MODEL_IDS = IMAGE_EDIT_MODELS.map((model) => model.id);
+export function findImageEditModel(id) {
+    return IMAGE_EDIT_MODELS.find((model) => model.id === id || model.catalogModel === id);
+}

package/dist/image-edit-settings.js

@@ -0,0 +1,11 @@
+const SETTINGS_KEY = "image-edit-model-selection";
+export function readLastImageEditModel(engine) {
+    const stored = engine.settings.get(SETTINGS_KEY);
+    const modelId = stored?.modelId;
+    return typeof modelId === "string" && modelId.trim() ? modelId.trim() : null;
+}
+export function writeLastImageEditModel(engine, modelId) {
+    const written = engine.settings.set(SETTINGS_KEY, { modelId });
+    if (!written.ok)
+        throw new Error(written.error.message);
+}

package/dist/image-region-edit.js

@@ -0,0 +1,32 @@
+import sharp from "sharp";
+export function imageRegionEditPrompt(regions, operation, prompt) {
+    const targets = regions.map((box, index) => `Region ${index + 1}: normalized box x=${box.x.toFixed(6)}, y=${box.y.toFixed(6)}, width=${box.width.toFixed(6)}, height=${box.height.toFixed(6)}`);
+    const instruction = operation === "remove"
+        ? "Remove the contents of the selected regions and fill them naturally from the surrounding scene."
+        : prompt.trim();
+    return [
+        instruction,
+        "Apply the change only inside the following regions of the input image. Coordinates run from 0 to 1, starting at the top-left corner.",
+        ...targets,
+        "Keep the same image dimensions, composition and camera framing. Preserve everything outside the selected regions exactly.",
+    ].join("\n");
+}
+export async function compositeImageRegionEdit(original, generated, regions) {
+    const source = await sharp(original).rotate().png().toBuffer();
+    const { width, height } = await sharp(source).metadata();
+    if (!width || !height)
+        throw new Error("Could not determine source image dimensions");
+    const edited = await sharp(generated).rotate().resize(width, height, { fit: "fill" })
+        .png().toBuffer();
+    const overlays = await Promise.all(regions.map(async (box) => {
+        const left = Math.min(width - 1, Math.floor(box.x * width));
+        const top = Math.min(height - 1, Math.floor(box.y * height));
+        const right = Math.min(width, Math.max(left + 1, Math.ceil((box.x + box.width) * width)));
+        const bottom = Math.min(height, Math.max(top + 1, Math.ceil((box.y + box.height) * height)));
+        const input = await sharp(edited).extract({
+            left, top, width: right - left, height: bottom - top,
+        }).toBuffer();
+        return { input, left, top };
+    }));
+    return sharp(source).composite(overlays).png().toBuffer();
+}