beauticode-dsh 1.0.19 → 1.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beauticode-dsh",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "Cordis plugin: image/video backgrounds for DeepSeek Harness web.",
   "type": "module",
   "main": "./index.mjs",

package/vendor/core/apply-transaction.js

@@ -3,6 +3,13 @@ import path from "node:path";
 import { MAX_INLINE_DATA_URL_BYTES } from "./constants.js";
 import { isLocalBackgroundSource, resolveBackgroundImagePath, resolveBackgroundVideoPath, } from "./media-source.js";
 import { detectImageMime } from "./media-validation.js";
+// Cold-first-access symptoms reported by the renderer while the OS is still
+// scanning or caching a large local video. The stalled attempt itself warms
+// the file and media pipeline, so one immediate retry usually renders.
+const RETRYABLE_RENDER_VERIFY_PATTERN = /首帧|Range 探针/;
+function isRetryableRenderVerifyFailure(status, reason) {
+    return status === "fail" && typeof reason === "string" && RETRYABLE_RENDER_VERIFY_PATTERN.test(reason);
+}
 /**
  * Minimal baseline only — live Codex path injects packages/adapter-codex
  * renderer/background.css (full-window main-surface transparency).
@@ -115,17 +122,32 @@ export class ApplyTransaction {
                 const payload = await measure("buildPayload", () => this.#buildPayload(manifest, staged, input.type === "video" ? input.startAt : undefined));
                 runtimeVideoPath = payload.video?.localPath ?? null;
                 await measure("hostApply", () => this.host.apply(payload));
-                const verify = await measure("rendererVerify", () => this.host.verify({
+                let verify = await measure("rendererVerify", () => this.host.verify({
                     generation: manifest.generation,
                     media: manifest.background?.type ?? "clear",
                 }, { deadlineMs: this.verifyDeadlineMs }));
+                if (verify.status !== "pass" &&
+                    manifest.background?.type === "video" &&
+                    isRetryableRenderVerifyFailure(verify.status, verify.reason)) {
+                    await measure("hostApplyRetry", () => this.host.apply(payload));
+                    verify = await measure("rendererVerifyRetry", () => this.host.verify({
+                        generation: manifest.generation,
+                        media: manifest.background?.type ?? "clear",
+                    }, { deadlineMs: this.verifyDeadlineMs }));
+                }
                 if (verify.status !== "pass") {
                     await measure("rollback", () => this.#rollback(snapshot, staged));
                     staged = null;
                     snapshot = null;
+                    // Field reports used to show only the renderer's final state.
+                    // Appending the server-side phase costs shows which stage ate the
+                    // deadline without needing the local import-timing log.
+                    const phaseSummary = Object.entries(phases)
+                        .map(([name, ms]) => `${name}=${ms}ms`)
+                        .join(",");
                     return {
                         ok: false,
-                        error: `Live verify did not pass (${verify.status}): ${verify.reason}`,
+                        error: `Live verify did not pass (${verify.status}): ${verify.reason}；事务阶段=${phaseSummary}`,
                         rolledBack: true,
                         sourceMode,
                         timings: timings(),

package/vendor/core/background-store.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
 import crypto from "node:crypto";
 import { COMMIT_MARKER_NAME, COMMIT_MARKER_STALE_MS, DEFAULT_VIDEO_BASENAME, MANIFEST_NAME, SAVED_META_NAME, SCHEMA_ID, } from "./constants.js";
-import { assertSafeBasename, MediaValidationError, validateImageFile, validateVideoFile, } from "./media-validation.js";
+import { assertSafeBasename, MediaValidationError, validateImageFile, validateVideoFile, warmVideoFileReads, } from "./media-validation.js";
 import { copyFileAtomic, emptyDir, ensureDataLayout, isPathInsideRoot, resolveDataPaths, rmrf, } from "./paths.js";
 import { normalizeBackgroundEffects } from "./types.js";
 import { isLocalBackgroundSource, managedPrimaryFile, resolveBackgroundImagePath, resolveBackgroundVideoPath, } from "./media-source.js";
@@ -289,6 +289,10 @@ export class BackgroundStore {
                 return null;
             if (isLocalBackgroundSource(manifest.background)) {
                 await validateVideoFile(source, { mode: "fast" });
+                // Zero-copy local videos stream straight from the original path, so
+                // the first range reads happen under the renderer verify deadline.
+                // Warm the header and moov-tail before that clock starts.
+                await warmVideoFileReads(source);
                 return source;
             }
             const cached = this.#runtimeVideoCache.get(manifest.generation);

package/vendor/core/media-validation.js

@@ -222,6 +222,39 @@ export async function validateVideoFile(filePath, opts = {}) {
         ctimeMs: inspected.ctimeMs,
     };
 }
+const WARM_VIDEO_HEAD_BYTES = 2 * 1024 * 1024;
+const WARM_VIDEO_TAIL_BYTES = 4 * 1024 * 1024;
+/**
+ * Best-effort warm read of the byte ranges a cold <video> pipeline requests
+ * first: the container header plus the file tail where non-faststart MP4s
+ * keep their moov atom. On a fresh machine the first read of a large local
+ * video can stall in a synchronous antivirus scan long past the renderer
+ * verify deadline; touching these regions during staging keeps that cost
+ * outside the timed apply. Warmup must never block or fail an import.
+ */
+export async function warmVideoFileReads(filePath) {
+    try {
+        const handle = await fs.open(filePath, "r");
+        try {
+            const size = (await handle.stat()).size;
+            const headLength = Math.min(WARM_VIDEO_HEAD_BYTES, size);
+            const tailLength = Math.min(WARM_VIDEO_TAIL_BYTES, Math.max(0, size - headLength));
+            const buffer = Buffer.allocUnsafe(Math.max(headLength, tailLength, 1));
+            if (headLength > 0) {
+                await handle.read(buffer, 0, headLength, 0);
+            }
+            if (tailLength > 0) {
+                await handle.read(buffer, 0, tailLength, size - tailLength);
+            }
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        /* Advisory only; correctness of the import does not depend on warmup. */
+    }
+}
 /** Basename-only guard for names stored inside active/staging trees. */
 export function assertSafeBasename(name, label) {
     if (typeof name !== "string" || name.length < 1 || name.length > 128) {