videobook 0.0.0-stage → 0.2.0

package/dist/image-subject-map.js

@@ -0,0 +1,523 @@
+import { createHash } from "node:crypto";
+import sharp from "sharp";
+import { findPrimaryMediaFile } from "videobook-engine";
+import { z } from "zod";
+export const IMAGE_SUBJECT_MAP_VERSION = 1;
+const IMAGE_SUBJECT_MAP_METADATA_KEY = "image-subject-map.v1";
+const imageSubjectMapWriteChains = new Map();
+const normalizedBoxSchema = z.object({
+    x: z.number().min(0).max(1),
+    y: z.number().min(0).max(1),
+    width: z.number().positive().max(1),
+    height: z.number().positive().max(1),
+}).strict().refine((box) => box.x + box.width <= 1.001 && box.y + box.height <= 1.001, { message: "subject box extends beyond the image" });
+const subjectSchema = z.object({
+    id: z.string().min(1),
+    label: z.string().min(1),
+    description: z.string(),
+    color: z.string().regex(/^#[0-9a-f]{6}$/i),
+    normalizedBox: normalizedBoxSchema,
+    layerFile: z.string().min(1),
+    thumbnailFile: z.string().min(1),
+    zIndex: z.number().int(),
+    exactEdit: z.boolean(),
+    maskIndex: z.number().int().min(0).optional(),
+}).strict();
+const subjectsSchema = z.array(subjectSchema).superRefine((subjects, context) => {
+    const ids = new Set();
+    const zIndexes = new Set();
+    for (const [index, subject] of subjects.entries()) {
+        if (ids.has(subject.id)) {
+            context.addIssue({
+                code: "custom",
+                path: [index, "id"],
+                message: `duplicate subject id ${subject.id}`,
+            });
+        }
+        if (zIndexes.has(subject.zIndex)) {
+            context.addIssue({
+                code: "custom",
+                path: [index, "zIndex"],
+                message: `duplicate subject z-index ${subject.zIndex}`,
+            });
+        }
+        ids.add(subject.id);
+        zIndexes.add(subject.zIndex);
+    }
+});
+const recordBaseSchema = z.object({
+    version: z.literal(IMAGE_SUBJECT_MAP_VERSION),
+    artifactId: z.string().min(1),
+    objectHash: z.string().min(1),
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+    jobId: z.string().min(1),
+}).strict();
+const analyzingRecordSchema = recordBaseSchema.extend({
+    status: z.literal("analyzing"),
+    startedAt: z.string().min(1),
+    taskId: z.string().min(1).optional(),
+});
+const failedRecordSchema = recordBaseSchema.extend({
+    status: z.literal("failed"),
+    error: z.string().min(1),
+    failedAt: z.string().min(1),
+    taskId: z.string().min(1).optional(),
+});
+const readyRecordSchema = recordBaseSchema.extend({
+    status: z.literal("ready"),
+    provider: z.literal("kie"),
+    model: z.literal("seedream/5-pro-layer-decomposition"),
+    analysisId: z.string().min(1),
+    analyzedAt: z.string().min(1),
+    taskId: z.string().min(1),
+    grokSourceTaskId: z.string().min(1).optional(),
+    baseFile: z.string().min(1),
+    subjects: subjectsSchema,
+});
+export const imageSubjectMapRecordSchema = z.discriminatedUnion("status", [
+    analyzingRecordSchema,
+    failedRecordSchema,
+    readyRecordSchema,
+]);
+export function grokMaskIndex(index) {
+    return Number.isInteger(index) && index >= 0 ? index : undefined;
+}
+const SUBJECT_BOX_IOU_THRESHOLD = 0.25;
+function boxIou(left, right) {
+    const x1 = Math.max(left.x, right.x);
+    const y1 = Math.max(left.y, right.y);
+    const x2 = Math.min(left.x + left.width, right.x + right.width);
+    const y2 = Math.min(left.y + left.height, right.y + right.height);
+    const overlap = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);
+    const union = left.width * left.height + right.width * right.height - overlap;
+    return union > 0 ? overlap / union : 0;
+}
+export function parseGrokSegmentMapResult(resultJson) {
+    let parsed;
+    try {
+        parsed = JSON.parse(resultJson);
+    }
+    catch {
+        throw new Error("Grok segment map returned invalid result JSON");
+    }
+    const root = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)
+        ? parsed
+        : null;
+    const nested = root && root.resultObject !== null && typeof root.resultObject === "object"
+        && !Array.isArray(root.resultObject)
+        ? root.resultObject
+        : null;
+    const raw = [root?.segments, nested?.segments, root?.result, nested?.result]
+        .find((value) => Array.isArray(value));
+    if (!Array.isArray(raw))
+        return [];
+    return raw.flatMap((entry) => {
+        if (entry === null || typeof entry !== "object" || Array.isArray(entry))
+            return [];
+        const item = entry;
+        const index = Number(item.index);
+        if (!Number.isInteger(index))
+            return [];
+        const name = typeof item.name === "string" && item.name.trim() ? item.name.trim() : undefined;
+        const maskUrl = typeof item.maskUrl === "string" && item.maskUrl
+            ? item.maskUrl
+            : typeof item.mask_url === "string" && item.mask_url
+                ? item.mask_url
+                : undefined;
+        const boxSource = item.normalizedBox ?? item.normalized_box ?? item.box;
+        const box = normalizedBoxSchema.safeParse(boxSource);
+        return [{
+                index,
+                ...(name ? { name } : {}),
+                ...(maskUrl ? { maskUrl } : {}),
+                ...(box.success ? { normalizedBox: box.data } : {}),
+            }];
+    });
+}
+export function applyGrokSegmentsToSubjects(subjects, segments) {
+    const usable = segments.filter((segment) => grokMaskIndex(segment.index) !== undefined);
+    const claimed = new Set();
+    return subjects.map((subject) => {
+        const byName = usable.find((segment) => !claimed.has(segment.index)
+            && segment.name
+            && segment.name.toLowerCase() === subject.label.toLowerCase());
+        const boxMatches = usable.flatMap((segment) => {
+            if (claimed.has(segment.index) || !segment.normalizedBox)
+                return [];
+            const iou = boxIou(subject.normalizedBox, segment.normalizedBox);
+            return iou >= SUBJECT_BOX_IOU_THRESHOLD ? [{ segment, iou }] : [];
+        }).sort((left, right) => right.iou - left.iou);
+        const match = byName ?? boxMatches[0]?.segment;
+        if (!match) {
+            const { maskIndex: _dropped, ...rest } = subject;
+            return { ...rest, exactEdit: false };
+        }
+        claimed.add(match.index);
+        const maskIndex = grokMaskIndex(match.index);
+        if (maskIndex === undefined) {
+            const { maskIndex: _dropped, ...rest } = subject;
+            return { ...rest, exactEdit: false };
+        }
+        return { ...subject, exactEdit: true, maskIndex };
+    });
+}
+export function exactEditMaskIndexes(subjects, subjectIds) {
+    const selected = subjects.filter((subject) => subjectIds.includes(subject.id));
+    if (selected.length === 0)
+        return null;
+    const indexes = [];
+    for (const subject of selected) {
+        if (!subject.exactEdit || subject.maskIndex === undefined)
+            return null;
+        const index = grokMaskIndex(subject.maskIndex);
+        if (index === undefined)
+            return null;
+        indexes.push(index);
+    }
+    return [...new Set(indexes)].sort((left, right) => left - right);
+}
+const SUBJECT_COLORS = [
+    "#ef4444",
+    "#3b82f6",
+    "#22c55e",
+    "#f59e0b",
+    "#a855f7",
+    "#06b6d4",
+    "#ec4899",
+    "#84cc16",
+    "#f97316",
+    "#6366f1",
+    "#14b8a6",
+    "#eab308",
+];
+function imageFileUrl(bookId, artifactId, filename) {
+    const encodedFilename = filename
+        .split("/")
+        .map((segment) => encodeURIComponent(segment))
+        .join("/");
+    return `/files/${encodeURIComponent(bookId)}/${encodeURIComponent(artifactId)}/${encodedFilename}`;
+}
+function positiveDimension(value) {
+    const number = Number(value);
+    return Number.isInteger(number) && number > 0 ? number : null;
+}
+export async function resolveImageSubjectSource(engine, artifactId) {
+    const artifact = engine.artifacts.get(artifactId);
+    if (!artifact.ok)
+        throw new Error(artifact.error.message);
+    if (artifact.value.kind !== "image") {
+        throw new Error(`Image subject analysis requires an image artifact, got ${artifact.value.kind}`);
+    }
+    const manifest = await engine.files.manifest(artifactId);
+    if (!manifest.ok)
+        throw new Error(manifest.error.message);
+    const file = findPrimaryMediaFile(manifest.value.files, artifact.value.kind);
+    if (!file)
+        throw new Error(`No primary image file found for ${artifactId}`);
+    const metadata = await engine.metadata.artifacts.read(artifactId, "original");
+    let width = metadata.ok ? positiveDimension(metadata.value?.width) : null;
+    let height = metadata.ok ? positiveDimension(metadata.value?.height) : null;
+    if (!width || !height) {
+        const read = await engine.files.read(artifactId, file.name);
+        if (!read.ok)
+            throw new Error(read.error.message);
+        const probed = await sharp(read.value).metadata();
+        width = positiveDimension(probed.width);
+        height = positiveDimension(probed.height);
+    }
+    if (!width || !height) {
+        throw new Error(`Could not determine dimensions for ${artifactId}`);
+    }
+    return {
+        artifactId,
+        file,
+        objectHash: file.objectHash,
+        width,
+        height,
+    };
+}
+export async function readImageSubjectMapRecord(engine, artifactId) {
+    const result = await engine.metadata.artifacts.read(artifactId, IMAGE_SUBJECT_MAP_METADATA_KEY);
+    if (!result.ok)
+        return null;
+    const parsed = imageSubjectMapRecordSchema.safeParse(result.value);
+    return parsed.success ? parsed.data : null;
+}
+async function serializeImageSubjectMapWrite(artifactId, operation) {
+    const previous = imageSubjectMapWriteChains.get(artifactId) ?? Promise.resolve();
+    const result = previous.catch(() => undefined).then(operation);
+    const tail = result.then(() => undefined, () => undefined);
+    imageSubjectMapWriteChains.set(artifactId, tail);
+    return await result.finally(() => {
+        if (imageSubjectMapWriteChains.get(artifactId) === tail) {
+            imageSubjectMapWriteChains.delete(artifactId);
+        }
+    });
+}
+async function writeImageSubjectMapRecordUnlocked(engine, record) {
+    const parsed = imageSubjectMapRecordSchema.parse(record);
+    const result = await engine.metadata.artifacts.write(record.artifactId, IMAGE_SUBJECT_MAP_METADATA_KEY, parsed);
+    if (!result.ok)
+        throw new Error(result.error.message);
+}
+export async function writeImageSubjectMapRecord(engine, record) {
+    await serializeImageSubjectMapWrite(record.artifactId, async () => {
+        await writeImageSubjectMapRecordUnlocked(engine, record);
+    });
+}
+export async function writeCurrentImageSubjectAnalysisRecord(engine, record) {
+    return await serializeImageSubjectMapWrite(record.artifactId, async () => {
+        const current = await readImageSubjectMapRecord(engine, record.artifactId);
+        if (current?.status !== "analyzing"
+            || current.objectHash !== record.objectHash
+            || current.jobId !== record.jobId) {
+            return false;
+        }
+        await writeImageSubjectMapRecordUnlocked(engine, record);
+        return true;
+    });
+}
+export function subjectAnalysisProviderFailureMessage(message, code) {
+    const detail = message?.trim() || code?.trim() || "Unknown provider error";
+    const codeDetail = code?.trim() && code.trim() !== detail
+        ? ` (${code.trim()})`
+        : "";
+    const normalized = `${detail}${codeDetail}`.replace(/[.\s]+$/u, "");
+    if (normalized.startsWith("Subject analysis provider failed:")
+        && normalized.includes("Retry in a moment")) {
+        return `${normalized}.`;
+    }
+    return `Subject analysis provider failed: ${normalized}. Retry in a moment.`;
+}
+export function imageSubjectMapResponse(bookId, source, record) {
+    if (!record || record.objectHash !== source.objectHash) {
+        return {
+            status: "idle",
+            artifact_id: source.artifactId,
+            object_hash: source.objectHash,
+            width: source.width,
+            height: source.height,
+            base_url: null,
+            error: null,
+            job_id: null,
+            subjects: [],
+        };
+    }
+    if (record.status !== "ready") {
+        return {
+            status: record.status,
+            artifact_id: source.artifactId,
+            object_hash: source.objectHash,
+            width: source.width,
+            height: source.height,
+            base_url: null,
+            error: record.status === "failed" ? record.error : null,
+            job_id: record.jobId,
+            ...(record.status === "analyzing"
+                ? { started_at: record.startedAt }
+                : {}),
+            subjects: [],
+        };
+    }
+    return {
+        status: "ready",
+        artifact_id: source.artifactId,
+        object_hash: source.objectHash,
+        width: record.width,
+        height: record.height,
+        base_url: imageFileUrl(bookId, source.artifactId, record.baseFile),
+        error: null,
+        job_id: record.jobId,
+        subjects: record.subjects.map((subject) => ({
+            id: subject.id,
+            label: subject.label,
+            description: subject.description,
+            color: subject.color,
+            normalized_box: subject.normalizedBox,
+            layer_url: imageFileUrl(bookId, source.artifactId, subject.layerFile),
+            thumbnail_url: imageFileUrl(bookId, source.artifactId, subject.thumbnailFile),
+            z_index: subject.zIndex,
+            capabilities: {
+                remove: true,
+                exact_edit: subject.exactEdit,
+            },
+        })),
+    };
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function pixelBox(box, width, height) {
+    const left = clamp(Math.round(box.x * width), 0, width - 1);
+    const top = clamp(Math.round(box.y * height), 0, height - 1);
+    const boxWidth = clamp(Math.round(box.width * width), 1, width - left);
+    const boxHeight = clamp(Math.round(box.height * height), 1, height - top);
+    return { left, top, width: boxWidth, height: boxHeight };
+}
+async function fullCanvasLayer(input, sourceWidth, sourceHeight, box) {
+    const metadata = await sharp(input).metadata();
+    if (metadata.width === sourceWidth && metadata.height === sourceHeight) {
+        return sharp(input).ensureAlpha().png().toBuffer();
+    }
+    if (box) {
+        const placement = pixelBox(box, sourceWidth, sourceHeight);
+        const resized = await sharp(input)
+            .ensureAlpha()
+            .resize(placement.width, placement.height, { fit: "fill" })
+            .png()
+            .toBuffer();
+        return sharp({
+            create: {
+                width: sourceWidth,
+                height: sourceHeight,
+                channels: 4,
+                background: { r: 0, g: 0, b: 0, alpha: 0 },
+            },
+        }).composite([{ input: resized, left: placement.left, top: placement.top }])
+            .png()
+            .toBuffer();
+    }
+    throw new Error(`Seedream layer dimensions ${metadata.width ?? 0}x${metadata.height ?? 0} do not match ${sourceWidth}x${sourceHeight} and have no valid bounding box`);
+}
+async function alphaBoundingBox(input) {
+    const { data, info } = await sharp(input)
+        .ensureAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    let minX = info.width;
+    let minY = info.height;
+    let maxX = -1;
+    let maxY = -1;
+    for (let y = 0; y < info.height; y += 1) {
+        for (let x = 0; x < info.width; x += 1) {
+            const alpha = data[(y * info.width + x) * info.channels + 3];
+            if (alpha === undefined || alpha <= 4)
+                continue;
+            minX = Math.min(minX, x);
+            minY = Math.min(minY, y);
+            maxX = Math.max(maxX, x);
+            maxY = Math.max(maxY, y);
+        }
+    }
+    if (maxX < minX || maxY < minY) {
+        throw new Error("Seedream returned an all-transparent subject layer");
+    }
+    return {
+        x: minX / info.width,
+        y: minY / info.height,
+        width: (maxX - minX + 1) / info.width,
+        height: (maxY - minY + 1) / info.height,
+    };
+}
+function subjectId(layer, zIndex) {
+    const hash = createHash("sha256")
+        .update(layer)
+        .update(":")
+        .update(String(zIndex))
+        .digest("hex")
+        .slice(0, 16);
+    return `subject-${hash}`;
+}
+async function subjectThumbnail(layer, box, width, height) {
+    const region = pixelBox(box, width, height);
+    return sharp(layer)
+        .extract(region)
+        .resize(192, 192, {
+        fit: "contain",
+        background: { r: 0, g: 0, b: 0, alpha: 0 },
+    })
+        .png()
+        .toBuffer();
+}
+export async function persistSeedreamSubjectLayers(engine, source, input) {
+    const analysisId = input.taskId.replace(/[^a-zA-Z0-9_-]/g, "-");
+    const root = `.image-subjects/${source.objectHash}/${analysisId}`;
+    const baseResponse = await fetch(input.baseUrl, { signal: input.signal });
+    if (!baseResponse.ok) {
+        throw new Error(`Failed to download Seedream base: ${baseResponse.status} ${baseResponse.statusText}`);
+    }
+    const base = await sharp(Buffer.from(await baseResponse.arrayBuffer()))
+        .resize(source.width, source.height, { fit: "fill" })
+        .png()
+        .toBuffer();
+    const baseFile = `${root}/base.png`;
+    const baseWrite = await engine.files.write(source.artifactId, baseFile, base);
+    if (!baseWrite.ok)
+        throw new Error(baseWrite.error.message);
+    const ordered = [...input.layers].sort((left, right) => left.zIndex - right.zIndex);
+    const subjects = [];
+    for (const [index, layer] of ordered.entries()) {
+        const response = await fetch(layer.url, { signal: input.signal });
+        if (!response.ok) {
+            throw new Error(`Failed to download Seedream layer: ${response.status} ${response.statusText}`);
+        }
+        const canvas = await fullCanvasLayer(Buffer.from(await response.arrayBuffer()), source.width, source.height, layer.normalizedBox);
+        const normalizedBox = await alphaBoundingBox(canvas);
+        const id = subjectId(canvas, layer.zIndex);
+        const layerFile = `${root}/layer-${index}-${id}.png`;
+        const thumbnailFile = `${root}/thumbnail-${index}-${id}.png`;
+        const thumbnail = await subjectThumbnail(canvas, normalizedBox, source.width, source.height);
+        const [layerWrite, thumbnailWrite] = await Promise.all([
+            engine.files.write(source.artifactId, layerFile, canvas),
+            engine.files.write(source.artifactId, thumbnailFile, thumbnail),
+        ]);
+        if (!layerWrite.ok)
+            throw new Error(layerWrite.error.message);
+        if (!thumbnailWrite.ok)
+            throw new Error(thumbnailWrite.error.message);
+        subjects.push({
+            id,
+            label: layer.name?.trim() || `Subject ${index + 1}`,
+            description: layer.description?.trim() || "",
+            color: SUBJECT_COLORS[index % SUBJECT_COLORS.length],
+            normalizedBox,
+            layerFile,
+            thumbnailFile,
+            zIndex: layer.zIndex,
+            exactEdit: false,
+        });
+    }
+    return readyRecordSchema.parse({
+        version: IMAGE_SUBJECT_MAP_VERSION,
+        status: "ready",
+        artifactId: source.artifactId,
+        objectHash: source.objectHash,
+        width: source.width,
+        height: source.height,
+        jobId: input.jobId,
+        provider: "kie",
+        model: "seedream/5-pro-layer-decomposition",
+        analysisId,
+        analyzedAt: new Date().toISOString(),
+        taskId: input.taskId,
+        baseFile,
+        subjects,
+    });
+}
+export async function composeImageSubjectRemoval(engine, sourceArtifactId, record, removedSubjectIds) {
+    const selected = new Set(removedSubjectIds);
+    const known = new Set(record.subjects.map((subject) => subject.id));
+    const missing = [...selected].filter((id) => !known.has(id));
+    if (missing.length > 0) {
+        throw new Error(`Unknown subject ids: ${missing.join(", ")}`);
+    }
+    const baseRead = await engine.files.read(sourceArtifactId, record.baseFile);
+    if (!baseRead.ok)
+        throw new Error(baseRead.error.message);
+    const retained = record.subjects
+        .filter((subject) => !selected.has(subject.id))
+        .sort((left, right) => left.zIndex - right.zIndex);
+    const layers = [];
+    for (const subject of retained) {
+        const read = await engine.files.read(sourceArtifactId, subject.layerFile);
+        if (!read.ok)
+            throw new Error(read.error.message);
+        layers.push(Buffer.from(read.value));
+    }
+    return sharp(baseRead.value)
+        .resize(record.width, record.height, { fit: "fill" })
+        .composite(layers.map((layer) => ({ input: layer, left: 0, top: 0 })))
+        .png()
+        .toBuffer();
+}

package/dist/image.js

@@ -0,0 +1,46 @@
+import sharp from "sharp";
+export async function decodeHeicToPng(buffer) {
+    const { default: decode } = await import("heic-decode");
+    const { width, height, data } = await decode({ buffer });
+    return sharp(Buffer.from(data), { raw: { width, height, channels: 4 } })
+        .png()
+        .toBuffer();
+}
+export async function probeImage(buffer) {
+    const metadata = await sharp(buffer).metadata();
+    const width = metadata.width ?? 0;
+    const height = metadata.height ?? 0;
+    return { width, height };
+}
+export async function cropToFill(buffer, targetW, targetH) {
+    return sharp(buffer)
+        .resize(targetW, targetH, { fit: "cover", position: "centre" })
+        .jpeg({ quality: 95 })
+        .toBuffer();
+}
+/** Extract a normalized (0..1) region and resize to target dimensions as JPEG. */
+export async function cropRegion(buffer, rect, targetW, targetH) {
+    const meta = await sharp(buffer).metadata();
+    const srcW = meta.width ?? 0;
+    const srcH = meta.height ?? 0;
+    if (!srcW || !srcH) {
+        throw new Error("Could not probe image dimensions");
+    }
+    let width = Math.max(1, Math.round(rect.w * srcW));
+    let height = Math.max(1, Math.round(rect.h * srcH));
+    if (width > srcW)
+        width = srcW;
+    if (height > srcH)
+        height = srcH;
+    let left = Math.max(0, Math.round(rect.x * srcW));
+    let top = Math.max(0, Math.round(rect.y * srcH));
+    if (left + width > srcW)
+        left = Math.max(0, srcW - width);
+    if (top + height > srcH)
+        top = Math.max(0, srcH - height);
+    return sharp(buffer)
+        .extract({ left, top, width, height })
+        .resize(targetW, targetH, { fit: "fill" })
+        .jpeg({ quality: 95 })
+        .toBuffer();
+}

package/dist/index.js

@@ -0,0 +1,12 @@
+import "./load-env.js";
+import { logger } from "./logger.js";
+import { installSignalHandlers, startServer } from "./serve.js";
+const port = Number(process.env.PORT ?? 3001);
+const starting = startServer({ port, ui: true });
+installSignalHandlers(starting);
+starting
+    .then((running) => running.ready)
+    .catch((error) => {
+    logger.error("startup-failed", { error, port });
+    process.exit(1);
+});

package/dist/job-deadline.js

@@ -0,0 +1,60 @@
+const JOB_CANCELLATION_GRACE_MS = 10_000;
+const JOB_TIMEOUTS_MS = new Map([
+    ["repair_search_indexes", 15 * 60_000],
+    ["render_project", 30 * 60_000],
+    ["render_timeline", 30 * 60_000],
+    ["render_qr_outro", 15 * 60_000],
+    ["analyze_keyword_placement", 5 * 60_000],
+    ["analyze_alive_captions", 10 * 60_000],
+    ["osg_placement", 5 * 60_000],
+    ["analyze_image_subjects", 30 * 60_000],
+    ["generate_image_subject_edit", 30 * 60_000],
+    ["burn_watermark", 15 * 60_000],
+    // Whole-job backstop above the 30 min /synth fetch timeout, so the client's
+    // more specific error wins when ace-server hangs; covers synth-lock wait,
+    // first-request model load, and the ffmpeg passes on a 240 s CPU-only run.
+    ["generate_acestep_cover", 45 * 60_000],
+]);
+export class JobDeadlineError extends Error {
+    jobType;
+    timeoutMs;
+    constructor(jobType, timeoutMs) {
+        super(`Job ${jobType} timed out after ${timeoutMs}ms`);
+        this.name = "JobDeadlineError";
+        this.jobType = jobType;
+        this.timeoutMs = timeoutMs;
+    }
+}
+function getJobTimeoutMs(jobType) {
+    return JOB_TIMEOUTS_MS.get(jobType) ?? null;
+}
+export async function runWithJobDeadline(jobType, run, timeoutMs = getJobTimeoutMs(jobType), cancellationGraceMs = JOB_CANCELLATION_GRACE_MS) {
+    const controller = new AbortController();
+    const work = Promise.resolve().then(() => run(controller.signal));
+    if (timeoutMs === null)
+        return work;
+    let deadlineTimer;
+    const settled = work.then((value) => ({ state: "resolved", value }), (error) => ({ state: "rejected", error }));
+    const deadline = new Promise((resolve) => {
+        deadlineTimer = setTimeout(() => resolve({ state: "deadline" }), timeoutMs);
+        deadlineTimer.unref?.();
+    });
+    const first = await Promise.race([settled, deadline]);
+    if (deadlineTimer !== undefined)
+        clearTimeout(deadlineTimer);
+    if (first.state === "resolved")
+        return first.value;
+    if (first.state === "rejected")
+        throw first.error;
+    const timeoutError = new JobDeadlineError(jobType, timeoutMs);
+    controller.abort(timeoutError);
+    let graceTimer;
+    const grace = new Promise((resolve) => {
+        graceTimer = setTimeout(resolve, cancellationGraceMs);
+        graceTimer.unref?.();
+    });
+    await Promise.race([settled.then(() => undefined), grace]);
+    if (graceTimer !== undefined)
+        clearTimeout(graceTimer);
+    throw timeoutError;
+}

package/dist/jobs/_alibaba-upload.js

@@ -0,0 +1,30 @@
+import { createAlibaba } from "../usage-providers.js";
+import { uploadFile } from "@apicity/alibaba";
+import { prepareAssetForUpload, uploadBytesToFreeHost } from "../upload.js";
+import { getApiKey } from "../api-key.js";
+import { logger } from "../logger.js";
+// Upload an asset to DashScope's OSS bucket via @apicity/alibaba's uploadFile
+// helper. Falls back to the free-host rotation if the policy fetch or OSS
+// POST fails.
+export async function uploadAssetToAlibaba(engine, assetId, filename, model) {
+    const { data, hashedFilename, contentType } = await prepareAssetForUpload(engine, assetId, filename);
+    const apiKey = getApiKey("DASHSCOPE_API_KEY");
+    if (apiKey) {
+        try {
+            const provider = createAlibaba({ apiKey, timeout: 60_000 });
+            return await uploadFile(provider, {
+                model,
+                data,
+                filename: hashedFilename,
+                contentType,
+            });
+        }
+        catch (err) {
+            logger.warn("alibaba-upload-fallback", { error: err });
+        }
+    }
+    else {
+        logger.warn("alibaba-upload-unconfigured");
+    }
+    return uploadBytesToFreeHost(data, hashedFilename);
+}