@hashtree/worker 0.1.1 → 0.1.2

package/dist/iris/mediaHandler.js

@@ -5,20 +5,73 @@
  * Handles media requests from the service worker via MessagePort.
  * Supports both direct CID-based requests and path-based requests with live streaming.
  */
-import { getCachedRoot } from './treeRootCache';
-import { subscribeToTreeRoots } from './treeRootSubscription';
+import { getCachedRoot, onCachedRootUpdate } from './treeRootCache';
+import { resolveTreeRootNow, subscribeToTreeRoots } from './treeRootSubscription';
 import { getErrorMessage } from './utils/errorMessage';
-import { nhashDecode } from '@hashtree/core';
+import { nhashDecode, toHex } from '@hashtree/core';
 import { nip19 } from 'nostr-tools';
+import { LRUCache } from './utils/lruCache';
 // Thumbnail filename patterns to look for (in priority order)
 const THUMBNAIL_PATTERNS = ['thumbnail.jpg', 'thumbnail.webp', 'thumbnail.png', 'thumbnail.jpeg'];
+const PLAYABLE_MEDIA_EXTENSION_SET = new Set([
+    '.mp4',
+    '.webm',
+    '.mkv',
+    '.mov',
+    '.avi',
+    '.m4v',
+    '.ogv',
+    '.3gp',
+    '.mp3',
+    '.wav',
+    '.flac',
+    '.m4a',
+    '.aac',
+    '.ogg',
+    '.oga',
+    '.opus',
+]);
+const MIME_TYPES = {
+    mp4: 'video/mp4',
+    m4v: 'video/mp4',
+    webm: 'video/webm',
+    ogg: 'video/ogg',
+    ogv: 'video/ogg',
+    mov: 'video/quicktime',
+    avi: 'video/x-msvideo',
+    mkv: 'video/x-matroska',
+    mp3: 'audio/mpeg',
+    wav: 'audio/wav',
+    flac: 'audio/flac',
+    m4a: 'audio/mp4',
+    aac: 'audio/aac',
+    oga: 'audio/ogg',
+    opus: 'audio/ogg',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    png: 'image/png',
+    webp: 'image/webp',
+};
 // Timeout for considering a stream "done" (no updates)
 const LIVE_STREAM_TIMEOUT = 10000; // 10 seconds
 const ROOT_WAIT_TIMEOUT_MS = 15000;
-const ROOT_WAIT_INTERVAL_MS = 200;
+const DIRECTORY_PROBE_TIMEOUT_MS = 1000;
+const IMMUTABLE_LOOKUP_CACHE_HIT_TTL_MS = 5 * 60 * 1000;
+const IMMUTABLE_LOOKUP_CACHE_MISS_TTL_MS = 1000;
+const DIRECTORY_CACHE_SIZE = 1024;
+const RESOLVED_ENTRY_CACHE_SIZE = 2048;
+const MUTABLE_RESOLVED_ENTRY_CACHE_SIZE = 2048;
+const FILE_SIZE_CACHE_SIZE = 1024;
+const THUMBNAIL_PATH_CACHE_SIZE = 1024;
 // Chunk size for streaming to media port
 const MEDIA_CHUNK_SIZE = 256 * 1024; // 256KB chunks - matches videoChunker's firstChunkSize
 const activeMediaStreams = new Map();
+const inflightRootWaits = new Map();
+const directoryLookupCache = createAsyncLookupCache(DIRECTORY_CACHE_SIZE);
+const resolvedEntryLookupCache = createAsyncLookupCache(RESOLVED_ENTRY_CACHE_SIZE);
+const mutableResolvedEntryLookupCache = createAsyncLookupCache(MUTABLE_RESOLVED_ENTRY_CACHE_SIZE);
+const fileSizeLookupCache = createAsyncLookupCache(FILE_SIZE_CACHE_SIZE);
+const thumbnailPathLookupCache = createAsyncLookupCache(THUMBNAIL_PATH_CACHE_SIZE);
 let mediaPort = null;
 let tree = null;
 let mediaDebugEnabled = false;
@@ -32,11 +85,73 @@ function logMediaDebug(event, data) {
         console.log(`[WorkerMedia] ${event}`);
     }
 }
+function createAsyncLookupCache(maxEntries) {
+    return {
+        values: new LRUCache(maxEntries),
+        inflight: new Map(),
+    };
+}
+function clearAsyncLookupCache(cache) {
+    cache.values.clear();
+    cache.inflight.clear();
+}
+function clearMediaLookupCaches() {
+    inflightRootWaits.clear();
+    clearAsyncLookupCache(directoryLookupCache);
+    clearAsyncLookupCache(resolvedEntryLookupCache);
+    clearAsyncLookupCache(mutableResolvedEntryLookupCache);
+    clearAsyncLookupCache(fileSizeLookupCache);
+    clearAsyncLookupCache(thumbnailPathLookupCache);
+}
+function getLookupTtlMs(value) {
+    return value == null ? IMMUTABLE_LOOKUP_CACHE_MISS_TTL_MS : IMMUTABLE_LOOKUP_CACHE_HIT_TTL_MS;
+}
+async function loadCachedLookup(cache, key, loader, ttlMsForValue) {
+    const now = Date.now();
+    const cached = cache.values.get(key);
+    if (cached && cached.expiresAt > now) {
+        return cached.value;
+    }
+    if (cached) {
+        cache.values.delete(key);
+    }
+    const inflight = cache.inflight.get(key);
+    if (inflight) {
+        return inflight;
+    }
+    const pending = loader()
+        .then((value) => {
+        const ttlMs = ttlMsForValue(value);
+        if (ttlMs > 0) {
+            cache.values.set(key, {
+                value,
+                expiresAt: Date.now() + ttlMs,
+            });
+        }
+        return value;
+    })
+        .finally(() => {
+        cache.inflight.delete(key);
+    });
+    cache.inflight.set(key, pending);
+    return pending;
+}
+function cidCacheKey(cid) {
+    return cid.key ? `${toHex(cid.hash)}?k=${toHex(cid.key)}` : toHex(cid.hash);
+}
+function sameCid(a, b) {
+    if (!a && !b)
+        return true;
+    if (!a || !b)
+        return false;
+    return cidCacheKey(a) === cidCacheKey(b);
+}
 /**
  * Initialize the media handler with the HashTree instance
  */
 export function initMediaHandler(hashTree) {
     tree = hashTree;
+    clearMediaLookupCaches();
 }
 /**
  * Register a MessagePort from the service worker for media streaming
@@ -44,6 +159,7 @@ export function initMediaHandler(hashTree) {
 export function registerMediaPort(port, debug) {
     mediaPort = port;
     mediaDebugEnabled = !!debug;
+    port.start?.();
     port.onmessage = async (e) => {
         const req = e.data;
         if (req.type === 'hashtree-file') {
@@ -137,7 +253,10 @@ async function handleMediaRequestByPath(req) {
         }
         // Navigate to file within tree if path specified
         if (filePath) {
-            const resolved = await tree.resolvePath(cid, filePath);
+            const resolved = await resolveMutableTreeEntry(npub, treeName, filePath, {
+                allowSingleSegmentRootFallback: false,
+                expectedMimeType: mimeType,
+            });
             if (!resolved) {
                 mediaPort.postMessage({
                     type: 'error',
@@ -231,7 +350,7 @@ function watchTreeRootForStream(npub, treeName, filePath, streamInfo) {
             // Navigate to file
             let fileCid = cid;
             if (filePath) {
-                const resolved = await tree.resolvePath(cid, filePath);
+                const resolved = await resolvePathFromDirectoryListings(cid, filePath);
                 if (!resolved) {
                     scheduleNext();
                     return;
@@ -275,7 +394,7 @@ function watchTreeRootForStream(npub, treeName, filePath, streamInfo) {
 async function handleSwFileRequest(req) {
     if (!tree || !mediaPort)
         return;
-    const { requestId, npub, nhash, treeName, path, start, end, mimeType, download } = req;
+    const { requestId, npub, nhash, treeName, path, start, end, rangeHeader, mimeType, download } = req;
     logMediaDebug('sw:request', {
         requestId,
         npub: npub ?? null,
@@ -284,81 +403,80 @@ async function handleSwFileRequest(req) {
         path,
         start,
         end: end ?? null,
+        rangeHeader: rangeHeader ?? null,
         mimeType,
         download: !!download,
     });
     try {
-        let cid = null;
+        let resolvedEntry = null;
         if (nhash) {
             // Direct nhash request - decode to CID
             const rootCid = nhashDecode(nhash);
-            // If path provided AND it contains a slash, navigate within the nhash directory
-            // Single filename without slashes is just a hint for MIME type - use rootCid directly
-            if (path && path.includes('/')) {
-                const entry = await tree.resolvePath(rootCid, path);
-                if (!entry) {
-                    sendSwError(requestId, 404, `File not found: ${path}`);
-                    return;
-                }
-                cid = entry.cid;
-            }
-            else if (path && !path.includes('/')) {
-                // Try to resolve as file within directory first
-                const entry = await tree.resolvePath(rootCid, path);
-                cid = entry ? entry.cid : rootCid;
-            }
-            else {
-                cid = rootCid;
+            resolvedEntry = await resolveEntryWithinRoot(rootCid, path || '', {
+                allowSingleSegmentRootFallback: true,
+                expectedMimeType: mimeType,
+            });
+            if (!resolvedEntry) {
+                sendSwError(requestId, 404, `File not found: ${path}`);
+                return;
             }
         }
         else if (npub && treeName) {
-            // Npub-based request - resolve through cached root
-            const rootCid = await waitForCachedRoot(npub, treeName);
-            if (!rootCid) {
-                sendSwError(requestId, 404, 'Tree not found');
+            // Npub-based request - resolve through mutable root history when needed
+            resolvedEntry = await resolveMutableTreeEntry(npub, treeName, path || '', {
+                allowSingleSegmentRootFallback: false,
+                expectedMimeType: mimeType,
+            });
+            if (!resolvedEntry) {
+                sendSwError(requestId, 404, 'File not found');
                 return;
             }
-            // Handle thumbnail requests without extension
-            let resolvedPath = path || '';
-            if (resolvedPath.endsWith('/thumbnail') || resolvedPath === 'thumbnail') {
-                const dirPath = resolvedPath.endsWith('/thumbnail')
-                    ? resolvedPath.slice(0, -'/thumbnail'.length)
-                    : '';
-                const actualPath = await findThumbnailInDir(rootCid, dirPath);
-                if (actualPath) {
-                    resolvedPath = actualPath;
-                }
-            }
-            // Navigate to file
-            if (resolvedPath) {
-                const entry = await tree.resolvePath(rootCid, resolvedPath);
-                if (!entry) {
-                    sendSwError(requestId, 404, 'File not found');
-                    return;
-                }
-                cid = entry.cid;
-            }
-            else {
-                cid = rootCid;
-            }
         }
-        if (!cid) {
+        if (!resolvedEntry?.cid) {
             sendSwError(requestId, 400, 'Invalid request');
             return;
         }
         // Get file size
-        const totalSize = await getFileSize(cid);
+        // Directory listings may report 0 for non-empty files when the actual byte size
+        // is not embedded in the tree node metadata. Treat that as unknown and resolve
+        // the real size from the file itself before building HTTP headers.
+        const knownSize = typeof resolvedEntry.size === 'number' && resolvedEntry.size > 0
+            ? resolvedEntry.size
+            : null;
+        const effectivePath = resolvedEntry.path ?? path;
+        const effectiveMimeType = (mimeType === 'application/octet-stream'
+            || isThumbnailAliasPath(path)
+            || isVideoAliasPath(path))
+            ? guessMimeTypeFromPath(effectivePath)
+            : mimeType;
+        const totalSize = knownSize ?? await getFileSize(resolvedEntry.cid);
         if (totalSize === null) {
-            sendSwError(requestId, 404, 'File data not found');
+            const canBufferWholeFile = !rangeHeader && start === 0 && end === undefined;
+            if (!canBufferWholeFile || typeof tree.readFile !== 'function') {
+                sendSwError(requestId, 404, 'File data not found');
+                return;
+            }
+            const fullData = await tree.readFile(resolvedEntry.cid);
+            if (!fullData) {
+                sendSwError(requestId, 404, 'File data not found');
+                return;
+            }
+            sendBufferedSwResponse(requestId, fullData, {
+                npub,
+                path: effectivePath,
+                mimeType: effectiveMimeType,
+                download,
+            });
             return;
         }
         // Stream the content
-        await streamSwResponse(requestId, cid, totalSize, {
+        await streamSwResponse(requestId, resolvedEntry.cid, totalSize, {
             npub,
-            path,
+            path: effectivePath,
             start,
             end,
-            mimeType,
+            rangeHeader,
+            mimeType: effectiveMimeType,
             download,
         });
     }
@@ -367,22 +485,72 @@ async function handleSwFileRequest(req) {
     }
 }
 async function waitForCachedRoot(npub, treeName) {
-    let cached = await getCachedRoot(npub, treeName);
+    const cached = await getCachedRoot(npub, treeName);
     if (cached)
         return cached;
+    const cacheKey = `${npub}/${treeName}`;
+    const inflight = inflightRootWaits.get(cacheKey);
+    if (inflight) {
+        return inflight;
+    }
     const pubkey = decodeNpubToPubkey(npub);
     if (pubkey) {
         subscribeToTreeRoots(pubkey);
     }
-    const deadline = Date.now() + ROOT_WAIT_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-        await new Promise((resolve) => setTimeout(resolve, ROOT_WAIT_INTERVAL_MS));
-        cached = await getCachedRoot(npub, treeName);
-        if (cached)
-            return cached;
-    }
-    logMediaDebug('root:timeout', { npub, treeName });
-    return null;
+    const pending = new Promise((resolve) => {
+        let settled = false;
+        const finish = (cid) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            unsubscribe();
+            resolve(cid);
+        };
+        const unsubscribe = onCachedRootUpdate((updatedNpub, updatedTreeName, cid) => {
+            if (updatedNpub === npub && updatedTreeName === treeName && cid) {
+                finish(cid);
+            }
+        });
+        const timeout = setTimeout(() => {
+            logMediaDebug('root:timeout', { npub, treeName });
+            finish(null);
+        }, ROOT_WAIT_TIMEOUT_MS);
+        void getCachedRoot(npub, treeName).then((current) => {
+            if (current) {
+                finish(current);
+            }
+        });
+        void resolveTreeRootNow(npub, treeName, ROOT_WAIT_TIMEOUT_MS).then((resolved) => {
+            if (resolved) {
+                finish(resolved);
+            }
+        }).catch(() => { });
+    }).finally(() => {
+        inflightRootWaits.delete(cacheKey);
+    });
+    inflightRootWaits.set(cacheKey, pending);
+    return pending;
+}
+async function resolveMutableTreeEntry(npub, treeName, path, options) {
+    const currentRoot = await waitForCachedRoot(npub, treeName);
+    const cacheKey = [
+        npub,
+        treeName,
+        currentRoot ? cidCacheKey(currentRoot) : 'none',
+        options?.allowSingleSegmentRootFallback ? 'root-fallback' : 'strict',
+        options?.expectedMimeType ?? '',
+        path,
+    ].join('|');
+    return loadCachedLookup(mutableResolvedEntryLookupCache, cacheKey, async () => {
+        if (currentRoot) {
+            const currentEntry = await resolveEntryWithinRoot(currentRoot, path, options);
+            if (currentEntry) {
+                return currentEntry;
+            }
+        }
+        return null;
+    }, (value) => getLookupTtlMs(value));
 }
 function decodeNpubToPubkey(npub) {
     if (!npub.startsWith('npub1'))
@@ -397,6 +565,405 @@ function decodeNpubToPubkey(npub) {
         return null;
     }
 }
+async function resolveEntryWithinRoot(rootCid, path, options) {
+    if (!tree)
+        return null;
+    const cacheKey = [
+        cidCacheKey(rootCid),
+        options?.allowSingleSegmentRootFallback ? 'root-fallback' : 'strict',
+        path,
+    ].join('|');
+    return loadCachedLookup(resolvedEntryLookupCache, cacheKey, async () => {
+        if (!path) {
+            return { cid: rootCid };
+        }
+        const resolvedThumbnail = await resolveThumbnailAliasEntry(rootCid, path);
+        if (resolvedThumbnail) {
+            return resolvedThumbnail;
+        }
+        if (isThumbnailAliasPath(path)) {
+            return null;
+        }
+        const resolvedPlayable = await resolvePlayableAliasEntry(rootCid, path);
+        if (resolvedPlayable) {
+            return resolvedPlayable;
+        }
+        if (isVideoAliasPath(path)) {
+            return null;
+        }
+        if (options?.allowSingleSegmentRootFallback &&
+            await canFallbackToRootBlob(rootCid, path, path, options?.expectedMimeType)) {
+            const isDirectory = await canListDirectory(rootCid);
+            if (!isDirectory) {
+                return { cid: rootCid };
+            }
+        }
+        if (options?.allowSingleSegmentRootFallback &&
+            !path.includes('/') &&
+            isExactThumbnailFilenamePath(path) &&
+            !(await canListDirectory(rootCid))) {
+            return null;
+        }
+        const entry = await resolvePathFromDirectoryListings(rootCid, path);
+        if (entry) {
+            return entry;
+        }
+        if (options?.allowSingleSegmentRootFallback &&
+            await canFallbackToRootBlob(rootCid, path, path, options?.expectedMimeType)) {
+            return { cid: rootCid };
+        }
+        return null;
+    }, (value) => getLookupTtlMs(value));
+}
+async function resolveCidWithinRoot(rootCid, path, options) {
+    return (await resolveEntryWithinRoot(rootCid, path, options))?.cid ?? null;
+}
+async function resolvePathFromDirectoryListings(rootCid, path) {
+    if (!tree)
+        return null;
+    const parts = path.split('/').filter(Boolean);
+    if (parts.length === 0) {
+        return { cid: rootCid };
+    }
+    let currentCid = rootCid;
+    for (let i = 0; i < parts.length; i += 1) {
+        const entries = await loadDirectoryListing(currentCid);
+        if (!entries) {
+            return null;
+        }
+        const entry = entries.find((candidate) => candidate.name === parts[i]);
+        if (!entry?.cid) {
+            return null;
+        }
+        if (i === parts.length - 1) {
+            return { cid: entry.cid, size: entry.size, path: parts.slice(0, i + 1).join('/') };
+        }
+        currentCid = entry.cid;
+    }
+    return null;
+}
+function hasImageBlobSignature(blob) {
+    if (blob.length >= 3 && blob[0] === 0xff && blob[1] === 0xd8 && blob[2] === 0xff) {
+        return true;
+    }
+    if (blob.length >= 8
+        && blob[0] === 0x89
+        && blob[1] === 0x50
+        && blob[2] === 0x4e
+        && blob[3] === 0x47
+        && blob[4] === 0x0d
+        && blob[5] === 0x0a
+        && blob[6] === 0x1a
+        && blob[7] === 0x0a) {
+        return true;
+    }
+    if (blob.length >= 12
+        && blob[0] === 0x52
+        && blob[1] === 0x49
+        && blob[2] === 0x46
+        && blob[3] === 0x46
+        && blob[8] === 0x57
+        && blob[9] === 0x45
+        && blob[10] === 0x42
+        && blob[11] === 0x50) {
+        return true;
+    }
+    if (blob.length >= 6
+        && blob[0] === 0x47
+        && blob[1] === 0x49
+        && blob[2] === 0x46
+        && blob[3] === 0x38
+        && (blob[4] === 0x37 || blob[4] === 0x39)
+        && blob[5] === 0x61) {
+        return true;
+    }
+    return false;
+}
+function readAscii(blob, start, end) {
+    return String.fromCharCode(...blob.slice(start, end));
+}
+function sniffPlayableMediaExtension(blob) {
+    if (!blob.length)
+        return null;
+    if (blob.length >= 12 && readAscii(blob, 4, 8) === 'ftyp') {
+        const brand = readAscii(blob, 8, 12).toLowerCase();
+        if (brand.startsWith('m4a'))
+            return '.m4a';
+        if (brand.startsWith('qt'))
+            return '.mov';
+        return '.mp4';
+    }
+    if (blob.length >= 4
+        && blob[0] === 0x1a
+        && blob[1] === 0x45
+        && blob[2] === 0xdf
+        && blob[3] === 0xa3) {
+        const lowerHeader = readAscii(blob, 0, Math.min(blob.length, 64)).toLowerCase();
+        return lowerHeader.includes('webm') ? '.webm' : '.mkv';
+    }
+    if (blob.length >= 4 && readAscii(blob, 0, 4) === 'OggS') {
+        return '.ogg';
+    }
+    if (blob.length >= 4 && readAscii(blob, 0, 4) === 'fLaC') {
+        return '.flac';
+    }
+    if (blob.length >= 12
+        && readAscii(blob, 0, 4) === 'RIFF'
+        && readAscii(blob, 8, 12) === 'WAVE') {
+        return '.wav';
+    }
+    if (blob.length >= 3 && readAscii(blob, 0, 3) === 'ID3') {
+        return '.mp3';
+    }
+    if (blob.length >= 2 && blob[0] === 0xff && (blob[1] & 0xf6) === 0xf0) {
+        return '.aac';
+    }
+    if (blob.length >= 2 && blob[0] === 0xff && (blob[1] & 0xe0) === 0xe0) {
+        return '.mp3';
+    }
+    return null;
+}
+function guessMimeTypeFromPath(path) {
+    const ext = path?.split('.').pop()?.toLowerCase() ?? '';
+    return MIME_TYPES[ext] || 'application/octet-stream';
+}
+async function canFallbackToRootBlob(rootCid, resolvedPath, originalPath, expectedMimeType) {
+    if (resolvedPath !== originalPath)
+        return false;
+    if (resolvedPath.includes('/'))
+        return false;
+    if (isExactThumbnailFilenamePath(resolvedPath)) {
+        if (!expectedMimeType?.startsWith('image/')) {
+            return false;
+        }
+        if (!tree) {
+            return false;
+        }
+        try {
+            if (typeof tree.readFileRange === 'function') {
+                const header = await tree.readFileRange(rootCid, 0, 64);
+                return !!header && hasImageBlobSignature(header);
+            }
+            if (typeof tree.getBlob === 'function') {
+                const blob = await tree.getBlob(rootCid.hash);
+                return !!blob && hasImageBlobSignature(blob);
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    return /\.[A-Za-z0-9]{1,16}$/.test(resolvedPath);
+}
+function isThumbnailAliasPath(path) {
+    return path === 'thumbnail' || path.endsWith('/thumbnail');
+}
+function isVideoAliasPath(path) {
+    return path === 'video' || path.endsWith('/video');
+}
+function isExactThumbnailFilenamePath(path) {
+    const fileName = path.split('/').filter(Boolean).at(-1)?.toLowerCase() ?? '';
+    return fileName.startsWith('thumbnail.');
+}
+function isImageFileName(fileName) {
+    const normalized = fileName.trim().toLowerCase();
+    return normalized.endsWith('.jpg')
+        || normalized.endsWith('.jpeg')
+        || normalized.endsWith('.png')
+        || normalized.endsWith('.webp');
+}
+function findThumbnailFileEntry(entries) {
+    for (const pattern of THUMBNAIL_PATTERNS) {
+        const directMatch = entries.find((entry) => entry.name === pattern && entry.cid);
+        if (directMatch?.cid) {
+            return directMatch;
+        }
+    }
+    return entries.find((entry) => isImageFileName(entry.name) && entry.cid) ?? null;
+}
+function resolveEmbeddedThumbnailLookup(value, entries, dirPath) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (trimmed.startsWith('nhash1')) {
+        try {
+            return {
+                path: dirPath ? `${dirPath}/thumbnail` : 'thumbnail',
+                cid: nhashDecode(trimmed),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    const normalized = trimmed
+        .split('?')[0]
+        ?.split('#')[0]
+        ?.split('/')
+        .filter(Boolean)
+        .at(-1);
+    if (!normalized) {
+        return null;
+    }
+    const entry = entries.find((candidate) => candidate.name === normalized && candidate.cid);
+    if (!entry?.cid) {
+        return null;
+    }
+    return {
+        path: dirPath ? `${dirPath}/${entry.name}` : entry.name,
+        cid: entry.cid,
+        size: entry.size,
+    };
+}
+async function resolveThumbnailLookupFromMetadata(entries, dirPath) {
+    if (!tree) {
+        return null;
+    }
+    const playableEntry = entries.find((entry) => isPlayableMediaFileName(entry.name));
+    const playableThumbnail = playableEntry?.meta && typeof playableEntry.meta.thumbnail === 'string'
+        ? playableEntry.meta.thumbnail
+        : null;
+    const embeddedPlayableThumbnail = resolveEmbeddedThumbnailLookup(playableThumbnail, entries, dirPath);
+    if (embeddedPlayableThumbnail) {
+        return embeddedPlayableThumbnail;
+    }
+    for (const metadataName of ['metadata.json', 'info.json']) {
+        const metadataEntry = entries.find((entry) => entry.name === metadataName && entry.cid);
+        if (!metadataEntry?.cid) {
+            continue;
+        }
+        try {
+            const metadataData = await tree.readFile(metadataEntry.cid);
+            if (!metadataData) {
+                continue;
+            }
+            const parsed = JSON.parse(new TextDecoder().decode(metadataData));
+            const embeddedThumbnail = resolveEmbeddedThumbnailLookup(parsed?.thumbnail, entries, dirPath);
+            if (embeddedThumbnail) {
+                return embeddedThumbnail;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+async function findThumbnailLookupInEntries(entries, dirPath) {
+    const directThumbnail = findThumbnailFileEntry(entries);
+    if (directThumbnail?.cid) {
+        return {
+            path: dirPath ? `${dirPath}/${directThumbnail.name}` : directThumbnail.name,
+            cid: directThumbnail.cid,
+            size: directThumbnail.size,
+        };
+    }
+    return await resolveThumbnailLookupFromMetadata(entries, dirPath);
+}
+async function detectDirectPlayableLookup(cid, dirPath) {
+    if (!tree || typeof tree.readFileRange !== 'function') {
+        return null;
+    }
+    try {
+        const header = await tree.readFileRange(cid, 0, 64);
+        if (!(header instanceof Uint8Array) || header.length === 0) {
+            return null;
+        }
+        const extension = sniffPlayableMediaExtension(header);
+        if (!extension) {
+            return null;
+        }
+        const fileName = `video${extension}`;
+        return {
+            cid,
+            path: dirPath ? `${dirPath}/${fileName}` : fileName,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function findPlayableLookupInEntries(entries, dirPath) {
+    const playableEntry = entries.find((entry) => isPlayableMediaFileName(entry.name) && entry.cid);
+    if (!playableEntry?.cid) {
+        return null;
+    }
+    return {
+        cid: playableEntry.cid,
+        size: playableEntry.size,
+        path: dirPath ? `${dirPath}/${playableEntry.name}` : playableEntry.name,
+    };
+}
+async function normalizeAliasPath(rootCid, path) {
+    if (!path)
+        return '';
+    const resolvedThumbnail = await resolveThumbnailAliasEntry(rootCid, path);
+    if (resolvedThumbnail) {
+        return resolvedThumbnail.path;
+    }
+    const resolvedPlayable = await resolvePlayableAliasEntry(rootCid, path);
+    if (resolvedPlayable?.path) {
+        return resolvedPlayable.path;
+    }
+    return path;
+}
+async function canListDirectory(rootCid) {
+    if (!tree)
+        return false;
+    try {
+        if ('isDirectory' in tree && typeof tree.isDirectory === 'function') {
+            return await tree.isDirectory(rootCid);
+        }
+        const entries = await listDirectoryWithProbeTimeout(rootCid);
+        return Array.isArray(entries);
+    }
+    catch {
+        return false;
+    }
+}
+export const __test__ = {
+    resolveCidWithinRoot,
+    resolveMutableTreeEntry,
+    normalizeAliasPath,
+    canListDirectory,
+    waitForCachedRoot,
+};
+async function resolveThumbnailAliasEntry(rootCid, path) {
+    if (!isThumbnailAliasPath(path)) {
+        return null;
+    }
+    const dirPath = path.endsWith('/thumbnail')
+        ? path.slice(0, -'/thumbnail'.length)
+        : '';
+    return findThumbnailLookupInDir(rootCid, dirPath);
+}
+async function resolvePlayableAliasEntry(rootCid, path) {
+    if (!isVideoAliasPath(path)) {
+        return null;
+    }
+    const dirPath = path.endsWith('/video')
+        ? path.slice(0, -'/video'.length)
+        : '';
+    return findPlayableLookupInDir(rootCid, dirPath);
+}
+async function loadDirectoryListing(cid) {
+    if (!tree)
+        return null;
+    return loadCachedLookup(directoryLookupCache, cidCacheKey(cid), async () => tree.listDirectory(cid), (value) => getLookupTtlMs(value));
+}
+async function listDirectoryWithProbeTimeout(cid) {
+    if (!tree)
+        return null;
+    return Promise.race([
+        loadDirectoryListing(cid),
+        new Promise((resolve) => setTimeout(() => resolve(null), DIRECTORY_PROBE_TIMEOUT_MS)),
+    ]);
+}
 /**
  * Send error response to SW
  */
@@ -417,46 +984,112 @@ function sendSwError(requestId, status, message) {
 async function getFileSize(cid) {
     if (!tree)
         return null;
-    const treeNode = await tree.getTreeNode(cid);
-    if (treeNode) {
-        // Chunked file - sum link sizes from decrypted tree node
-        return treeNode.links.reduce((sum, l) => sum + l.size, 0);
-    }
-    // Single blob - fetch to check existence and get size
-    const blob = await tree.getBlob(cid.hash);
-    if (!blob)
-        return null;
-    // For encrypted blobs, decrypted size = encrypted size - 16 (nonce overhead)
-    return cid.key ? Math.max(0, blob.length - 16) : blob.length;
+    return loadCachedLookup(fileSizeLookupCache, cidCacheKey(cid), async () => {
+        const treeNode = await tree.getTreeNode(cid);
+        if (treeNode) {
+            // Chunked file - sum link sizes from decrypted tree node
+            return treeNode.links.reduce((sum, l) => sum + l.size, 0);
+        }
+        // Single blob - fetch to check existence and get size
+        const blob = await tree.getBlob(cid.hash);
+        if (!blob)
+            return null;
+        // For encrypted blobs, decrypted size = encrypted size - 16 (nonce overhead)
+        return cid.key ? Math.max(0, blob.length - 16) : blob.length;
+    }, (value) => getLookupTtlMs(value));
 }
 /**
  * Find actual thumbnail file in a directory
  */
-async function findThumbnailInDir(rootCid, dirPath) {
+async function findThumbnailLookupInDir(rootCid, dirPath) {
     if (!tree)
         return null;
-    try {
-        // Get directory CID
-        const dirEntry = dirPath
-            ? await tree.resolvePath(rootCid, dirPath)
-            : { cid: rootCid };
-        if (!dirEntry)
+    return loadCachedLookup(thumbnailPathLookupCache, `${cidCacheKey(rootCid)}|${dirPath}`, async () => {
+        try {
+            const dirEntry = dirPath
+                ? await resolvePathFromDirectoryListings(rootCid, dirPath)
+                : { cid: rootCid };
+            if (!dirEntry)
+                return null;
+            const entries = await listDirectoryWithProbeTimeout(dirEntry.cid);
+            if (!entries)
+                return null;
+            const rootThumbnail = await findThumbnailLookupInEntries(entries, dirPath);
+            if (rootThumbnail) {
+                return rootThumbnail;
+            }
+            const hasPlayableMediaFile = entries.some((entry) => isPlayableMediaFileName(entry.name));
+            if (!hasPlayableMediaFile && entries.length > 0) {
+                const sortedEntries = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+                for (const entry of sortedEntries.slice(0, 3)) {
+                    if (entry.name.endsWith('.json') || entry.name.endsWith('.txt')) {
+                        continue;
+                    }
+                    try {
+                        const subEntries = await listDirectoryWithProbeTimeout(entry.cid);
+                        if (!subEntries) {
+                            continue;
+                        }
+                        const prefix = dirPath ? `${dirPath}/${entry.name}` : entry.name;
+                        const nestedThumbnail = await findThumbnailLookupInEntries(subEntries, prefix);
+                        if (nestedThumbnail) {
+                            return nestedThumbnail;
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
             return null;
-        // List directory contents
-        const entries = await tree.listDirectory(dirEntry.cid);
-        if (!entries)
+        }
+        catch {
             return null;
-        // Find first matching thumbnail pattern
-        for (const pattern of THUMBNAIL_PATTERNS) {
-            if (entries.some(e => e.name === pattern)) {
-                return dirPath ? `${dirPath}/${pattern}` : pattern;
-            }
         }
+    }, (value) => getLookupTtlMs(value));
+}
+async function findPlayableLookupInDir(rootCid, dirPath) {
+    if (!tree)
         return null;
-    }
-    catch {
-        return null;
-    }
+    return loadCachedLookup(resolvedEntryLookupCache, `${cidCacheKey(rootCid)}|video|${dirPath}`, async () => {
+        try {
+            const dirEntry = dirPath
+                ? await resolvePathFromDirectoryListings(rootCid, dirPath)
+                : { cid: rootCid, path: '' };
+            if (!dirEntry)
+                return null;
+            const entries = await listDirectoryWithProbeTimeout(dirEntry.cid);
+            if (entries && entries.length > 0) {
+                const directPlayable = findPlayableLookupInEntries(entries, dirPath);
+                if (directPlayable) {
+                    return directPlayable;
+                }
+                const sortedEntries = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+                for (const entry of sortedEntries.slice(0, 3)) {
+                    if (entry.name.endsWith('.json') || entry.name.endsWith('.txt') || !entry.cid) {
+                        continue;
+                    }
+                    const prefix = dirPath ? `${dirPath}/${entry.name}` : entry.name;
+                    const subEntries = await listDirectoryWithProbeTimeout(entry.cid);
+                    if (!subEntries || subEntries.length === 0) {
+                        const directPlayableChild = await detectDirectPlayableLookup(entry.cid, prefix);
+                        if (directPlayableChild) {
+                            return directPlayableChild;
+                        }
+                        continue;
+                    }
+                    const nestedPlayable = findPlayableLookupInEntries(subEntries, prefix);
+                    if (nestedPlayable) {
+                        return nestedPlayable;
+                    }
+                }
+            }
+            return await detectDirectPlayableLookup(dirEntry.cid, dirPath);
+        }
+        catch {
+            return null;
+        }
+    }, (value) => getLookupTtlMs(value));
 }
 /**
  * Stream response to SW with proper HTTP headers
@@ -464,9 +1097,20 @@ async function findThumbnailInDir(rootCid, dirPath) {
 async function streamSwResponse(requestId, cid, totalSize, options) {
     if (!tree || !mediaPort)
         return;
-    const { npub, path, start = 0, end, mimeType = 'application/octet-stream', download } = options;
-    const rangeStart = start;
-    const rangeEnd = end !== undefined ? Math.min(end, totalSize - 1) : totalSize - 1;
+    const { npub, path, start = 0, end, rangeHeader, mimeType = 'application/octet-stream', download } = options;
+    let rangeStart = start;
+    let rangeEnd = end !== undefined ? Math.min(end, totalSize - 1) : totalSize - 1;
+    if (rangeHeader) {
+        const parsedRange = parseHttpByteRange(rangeHeader, totalSize);
+        if (parsedRange.kind === 'range') {
+            rangeStart = parsedRange.range.start;
+            rangeEnd = parsedRange.range.endInclusive;
+        }
+        else if (parsedRange.kind === 'unsatisfiable') {
+            sendSwError(requestId, 416, `Range not satisfiable for ${totalSize} byte file`);
+            return;
+        }
+    }
     const contentLength = rangeEnd - rangeStart + 1;
     // Build cache control header
     const isNpubRequest = !!npub;
@@ -493,7 +1137,7 @@ async function streamSwResponse(requestId, cid, totalSize, options) {
         headers['Content-Disposition'] = `attachment; filename="${filename}"`;
     }
     // Determine status (206 for range requests)
-    const isRangeRequest = end !== undefined || start > 0;
+    const isRangeRequest = !!rangeHeader || end !== undefined || start > 0;
     const status = isRangeRequest ? 206 : 200;
     if (isRangeRequest) {
         headers['Content-Range'] = `bytes ${rangeStart}-${rangeEnd}/${totalSize}`;
@@ -526,4 +1170,96 @@ async function streamSwResponse(requestId, cid, totalSize, options) {
     // Signal done
     mediaPort.postMessage({ type: 'done', requestId });
 }
+function sendBufferedSwResponse(requestId, data, options) {
+    if (!mediaPort)
+        return;
+    const { npub, path, mimeType = 'application/octet-stream', download } = options;
+    const isNpubRequest = !!npub;
+    const isImage = mimeType.startsWith('image/');
+    let cacheControl;
+    if (!isNpubRequest) {
+        cacheControl = 'public, max-age=31536000, immutable';
+    }
+    else if (isImage) {
+        cacheControl = 'public, max-age=60, stale-while-revalidate=86400';
+    }
+    else {
+        cacheControl = 'no-cache, no-store, must-revalidate';
+    }
+    const headers = {
+        'Content-Type': mimeType,
+        'Content-Length': String(data.length),
+        'Cache-Control': cacheControl,
+    };
+    if (download) {
+        headers['Content-Disposition'] = `attachment; filename="${path || 'file'}"`;
+    }
+    mediaPort.postMessage({
+        type: 'headers',
+        requestId,
+        status: 200,
+        headers,
+        totalSize: data.length,
+    });
+    mediaPort.postMessage({ type: 'chunk', requestId, data }, [data.buffer]);
+    mediaPort.postMessage({ type: 'done', requestId });
+}
+function parseHttpByteRange(rangeHeader, totalSize) {
+    if (!rangeHeader)
+        return { kind: 'unsupported' };
+    const bytesRange = rangeHeader.startsWith('bytes=')
+        ? rangeHeader.slice('bytes='.length)
+        : null;
+    if (!bytesRange || bytesRange.includes(','))
+        return { kind: 'unsupported' };
+    if (totalSize <= 0)
+        return { kind: 'unsatisfiable' };
+    const parts = bytesRange.split('-', 2);
+    if (parts.length !== 2)
+        return { kind: 'unsupported' };
+    const [startPart, endPart] = parts;
+    if (!startPart) {
+        const suffixLength = Number.parseInt(endPart, 10);
+        if (!Number.isFinite(suffixLength) || suffixLength <= 0) {
+            return { kind: 'unsatisfiable' };
+        }
+        const clampedSuffix = Math.min(suffixLength, totalSize);
+        return {
+            kind: 'range',
+            range: {
+                start: totalSize - clampedSuffix,
+                endInclusive: totalSize - 1,
+            },
+        };
+    }
+    const start = Number.parseInt(startPart, 10);
+    if (!Number.isFinite(start) || start < 0 || start >= totalSize) {
+        return { kind: 'unsatisfiable' };
+    }
+    const endInclusive = endPart ? Number.parseInt(endPart, 10) : totalSize - 1;
+    if (!Number.isFinite(endInclusive) || endInclusive < start) {
+        return { kind: 'unsatisfiable' };
+    }
+    return {
+        kind: 'range',
+        range: {
+            start,
+            endInclusive: Math.min(endInclusive, totalSize - 1),
+        },
+    };
+}
+function isPlayableMediaFileName(name) {
+    const normalized = name.trim().toLowerCase();
+    if (!normalized || normalized.endsWith('/')) {
+        return false;
+    }
+    if (normalized.startsWith('video.')) {
+        return true;
+    }
+    const lastDot = normalized.lastIndexOf('.');
+    if (lastDot === -1) {
+        return false;
+    }
+    return PLAYABLE_MEDIA_EXTENSION_SET.has(normalized.slice(lastDot));
+}
 //# sourceMappingURL=mediaHandler.js.map