ultravisor 1.0.24 → 1.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ultravisor",
-    "version": "1.0.24",
+    "version": "1.0.25",
     "description": "Cyclic process execution with ai integration.",
     "main": "source/Ultravisor.cjs",
     "bin": {

package/source/cli/Ultravisor-CLIProgram.cjs

@@ -18,6 +18,9 @@ const libServiceExecutionManifest = require('../services/Ultravisor-ExecutionMan
 const libServiceBeaconCoordinator = require('../services/Ultravisor-Beacon-Coordinator.cjs');
 const libServiceBeaconReachability = require('../services/Ultravisor-Beacon-Reachability.cjs');
 const libServiceBeaconQueueJournal = require('../services/persistence/Ultravisor-Beacon-QueueJournal.cjs');
+const libServiceBeaconFleetStore = require('../services/persistence/Ultravisor-Beacon-FleetStore.cjs');
+const libServiceDirectoryDistributor = require('../services/Ultravisor-DirectoryDistributor.cjs');
+const libServiceFleetManager = require('../services/Ultravisor-FleetManager.cjs');
 
 // TODO: Remove this when Restify is fixed.
 process.removeAllListeners('warning')
@@ -215,6 +218,21 @@ if (tmpCoordinator)
 	tmpCoordinator.loadActionCatalog();
 }
 
+// --- Fleet management (per-(beacon, model) install/enable state) ---
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists(
+	'UltravisorBeaconFleetStore', libServiceBeaconFleetStore);
+let tmpFleetStore = Object.values(_Ultravisor_Pict.fable.servicesMap['UltravisorBeaconFleetStore'])[0];
+if (tmpFleetStore)
+{
+	tmpFleetStore.initialize(_Ultravisor_Pict.fable.settings.UltravisorFileStorePath);
+}
+
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists(
+	'UltravisorDirectoryDistributor', libServiceDirectoryDistributor);
+
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists(
+	'UltravisorFleetManager', libServiceFleetManager);
+
 _Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('UltravisorAPIServer', libWebServerAPIServer);
 
 // ── Service name aliases ────────────────────────────────

package/source/datamodel/Ultravisor-Fleet.json

@@ -0,0 +1,66 @@
+{
+	"Tables":
+	{
+		"BeaconModelInstallation":
+		{
+			"TableName": "BeaconModelInstallation",
+			"Domain": "Default",
+			"Description": "Per-(beacon, model) installation state. Authoritative source of truth for which beacons may be dispatched a given model. Status tracks install lifecycle; EnabledForDispatch is a separate operator toggle.",
+			"Columns":
+			[
+				{ "Column": "IDBeaconModelInstallation", "DataType": "ID" },
+				{ "Column": "GUIDBeaconModelInstallation", "DataType": "GUID", "Size": "36" },
+				{ "Column": "CreateDate", "DataType": "DateTime" },
+				{ "Column": "CreatingIDUser", "DataType": "Numeric", "Size": "int" },
+				{ "Column": "UpdateDate", "DataType": "DateTime" },
+				{ "Column": "UpdatingIDUser", "DataType": "Numeric", "Size": "int" },
+				{ "Column": "Deleted", "DataType": "Boolean" },
+				{ "Column": "DeleteDate", "DataType": "DateTime" },
+				{ "Column": "DeletingIDUser", "DataType": "Numeric", "Size": "int" },
+				{ "Column": "BeaconID", "DataType": "String", "Size": "128" },
+				{ "Column": "BeaconName", "DataType": "String", "Size": "256" },
+				{ "Column": "ModelKey", "DataType": "String", "Size": "256" },
+				{ "Column": "ModelName", "DataType": "String", "Size": "256" },
+				{ "Column": "ModelSourceDir", "DataType": "String", "Size": "1024" },
+				{ "Column": "ExpectedTreeHash", "DataType": "String", "Size": "128" },
+				{ "Column": "InstalledTreeHash", "DataType": "String", "Size": "128" },
+				{ "Column": "InstalledBytes", "DataType": "Numeric", "Size": "bigint" },
+				{ "Column": "Status", "DataType": "String", "Size": "32" },
+				{ "Column": "EnabledForDispatch", "DataType": "Boolean" },
+				{ "Column": "PushProgressBytes", "DataType": "Numeric", "Size": "bigint" },
+				{ "Column": "PushTotalBytes", "DataType": "Numeric", "Size": "bigint" },
+				{ "Column": "LastError", "DataType": "String", "Size": "4096" },
+				{ "Column": "InstalledAt", "DataType": "DateTime" },
+				{ "Column": "LastUpdatedAt", "DataType": "DateTime" },
+				{ "Column": "Source", "DataType": "String", "Size": "32" }
+			]
+		},
+		"BeaconRuntimeInstallation":
+		{
+			"TableName": "BeaconRuntimeInstallation",
+			"Domain": "Default",
+			"Description": "Per-(beacon, runtime) state. A runtime is a named directory of pipeline-worker code (e.g. retold-labs' examples/pipeline-workers). Auto-pushed on beacon connect. Tracks last-known runtime hash so the hub can short-circuit pushes when the worker is already up to date.",
+			"Columns":
+			[
+				{ "Column": "IDBeaconRuntimeInstallation", "DataType": "ID" },
+				{ "Column": "GUIDBeaconRuntimeInstallation", "DataType": "GUID", "Size": "36" },
+				{ "Column": "CreateDate", "DataType": "DateTime" },
+				{ "Column": "CreatingIDUser", "DataType": "Numeric", "Size": "int" },
+				{ "Column": "UpdateDate", "DataType": "DateTime" },
+				{ "Column": "UpdatingIDUser", "DataType": "Numeric", "Size": "int" },
+				{ "Column": "Deleted", "DataType": "Boolean" },
+				{ "Column": "DeleteDate", "DataType": "DateTime" },
+				{ "Column": "DeletingIDUser", "DataType": "Numeric", "Size": "int" },
+				{ "Column": "BeaconID", "DataType": "String", "Size": "128" },
+				{ "Column": "BeaconName", "DataType": "String", "Size": "256" },
+				{ "Column": "RuntimeName", "DataType": "String", "Size": "128" },
+				{ "Column": "ExpectedRuntimeHash", "DataType": "String", "Size": "128" },
+				{ "Column": "InstalledRuntimeHash", "DataType": "String", "Size": "128" },
+				{ "Column": "Status", "DataType": "String", "Size": "32" },
+				{ "Column": "LastError", "DataType": "String", "Size": "4096" },
+				{ "Column": "InstalledAt", "DataType": "DateTime" },
+				{ "Column": "LastUpdatedAt", "DataType": "DateTime" }
+			]
+		}
+	}
+}

package/source/services/Ultravisor-Beacon-Coordinator.cjs

@@ -242,9 +242,19 @@ class UltravisorBeaconCoordinator extends libPictService
 	{
 		let tmpName = pBeaconInfo.Name || 'unnamed';
 
-		// Check for an existing offline beacon with the same name to reclaim
+		// Check for an existing beacon with the same name to reclaim.
+		// Status='Offline' is the original reconnect-after-disconnect case.
+		// Status='Online' is the post-enable refreshRegistration case
+		// (SDK pushed updated capabilities without disconnecting first).
+		// Either way, same name → same beacon — update in place rather
+		// than creating a duplicate record (which would orphan the
+		// FleetStore installation rows keyed on the old BeaconID and
+		// confuse the dispatch filter).
 		let tmpExistingBeacon = this.findBeaconByName(tmpName);
-		if (tmpExistingBeacon && tmpExistingBeacon.Status === 'Offline')
+		if (tmpExistingBeacon
+			&& (tmpExistingBeacon.Status === 'Offline'
+				|| tmpExistingBeacon.Status === 'Online'
+				|| tmpExistingBeacon.Status === 'Busy'))
 		{
 			tmpExistingBeacon.SessionID = pSessionID || null;
 			tmpExistingBeacon.LastHeartbeat = new Date().toISOString();
@@ -352,6 +362,37 @@ class UltravisorBeaconCoordinator extends libPictService
 			tmpReachability.onBeaconRegistered(tmpBeaconID);
 		}
 
+		// Notify the fleet manager so it can:
+		//   - auto-push any registered runtimes whose AutoPushOnConnect
+		//     is true and whose hash on the worker is stale
+		//   - auto-discover models the worker reports via LWM_Inventory
+		//     and import them into the fleet table at Source='discovered',
+		//     EnabledForDispatch=true (so existing dispatches keep working
+		//     without operator intervention)
+		//
+		// Critical: defer to the next tick. The WebSocket upgrade handler
+		// (which sets `_WorkItemPushHandler`) runs in the SAME tick as
+		// `/Beacon/Register`. If we kick off LWM_Inventory or runtime
+		// pushes synchronously here, those work items get pre-assigned
+		// (via the fleet-push affinity) BUT the WS handler isn't wired
+		// yet, so they never deliver — they just fill the beacon's
+		// CurrentWorkItems slot and starve every subsequent dispatch.
+		// setImmediate buys us "after the WS upgrade settles" without
+		// adding a real timer.
+		let tmpFleet = this._getService('UltravisorFleetManager');
+		if (tmpFleet && typeof tmpFleet.onBeaconConnected === 'function')
+		{
+			setImmediate(() =>
+			{
+				try { tmpFleet.onBeaconConnected(tmpBeaconID); }
+				catch (pErr)
+				{
+					this.log.warn(
+						`BeaconCoordinator: FleetManager.onBeaconConnected threw: ${pErr.message}`);
+				}
+			});
+		}
+
 		return tmpBeacon;
 	}
 
@@ -1171,6 +1212,31 @@ class UltravisorBeaconCoordinator extends libPictService
 				continue;
 			}
 
+			// Fleet-manager dispatch filter (same logic as pollForWork's
+			// pending-pass). System actions / unknown-model dispatches
+			// fall through; per-(beacon, model) gating only applies when
+			// the work item targets a known-installed model.
+			let tmpFleetWS = this._getService('UltravisorFleetManager');
+			if (tmpFleetWS && typeof tmpFleetWS.checkDispatchAllowed === 'function')
+			{
+				let tmpAllowWS;
+				try { tmpAllowWS = tmpFleetWS.checkDispatchAllowed(tmpBeacon.BeaconID, pWorkItem); }
+				catch (pErr)
+				{
+					this.log.warn(
+						`BeaconCoordinator: WS-push fleet filter threw: ${pErr.message} — allowing`);
+					tmpAllowWS = { Allowed: true };
+				}
+				if (tmpAllowWS && tmpAllowWS.Allowed === false)
+				{
+					this.log.info(
+						`BeaconCoordinator: WS-push fleet filter denied beacon [${tmpBeacon.BeaconID}] `
+						+ `for [${pWorkItem.Capability}/${pWorkItem.Action}] `
+						+ `(model=${tmpAllowWS.MatchedModelKey}, reason=${tmpAllowWS.Reason}).`);
+					continue;
+				}
+			}
+
 			// Assign the work item to this beacon
 			pWorkItem.Status = 'Running';
 			pWorkItem.AssignedBeaconID = tmpBeacon.BeaconID;
@@ -1341,6 +1407,35 @@ class UltravisorBeaconCoordinator extends libPictService
 				continue;
 			}
 
+			// Fleet-manager dispatch filter: gate on per-(beacon, model)
+			// EnabledForDispatch state when the work item targets a
+			// known-installed model. System actions (LabsWorkerManagement,
+			// VideoPipeline/VP_EncodeVideo, etc.) and dispatches with no
+			// extractable model key fall through unchanged. See
+			// FleetManager.checkDispatchAllowed() for policy.
+			let tmpFleetForFilter = this._getService('UltravisorFleetManager');
+			if (tmpFleetForFilter && typeof tmpFleetForFilter.checkDispatchAllowed === 'function')
+			{
+				let tmpAllow;
+				try { tmpAllow = tmpFleetForFilter.checkDispatchAllowed(pBeaconID, tmpWorkItem); }
+				catch (pErr)
+				{
+					this.log.warn(
+						`BeaconCoordinator: fleet filter threw on `
+						+ `[${tmpWorkItem.WorkItemHash}]: ${pErr.message} — allowing`);
+					tmpAllow = { Allowed: true };
+				}
+				if (tmpAllow && tmpAllow.Allowed === false)
+				{
+					this.log.info(
+						`BeaconCoordinator: fleet filter denied beacon [${pBeaconID}] `
+						+ `for [${tmpWorkItem.Capability}/${tmpWorkItem.Action}] `
+						+ `(model=${tmpAllow.MatchedModelKey}, reason=${tmpAllow.Reason}) — `
+						+ `keeping work item pending for an enabled beacon.`);
+					continue;
+				}
+			}
+
 			// Claim this work item
 			let tmpPollClaimIso = new Date().toISOString();
 			let tmpPollFromStatus = tmpWorkItem.Status;

package/source/services/Ultravisor-DirectoryDistributor.cjs

@@ -0,0 +1,280 @@
+/**
+ * Ultravisor — DirectoryDistributor
+ *
+ * Generic mesh primitive for "push the contents of a directory to a
+ * remote beacon, validate end-to-end with sha256 tree-hashing, and
+ * finalize." Originally cribbed from retold-labs/source/RetoldLabs-PythonRuntime.cjs
+ * (which was app-specific to pushing pipeline-workers/) and
+ * generalized so both runtime push (Layer 1b) and model push (Layer 2)
+ * — and any future "ship a directory tree to a worker" use case — can
+ * use the same code path.
+ *
+ * What it does:
+ *   1. Scans a source directory (skipping ignored basenames), computes
+ *      a sha256 tree-hash + per-file chunk plan.
+ *   2. Streams each file as a sequence of chunks via a caller-supplied
+ *      `pDispatch(actionName, settingsObject)` async function. The
+ *      dispatcher is the only thing this service knows about beacons
+ *      (we don't reach into the BeaconCoordinator directly — that's
+ *      the FleetManager's job).
+ *   3. Calls a finalizer LWM action with the expected tree-hash.
+ *
+ * What it doesn't do:
+ *   - Pick which beacon to push to (FleetManager).
+ *   - Persist installation state (FleetManager + DB).
+ *   - Run the worker's post-finalize re-scan (worker handles that
+ *     locally inside its finalize action handler).
+ *
+ * Caller contract for `pDispatch`:
+ *     pDispatch(actionName: string, settings: object) -> Promise<response>
+ *   where `response` is the beacon's `{ Outputs: {...}, Log: [...] }`
+ *   envelope (see Ultravisor-Beacon-Client.cjs:588). Outputs.Status
+ *   and Outputs.ExitCode drive success/failure detection.
+ *
+ * @author Steven Velozo <steven@velozo.com>
+ */
+
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+const libPath = require('path');
+const libFileStream = require('ultravisor-file-stream');
+
+// Always-skip names. Callers may add to this set per push (e.g.
+// pushing a model dir excludes 'venvs' too); we keep the universal
+// suspects baked in.
+const DEFAULT_IGNORE_BASENAMES = new Set([
+	'__pycache__',
+	'node_modules',
+	'.DS_Store',
+	'.git'
+]);
+
+const DEFAULT_CHUNK_BYTES = libFileStream.DEFAULT_CHUNK_BYTES;
+
+class UltravisorDirectoryDistributor extends libFableServiceProviderBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+		this.serviceType = 'UltravisorDirectoryDistributor';
+
+		this._chunkBytes = this.options.ChunkBytes || DEFAULT_CHUNK_BYTES;
+	}
+
+	/**
+	 * Hash + manifest a source directory.
+	 *
+	 * @param {string} pSourceDir
+	 * @param {object} [pOptions]
+	 *   - IgnoreBasenames  Set<string>  extra skip names (merged with default)
+	 * @returns {{Hash, FileCount, TotalBytes, Files}}
+	 */
+	scan(pSourceDir, pOptions)
+	{
+		let tmpIgnore = this._mergedIgnore(pOptions && pOptions.IgnoreBasenames);
+		let tmpScan = libFileStream.hashDirectoryTree(pSourceDir, tmpIgnore);
+		if (this.log)
+		{
+			this.log.info(
+				`UltravisorDirectoryDistributor: scanned ${pSourceDir} — `
+				+ `hash=${tmpScan.Hash.slice(0, 16)}... `
+				+ `files=${tmpScan.FileCount} bytes=${tmpScan.TotalBytes}`);
+		}
+		return tmpScan;
+	}
+
+	/**
+	 * Build the chunk payloads for a single file inside a source dir.
+	 *
+	 * The wire RelativePath is what the worker stores at — it's the
+	 * caller's responsibility to compose that. For a runtime push the
+	 * orchestrator passes the in-source relative path verbatim
+	 * ('worker_protocol.py'); for a model push the orchestrator
+	 * prefixes the model basename ('sd15/weights/model.safetensors')
+	 * so the worker's LWM_PushModel handler writes it under
+	 * `<library>/sd15/weights/model.safetensors`.
+	 */
+	buildChunksForFile(pSourceDir, pInSourceRelativePath, pWireRelativePath)
+	{
+		let tmpLocalRel = pInSourceRelativePath.split('/').join(libPath.sep);
+		let tmpFullPath = libPath.join(pSourceDir, tmpLocalRel);
+		return libFileStream.buildChunksForFile(tmpFullPath,
+			{ ChunkBytes: this._chunkBytes, RelativePath: pWireRelativePath });
+	}
+
+	/**
+	 * Orchestrate the full push to one beacon target.
+	 *
+	 * @param {object} pConfig
+	 *   - SourceDir         (required) absolute path on hub disk
+	 *   - PushAction        (required) LWM action name for chunks
+	 *                                  (e.g. 'LWM_PushPythonRuntime',
+	 *                                  'LWM_PushModel')
+	 *   - FinalizeAction    (required) LWM action name for finalize
+	 *   - DestPathPrefix    (optional) prepended to each file's
+	 *                                  in-source RelativePath when
+	 *                                  building the wire RelativePath.
+	 *                                  Empty for runtime pushes;
+	 *                                  '<model-name>' for model pushes.
+	 *   - ExpectedHashKey   (optional) Settings key the finalize action
+	 *                                  reads to validate the tree-hash.
+	 *                                  'ExpectedRuntimeHash' (default),
+	 *                                  'ExpectedModelHash', etc.
+	 *   - FinalizeExtras    (optional) merged into the finalize-action
+	 *                                  Settings (worker-side handlers
+	 *                                  may need extra context — e.g.
+	 *                                  the model name for inventory
+	 *                                  re-scan).
+	 *   - IgnoreBasenames   (optional) Set of extra skip names.
+	 * @param {function} pDispatch  async (actionName, settings) -> response
+	 * @param {function} [pProgress] optional ({BytesPushed, TotalBytes,
+	 *                              FilesPushed, FileCount, CurrentFile})
+	 */
+	async pushDirectoryToTarget(pConfig, pDispatch, pProgress)
+	{
+		let tmpSourceDir = pConfig.SourceDir;
+		let tmpPushAction = pConfig.PushAction;
+		let tmpFinalizeAction = pConfig.FinalizeAction;
+		let tmpDestPrefix = pConfig.DestPathPrefix || '';
+		let tmpExpectedHashKey = pConfig.ExpectedHashKey || 'ExpectedRuntimeHash';
+		let tmpFinalizeExtras = pConfig.FinalizeExtras || {};
+
+		if (!tmpSourceDir || !tmpPushAction || !tmpFinalizeAction)
+		{
+			return {
+				Status: 'Error',
+				Error: 'pushDirectoryToTarget: SourceDir, PushAction, FinalizeAction all required.',
+				FilesPushed: 0,
+				BytesPushed: 0
+			};
+		}
+
+		let tmpStart = Date.now();
+		let tmpScan = this.scan(tmpSourceDir, { IgnoreBasenames: pConfig.IgnoreBasenames });
+
+		if (tmpScan.FileCount === 0)
+		{
+			return {
+				Status: 'Error',
+				Error: `pushDirectoryToTarget: source directory ${tmpSourceDir} is empty.`,
+				FilesPushed: 0,
+				BytesPushed: 0
+			};
+		}
+
+		let tmpBytesPushed = 0;
+		let tmpFilesPushed = 0;
+
+		for (let tmpFile of tmpScan.Files)
+		{
+			// Compose wire RelativePath: optionally prefix with the
+			// destination subdir so the worker writes the file at
+			// '<base>/<DestPathPrefix>/<file-rel>'.
+			let tmpWireRel = tmpDestPrefix
+				? this._joinForwardSlash(tmpDestPrefix, tmpFile.RelativePath)
+				: tmpFile.RelativePath;
+
+			let tmpChunks = this.buildChunksForFile(tmpSourceDir, tmpFile.RelativePath, tmpWireRel);
+			for (let tmpChunk of tmpChunks)
+			{
+				let tmpResp = await pDispatch(tmpPushAction, tmpChunk);
+				if (!this._isOkResponse(tmpResp))
+				{
+					return {
+						Status: 'Error',
+						Error: `push chunk ${tmpChunk.ChunkIndex}/${tmpChunk.TotalChunks} `
+							+ `for ${tmpWireRel} failed: `
+							+ `${this._extractError(tmpResp)}`,
+						FilesPushed: tmpFilesPushed,
+						BytesPushed: tmpBytesPushed,
+						FailedResponse: tmpResp
+					};
+				}
+				tmpBytesPushed += Buffer.byteLength(tmpChunk.Content || '', 'base64');
+				if (typeof pProgress === 'function')
+				{
+					try
+					{
+						pProgress({
+							BytesPushed: tmpBytesPushed,
+							TotalBytes: tmpScan.TotalBytes,
+							FilesPushed: tmpFilesPushed,
+							FileCount: tmpScan.FileCount,
+							CurrentFile: tmpWireRel
+						});
+					}
+					catch (e) { /* progress callbacks shouldn't fail the push */ }
+				}
+			}
+			tmpFilesPushed++;
+		}
+
+		// Finalize.
+		let tmpFinalizeSettings = Object.assign({}, tmpFinalizeExtras);
+		tmpFinalizeSettings[tmpExpectedHashKey] = tmpScan.Hash;
+
+		let tmpFinalResp = await pDispatch(tmpFinalizeAction, tmpFinalizeSettings);
+		let tmpFinalOk = this._isOkResponse(tmpFinalResp);
+
+		return {
+			Status: tmpFinalOk ? 'Success' : 'Error',
+			Error: tmpFinalOk ? null : this._extractError(tmpFinalResp),
+			SourceDir: tmpSourceDir,
+			TreeHash: tmpScan.Hash,
+			FilesPushed: tmpFilesPushed,
+			FileCount: tmpScan.FileCount,
+			BytesPushed: tmpBytesPushed,
+			TotalBytes: tmpScan.TotalBytes,
+			FinalizeResponse: tmpFinalResp,
+			DurationMs: Date.now() - tmpStart
+		};
+	}
+
+	// ── Internals ──────────────────────────────────────────────
+
+	_mergedIgnore(pExtra)
+	{
+		if (!pExtra || (pExtra.size === 0))
+		{
+			return DEFAULT_IGNORE_BASENAMES;
+		}
+		let tmpMerged = new Set(DEFAULT_IGNORE_BASENAMES);
+		for (let tmpName of pExtra) tmpMerged.add(tmpName);
+		return tmpMerged;
+	}
+
+	_joinForwardSlash(pA, pB)
+	{
+		// Always emit forward-slash-delimited wire paths regardless of
+		// host OS. Worker's chunked-write normalizes to local sep.
+		let tmpA = String(pA || '').replace(/^\/+|\/+$/g, '');
+		let tmpB = String(pB || '').replace(/^\/+/, '');
+		if (!tmpA) return tmpB;
+		if (!tmpB) return tmpA;
+		return tmpA + '/' + tmpB;
+	}
+
+	_isOkResponse(pResp)
+	{
+		if (!pResp) return false;
+		if (pResp.Success === false) return false;
+		let tmpOutputs = pResp.Outputs || {};
+		// Worker contract: Outputs.Status === 'Success' OR ExitCode falsy.
+		if (tmpOutputs.Status && tmpOutputs.Status !== 'Success') return false;
+		if (tmpOutputs.ExitCode && tmpOutputs.ExitCode !== 0) return false;
+		return true;
+	}
+
+	_extractError(pResp)
+	{
+		if (!pResp) return 'no response';
+		let tmpOutputs = pResp.Outputs || {};
+		return tmpOutputs.Error
+			|| tmpOutputs.Status
+			|| pResp.Error
+			|| 'unknown';
+	}
+}
+
+module.exports = UltravisorDirectoryDistributor;
+module.exports.DEFAULT_IGNORE_BASENAMES = DEFAULT_IGNORE_BASENAMES;
+module.exports.DEFAULT_CHUNK_BYTES = DEFAULT_CHUNK_BYTES;