retold-remote 0.0.5 → 0.0.7

package/source/server/RetoldRemote-ParimeCache.js

@@ -0,0 +1,349 @@
+/**
+ * Retold Remote -- Parime Cache Adapter
+ *
+ * Wraps parime's ParimeBinaryStorage as a unified cache layer for
+ * retold-remote.  Supports two modes:
+ *
+ *   1. Embedded (default): ParimeBinaryStorage accessed directly in-process.
+ *   2. Remote: If fable.settings.ParimeCacheServer is a URL, all cache
+ *      operations route through HTTP to a remote parime server.
+ *
+ * This adapter provides helper methods for cache key generation and
+ * passthrough access to the underlying storage.
+ */
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+const libCrypto = require('crypto');
+
+class RetoldRemoteParimeCache extends libFableServiceProviderBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'RetoldRemoteParimeCache';
+
+		this._remoteURL = (typeof(this.fable.settings.ParimeCacheServer) === 'string'
+			&& this.fable.settings.ParimeCacheServer.length > 0)
+			? this.fable.settings.ParimeCacheServer.replace(/\/+$/, '')
+			: null;
+	}
+
+	/**
+	 * Whether this adapter is operating in remote mode.
+	 *
+	 * @returns {boolean}
+	 */
+	get isRemote()
+	{
+		return this._remoteURL !== null;
+	}
+
+	/**
+	 * Build a cache key from an array of components.
+	 *
+	 * Components are joined with ':' and hashed with SHA-256.
+	 * Optionally truncate to pHashLength characters.
+	 *
+	 * @param {Array<string|number>} pComponents - Values to include in the key.
+	 * @param {number} [pHashLength] - Truncate the hash to this many hex chars.
+	 * @returns {string} The hex hash.
+	 */
+	buildCacheKey(pComponents, pHashLength)
+	{
+		let tmpInput = pComponents.join(':');
+		let tmpHash = libCrypto.createHash('sha256').update(tmpInput).digest('hex');
+		if (typeof(pHashLength) === 'number' && pHashLength > 0)
+		{
+			return tmpHash.substring(0, pHashLength);
+		}
+		return tmpHash;
+	}
+
+	/**
+	 * Get the underlying ParimeBinaryStorage service.
+	 *
+	 * @returns {object} The ParimeBinaryStorage instance.
+	 */
+	get storage()
+	{
+		return this.fable.ParimeBinaryStorage;
+	}
+
+	/**
+	 * Resolve a category + key to an absolute filesystem path.
+	 *
+	 * Only valid in embedded mode (not remote).
+	 *
+	 * @param {string} pCategory - The cache category.
+	 * @param {string} pKey - The cache key.
+	 * @returns {string} Absolute file path.
+	 */
+	resolvePath(pCategory, pKey)
+	{
+		return this.fable.ParimeBinaryStorage.resolvePath(pCategory, pKey);
+	}
+
+	/**
+	 * Check if a cached item exists.
+	 *
+	 * @param {string} pCategory - The cache category.
+	 * @param {string} pKey - The cache key.
+	 * @param {function} fCallback - Callback(pError, pExists).
+	 */
+	exists(pCategory, pKey, fCallback)
+	{
+		if (this._remoteURL)
+		{
+			return this._remoteExists(pCategory, pKey, fCallback);
+		}
+		return this.fable.ParimeBinaryStorage.exists(pCategory, pKey, fCallback);
+	}
+
+	/**
+	 * Read a cached item.
+	 *
+	 * @param {string} pCategory - The cache category.
+	 * @param {string} pKey - The cache key.
+	 * @param {function} fCallback - Callback(pError, pBuffer).
+	 */
+	read(pCategory, pKey, fCallback)
+	{
+		if (this._remoteURL)
+		{
+			return this._remoteRead(pCategory, pKey, fCallback);
+		}
+		return this.fable.ParimeBinaryStorage.read(pCategory, pKey, fCallback);
+	}
+
+	/**
+	 * Write a cached item.
+	 *
+	 * @param {string} pCategory - The cache category.
+	 * @param {string} pKey - The cache key.
+	 * @param {Buffer} pBuffer - The data to write.
+	 * @param {function} fCallback - Callback(pError).
+	 */
+	write(pCategory, pKey, pBuffer, fCallback)
+	{
+		if (this._remoteURL)
+		{
+			return this._remoteWrite(pCategory, pKey, pBuffer, fCallback);
+		}
+		return this.fable.ParimeBinaryStorage.write(pCategory, pKey, pBuffer, fCallback);
+	}
+
+	/**
+	 * Get a readable stream for a cached item.
+	 *
+	 * Only valid in embedded mode.
+	 *
+	 * @param {string} pCategory - The cache category.
+	 * @param {string} pKey - The cache key.
+	 * @param {object} [pOptions] - Stream options ({ start, end }).
+	 * @returns {ReadStream}
+	 */
+	readStream(pCategory, pKey, pOptions)
+	{
+		return this.fable.ParimeBinaryStorage.readStream(pCategory, pKey, pOptions);
+	}
+
+	/**
+	 * Get file stats for a cached item.
+	 *
+	 * @param {string} pCategory - The cache category.
+	 * @param {string} pKey - The cache key.
+	 * @param {function} fCallback - Callback(pError, pStats).
+	 */
+	stat(pCategory, pKey, fCallback)
+	{
+		if (this._remoteURL)
+		{
+			return this._remoteStat(pCategory, pKey, fCallback);
+		}
+		return this.fable.ParimeBinaryStorage.stat(pCategory, pKey, fCallback);
+	}
+
+	/**
+	 * Delete a cached item.
+	 *
+	 * @param {string} pCategory - The cache category.
+	 * @param {string} pKey - The cache key.
+	 * @param {function} fCallback - Callback(pError).
+	 */
+	delete(pCategory, pKey, fCallback)
+	{
+		if (this._remoteURL)
+		{
+			return this._remoteDelete(pCategory, pKey, fCallback);
+		}
+		return this.fable.ParimeBinaryStorage.delete(pCategory, pKey, fCallback);
+	}
+
+	// ── Remote mode helpers ──────────────────────────────────────
+
+	/**
+	 * @private
+	 */
+	_remoteExists(pCategory, pKey, fCallback)
+	{
+		let tmpURL = `${this._remoteURL}/1.0/Binary/${encodeURIComponent(pCategory)}/${pKey}/Stat`;
+		let libHTTP = require('http');
+		let tmpParsed = new URL(tmpURL);
+
+		let tmpReq = libHTTP.request(
+			{
+				hostname: tmpParsed.hostname,
+				port: tmpParsed.port,
+				path: tmpParsed.pathname,
+				method: 'GET'
+			},
+			(pResponse) =>
+			{
+				let tmpChunks = [];
+				pResponse.on('data', (pChunk) => { tmpChunks.push(pChunk); });
+				pResponse.on('end', () =>
+				{
+					return fCallback(null, pResponse.statusCode === 200);
+				});
+			});
+		tmpReq.on('error', (pError) => { return fCallback(pError); });
+		tmpReq.end();
+	}
+
+	/**
+	 * @private
+	 */
+	_remoteRead(pCategory, pKey, fCallback)
+	{
+		let tmpURL = `${this._remoteURL}/1.0/Binary/${encodeURIComponent(pCategory)}/${pKey}`;
+		let libHTTP = require('http');
+		let tmpParsed = new URL(tmpURL);
+
+		let tmpReq = libHTTP.request(
+			{
+				hostname: tmpParsed.hostname,
+				port: tmpParsed.port,
+				path: tmpParsed.pathname,
+				method: 'GET'
+			},
+			(pResponse) =>
+			{
+				if (pResponse.statusCode === 404)
+				{
+					pResponse.resume();
+					return fCallback(null, null);
+				}
+				let tmpChunks = [];
+				pResponse.on('data', (pChunk) => { tmpChunks.push(pChunk); });
+				pResponse.on('end', () =>
+				{
+					return fCallback(null, Buffer.concat(tmpChunks));
+				});
+			});
+		tmpReq.on('error', (pError) => { return fCallback(pError); });
+		tmpReq.end();
+	}
+
+	/**
+	 * @private
+	 */
+	_remoteWrite(pCategory, pKey, pBuffer, fCallback)
+	{
+		let tmpURL = `${this._remoteURL}/1.0/Binary/${encodeURIComponent(pCategory)}/${pKey}`;
+		let libHTTP = require('http');
+		let tmpParsed = new URL(tmpURL);
+
+		let tmpReq = libHTTP.request(
+			{
+				hostname: tmpParsed.hostname,
+				port: tmpParsed.port,
+				path: tmpParsed.pathname,
+				method: 'PUT',
+				headers: { 'Content-Type': 'application/octet-stream' }
+			},
+			(pResponse) =>
+			{
+				pResponse.resume();
+				pResponse.on('end', () =>
+				{
+					return fCallback(pResponse.statusCode >= 400
+						? new Error(`Remote write failed: ${pResponse.statusCode}`)
+						: null);
+				});
+			});
+		tmpReq.on('error', (pError) => { return fCallback(pError); });
+		tmpReq.write(pBuffer);
+		tmpReq.end();
+	}
+
+	/**
+	 * @private
+	 */
+	_remoteStat(pCategory, pKey, fCallback)
+	{
+		let tmpURL = `${this._remoteURL}/1.0/Binary/${encodeURIComponent(pCategory)}/${pKey}/Stat`;
+		let libHTTP = require('http');
+		let tmpParsed = new URL(tmpURL);
+
+		let tmpReq = libHTTP.request(
+			{
+				hostname: tmpParsed.hostname,
+				port: tmpParsed.port,
+				path: tmpParsed.pathname,
+				method: 'GET'
+			},
+			(pResponse) =>
+			{
+				let tmpChunks = [];
+				pResponse.on('data', (pChunk) => { tmpChunks.push(pChunk); });
+				pResponse.on('end', () =>
+				{
+					if (pResponse.statusCode === 404)
+					{
+						return fCallback(null, null);
+					}
+					try
+					{
+						let tmpBody = JSON.parse(Buffer.concat(tmpChunks).toString());
+						return fCallback(null, { size: tmpBody.Size });
+					}
+					catch (pError)
+					{
+						return fCallback(pError);
+					}
+				});
+			});
+		tmpReq.on('error', (pError) => { return fCallback(pError); });
+		tmpReq.end();
+	}
+
+	/**
+	 * @private
+	 */
+	_remoteDelete(pCategory, pKey, fCallback)
+	{
+		let tmpURL = `${this._remoteURL}/1.0/Binary/${encodeURIComponent(pCategory)}/${pKey}`;
+		let libHTTP = require('http');
+		let tmpParsed = new URL(tmpURL);
+
+		let tmpReq = libHTTP.request(
+			{
+				hostname: tmpParsed.hostname,
+				port: tmpParsed.port,
+				path: tmpParsed.pathname,
+				method: 'DELETE'
+			},
+			(pResponse) =>
+			{
+				pResponse.resume();
+				pResponse.on('end', () =>
+				{
+					return fCallback(null);
+				});
+			});
+		tmpReq.on('error', (pError) => { return fCallback(pError); });
+		tmpReq.end();
+	}
+}
+
+module.exports = RetoldRemoteParimeCache;

package/source/server/RetoldRemote-ThumbnailCache.js

@@ -1,45 +1,67 @@
 /**
  * Retold Remote -- Filesystem Thumbnail Cache
  *
- * Caches generated thumbnails as files in a hidden directory under the
- * content root.  Cache keys are derived from the file path, modification
- * time, and requested dimensions so that stale entries are automatically
- * invalidated when the source file changes.
+ * Caches generated thumbnails using Parime's ParimeBinaryStorage.
+ * Cache keys use a two-level structure: a folder hash derived from
+ * the source file's directory, and a file-specific hash derived from
+ * the filename, modification time, and requested dimensions.
+ *
+ * This means all thumbnails for images in the same folder are
+ * co-located under the same shard directory — browsing a gallery
+ * folder of 10,000 images creates entries in ONE shard directory
+ * rather than 10,000 separate shard paths.
+ *
+ * Stale entries are automatically invalidated when the source file
+ * changes (because mtime is part of the file-specific hash).
  */
 const libFs = require('fs');
 const libPath = require('path');
 const libCrypto = require('crypto');
 
+const _CATEGORY = 'thumbnails';
+
 class ThumbnailCache
 {
 	/**
-	 * @param {string} pCachePath - Absolute path to the cache directory
+	 * @param {object} pFable - The Fable instance (must have ParimeBinaryStorage wired)
 	 */
-	constructor(pCachePath)
+	constructor(pFable)
 	{
-		this._cachePath = pCachePath;
-
-		// Ensure the cache directory exists
-		if (!libFs.existsSync(this._cachePath))
-		{
-			libFs.mkdirSync(this._cachePath, { recursive: true });
-		}
+		this._fable = pFable;
+		this._storage = pFable.ParimeBinaryStorage;
 	}
 
 	/**
 	 * Build a cache key from the source file path, its mtime, and the
 	 * requested thumbnail dimensions.
 	 *
+	 * The key has two parts separated by a slash:
+	 *   {folderHash}/{fileHash}
+	 *
+	 * The folder hash groups all thumbnails from the same directory
+	 * together so they land in the same shard directory on disk.
+	 * The file hash uniquely identifies a particular file at a
+	 * particular mtime and dimension.
+	 *
 	 * @param {string} pFilePath   - Relative path to the source file
 	 * @param {number} pMtime      - Source file mtime (ms since epoch)
 	 * @param {number} pWidth      - Thumbnail width
 	 * @param {number} pHeight     - Thumbnail height
-	 * @returns {string} A hex hash suitable for use as a filename
+	 * @returns {string} A composite key "{folderHash}/{fileHash}"
 	 */
 	buildKey(pFilePath, pMtime, pWidth, pHeight)
 	{
-		let tmpInput = `${pFilePath}:${pMtime}:${pWidth}x${pHeight}`;
-		return libCrypto.createHash('sha256').update(tmpInput).digest('hex');
+		let tmpDir = libPath.dirname(pFilePath);
+		let tmpFile = libPath.basename(pFilePath);
+
+		// Folder hash — first 16 hex chars; used for sharding and co-location
+		let tmpFolderHash = libCrypto.createHash('sha256').update(tmpDir).digest('hex').substring(0, 16);
+
+		// File-specific hash — full 64 hex chars; unique per file + dimensions
+		let tmpFileInput = `${tmpFile}:${pMtime}:${pWidth}x${pHeight}`;
+		let tmpFileHash = libCrypto.createHash('sha256').update(tmpFileInput).digest('hex');
+
+		return `${tmpFolderHash}/${tmpFileHash}`;
 	}
 
 	/**
@@ -52,7 +74,8 @@ class ThumbnailCache
 	 */
 	get(pKey, pFormat)
 	{
-		let tmpPath = libPath.join(this._cachePath, `${pKey}.${pFormat || 'webp'}`);
+		let tmpFileKey = `${pKey}.${pFormat || 'webp'}`;
+		let tmpPath = this._storage.resolvePath(_CATEGORY, tmpFileKey);
 		if (libFs.existsSync(tmpPath))
 		{
 			return tmpPath;
@@ -70,19 +93,28 @@ class ThumbnailCache
 	 */
 	put(pKey, pBuffer, pFormat)
 	{
-		let tmpPath = libPath.join(this._cachePath, `${pKey}.${pFormat || 'webp'}`);
+		let tmpFileKey = `${pKey}.${pFormat || 'webp'}`;
+		let tmpPath = this._storage.resolvePath(_CATEGORY, tmpFileKey);
+
+		// Ensure parent directory exists (for sharded paths)
+		let tmpDir = libPath.dirname(tmpPath);
+		if (!libFs.existsSync(tmpDir))
+		{
+			libFs.mkdirSync(tmpDir, { recursive: true });
+		}
+
 		libFs.writeFileSync(tmpPath, pBuffer);
 		return tmpPath;
 	}
 
 	/**
-	 * Get the absolute path to the cache directory.
+	 * Get the cache category name.
 	 *
 	 * @returns {string}
 	 */
 	getCachePath()
 	{
-		return this._cachePath;
+		return this._storage.resolvePath(_CATEGORY, '');
 	}
 }
 

package/source/server/RetoldRemote-VideoFrameService.js

@@ -47,16 +47,7 @@ class RetoldRemoteVideoFrameService extends libFableServiceProviderBase
 
 		this.contentPath = libPath.resolve(this.options.ContentPath);
 
-		this.cachePath = this.options.CachePath
-			|| libPath.join(process.cwd(), 'dist', 'retold-cache', 'video-frames');
-
-		// Ensure cache directory exists
-		if (!libFs.existsSync(this.cachePath))
-		{
-			libFs.mkdirSync(this.cachePath, { recursive: true });
-		}
-
-		this.fable.log.info(`Video Frame Service: cache at ${this.cachePath}`);
+		this.fable.log.info('Video Frame Service: using ParimeBinaryStorage (category: video-frames)');
 	}
 
 	/**
@@ -75,7 +66,7 @@ class RetoldRemoteVideoFrameService extends libFableServiceProviderBase
 	{
 		let tmpInput = `${pAbsPath}:${pMtimeMs}:${pFrameCount}:${pWidth}x${pHeight}`;
 		let tmpHash = libCrypto.createHash('sha256').update(tmpInput).digest('hex').substring(0, 16);
-		return libPath.join(this.cachePath, tmpHash);
+		return this.fable.ParimeBinaryStorage.resolvePath('video-frames', tmpHash);
 	}
 
 	/**
@@ -398,7 +389,7 @@ class RetoldRemoteVideoFrameService extends libFableServiceProviderBase
 			return fCallback(new Error('Invalid cache key.'));
 		}
 
-		let tmpCacheDir = libPath.join(this.cachePath, pCacheKey);
+		let tmpCacheDir = this.fable.ParimeBinaryStorage.resolvePath('video-frames', pCacheKey);
 		if (!libFs.existsSync(tmpCacheDir))
 		{
 			return fCallback(new Error('Cache directory not found. Extract frames first.'));
@@ -466,11 +457,12 @@ class RetoldRemoteVideoFrameService extends libFableServiceProviderBase
 			return null;
 		}
 
-		let tmpPath = libPath.join(this.cachePath, pCacheKey, pFilename);
+		let tmpCacheDir = this.fable.ParimeBinaryStorage.resolvePath('video-frames', pCacheKey);
+		let tmpPath = libPath.join(tmpCacheDir, pFilename);
 
-		// Double-check it's under our cache dir
+		// Double-check it's under the storage root
 		let tmpResolved = libPath.resolve(tmpPath);
-		if (!tmpResolved.startsWith(this.cachePath))
+		if (!tmpResolved.startsWith(this.fable.ParimeBinaryStorage.storageRoot))
 		{
 			return null;
 		}

package/source/views/PictView-Remote-AudioExplorer.js

@@ -342,7 +342,7 @@ class RetoldRemoteAudioExplorerView extends libPictView
 		// Header
 		tmpHTML += '<div class="retold-remote-aex-header">';
 		tmpHTML += '<button class="retold-remote-aex-nav-btn" onclick="pict.views[\'RetoldRemote-AudioExplorer\'].goBack()" title="Back to audio (Esc)">&larr; Back</button>';
-		tmpHTML += '<div class="retold-remote-aex-title">Audio Explorer &mdash; ' + this._escapeHTML(tmpFileName) + '</div>';
+		tmpHTML += '<div class="retold-remote-aex-title">Audio Explorer &mdash; ' + this.pict.providers['RetoldRemote-FormattingUtilities'].escapeHTML(tmpFileName) + '</div>';
 		tmpHTML += '</div>';
 
 		// Info bar (populated after waveform loads)
@@ -449,18 +449,18 @@ class RetoldRemoteAudioExplorerView extends libPictView
 		if (tmpInfoBar)
 		{
 			let tmpInfoHTML = '';
-			tmpInfoHTML += '<span class="retold-remote-aex-info-item"><span class="retold-remote-aex-info-label">Duration</span> <span class="retold-remote-aex-info-value">' + this._escapeHTML(tmpData.DurationFormatted) + '</span></span>';
+			tmpInfoHTML += '<span class="retold-remote-aex-info-item"><span class="retold-remote-aex-info-label">Duration</span> <span class="retold-remote-aex-info-value">' + this.pict.providers['RetoldRemote-FormattingUtilities'].escapeHTML(tmpData.DurationFormatted) + '</span></span>';
 			if (tmpData.SampleRate)
 			{
 				tmpInfoHTML += '<span class="retold-remote-aex-info-item"><span class="retold-remote-aex-info-label">Sample Rate</span> <span class="retold-remote-aex-info-value">' + (tmpData.SampleRate / 1000).toFixed(1) + ' kHz</span></span>';
 			}
 			if (tmpData.Channels)
 			{
-				tmpInfoHTML += '<span class="retold-remote-aex-info-item"><span class="retold-remote-aex-info-label">Channels</span> <span class="retold-remote-aex-info-value">' + tmpData.Channels + (tmpData.ChannelLayout ? ' (' + this._escapeHTML(tmpData.ChannelLayout) + ')' : '') + '</span></span>';
+				tmpInfoHTML += '<span class="retold-remote-aex-info-item"><span class="retold-remote-aex-info-label">Channels</span> <span class="retold-remote-aex-info-value">' + tmpData.Channels + (tmpData.ChannelLayout ? ' (' + this.pict.providers['RetoldRemote-FormattingUtilities'].escapeHTML(tmpData.ChannelLayout) + ')' : '') + '</span></span>';
 			}
 			if (tmpData.Codec)
 			{
-				tmpInfoHTML += '<span class="retold-remote-aex-info-item"><span class="retold-remote-aex-info-label">Codec</span> <span class="retold-remote-aex-info-value">' + this._escapeHTML(tmpData.Codec) + '</span></span>';
+				tmpInfoHTML += '<span class="retold-remote-aex-info-item"><span class="retold-remote-aex-info-label">Codec</span> <span class="retold-remote-aex-info-value">' + this.pict.providers['RetoldRemote-FormattingUtilities'].escapeHTML(tmpData.Codec) + '</span></span>';
 			}
 			if (tmpData.Bitrate)
 			{
@@ -468,9 +468,9 @@ class RetoldRemoteAudioExplorerView extends libPictView
 			}
 			if (tmpData.FileSize)
 			{
-				tmpInfoHTML += '<span class="retold-remote-aex-info-item"><span class="retold-remote-aex-info-label">Size</span> <span class="retold-remote-aex-info-value">' + this._formatFileSize(tmpData.FileSize) + '</span></span>';
+				tmpInfoHTML += '<span class="retold-remote-aex-info-item"><span class="retold-remote-aex-info-label">Size</span> <span class="retold-remote-aex-info-value">' + this.pict.providers['RetoldRemote-FormattingUtilities'].formatFileSize(tmpData.FileSize) + '</span></span>';
 			}
-			tmpInfoHTML += '<span class="retold-remote-aex-info-item"><span class="retold-remote-aex-info-label">Peaks</span> <span class="retold-remote-aex-info-value">' + tmpData.PeakCount + ' (' + this._escapeHTML(tmpData.Method) + ')</span></span>';
+			tmpInfoHTML += '<span class="retold-remote-aex-info-item"><span class="retold-remote-aex-info-label">Peaks</span> <span class="retold-remote-aex-info-value">' + tmpData.PeakCount + ' (' + this.pict.providers['RetoldRemote-FormattingUtilities'].escapeHTML(tmpData.Method) + ')</span></span>';
 
 			tmpInfoBar.innerHTML = tmpInfoHTML;
 			tmpInfoBar.style.display = '';
@@ -964,7 +964,7 @@ class RetoldRemoteAudioExplorerView extends libPictView
 		{
 			let tmpViewStartTime = this._viewStart * tmpDuration;
 			let tmpViewEndTime = this._viewEnd * tmpDuration;
-			tmpViewRangeEl.textContent = this._formatTimestamp(tmpViewStartTime) + ' - ' + this._formatTimestamp(tmpViewEndTime);
+			tmpViewRangeEl.textContent = this.pict.providers['RetoldRemote-FormattingUtilities'].formatTimestamp(tmpViewStartTime, true) + ' - ' + this.pict.providers['RetoldRemote-FormattingUtilities'].formatTimestamp(tmpViewEndTime, true);
 		}
 
 		// Selection
@@ -976,7 +976,7 @@ class RetoldRemoteAudioExplorerView extends libPictView
 				let tmpSelMin = Math.min(this._selectionStart, this._selectionEnd) * tmpDuration;
 				let tmpSelMax = Math.max(this._selectionStart, this._selectionEnd) * tmpDuration;
 				let tmpSelDur = tmpSelMax - tmpSelMin;
-				tmpSelRangeEl.textContent = this._formatTimestamp(tmpSelMin) + ' - ' + this._formatTimestamp(tmpSelMax) + ' (' + this._formatTimestamp(tmpSelDur) + ')';
+				tmpSelRangeEl.textContent = this.pict.providers['RetoldRemote-FormattingUtilities'].formatTimestamp(tmpSelMin, true) + ' - ' + this.pict.providers['RetoldRemote-FormattingUtilities'].formatTimestamp(tmpSelMax, true) + ' (' + this.pict.providers['RetoldRemote-FormattingUtilities'].formatTimestamp(tmpSelDur, true) + ')';
 			}
 			else
 			{
@@ -994,7 +994,7 @@ class RetoldRemoteAudioExplorerView extends libPictView
 				if (tmpWrap)
 				{
 					let tmpNorm = this._viewStart + (this._cursorX / tmpWrap.clientWidth) * (this._viewEnd - this._viewStart);
-					tmpCursorEl.textContent = this._formatTimestamp(tmpNorm * tmpDuration);
+					tmpCursorEl.textContent = this.pict.providers['RetoldRemote-FormattingUtilities'].formatTimestamp(tmpNorm * tmpDuration, true);
 				}
 			}
 			else
@@ -1167,45 +1167,12 @@ class RetoldRemoteAudioExplorerView extends libPictView
 		if (tmpBody)
 		{
 			tmpBody.innerHTML = '<div class="retold-remote-aex-error">'
-				+ '<div class="retold-remote-aex-error-message">' + this._escapeHTML(pMessage || 'An error occurred.') + '</div>'
+				+ '<div class="retold-remote-aex-error-message">' + this.pict.providers['RetoldRemote-FormattingUtilities'].escapeHTML(pMessage || 'An error occurred.') + '</div>'
 				+ '<button class="retold-remote-aex-nav-btn" onclick="pict.views[\'RetoldRemote-AudioExplorer\'].goBack()">Back to Audio</button>'
 				+ '</div>';
 		}
 	}
 
-	_formatTimestamp(pSeconds)
-	{
-		if (pSeconds === null || pSeconds === undefined || isNaN(pSeconds))
-		{
-			return '--';
-		}
-		let tmpHours = Math.floor(pSeconds / 3600);
-		let tmpMinutes = Math.floor((pSeconds % 3600) / 60);
-		let tmpSecs = Math.floor(pSeconds % 60);
-		let tmpMs = Math.floor((pSeconds % 1) * 10);
-
-		if (tmpHours > 0)
-		{
-			return `${tmpHours}:${String(tmpMinutes).padStart(2, '0')}:${String(tmpSecs).padStart(2, '0')}.${tmpMs}`;
-		}
-		return `${tmpMinutes}:${String(tmpSecs).padStart(2, '0')}.${tmpMs}`;
-	}
-
-	_escapeHTML(pText)
-	{
-		if (!pText) return '';
-		return pText.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
-	}
-
-	_formatFileSize(pBytes)
-	{
-		if (!pBytes || pBytes === 0) return '0 B';
-		let tmpUnits = ['B', 'KB', 'MB', 'GB', 'TB'];
-		let tmpIndex = Math.floor(Math.log(pBytes) / Math.log(1024));
-		if (tmpIndex >= tmpUnits.length) tmpIndex = tmpUnits.length - 1;
-		let tmpSize = pBytes / Math.pow(1024, tmpIndex);
-		return tmpSize.toFixed(tmpIndex === 0 ? 0 : 1) + ' ' + tmpUnits[tmpIndex];
-	}
 }
 
 RetoldRemoteAudioExplorerView.default_configuration = _ViewConfiguration;