@bonginkan/maria 4.3.16 → 4.3.18

package/dist/server-express.cjs

@@ -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);
@@ -7045,7 +7054,8 @@ 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);
     }
     if (!ctx.skipManifest) {
       const manifestObj = {
@@ -7064,7 +7074,7 @@ async function saveArtifacts(ctx, items, manifest) {
       }
       await atomicRename(manifestStage, manifestFull);
       await fsp__namespace.rm(stage, { recursive: true, force: true });
-      return { files: saved, manifestPath: manifestPathRel };
+      return { files: saved, manifestPath: manifestPathRel.replace(/\\/g, "/") };
     } else {
       await fsp__namespace.rm(stage, { recursive: true, force: true });
       return { files: saved, manifestPath: "" };
@@ -7111,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;
@@ -7801,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",
@@ -7830,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",
@@ -8432,34 +8449,55 @@ var IMSFacade = class {
   constructor(options = {}) {
     this.options = options;
     const projectId = options.projectId || process.env.GCLOUD_PROJECT || process.env.GOOGLE_CLOUD_PROJECT || "maria-code-470602";
-    this.secrets = new SecretManagerIntegration({ projectId, secrets: {} });
+    this.secrets = new SecretManagerIntegration({
+      projectId,
+      secrets: {
+        openAI: "openai-api-key",
+        googleAI: "google-ai-api-key",
+        anthropic: "anthropic-api-key",
+        groq: "groq-api-key"
+      }
+    });
   }
   secrets;
   /** Route a simple chat request through IMS selection + providers */
   async routeChat(req) {
     const traceId = `ims_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
     const optional = await this.secrets.getOptionalConfig().catch(() => ({}));
-    const [openaiApiKey, groqApiKey, anthropicApiKey, googleApiKey] = await Promise.all([
-      this.secrets.getApiKey("openai"),
-      this.secrets.getApiKey("groq"),
-      this.secrets.getApiKey("anthropic"),
-      this.secrets.getApiKey("google")
-    ]);
+    const allKeys = await this.secrets.getAllApiKeys().catch(() => ({}));
+    const openaiApiKey = allKeys.openaiApiKey || process.env.OPENAI_API_KEY;
+    const groqApiKey = allKeys.groqApiKey || process.env.GROQ_API_KEY;
+    const anthropicApiKey = allKeys.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+    const googleApiKey = allKeys.googleApiKey || process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || process.env.GOOGLE_AI_API_KEY;
     const selection = this.selectProviderAndModel({
       defaultProvider: optional.defaultProvider,
       defaultModel: optional.defaultModel,
       keys: { openaiApiKey, groqApiKey, anthropicApiKey, googleApiKey }
     });
+    const anyKey = openaiApiKey || groqApiKey || anthropicApiKey || googleApiKey;
+    if (!anyKey) {
+      const fallback = this.buildPoliteFallback(req.prompt);
+      return {
+        success: true,
+        content: fallback,
+        meta: { provider: "none", model: "none", traceId, reasons: ["no-keys-detected"] }
+      };
+    }
     const adapter = new IMSProviderAdapter({
-      openaiApiKey: openaiApiKey || process.env.OPENAI_API_KEY,
-      groqApiKey: groqApiKey || process.env.GROQ_API_KEY,
-      anthropicApiKey: anthropicApiKey || process.env.ANTHROPIC_API_KEY,
-      googleApiKey: googleApiKey || process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || process.env.GOOGLE_AI_API_KEY,
+      openaiApiKey,
+      groqApiKey,
+      anthropicApiKey,
+      googleApiKey,
       enableMetrics: true,
       enableFallback: true,
       maxRetries: 2
     });
-    await adapter.initialize();
+    try {
+      await adapter.initialize();
+    } catch {
+      const fallback = this.buildPoliteFallback(req.prompt);
+      return { success: true, content: fallback, meta: { provider: "none", model: "none", traceId, reasons: ["adapter-init-failed"] } };
+    }
     const modelDef = {
       id: `${selection.provider}:${selection.model}`,
       providerId: selection.provider,
@@ -8482,12 +8520,17 @@ var IMSFacade = class {
       generationParams: gen,
       trace: { traceId, routedAt: (/* @__PURE__ */ new Date()).toISOString(), policyUsed: this.options.defaultPolicyId || "dev", fallbackChain: [] }
     };
-    const sys = req.systemPrompt && String(req.systemPrompt).trim() || "You are a concise assistant.";
+    const sys = req.systemPrompt && String(req.systemPrompt).trim() || "You are a concise assistant. Make sure you answer in plain text, as a natural chat.";
     const messages = [
       { role: "system", content: sys },
       { role: "user", content: req.prompt }
     ];
-    const { content } = await adapter.executeModelCall(messages, routeResult, modelDef);
+    let content = "";
+    try {
+      ({ content } = await adapter.executeModelCall(messages, routeResult, modelDef));
+    } catch {
+      content = this.buildPoliteFallback(req.prompt);
+    }
     return {
       success: true,
       content,
@@ -8499,6 +8542,12 @@ var IMSFacade = class {
       }
     };
   }
+  buildPoliteFallback(prompt) {
+    const p = (prompt || "").trim();
+    return p ? `Sorry, I can't reach the AI service right now.
+Your request: "${p}"
+I can still help summarize, clarify, or suggest next steps. Try again in a moment, or ask me to rephrase.` : "Sorry, I can't reach the AI service right now. Please try again in a moment.";
+  }
   selectProviderAndModel(input) {
     const reasons = [];
     if (input.defaultProvider && input.defaultModel) {
@@ -8509,11 +8558,11 @@ var IMSFacade = class {
       }
       reasons.push("override: default-provider has no key");
     }
-    if (input.keys.openaiApiKey) return { provider: "openai", model: "gpt-4o", reasons: [...reasons, "fallback: openai key present"] };
-    if (input.keys.googleApiKey) return { provider: "google", model: "gemini-2.5-pro", reasons: [...reasons, "fallback: google key present"] };
+    if (input.keys.openaiApiKey) return { provider: "openai", model: "gpt-5-mini", reasons: [...reasons, "fallback: openai key present"] };
+    if (input.keys.googleApiKey) return { provider: "google", model: "gemini-2.5-flash", reasons: [...reasons, "fallback: google key present"] };
     if (input.keys.groqApiKey) return { provider: "groq", model: "llama-3.1-70b-versatile", reasons: [...reasons, "fallback: groq key present"] };
-    if (input.keys.anthropicApiKey) return { provider: "anthropic", model: "claude-3-5-sonnet-latest", reasons: [...reasons, "fallback: anthropic key present"] };
-    return { provider: "openai", model: "gpt-4o", reasons: [...reasons, "last-resort: no keys detected"] };
+    if (input.keys.anthropicApiKey) return { provider: "anthropic", model: "claude-sonnet-4-20250514", reasons: [...reasons, "fallback: anthropic key present"] };
+    return { provider: "openai", model: "gpt-5-mini", reasons: [...reasons, "last-resort: no keys detected"] };
   }
   hasKey(provider, keys) {
     switch (provider) {
@@ -8548,7 +8597,7 @@ 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) => {
@@ -8572,7 +8621,7 @@ app.get("/api/status", (req, res) => {
 app.get("/", (req, res) => {
   res.json({
     name: "MARIA CODE API",
-    version: "4.3.9",
+    version: "4.3.18",
     status: "running",
     environment: process.env.NODE_ENV || "development",
     endpoints: {
@@ -8587,6 +8636,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);
@@ -8664,8 +8737,12 @@ app.post("/api/ai", rateLimitMiddleware, async (req, res) => {
     return res.json(resp);
   } catch (error) {
     console.error("[AI API] Error:", error?.message || error);
-    const status = error?.status || 500;
-    return res.status(status).json({ error: "ai_request_failed", message: error?.message || "AI request failed" });
+    const polite = typeof req.body?.prompt === "string" ? `Sorry, I couldn't reach the AI service right now. Here\u2019s a quick human-style reply to keep you moving:
+
+${String(req.body.prompt)}
+
+If you want, I can try again in a moment or help you rephrase.` : `Sorry, I couldn't reach the AI service right now. Please try again in a moment.`;
+    return res.status(200).json({ success: true, data: { content: polite } });
   }
 });
 app.post("/api/auth/revoke", async (req, res) => {
@@ -8716,9 +8793,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" });
@@ -8760,17 +8838,15 @@ 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" });
+    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));
@@ -8778,7 +8854,7 @@ app.post("/api/v1/video", rateLimitMiddleware, async (req, res) => {
     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";
@@ -8793,14 +8869,15 @@ app.post("/api/v1/video", rateLimitMiddleware, async (req, res) => {
       // 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) {
@@ -8820,36 +8897,143 @@ app.post("/api/v1/video", rateLimitMiddleware, async (req, res) => {
       const looksHtml = headStr.includes("<!doctype") || headStr.includes("<html") || headStr.includes("<?xml");
       return (hasFtyp2 || isWebm2) && !looksHtml;
     };
-    const ensureFileMaterialized = async (p, waitMs = 1e4) => {
+    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(p);
-          if (st && st.size > 0) return;
+          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: ${p}`);
+        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, 15e3);
+        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;
-    for (let attempt = 1; attempt <= 3 && !videoBytes; attempt++) {
-      videoBytes = await trySdkDownloadOnce();
-      if (!videoBytes) await new Promise((r2) => setTimeout(r2, 600 * attempt));
-    }
-    if (!videoBytes) {
-      throw new Error("failed to download valid video bytes");
+    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)));
     }
+    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";
@@ -8884,7 +9068,8 @@ app.post("/api/v1/video", rateLimitMiddleware, async (req, res) => {
       metrics: { durationMs: Date.now() - startedMs, retries: 0, fallbacks: 0 },
       trace: traceId
     };
-    const saved = await saveArtifacts({ root: process.cwd(), kind: "video", baseDir: "artifacts/media/videos", flat: false, skipManifest: true }, [{ 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);
@@ -8899,13 +9084,11 @@ app.post("/api/v1/video", rateLimitMiddleware, async (req, res) => {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       uid
     });
-    return res.json({ success: true, data: { url: saved.files[0] ? `/${saved.files[0]}` : void 0, files: saved.files, jobId: manifest.trace, applied: { durationSeconds: effectiveDuration, frameRate: effectiveFps } } });
+    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) => {