beauticode-dsh 1.0.7 → 1.0.13

package/vendor/adapter-dsh/session.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { ApplyTransaction, BackgroundStore, MediaServerController, buildHostApplyPayload, defaultDataRoot, persistAndApplyImportedMedia, resolveSessionBundledThemes, } from "../core/index.js";
+import { ApplyTransaction, BackgroundStore, MediaServerController, buildHostApplyPayload, defaultDataRoot, isLocalBackgroundSource, resolveSessionBundledThemes, resolveBackgroundImagePath, } from "../core/index.js";
 import { DshHostApplier, normalizeDshBaseUrl } from "./bridge.js";
 import { DSH_HOST_DESCRIPTOR } from "./host-descriptor.js";
 import { acquireDshInjectorLock } from "./injector-lock.js";
@@ -93,16 +93,26 @@ export class DshSession {
             this.startHandoffLoop();
             void this.yieldToTrayIfRequested();
         }
-        // Finish the initial restore check before accepting the first user apply.
-        // Otherwise a click immediately after lazy session startup can race the
-        // background reapply and be rejected as a concurrent operation.
-        await this.watchOnce();
+        void this.watchOnce();
         return { port: this.bridgePort() };
     }
     async apply(input) {
         return this.trackOperation(this.applyInternal(input));
     }
-    async applyInternal(input) {
+    async applyAndSaveTheme(input, name) {
+        const result = await this.trackOperation(this.applyInternal(input, name));
+        if (!result.ok)
+            return result;
+        if (!result.theme) {
+            return {
+                ok: false,
+                error: "Theme apply completed without a saved theme.",
+                rolledBack: false,
+            };
+        }
+        return { ...result, theme: result.theme };
+    }
+    async applyInternal(input, themeName) {
         if (!this.releaseLock || this.closed || !this.host) {
             throw new Error("Session is not started");
         }
@@ -115,16 +125,37 @@ export class DshSession {
         }
         this.userBusy = true;
         try {
+            // The startup/watch probe may already have opened active/background.json
+            // before userBusy became true. On Windows that read can overlap the
+            // transaction's atomic active-directory rename and cause EPERM. Drain
+            // that one read before beginning any apply mutation; later watch ticks
+            // observe userBusy and do not reapply.
+            const inFlightWatch = this.watchTask;
+            if (inFlightWatch)
+                await inFlightWatch;
             const tx = new ApplyTransaction({
                 store: this.store,
                 media: this.media,
                 host: this.host,
+                includeImageDataUrl: false,
                 verifyDeadlineMs: this.verifyDeadlineMs,
                 offline: false,
             });
-            const result = await tx.run(input);
+            const saved = { theme: null };
+            const result = await tx.run(input, themeName
+                ? {
+                    beforeFinalize: async () => {
+                        saved.theme = await this.store.saveCurrentTheme(themeName);
+                    },
+                    onRollback: async () => {
+                        if (saved.theme) {
+                            await this.store.deleteSavedTheme(saved.theme.id);
+                        }
+                    },
+                }
+                : undefined);
             if (result.ok) {
-                this.activeThemeId = null;
+                this.activeThemeId = saved.theme?.type === "video" ? saved.theme.id : null;
                 this.lastProgressWriteSec = -1;
                 if (input.type === "clear") {
                     this.fishMode = false;
@@ -143,7 +174,7 @@ export class DshSession {
                 }
                 await this.host.setBackgroundTone(this.backgroundTone).catch(() => null);
             }
-            return result;
+            return result.ok && saved.theme ? { ...result, theme: saved.theme } : result;
         }
         finally {
             this.userBusy = false;
@@ -184,21 +215,26 @@ export class DshSession {
                 }
             }
             if (manifest.background) {
-                const runtimeImagePath = await this.store.prepareRuntimeImage(manifest);
-                if (!runtimeImagePath) {
-                    throw new Error("DSH image reapply requires a detached runtime copy.");
-                }
-                stagedImage = await this.media.stage(runtimeImagePath);
-                if (manifest.background.type === "video" && manifest.background.video) {
+                const imagePath = resolveBackgroundImagePath(this.store.paths.activeDir, manifest.background);
+                if (!imagePath)
+                    throw new Error("Background has no image source.");
+                stagedImage = await this.media.stage(imagePath, {
+                    validation: manifest.background.type === "image" && isLocalBackgroundSource(manifest.background)
+                        ? "fast"
+                        : "full",
+                });
+                if (manifest.background.type === "video") {
                     const runtimeVideoPath = await this.store.prepareRuntimeVideo(manifest);
                     if (!runtimeVideoPath) {
                         throw new Error("DSH video reapply requires a detached runtime copy.");
                     }
-                    stagedVideo = await this.media.stage(runtimeVideoPath);
+                    stagedVideo = await this.media.stage(runtimeVideoPath, {
+                        validation: isLocalBackgroundSource(manifest.background) ? "fast" : "full",
+                    });
                 }
             }
             const staged = { image: stagedImage, video: stagedVideo };
-            const payload = await buildHostApplyPayload(this.store, manifest, staged, "");
+            const payload = await buildHostApplyPayload(this.store, manifest, staged, "", undefined, { includeImageDataUrl: false });
             if (payload.video && resumeAt != null)
                 payload.video.startAt = resumeAt;
             await this.host.apply(payload);
@@ -261,7 +297,6 @@ export class DshSession {
             fish: this.fishMode,
             muted: this.videoMuted,
             tone: this.backgroundTone,
-            themeId: this.activeThemeId,
         };
     }
     async saveCurrentTheme(name) {
@@ -278,16 +313,15 @@ export class DshSession {
             }
         }
         const theme = await this.store.saveCurrentTheme(name, { videoPositionSec });
-        this.activeThemeId = theme.id;
-        this.lastProgressWriteSec = -1;
+        if (theme.type === "video") {
+            this.activeThemeId = theme.id;
+            this.lastProgressWriteSec = -1;
+        }
+        else {
+            this.activeThemeId = null;
+        }
         return theme;
     }
-    async importSavedTheme(input) {
-        return this.store.importSavedThemeFromMedia(input);
-    }
-    async applyImportedMedia(input, opts = {}) {
-        return this.trackOperation(persistAndApplyImportedMedia(this, input, opts));
-    }
     async listSavedThemes() {
         return this.store.listSavedThemes();
     }
@@ -304,7 +338,7 @@ export class DshSession {
             const saved = await this.store.loadSavedTheme(themeId);
             const result = await this.apply(saved.input);
             if (result.ok) {
-                this.activeThemeId = saved.themeId;
+                this.activeThemeId = saved.input.type === "video" ? saved.themeId : null;
                 this.lastProgressWriteSec = -1;
             }
             return result;

package/vendor/adapter-dsh/tray-handoff.js

@@ -1,19 +1,26 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { isRecordedPidLive } from "../core/index.js";
 export const TRAY_CLAIM_FILE = "tray-claim.json";
 export const TRAY_CLAIM_SCHEMA = "beauticode.tray-claim/v1";
 export const SESSION_HOST_FILE = "session-host.json";
 export const SESSION_HOST_SCHEMA = "beauticode.session-host/v1";
 export const DSH_CONTROL_FILE = "dsh-control.json";
 export const DSH_CONTROL_SCHEMA = "beauticode.dsh-control/v1";
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return Boolean(error && typeof error === "object" && "code" in error && error.code === "EPERM");
+    }
+}
 async function readLivePid(filePath, schema) {
     let raw;
-    let mtimeMs = 0;
     try {
-        const [text, stat] = await Promise.all([fs.readFile(filePath, "utf8"), fs.stat(filePath)]);
-        raw = text;
-        mtimeMs = stat.mtimeMs;
+        raw = await fs.readFile(filePath, "utf8");
     }
     catch {
         return null;
@@ -23,12 +30,7 @@ async function readLivePid(filePath, schema) {
         if (schema && parsed.schema !== schema)
             return null;
         const pid = Number(parsed.pid);
-        if (!Number.isInteger(pid) || pid <= 0)
-            return null;
-        const startedAt = typeof parsed.startedAt === "string" && parsed.startedAt
-            ? parsed.startedAt
-            : new Date(mtimeMs).toISOString();
-        if (!(await isRecordedPidLive(pid, startedAt)))
+        if (!Number.isInteger(pid) || pid <= 0 || !isPidAlive(pid))
             return null;
         return pid;
     }

package/vendor/core/apply-transaction.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 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";
 /**
  * Minimal baseline only — live Codex path injects packages/adapter-codex
@@ -39,6 +40,7 @@ export class ApplyTransaction {
     cssText;
     verifyDeadlineMs;
     offline;
+    includeImageDataUrl;
     #busy = false;
     constructor(opts) {
         this.store = opts.store;
@@ -47,11 +49,12 @@ export class ApplyTransaction {
         this.cssText = opts.cssText ?? DEFAULT_CSS;
         this.verifyDeadlineMs = opts.verifyDeadlineMs ?? 30_000;
         this.offline = opts.offline ?? false;
+        this.includeImageDataUrl = opts.includeImageDataUrl ?? true;
     }
     get busy() {
         return this.#busy;
     }
-    async run(input) {
+    async run(input, hooks = {}) {
         if (this.#busy) {
             return {
                 ok: false,
@@ -61,7 +64,7 @@ export class ApplyTransaction {
         }
         this.#busy = true;
         try {
-            return await this.store.withExclusiveMutation(() => this.#runExclusive(input));
+            return await this.store.withExclusiveMutation(() => this.#runExclusive(input, hooks));
         }
         catch (error) {
             return {
@@ -74,45 +77,78 @@ export class ApplyTransaction {
             this.#busy = false;
         }
     }
-    async #runExclusive(input) {
+    async #runExclusive(input, hooks) {
+        const startedAt = performance.now();
+        const phases = {};
+        const measure = async (name, work) => {
+            const phaseStartedAt = performance.now();
+            try {
+                return await work();
+            }
+            finally {
+                phases[name] = Math.round((performance.now() - phaseStartedAt) * 10) / 10;
+            }
+        };
+        const requestedSourceMode = input.type === "clear" ? "clear" : input.source ?? "managed";
+        const timings = () => ({
+            totalMs: Math.round((performance.now() - startedAt) * 10) / 10,
+            phases: { ...phases },
+        });
         let snapshot = null;
         let staged = null;
         let runtimeVideoPath = null;
+        let finalizeStarted = false;
         try {
-            await this.store.init();
-            snapshot = await this.store.snapshot();
-            const manifest = await this.store.commitImport(input);
-            staged = await this.#stageMediaFor(manifest);
+            await measure("initialize", () => this.store.init());
+            snapshot = await measure("snapshot", () => this.store.snapshot());
+            const manifest = await measure("commitImport", () => this.store.commitImport(input));
+            const sourceMode = !manifest.background
+                ? "clear"
+                : isLocalBackgroundSource(manifest.background)
+                    ? "local"
+                    : "managed";
+            if (requestedSourceMode === "local" && sourceMode !== "local") {
+                throw new Error("Local import contract was not preserved by the media store.");
+            }
+            staged = await measure("stageMedia", () => this.#stageMediaFor(manifest));
             if (!this.offline && this.host) {
-                const payload = await this.#buildPayload(manifest, staged, input.type === "video" ? input.startAt : undefined);
+                const payload = await measure("buildPayload", () => this.#buildPayload(manifest, staged, input.type === "video" ? input.startAt : undefined));
                 runtimeVideoPath = payload.video?.localPath ?? null;
-                await this.host.apply(payload);
-                const verify = await this.host.verify({
+                await measure("hostApply", () => this.host.apply(payload));
+                const verify = await measure("rendererVerify", () => this.host.verify({
                     generation: manifest.generation,
                     media: manifest.background?.type ?? "clear",
-                }, { deadlineMs: this.verifyDeadlineMs });
+                }, { deadlineMs: this.verifyDeadlineMs }));
                 if (verify.status !== "pass") {
-                    await this.#rollback(snapshot, staged);
+                    await measure("rollback", () => this.#rollback(snapshot, staged));
                     staged = null;
                     snapshot = null;
                     return {
                         ok: false,
                         error: `Live verify did not pass (${verify.status}): ${verify.reason}`,
                         rolledBack: true,
+                        sourceMode,
+                        timings: timings(),
                     };
                 }
             }
-            await this.media.commit(staged);
-            await this.store.pruneRuntimeMedia(runtimeKeepPaths(staged, runtimeVideoPath));
+            await measure("mediaCommit", () => this.media.commit(staged));
+            await measure("pruneRuntimeMedia", () => this.store.pruneRuntimeMedia(runtimeVideoPath));
             staged = null;
+            if (hooks.beforeFinalize) {
+                finalizeStarted = true;
+                await measure("saveTheme", () => hooks.beforeFinalize(manifest));
+            }
             if (snapshot) {
-                await this.store.clearSnapshot(snapshot);
+                await measure("clearSnapshot", () => this.store.clearSnapshot(snapshot));
                 snapshot = null;
             }
             return {
                 ok: true,
                 generation: manifest.generation,
                 mode: manifest.background?.type ?? "clear",
+                sourceMode,
+                timings: timings(),
             };
         }
         catch (err) {
@@ -120,7 +156,7 @@ export class ApplyTransaction {
             let rolledBack = false;
             if (snapshot) {
                 try {
-                    await this.#rollback(snapshot, staged);
+                    await measure("rollback", () => this.#rollback(snapshot, staged));
                     staged = null;
                     snapshot = null;
                     rolledBack = true;
@@ -134,32 +170,47 @@ export class ApplyTransaction {
                 await this.#abortPair(staged);
                 staged = null;
             }
-            return { ok: false, error: message, rolledBack };
+            if (finalizeStarted && hooks.onRollback) {
+                await measure("finalizeRollback", () => hooks.onRollback()).catch(() => { });
+            }
+            return {
+                ok: false,
+                error: message,
+                rolledBack,
+                sourceMode: requestedSourceMode,
+                timings: timings(),
+            };
         }
     }
     async #stageMediaFor(manifest) {
         if (!manifest.background) {
             return { image: null, video: null };
         }
-        // Serve stills and videos from runtime-media copies so Windows can rotate
-        // `active/` while the previous generation is still being read.
-        const runtimeImagePath = await this.store.prepareRuntimeImage(manifest);
-        if (!runtimeImagePath) {
-            throw new Error("Image media staging requires a detached runtime copy.");
-        }
-        const image = await this.media.stage(runtimeImagePath);
+        const imagePath = resolveBackgroundImagePath(this.store.paths.activeDir, manifest.background);
+        if (!imagePath)
+            throw new Error("Background has no image source.");
+        const image = await this.media.stage(imagePath, {
+            validation: manifest.background.type === "image" && isLocalBackgroundSource(manifest.background)
+                ? "fast"
+                : "full",
+        });
         let video = null;
-        if (manifest.background.type === "video" && manifest.background.video) {
+        if (manifest.background.type === "video") {
+            // DSH streams this handle for the lifetime of the active <video>. On
+            // Windows, serving active/background.mp4 directly keeps the active
+            // directory open and the next atomic directory swap fails with EPERM.
             const runtimeVideoPath = await this.store.prepareRuntimeVideo(manifest);
             if (!runtimeVideoPath) {
                 throw new Error("Video media staging requires a detached runtime copy.");
             }
-            video = await this.media.stage(runtimeVideoPath);
+            video = await this.media.stage(runtimeVideoPath, {
+                validation: isLocalBackgroundSource(manifest.background) ? "fast" : "full",
+            });
         }
         return { image, video };
     }
     async #buildPayload(manifest, staged, videoStartAt) {
-        return buildHostApplyPayload(this.store, manifest, staged, this.cssText, videoStartAt);
+        return buildHostApplyPayload(this.store, manifest, staged, this.cssText, videoStartAt, { includeImageDataUrl: this.includeImageDataUrl });
     }
     async #abortPair(staged) {
         if (!staged)
@@ -190,7 +241,7 @@ export class ApplyTransaction {
                 }
             }
             await this.media.commit(restoredMedia);
-            await this.store.pruneRuntimeMedia(runtimeKeepPaths(restoredMedia, runtimeVideoPath));
+            await this.store.pruneRuntimeMedia(runtimeVideoPath);
             restoredMedia = null;
             await this.store.clearSnapshot(snapshot);
         }
@@ -199,17 +250,7 @@ export class ApplyTransaction {
         }
     }
 }
-function runtimeKeepPaths(staged, extra) {
-    const keep = [];
-    if (staged?.image?.filePath)
-        keep.push(staged.image.filePath);
-    if (staged?.video?.filePath)
-        keep.push(staged.video.filePath);
-    if (extra)
-        keep.push(extra);
-    return keep;
-}
-export async function buildHostApplyPayload(store, manifest, staged, cssText, videoStartAt) {
+export async function buildHostApplyPayload(store, manifest, staged, cssText, videoStartAt, opts = {}) {
     if (!manifest.background) {
         return {
             generation: manifest.generation,
@@ -220,8 +261,10 @@ export async function buildHostApplyPayload(store, manifest, staged, cssText, vi
             cssText,
         };
     }
-    const imagePath = path.join(store.paths.activeDir, manifest.background.image);
-    const imageDataUrl = await fileToDataUrl(imagePath);
+    const imagePath = resolveBackgroundImagePath(store.paths.activeDir, manifest.background);
+    if (!imagePath)
+        throw new Error("Background has no image source.");
+    const imageDataUrl = opts.includeImageDataUrl === false ? null : await fileToDataUrl(imagePath);
     const imageUrl = staged?.image?.srcUrl ?? null;
     if (manifest.background.type === "image") {
         return {
@@ -234,10 +277,9 @@ export async function buildHostApplyPayload(store, manifest, staged, cssText, vi
             atmosphere: manifest.background.effects ?? null,
         };
     }
-    if (!manifest.background.video) {
-        throw new Error("Video background is missing a video basename.");
-    }
-    const videoPath = path.join(store.paths.activeDir, manifest.background.video);
+    const videoPath = resolveBackgroundVideoPath(store.paths.activeDir, manifest.background);
+    if (!videoPath)
+        throw new Error("Video background has no video source.");
     const runtimeVideoPath = await store.prepareRuntimeVideo(manifest);
     if (!runtimeVideoPath) {
         throw new Error("Video payload requires a detached runtime copy.");