wallpaper-engine-dsh 0.1.5 → 0.1.7

package/lib/core.js

@@ -191,11 +191,13 @@ export function weBinaryName(platform = process.platform) {
 
 /**
  * First candidate directory that contains the WE binary, in order.
+ * Async: io methods may be sync or return promises (the host injects
+ * fs/promises so discovery never blocks the event loop).
  * @param {string[]} candidates
- * @param {{ existsSync?: (p: string) => boolean, platform?: string }} [io]
- * @returns {string | null}
+ * @param {{ existsSync?: (p: string) => boolean | Promise<boolean>, platform?: string }} [io]
+ * @returns {Promise<string | null>}
  */
-export function findInstallDir(candidates, io = {}) {
+export async function findInstallDir(candidates, io = {}) {
   const exists = io.existsSync || existsSync;
   const bin = weBinaryName(io.platform || process.platform);
   const seen = new Set();
@@ -204,7 +206,7 @@ export function findInstallDir(candidates, io = {}) {
     const dir = normalize(String(raw));
     if (seen.has(dir)) continue;
     seen.add(dir);
-    if (exists(join(dir, bin))) return dir;
+    if (await exists(join(dir, bin))) return dir;
   }
   return null;
 }
@@ -237,15 +239,15 @@ export function installDirCandidates(input = {}) {
  * libraryfolders.vdf, so it must be recovered by direct inspection).
  * @param {string[]} probes
  * @param {string[]} vdfLibraries
- * @param {{ existsSync?: (p: string) => boolean, platform?: string }} [io]
- * @returns {string[]}
+ * @param {{ existsSync?: (p: string) => boolean | Promise<boolean>, platform?: string }} [io]
+ * @returns {Promise<string[]>}
  */
-export function workshopLibraryRoots(probes, vdfLibraries, io = {}) {
+export async function workshopLibraryRoots(probes, vdfLibraries, io = {}) {
   const exists = io.existsSync || existsSync;
   const bin = weBinaryName(io.platform || process.platform);
   const libs = [...vdfLibraries];
   for (const probe of probes) {
-    if (exists(join(probe, 'steamapps', 'common', 'wallpaper_engine', bin))) {
+    if (await exists(join(probe, 'steamapps', 'common', 'wallpaper_engine', bin))) {
       libs.push(probe);
     }
   }
@@ -298,18 +300,20 @@ export function isInsideDir(root, target, platform = process.platform) {
  * server at arbitrary files.
  *
  * @param {string} dir
- * @param {{ readFileSync?: (p: string, e: string) => string, existsSync?: (p: string) => boolean }} [io]
+ * @param {{ readFileSync?: (p: string, e: string) => string | Promise<string>, existsSync?: (p: string) => boolean | Promise<boolean> }} [io]
  */
-export function readProject(dir, io = {}) {
+export async function readProject(dir, io = {}) {
   const read = io.readFileSync || readFileSync;
   const exists = io.existsSync || existsSync;
   const pj = join(dir, 'project.json');
-  if (!exists(pj)) return null;
+  if (!await exists(pj)) return null;
   try {
-    const o = JSON.parse(read(pj, 'utf8'));
+    const o = JSON.parse(await read(pj, 'utf8'));
     if (!o || typeof o !== 'object' || typeof o.file !== 'string' || !o.file.trim()) return null;
-    let type = typeof o.type === 'string' ? o.type.toLowerCase() : inferType(o.file);
-    if (!KINDS.includes(type)) type = 'scene';
+    // A declared-but-unknown type (typo, trailing whitespace) is not
+    // evidence of "scene": fall back to extension inference first.
+    let type = typeof o.type === 'string' ? o.type.trim().toLowerCase() : '';
+    if (!KINDS.includes(type)) type = inferType(o.file);
     const fileAbs = resolve(dir, o.file);
     if (!isInsideDir(dir, fileAbs)) return null;
     let previewAbs = null;
@@ -334,19 +338,19 @@ export function readProject(dir, io = {}) {
  * Enumerate every wallpaper project under the given roots (first occurrence
  * of an id wins), sorted case-insensitively by title.
  * @param {string[]} roots
- * @param {{ readdirSync?: (p: string) => string[], statSync?: (p: string) => { isDirectory(): boolean } }} [io]
+ * @param {{ readdirSync?: (p: string) => string[] | Promise<string[]>, statSync?: (p: string) => { isDirectory(): boolean } | Promise<{ isDirectory(): boolean }> }} [io]
  */
-export function enumerateWallpapers(roots, io = {}) {
+export async function enumerateWallpapers(roots, io = {}) {
   const readdir = io.readdirSync || readdirSync;
   const stat = io.statSync || statSync;
   const found = new Map();
   for (const root of roots) {
     let entries;
-    try { entries = readdir(root); } catch { continue; }
+    try { entries = await readdir(root); } catch { continue; }
     for (const entry of entries) {
       const dir = join(root, entry);
-      try { if (!stat(dir).isDirectory()) continue; } catch { continue; }
-      const proj = readProject(dir, io);
+      try { if (!(await stat(dir)).isDirectory()) continue; } catch { continue; }
+      const proj = await readProject(dir, io);
       if (!proj || found.has(proj.id)) continue;
       found.set(proj.id, proj);
     }
@@ -360,21 +364,21 @@ export function enumerateWallpapers(roots, io = {}) {
  * plus the workshop content folder of every owning library.
  * @param {string | null} installDir
  * @param {string[]} libraryRoots
- * @param {{ existsSync?: (p: string) => boolean }} [io]
- * @returns {string[]}
+ * @param {{ existsSync?: (p: string) => boolean | Promise<boolean> }} [io]
+ * @returns {Promise<string[]>}
  */
-export function wallpaperRoots(installDir, libraryRoots, io = {}) {
+export async function wallpaperRoots(installDir, libraryRoots, io = {}) {
   const exists = io.existsSync || existsSync;
   const roots = [];
   if (installDir) {
     for (const sub of ['defaultprojects', 'myprojects']) {
       const p = join(installDir, 'projects', sub);
-      if (exists(p)) roots.push(p);
+      if (await exists(p)) roots.push(p);
     }
   }
   for (const lib of libraryRoots) {
     const ws = join(lib, 'steamapps', 'workshop', 'content', WE_APPID);
-    if (exists(ws)) roots.push(ws);
+    if (await exists(ws)) roots.push(ws);
   }
   return roots;
 }
@@ -463,30 +467,36 @@ export function resolvePlaylistItem(item, byPath, byId) {
 /**
  * Parse an HTTP Range header for a resource of `size` bytes.
  * Supports `bytes=a-b`, `bytes=a-`, `bytes=-suffix`.
+ *
+ * RFC 9110 §14.2: a server MUST ignore a Range header it does not understand
+ * (malformed, wrong unit, multi-range) and answer 200 — 416 is reserved for
+ * syntactically valid but unsatisfiable ranges.
+ *
  * @returns {null | { start: number, end: number } | { error: true }}
- *   null    → no/empty header, serve the whole body (200)
- *   error   → unsatisfiable or malformed, answer 416
+ *   null    → no header, or an invalid/unsupported one: ignore it, serve 200
+ *   error   → valid syntax but unsatisfiable for this resource: answer 416
  *   start/end → inclusive byte range, answer 206
  */
 export function parseRangeHeader(header, size) {
   if (!header || typeof header !== 'string') return null;
   if (!Number.isFinite(size) || size < 0) return { error: true };
   const m = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
-  if (!m) return { error: true };
+  if (!m) return null; // wrong unit / multi-range / garbage → ignore (200)
   const [, a, b] = m;
-  if (a === '' && b === '') return { error: true };
+  if (a === '' && b === '') return null; // "bytes=-" is not a range → 200
   let start;
   let end;
   if (a === '') {
     const suffix = parseInt(b, 10);
-    if (!Number.isFinite(suffix) || suffix <= 0) return { error: true };
+    if (!Number.isFinite(suffix) || suffix <= 0) return null; // "bytes=-0"
     start = Math.max(0, size - suffix);
     end = size - 1;
   } else {
     start = parseInt(a, 10);
     end = b === '' ? size - 1 : Math.min(parseInt(b, 10), size - 1);
   }
-  if (!Number.isFinite(start) || !Number.isFinite(end)) return { error: true };
+  if (!Number.isFinite(start) || !Number.isFinite(end)) return null;
+  // Valid syntax; unsatisfiable for this resource.
   if (size === 0 || start > end || start >= size) return { error: true };
   return { start, end };
 }
@@ -517,13 +527,16 @@ export function mimeFor(absPath) {
  *
  * @param {{ installDir: string | null, libraryRoots: string[] }} discovery
  * @param {object} [io] overridable IO: existsSync/readFileSync/readdirSync/
- *   statSync (default to node:fs), plus:
- *   - `mint(entry)` — mint a media/preview token for a file entry; the host
- *     provides a random-token map, tests provide a spy.
+ *   statSync (default to node:fs sync functions; each may also return a
+ *   promise — the host injects fs/promises to keep the event loop free),
+ *   plus:
+ *   - `mint(entry)` — mint a media/preview token for a file entry; when it
+ *     returns a falsy value (or is omitted) the URL is null, never
+ *     "…/media/null".
  *   - `base` — URL prefix for media/preview links (default '/we-background').
- * @returns {{ installDir, total, portableCount, wallpapers, playlists }}
+ * @returns {Promise<{ installDir, total, portableCount, wallpapers, playlists }>}
  */
-export function buildInventoryFrom(discovery = {}, io = {}) {
+export async function buildInventoryFrom(discovery = {}, io = {}) {
   const exists = io.existsSync || existsSync;
   const read = io.readFileSync || readFileSync;
   const mint = io.mint || (() => null);
@@ -531,35 +544,38 @@ export function buildInventoryFrom(discovery = {}, io = {}) {
 
   const installDir = discovery.installDir || null;
   const libraryRoots = Array.isArray(discovery.libraryRoots) ? discovery.libraryRoots : [];
-  const roots = wallpaperRoots(installDir, libraryRoots, { existsSync: exists });
-  const projects = enumerateWallpapers(roots, io);
+  const roots = await wallpaperRoots(installDir, libraryRoots, { existsSync: exists });
+  const projects = await enumerateWallpapers(roots, io);
   const byId = new Map(projects.map((p) => [p.id, p]));
   const byPath = new Map(projects.map((p) => [pathKey(p.fileAbs), p.id]));
 
-  const wallpapers = projects.map((p) => {
+  const wallpapers = [];
+  for (const p of projects) {
     const portable = PORTABLE_KINDS.includes(p.type);
-    const hasMedia = portable && exists(p.fileAbs);
-    const hasPreview = Boolean(p.previewAbs) && exists(p.previewAbs);
-    return {
+    const hasMedia = portable && await exists(p.fileAbs);
+    const hasPreview = Boolean(p.previewAbs) && await exists(p.previewAbs);
+    const mediaToken = hasMedia
+      ? mint({ abs: p.fileAbs, rootDir: p.type === 'web' ? p.dir : null, key: `${p.id}:media` })
+      : null;
+    const previewToken = hasPreview
+      ? mint({ abs: p.previewAbs, rootDir: null, key: `${p.id}:preview` })
+      : null;
+    wallpapers.push({
       id: p.id,
       title: p.title,
       type: p.type,
-      playable: hasMedia,
-      media: hasMedia
-        ? `${base}/media/${mint({ abs: p.fileAbs, rootDir: p.type === 'web' ? p.dir : null })}`
-        : null,
-      preview: hasPreview
-        ? `${base}/preview/${mint({ abs: p.previewAbs, rootDir: null })}`
-        : null,
-    };
-  });
+      playable: hasMedia && Boolean(mediaToken),
+      media: hasMedia && mediaToken ? `${base}/media/${mediaToken}` : null,
+      preview: hasPreview && previewToken ? `${base}/preview/${previewToken}` : null,
+    });
+  }
   const playableIds = new Set(wallpapers.filter((w) => w.playable).map((w) => w.id));
 
   let playlists = [];
   const configPath = installDir ? join(installDir, 'config.json') : null;
-  if (configPath && exists(configPath)) {
+  if (configPath && await exists(configPath)) {
     try {
-      playlists = parsePlaylists(JSON.parse(read(configPath, 'utf8')));
+      playlists = parsePlaylists(JSON.parse(await read(configPath, 'utf8')));
     } catch { /* malformed config.json → no playlists, not fatal */ }
   }
   const playlistView = playlists.map((playlist, index) => {