@bonginkan/maria 4.3.15 → 4.3.17

package/dist/server/express-server.js

@@ -6531,12 +6531,12 @@ __export(src_exports, {
   Response: () => Response,
   blobFrom: () => blobFrom,
   blobFromSync: () => blobFromSync,
-  default: () => fetch,
+  default: () => fetch2,
   fileFrom: () => fileFrom,
   fileFromSync: () => fileFromSync,
   isRedirect: () => isRedirect
 });
-async function fetch(url, options_) {
+async function fetch2(url, options_) {
   return new Promise((resolve2, reject) => {
     const request = new Request(url, options_);
     const { parsedURL, options } = getNodeRequestOptions(request);
@@ -6668,7 +6668,7 @@ async function fetch(url, options_) {
             if (responseReferrerPolicy) {
               requestOptions.referrerPolicy = responseReferrerPolicy;
             }
-            resolve2(fetch(new Request(locationURL, requestOptions)));
+            resolve2(fetch2(new Request(locationURL, requestOptions)));
             finalize();
             return;
           }
@@ -6991,6 +6991,15 @@ async function hasCaseInsensitiveCollision(dirFull, targetFile) {
 async function atomicRename(stage, dest) {
   try {
     await fsp__namespace.rename(stage, dest);
+    try {
+      const fd = await fsp__namespace.open(dest, "r");
+      try {
+        await fd.sync();
+      } finally {
+        await fd.close();
+      }
+    } catch {
+    }
   } catch (e2) {
     if (e2 && e2.code === "EXDEV") {
       await fsp__namespace.copyFile(stage, dest);
@@ -7008,7 +7017,7 @@ async function atomicRename(stage, dest) {
 }
 async function saveArtifacts(ctx, items, manifest) {
   const root = ctx.root;
-  const base = ctx.baseDir || (ctx.kind === "image" ? "artifacts/media/images" : "artifacts/media/videos");
+  const base = typeof ctx.baseDir === "string" ? ctx.baseDir : "";
   const trace = ctx.trace || Math.random().toString(36).slice(2, 10).toUpperCase();
   const stage = stageDir(root, trace);
   ensureDirSync(stage);
@@ -7016,7 +7025,7 @@ async function saveArtifacts(ctx, items, manifest) {
     const dateSeg = datePath(/* @__PURE__ */ new Date());
     const reqHash = manifest.request && manifest.request.promptHash || "sha256:unknown";
     const slug = hashPrefix(reqHash, 6);
-    const outDirSeg = `${base}/${dateSeg}/${slug}`;
+    const outDirSeg = ctx.flat ? base || "" : `${base ? base + "/" : ""}${dateSeg}/${slug}`;
     const outDir = safeJoin(root, outDirSeg).full;
     ensureDirSync(outDir);
     const saved = [];
@@ -7026,7 +7035,8 @@ async function saveArtifacts(ctx, items, manifest) {
       const ext = it.ext.startsWith(".") ? it.ext : `.${it.ext}`;
       const baseName = it.logicalName ? `${it.logicalName}` : `${contentHash}`;
       const fname = `${baseName}${ext}`;
-      const dest = safeJoin(root, `${outDirSeg}/${fname}`);
+      const relPath = outDirSeg ? `${outDirSeg}/${fname}` : `${fname}`;
+      const dest = safeJoin(root, relPath);
       validateWinPathEdge(dest.full);
       if (await hasCaseInsensitiveCollision(path__namespace.dirname(dest.full), path__namespace.basename(dest.full))) {
         throw new Error("case-insensitive filename collision");
@@ -7044,25 +7054,31 @@ async function saveArtifacts(ctx, items, manifest) {
       }
       await fsp__namespace.writeFile(stg, it.bytes);
       await atomicRename(stg, dest.full);
-      saved.push(dest.rel);
+      const relPosix = dest.rel.replace(/\\/g, "/");
+      saved.push(relPosix);
     }
-    const manifestObj = {
-      manifestVersion: 1,
-      ...manifest,
-      createdAt: manifest.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
-      artifacts: manifest.artifacts && manifest.artifacts.length > 0 ? manifest.artifacts : saved.map((file) => ({ file, hash: `sha256:${path__namespace.basename(file).split(".")[0]}` }))
-    };
-    const manifestPathRel = `${outDirSeg}/manifest.json`;
-    const manifestStage = path__namespace.join(stage, "manifest.json.part");
-    const manifestFull = safeJoin(root, manifestPathRel).full;
-    await fsp__namespace.writeFile(manifestStage, JSON.stringify(manifestObj, null, 2), "utf8");
-    try {
-      console.log(`[store] manifest -> ${manifestPathRel}`);
-    } catch {
+    if (!ctx.skipManifest) {
+      const manifestObj = {
+        manifestVersion: 1,
+        ...manifest,
+        createdAt: manifest.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+        artifacts: manifest.artifacts && manifest.artifacts.length > 0 ? manifest.artifacts : saved.map((file) => ({ file, hash: `sha256:${path__namespace.basename(file).split(".")[0]}` }))
+      };
+      const manifestPathRel = `${outDirSeg ? outDirSeg + "/" : ""}manifest.json`;
+      const manifestStage = path__namespace.join(stage, "manifest.json.part");
+      const manifestFull = safeJoin(root, manifestPathRel).full;
+      await fsp__namespace.writeFile(manifestStage, JSON.stringify(manifestObj, null, 2), "utf8");
+      try {
+        console.log(`[store] manifest -> ${manifestPathRel}`);
+      } catch {
+      }
+      await atomicRename(manifestStage, manifestFull);
+      await fsp__namespace.rm(stage, { recursive: true, force: true });
+      return { files: saved, manifestPath: manifestPathRel.replace(/\\/g, "/") };
+    } else {
+      await fsp__namespace.rm(stage, { recursive: true, force: true });
+      return { files: saved, manifestPath: "" };
     }
-    await atomicRename(manifestStage, manifestFull);
-    await fsp__namespace.rm(stage, { recursive: true, force: true });
-    return { files: saved, manifestPath: manifestPathRel };
   } catch (e2) {
     await fsp__namespace.rm(stage, { recursive: true, force: true });
     throw e2;
@@ -7105,6 +7121,13 @@ var GeminiMediaProvider = class {
         `GeminiMediaProvider.generateImage request failed: model=${modelName}; prompt="${promptPreview}"; error=${errMsg}`
       );
     }
+    const feedback = resp?.response?.promptFeedback;
+    const blockReason = feedback?.blockReason || feedback?.block_reason;
+    if (blockReason) {
+      const modelName2 = this.primaryModel;
+      const reason = String(blockReason);
+      throw new Error(`GeminiMediaProvider.policy_violation: model=${modelName2}; reason=${reason}`);
+    }
     const parts = resp?.response?.candidates?.[0]?.content?.parts || [];
     for (const p of parts) {
       const data = p?.inlineData?.data || p?.inline_data?.data;
@@ -7795,12 +7818,12 @@ var UnifiedBaseProvider = class {
   }
   // Helper method for HTTP requests
   async makeRequest(url, options) {
-    const fetch2 = (await Promise.resolve().then(() => (init_src(), src_exports))).default;
+    const fetch3 = (await Promise.resolve().then(() => (init_src(), src_exports))).default;
     const timeoutMs = options.timeout || 3e4;
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
     try {
-      const response2 = await fetch2(url, {
+      const response2 = await fetch3(url, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -7824,12 +7847,12 @@ var UnifiedBaseProvider = class {
   }
   // Helper method for streaming requests
   async makeStreamRequest(url, options) {
-    const fetch2 = (await Promise.resolve().then(() => (init_src(), src_exports))).default;
+    const fetch3 = (await Promise.resolve().then(() => (init_src(), src_exports))).default;
     const timeoutMs = options.timeout || 3e4;
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
     try {
-      const response2 = await fetch2(url, {
+      const response2 = await fetch3(url, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -8532,12 +8555,17 @@ var app = express__default.default();
 var port = process.env.PORT || 8080;
 app.use(helmet__default.default());
 app.use(cors__default.default());
-app.use(compression__default.default());
+app.use(compression__default.default({
+  filter: (req, res) => {
+    if (/\.(mp4|webm|mov)$/i.test(req.url)) return false;
+    return compression.filter(req, res);
+  }
+}));
 app.use(express__default.default.json({ limit: "10mb" }));
 app.use(express__default.default.urlencoded({ extended: true }));
 try {
   const artifactsDir = path__namespace.default.resolve(process.cwd(), "artifacts");
-  app.use("/artifacts", express__default.default.static(artifactsDir, { fallthrough: true, extensions: ["json", "png", "jpg", "webp", "mp4"] }));
+  app.use("/artifacts", express__default.default.static(artifactsDir, { fallthrough: true, extensions: ["json", "png", "jpg", "webp", "mp4", "webm", "mov"] }));
 } catch {
 }
 app.use((req, res, next) => {
@@ -8561,7 +8589,7 @@ app.get("/api/status", (req, res) => {
 app.get("/", (req, res) => {
   res.json({
     name: "MARIA CODE API",
-    version: "4.3.9",
+    version: "4.3.17",
     status: "running",
     environment: process.env.NODE_ENV || "development",
     endpoints: {
@@ -8576,6 +8604,30 @@ app.get("/", (req, res) => {
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   });
 });
+function classifyMediaError(err) {
+  const raw = err;
+  const msg = String(raw?.message || raw || "unknown error");
+  const lower2 = msg.toLowerCase();
+  if (lower2.includes("missing api key") || lower2.includes("api key") && lower2.includes("missing")) {
+    return { status: 503, code: "provider_unavailable", message: "Provider API key is not configured", hint: "Set GOOGLE_API_KEY or GEMINI_API_KEY on the server" };
+  }
+  if (lower2.includes("invalid api key") || lower2.includes("permission denied") || lower2.includes("unauthorized")) {
+    return { status: 502, code: "provider_auth_failed", message: "Provider authentication failed", hint: "Verify your Google AI Studio API key" };
+  }
+  if (lower2.includes("blockreason") || lower2.includes("safety") || lower2.includes("blocked") || lower2.includes("policy")) {
+    return { status: 422, code: "policy_violation", message: "Request was blocked by provider policy", hint: "Modify the prompt to comply with safety policies" };
+  }
+  if (lower2.includes("no inline image returned") || lower2.includes("no video returned") || lower2.includes("refus")) {
+    return { status: 422, code: "content_refused", message: "Model refused or returned no content", hint: "Try rephrasing the prompt or a different model" };
+  }
+  if (lower2.includes("timeout")) {
+    return { status: 504, code: "timeout", message: "Generation timed out", hint: "Please retry later" };
+  }
+  if (lower2.includes("rate limit") || lower2.includes("429")) {
+    return { status: 429, code: "rate_limited", message: "Rate limit exceeded", hint: "Slow down requests or try again shortly" };
+  }
+  return { status: 500, code: "internal_error", message: "Failed to generate media" };
+}
 async function decodeFirebaseToken(token) {
   try {
     const admin = await import('firebase-admin').catch(() => null);
@@ -8705,9 +8757,10 @@ app.post("/api/v1/image", rateLimitMiddleware, async (req, res) => {
   try {
     await loadProviderKeys();
     const auth = req.headers.authorization;
-    if (!auth || !auth.startsWith("Bearer ")) return res.status(401).json({ error: "unauthorized" });
+    if (!auth || !auth.startsWith("Bearer ")) return res.status(401).json({ error: "unauthorized", message: "Login required", hint: "Sign in and retry" });
     const idToken = auth.substring("Bearer ".length).trim();
     const decoded = await decodeFirebaseToken(idToken).catch(() => null);
+    if (!decoded) return res.status(401).json({ error: "unauthorized", message: "Invalid login session", hint: "Re-login to continue" });
     const uid = decoded?.uid || decoded?.sub || "current";
     const { prompt, model, size = "1024x1024", format = "png", count = 1, seed } = req.body || {};
     if (!prompt) return res.status(400).json({ error: "bad_request", message: "prompt required" });
@@ -8749,42 +8802,46 @@ app.post("/api/v1/image", rateLimitMiddleware, async (req, res) => {
     return res.json({ success: true, data: { url: saved.manifestPath, files: saved.files, filesInline, jobId: manifest.trace } });
   } catch (error) {
     console.error("[Image API] Error:", error);
-    return res.status(500).json({
-      error: "internal_error",
-      message: "Failed to generate image"
-    });
+    const mapped = classifyMediaError(error);
+    return res.status(mapped.status).json({ error: mapped.code, message: mapped.message, hint: mapped.hint });
   }
 });
 app.post("/api/v1/video", rateLimitMiddleware, async (req, res) => {
   try {
     await loadProviderKeys();
     const auth = req.headers.authorization;
-    if (!auth || !auth.startsWith("Bearer ")) return res.status(401).json({ error: "unauthorized" });
-    const { prompt, duration = 5, fps = 24, res: resStr = "1280x720", format = "mp4", model, seed } = req.body || {};
+    if (!auth || !auth.startsWith("Bearer ")) return res.status(401).json({ error: "unauthorized", message: "Login required", hint: "Sign in and retry" });
+    const { prompt, duration = 8, fps = 24, res: resStr = "1280x720", format = "mp4", model, seed } = req.body || {};
     if (!prompt) return res.status(400).json({ error: "bad_request", message: "prompt required" });
     const m2 = /^(\d{2,4})x(\d{2,4})$/.exec(String(resStr));
     if (!m2) return res.status(400).json({ error: "bad_request", message: "res must be WxH" });
     const w = +m2[1], h2 = +m2[2];
     const { GoogleGenAI } = __require("@google/genai");
     const apiKey = process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY;
-    if (!apiKey) return res.status(500).json({ error: "internal_error", message: "No Google API key configured" });
+    if (!apiKey) return res.status(503).json({ error: "provider_unavailable", message: "Provider API key is not configured", hint: "Set GOOGLE_API_KEY or GEMINI_API_KEY on the server" });
     const ai = new GoogleGenAI({ apiKey });
     const veoModel = model && String(model).trim() || process.env.MARIA_VIDEO_MODEL || "veo-3.0-generate-001";
     const aspectRatio = w >= h2 ? "16:9" : "9:16";
     const startedMs = Date.now();
+    const requestedDuration = Number(duration);
+    const effectiveDuration = Number.isFinite(requestedDuration) && requestedDuration === 8 ? 8 : 8;
+    const requestedFps = Number(fps);
+    const effectiveFps = Number.isFinite(requestedFps) ? Math.min(60, Math.max(1, Math.floor(requestedFps))) : 24;
     let operation = await ai.models.generateVideos({
       model: veoModel,
       prompt: String(prompt),
-      config: { aspectRatio }
+      // Pass duration/fps to provider to avoid default ~1s clips
+      config: { aspectRatio, durationSeconds: effectiveDuration, frameRate: effectiveFps }
     });
-    const deadline = Date.now() + 6e5;
+    const deadline = Date.now() + 72e4;
     while (!operation?.done) {
       if (Date.now() > deadline) {
         return res.status(504).json({ error: "timeout", message: "video generation timed out" });
       }
-      await new Promise((r2) => setTimeout(r2, 2e3));
+      await new Promise((r2) => setTimeout(r2, 1e4));
       operation = await ai.operations.getVideosOperation({ operation });
     }
+    await new Promise((r2) => setTimeout(r2, 2500));
     const videoRef = operation?.response?.generatedVideos?.[0]?.video;
     const videoMime = videoRef && (videoRef.mimeType || videoRef.mime_type) ? String(videoRef.mimeType || videoRef.mime_type) : void 0;
     if (!videoRef) {
@@ -8794,22 +8851,153 @@ app.post("/api/v1/video", rateLimitMiddleware, async (req, res) => {
     const tmpDir = path__namespace.default.join(process.cwd(), ".stage", traceId);
     await fsp__namespace.default.mkdir(tmpDir, { recursive: true });
     const tmpOut = path__namespace.default.join(tmpDir, "video.bin");
-    await ai.files.download({ file: videoRef, downloadPath: tmpOut });
-    {
-      const deadline2 = Date.now() + 1e4;
+    const dlApiKey = process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY || "";
+    const isLikelyValidVideo = async (buf) => {
+      if (!buf || buf.length < 16) return false;
+      const head = buf.subarray(0, Math.min(256, buf.length));
+      const headStr = head.toString("latin1");
+      const hasFtyp2 = headStr.indexOf("ftyp") >= 0 || head.includes(Buffer.from("ftyp", "ascii"));
+      const isWebm2 = head[0] === 26 && head[1] === 69 && head[2] === 223 && head[3] === 163;
+      const looksHtml = headStr.includes("<!doctype") || headStr.includes("<html") || headStr.includes("<?xml");
+      return (hasFtyp2 || isWebm2) && !looksHtml;
+    };
+    const readUint32BE = (buf, off) => (buf[off] << 24 | buf[off + 1] << 16 | buf[off + 2] << 8 | buf[off + 3]) >>> 0;
+    const readUint64BE = (buf, off) => {
+      const hi = readUint32BE(buf, off);
+      const lo = readUint32BE(buf, off + 4);
+      return hi * 2 ** 32 + lo;
+    };
+    const tryParseMp4DurationSec = (buf) => {
+      try {
+        for (let i2 = 0; i2 + 8 < buf.length; ) {
+          const size = readUint32BE(buf, i2);
+          const type = buf.subarray(i2 + 4, i2 + 8).toString("latin1");
+          if (!size || size < 8) break;
+          if (type === "moov") {
+            const end = Math.min(buf.length, i2 + size);
+            let j = i2 + 8;
+            while (j + 8 < end) {
+              const sz = readUint32BE(buf, j);
+              const tp = buf.subarray(j + 4, j + 8).toString("latin1");
+              if (!sz || sz < 8) break;
+              if (tp === "mvhd") {
+                const ver = buf[j + 8];
+                if (ver === 1) {
+                  const timescale = readUint32BE(buf, j + 28);
+                  const duration2 = readUint64BE(buf, j + 32);
+                  if (timescale > 0) return duration2 / timescale;
+                } else {
+                  const timescale = readUint32BE(buf, j + 20);
+                  const duration2 = readUint32BE(buf, j + 24);
+                  if (timescale > 0) return duration2 / timescale;
+                }
+                break;
+              }
+              j += sz;
+            }
+            break;
+          }
+          i2 += size;
+        }
+      } catch {
+      }
+      return null;
+    };
+    const hasAtom = (buf, atom) => {
+      const tgt = Buffer.from(atom, "latin1");
+      return buf.indexOf(tgt) !== -1;
+    };
+    const validateVideoBytes = (buf) => {
+      if (!buf || buf.length < 1024) return { kind: "unknown", ok: false, durationSec: null, reason: "too_small" };
+      const header2 = buf.subarray(0, 256);
+      const headerStr2 = header2.toString("latin1");
+      const hasFtyp2 = headerStr2.indexOf("ftyp") >= 0 || header2.includes(Buffer.from("ftyp", "ascii"));
+      const isWebm2 = header2[0] === 26 && header2[1] === 69 && header2[2] === 223 && header2[3] === 163;
+      if (isWebm2) {
+        return { kind: "webm", ok: buf.length > 2e5, durationSec: null };
+      }
+      if (hasFtyp2) {
+        const majorBrand = header2.subarray(8, 12).toString("latin1").toLowerCase();
+        const kind = majorBrand.startsWith("qt") ? "mov" : "mp4";
+        const hasMoov = hasAtom(buf, "moov");
+        const dur = tryParseMp4DurationSec(buf);
+        const nearTarget = typeof dur === "number" ? dur + 0.75 >= effectiveDuration : false;
+        const ok = hasMoov && nearTarget;
+        return { kind, ok, durationSec: dur, reason: ok ? void 0 : !hasMoov ? "missing_moov" : "short_duration" };
+      }
+      return { kind: "unknown", ok: false, durationSec: null, reason: "unknown_header" };
+    };
+    const ensureFileMaterialized = async (p, waitMs = 45e3) => {
+      const deadline2 = Date.now() + waitMs;
+      let lastSize = -1;
+      let stableCount = 0;
       while (true) {
         try {
-          const st = await fsp__namespace.default.stat(tmpOut);
-          if (st && st.size > 0) break;
+          const st = await fsp__namespace.default.stat(p);
+          if (st && st.size > 0) {
+            if (st.size === lastSize) {
+              stableCount++;
+              if (stableCount >= 5) return;
+            } else {
+              stableCount = 0;
+              lastSize = st.size;
+            }
+          }
         } catch {
         }
-        if (Date.now() > deadline2) {
-          throw new Error(`video file not found after download: ${tmpOut}`);
-        }
+        if (Date.now() > deadline2) throw new Error(`video file not fully materialized: ${p}`);
         await new Promise((r2) => setTimeout(r2, 200));
       }
+    };
+    const trySdkDownloadOnce = async () => {
+      try {
+        await ai.files.download({ file: videoRef, downloadPath: tmpOut });
+        await ensureFileMaterialized(tmpOut, 45e3);
+        const bytes = await fsp__namespace.default.readFile(tmpOut);
+        if (await isLikelyValidVideo(bytes)) return bytes;
+      } catch {
+      }
+      return null;
+    };
+    const tryManualDownload = async () => {
+      try {
+        const fileObj = videoRef;
+        const direct = fileObj?.uri || fileObj?.url || fileObj?.downloadUri || fileObj?.downloadUrl || "";
+        if (!direct || typeof direct !== "string") return null;
+        const res2 = await fetch(direct, {
+          method: "GET",
+          headers: dlApiKey ? { "x-goog-api-key": dlApiKey } : void 0,
+          redirect: "follow"
+        });
+        if (!res2.ok) return null;
+        const lenHeader = res2.headers?.get?.("content-length");
+        const expectedLen = lenHeader ? Number(lenHeader) : void 0;
+        const ab = await res2.arrayBuffer();
+        const buf = Buffer.from(ab);
+        if (typeof expectedLen === "number" && Number.isFinite(expectedLen) && expectedLen > 0 && buf.length !== expectedLen) {
+          return null;
+        }
+        await fsp__namespace.default.writeFile(tmpOut, buf);
+        if (await isLikelyValidVideo(buf)) return buf;
+      } catch {
+      }
+      return null;
+    };
+    let videoBytes = null;
+    const maxAttempts = 10;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      let bytes = await trySdkDownloadOnce();
+      if (!bytes) bytes = await tryManualDownload();
+      if (bytes && await isLikelyValidVideo(bytes)) {
+        const v = validateVideoBytes(bytes);
+        if (v.ok) {
+          videoBytes = bytes;
+          break;
+        }
+      }
+      await new Promise((r2) => setTimeout(r2, Math.min(8e3, 1500 * attempt)));
     }
-    const videoBytes = await fsp__namespace.default.readFile(tmpOut);
+    if (!videoBytes) throw new Error("failed to obtain fully materialized video");
     const header = videoBytes.subarray(0, 256);
     const headerStr = header.toString("latin1");
     let outExt = ".mp4";
@@ -8819,23 +9007,33 @@ app.post("/api/v1/video", rateLimitMiddleware, async (req, res) => {
     if (videoMime && /webm/i.test(videoMime)) {
       outExt = ".webm";
       outMime = "video/webm";
+    } else if (videoMime && /quicktime/i.test(videoMime)) {
+      outExt = ".mov";
+      outMime = "video/quicktime";
     } else if (isWebm) {
       outExt = ".webm";
       outMime = "video/webm";
     } else if (hasFtyp) {
-      outExt = ".mp4";
-      outMime = "video/mp4";
+      const majorBrand = header.subarray(8, 12).toString("latin1");
+      if ((majorBrand || "").toLowerCase().startsWith("qt")) {
+        outExt = ".mov";
+        outMime = "video/quicktime";
+      } else {
+        outExt = ".mp4";
+        outMime = "video/mp4";
+      }
     }
     await fsp__namespace.default.rm(tmpDir, { recursive: true, force: true });
     const promptHash = hashPrompt(prompt);
     const manifest = {
       kind: "video",
-      request: { promptHash, seed, params: { size: [w, h2], fps, duration, format: outExt.replace(".", "") }, model: veoModel, provider: "google" },
+      request: { promptHash, seed, params: { size: [w, h2], fps: effectiveFps, duration: effectiveDuration, format: outExt.replace(".", "") }, model: veoModel, provider: "google" },
       artifacts: [],
       metrics: { durationMs: Date.now() - startedMs, retries: 0, fallbacks: 0 },
       trace: traceId
     };
-    const saved = await saveArtifacts({ root: process.cwd(), kind: "video" }, [{ bytes: videoBytes, ext: outExt }], manifest);
+    const baseDir = path__namespace.default.join("artifacts", "media", "videos", traceId);
+    const saved = await saveArtifacts({ root: process.cwd(), kind: "video", baseDir, flat: true }, [{ bytes: videoBytes, ext: outExt }], manifest);
     const idemKey = req.headers["idempotency-key"] || void 0;
     const idToken = auth.substring("Bearer ".length).trim();
     const decoded = await decodeFirebaseToken(idToken).catch(() => null);
@@ -8850,13 +9048,11 @@ app.post("/api/v1/video", rateLimitMiddleware, async (req, res) => {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       uid
     });
-    return res.json({ success: true, data: { url: saved.manifestPath, files: saved.files, jobId: manifest.trace } });
+    return res.json({ success: true, data: { url: saved.manifestPath || (saved.files[0] ? `/${saved.files[0]}` : void 0), files: saved.files, jobId: manifest.trace, applied: { durationSeconds: effectiveDuration, frameRate: effectiveFps } } });
   } catch (error) {
     console.error("[Video API] Error:", error);
-    return res.status(500).json({
-      error: "internal_error",
-      message: "Failed to generate video"
-    });
+    const mapped = classifyMediaError(error);
+    return res.status(mapped.status).json({ error: mapped.code, message: mapped.message, hint: mapped.hint });
   }
 });
 app.get("/api/v1/jobs/:id", async (req, res) => {