amule-ec-client 0.6.1 → 0.7.0

package/dist/SharedFilesResponse-DE0cd1DT.js

@@ -0,0 +1,45 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { f as findNumericTag, p as findTag } from "./Tag-B5gWV2XF.js";
+import { a as toOptionalNumber, n as tagOwnNumericValue } from "./utils-CNoUroOI.js";
+//#region src/response/SharedFilesResponse.ts
+var SharedFilesResponse_exports = /* @__PURE__ */ __exportAll({
+	SharedFilesResponseParser: () => SharedFilesResponseParser,
+	parseKnownFileFields: () => parseKnownFileFields
+});
+/**
+* Parse the fields shared by every known-file shaped tag (EC_TAG_KNOWNFILE and
+* EC_TAG_PARTFILE both carry them).
+*/
+function parseKnownFileFields(fileTag) {
+	const tags = fileTag.nestedTags || [];
+	const hashTag = findTag(tags, 798);
+	const fileNameTag = findTag(tags, 769);
+	return {
+		ecid: tagOwnNumericValue(fileTag),
+		fileHashHexString: hashTag ? hashTag.getValue().toString("hex") : void 0,
+		fileName: fileNameTag ? fileNameTag.getValue() : void 0,
+		filePath: findTag(tags, 1032)?.getValue(),
+		sizeFull: toOptionalNumber(findNumericTag(tags, 771)?.getLong()),
+		fileEd2kLink: findTag(tags, 782)?.getValue(),
+		upPrio: findNumericTag(tags, 1035)?.getInt(),
+		getRequests: findNumericTag(tags, 1027)?.getShort(),
+		getAllRequests: findNumericTag(tags, 1028)?.getInt(),
+		getAccepts: findNumericTag(tags, 1029)?.getShort(),
+		getAllAccepts: findNumericTag(tags, 1030)?.getInt(),
+		getXferred: toOptionalNumber(findNumericTag(tags, 1025)?.getLong()),
+		getAllXferred: toOptionalNumber(findNumericTag(tags, 1026)?.getLong()),
+		getCompleteSourcesLow: findNumericTag(tags, 1033)?.getShort(),
+		getCompleteSourcesHigh: findNumericTag(tags, 1034)?.getShort(),
+		getCompleteSources: findNumericTag(tags, 1037)?.getShort(),
+		getOnQueue: findNumericTag(tags, 1036)?.getShort(),
+		getComment: findTag(tags, 1038)?.getValue(),
+		getRating: findNumericTag(tags, 1039)?.getInt()
+	};
+}
+var SharedFilesResponseParser = class {
+	static fromPacket(packet) {
+		return { files: packet.tags.filter((tag) => tag.name === 1024).map(parseKnownFileFields) };
+	}
+};
+//#endregion
+export { SharedFilesResponse_exports as n, parseKnownFileFields as r, SharedFilesResponseParser as t };

package/dist/{StatsRequest-CGGumOOx.js → StatsRequest-DVwx5wk1.js}

@@ -1,6 +1,5 @@
-import { t as Request } from "./Request-C0UUuQIX.js";
-import "./Codes-CjiW7Pdl.js";
-import { s as UByteTag } from "./Tag-CZF6BRMY.js";
+import { t as Request } from "./Request-BvScDpeu.js";
+import { s as UByteTag } from "./Tag-B5gWV2XF.js";
 //#region src/request/StatsRequest.ts
 /**
 * Stats Request - Request server statistics

package/dist/{StatsResponse-DxQk686g.js → StatsResponse-CP2F2zt0.js}

@@ -1,6 +1,11 @@
-import "./Codes-CjiW7Pdl.js";
-import { f as findNumericTag, p as findTag } from "./Tag-CZF6BRMY.js";
+import { f as findNumericTag, p as findTag } from "./Tag-B5gWV2XF.js";
+import { n as tagOwnNumericValue } from "./utils-CNoUroOI.js";
 //#region src/response/StatsResponse.ts
+const CONNSTATE_ED2K_CONNECTED = 1;
+const CONNSTATE_ED2K_CONNECTING = 2;
+const CONNSTATE_KAD_CONNECTED = 4;
+const CONNSTATE_KAD_FIREWALLED = 8;
+const CONNSTATE_KAD_RUNNING = 16;
 var StatsResponseParser = class {
 	static fromPacket(packet) {
 		const uploadOverhead = findNumericTag(packet.tags, 516)?.getValue() || 0;
@@ -25,6 +30,7 @@ var StatsResponseParser = class {
 		let clientId = 0;
 		let kadId;
 		let connectedServer;
+		let connectionState;
 		if (connStateTag && connStateTag.nestedTags) {
 			ed2kId = Number(findNumericTag(connStateTag.nestedTags, 6)?.getValue() || 0);
 			clientId = Number(findNumericTag(connStateTag.nestedTags, 10)?.getValue() || 0);
@@ -44,6 +50,22 @@ var StatsResponseParser = class {
 					description: findTag(serverTag.nestedTags || [], 1282)?.getValue()
 				};
 			}
+			const stateBits = tagOwnNumericValue(connStateTag) ?? 0;
+			connectionState = {
+				ed2kConnected: (stateBits & CONNSTATE_ED2K_CONNECTED) !== 0,
+				ed2kConnecting: (stateBits & CONNSTATE_ED2K_CONNECTING) !== 0,
+				kadConnected: (stateBits & CONNSTATE_KAD_CONNECTED) !== 0,
+				kadFirewalled: (stateBits & CONNSTATE_KAD_FIREWALLED) !== 0,
+				kadRunning: (stateBits & CONNSTATE_KAD_RUNNING) !== 0,
+				ed2kId: ed2kId || void 0,
+				clientId: clientId || void 0,
+				serverIpv4: connectedServer ? {
+					address: connectedServer.ip,
+					port: connectedServer.port
+				} : void 0,
+				serverName: connectedServer?.name,
+				serverDescription: connectedServer?.description
+			};
 		}
 		const id = clientId || Number(findNumericTag(packet.tags, 10)?.getValue() || 0);
 		return {
@@ -51,6 +73,7 @@ var StatsResponseParser = class {
 			ed2kId,
 			kadId,
 			connectedServer,
+			connectionState,
 			uploadOverhead: Number(uploadOverhead),
 			downloadOverhead: Number(downloadOverhead),
 			bannedCount: Number(bannedCount),

package/dist/{Codes-CjiW7Pdl.js → Tag-B5gWV2XF.js}

@@ -389,6 +389,14 @@ let ECSearchType = /* @__PURE__ */ function(ECSearchType) {
 	ECSearchType[ECSearchType["EC_SEARCH_WEB"] = 3] = "EC_SEARCH_WEB";
 	return ECSearchType;
 }({});
+let ECSearchFileDownloadStatus = /* @__PURE__ */ function(ECSearchFileDownloadStatus) {
+	ECSearchFileDownloadStatus[ECSearchFileDownloadStatus["NEW"] = 0] = "NEW";
+	ECSearchFileDownloadStatus[ECSearchFileDownloadStatus["DOWNLOADED"] = 1] = "DOWNLOADED";
+	ECSearchFileDownloadStatus[ECSearchFileDownloadStatus["QUEUED"] = 2] = "QUEUED";
+	ECSearchFileDownloadStatus[ECSearchFileDownloadStatus["CANCELED"] = 3] = "CANCELED";
+	ECSearchFileDownloadStatus[ECSearchFileDownloadStatus["QUEUEDCANCELED"] = 4] = "QUEUEDCANCELED";
+	return ECSearchFileDownloadStatus;
+}({});
 let EcPrefs = /* @__PURE__ */ function(EcPrefs) {
 	EcPrefs[EcPrefs["EC_PREFS_CATEGORIES"] = 1] = "EC_PREFS_CATEGORIES";
 	EcPrefs[EcPrefs["EC_PREFS_GENERAL"] = 2] = "EC_PREFS_GENERAL";
@@ -406,4 +414,263 @@ let EcPrefs = /* @__PURE__ */ function(EcPrefs) {
 	return EcPrefs;
 }({});
 //#endregion
-export { EcPrefs as a, ECTagName as i, ECOpCode as n, ProtocolVersion as o, ECSearchType as r, ECDetailLevel as t };
+//#region src/ec/tag/Tag.ts
+var Tag = class {
+	name;
+	type;
+	nameValue;
+	value;
+	nestedTags;
+	constructor(name, type, nestedTags = [], nameValue = name) {
+		this.name = name;
+		this.type = type;
+		this.nameValue = nameValue;
+		if (nestedTags.length > 0) this.nestedTags = nestedTags;
+	}
+	getValue() {
+		return this.value;
+	}
+	setValue(value) {
+		this.value = value;
+	}
+};
+var CustomTag = class extends Tag {
+	constructor(name, value, subtags = [], nameValue = name) {
+		super(name, 1, subtags, nameValue);
+		if (value !== void 0) this.setValue(value);
+	}
+	parseValue(value) {
+		this.setValue(value);
+	}
+	encodeValue() {
+		return this.getValue();
+	}
+};
+var UByteTag = class UByteTag extends Tag {
+	constructor(name, value, subtags = [], nameValue = name) {
+		super(name, 2, subtags, nameValue);
+		if (value !== void 0) this.setValue(value);
+	}
+	static withValue(name, value, subtags = []) {
+		return new UByteTag(name, value, subtags);
+	}
+	parseValue(value) {
+		if (value.length === 0) this.setValue(0);
+		else if (value.length === 1) this.setValue(value[0]);
+		else throw new Error("UInt8Tag value must be 1 byte long");
+	}
+	encodeValue() {
+		const buf = Buffer.allocUnsafe(1);
+		buf.writeUInt8(this.getValue());
+		return buf;
+	}
+	getShort() {
+		return this.getValue();
+	}
+	getInt() {
+		return this.getValue();
+	}
+	getLong() {
+		return BigInt(this.getValue());
+	}
+};
+var UShortTag = class UShortTag extends Tag {
+	constructor(name, value, subtags = [], nameValue = name) {
+		super(name, 3, subtags, nameValue);
+		if (value !== void 0) this.setValue(value);
+	}
+	static withValue(name, value, subtags = []) {
+		return new UShortTag(name, value, subtags);
+	}
+	parseValue(value) {
+		if (value.length === 0) this.setValue(0);
+		else if (value.length === 2) this.setValue(value.readUInt16BE(0));
+		else throw new Error("UInt16Tag value must be 2 bytes long");
+	}
+	encodeValue() {
+		const buf = Buffer.allocUnsafe(2);
+		buf.writeUInt16BE(this.getValue());
+		return buf;
+	}
+	getShort() {
+		return this.getValue();
+	}
+	getInt() {
+		return this.getValue();
+	}
+	getLong() {
+		return BigInt(this.getValue());
+	}
+};
+var UIntTag = class UIntTag extends Tag {
+	constructor(name, value, subtags = [], nameValue = name) {
+		super(name, 4, subtags, nameValue);
+		if (value !== void 0) this.setValue(value);
+	}
+	static withValue(name, value, subtags = []) {
+		return new UIntTag(name, value, subtags);
+	}
+	parseValue(value) {
+		if (value.length === 0) this.setValue(0);
+		else if (value.length === 4) this.setValue(value.readUInt32BE(0));
+		else throw new Error("UInt32Tag value must be 4 bytes long");
+	}
+	encodeValue() {
+		const buf = Buffer.allocUnsafe(4);
+		buf.writeUInt32BE(this.getValue());
+		return buf;
+	}
+	getShort() {
+		throw new Error("Unsigned Integer cannot be cast to short");
+	}
+	getInt() {
+		return this.getValue();
+	}
+	getLong() {
+		return BigInt(this.getValue());
+	}
+};
+var ULongTag = class ULongTag extends Tag {
+	constructor(name, value, subtags = [], nameValue = name) {
+		super(name, 5, subtags, nameValue);
+		if (value !== void 0) this.setValue(value);
+	}
+	static withValue(name, value, subtags = []) {
+		return new ULongTag(name, value, subtags);
+	}
+	parseValue(value) {
+		if (value.length === 0) this.setValue(0n);
+		else if (value.length === 8) this.setValue(value.readBigUInt64BE(0));
+		else throw new Error("UInt64Tag value must be 8 bytes long");
+	}
+	encodeValue() {
+		const buf = Buffer.allocUnsafe(8);
+		buf.writeBigUInt64BE(this.getValue());
+		return buf;
+	}
+	getShort() {
+		throw new Error("Unsigned Long cannot be cast to short");
+	}
+	getInt() {
+		throw new Error("Unsigned Long cannot be cast to int");
+	}
+	getLong() {
+		return this.getValue();
+	}
+};
+var UInt128Tag = class UInt128Tag extends Tag {
+	constructor(name, value, subtags = [], nameValue = name) {
+		super(name, 10, subtags, nameValue);
+		if (value !== void 0) this.setValue(value);
+	}
+	static withValue(name, value, subtags = []) {
+		return new UInt128Tag(name, value, subtags);
+	}
+	parseValue(value) {
+		if (value.length === 0) this.setValue(0n);
+		else {
+			let result = 0n;
+			for (let i = 0; i < value.length; i++) result = result << 8n | BigInt(value[i]);
+			this.setValue(result);
+		}
+	}
+	encodeValue() {
+		const val = this.getValue();
+		const bytes = [];
+		let remaining = val;
+		while (remaining > 0n) {
+			bytes.unshift(Number(remaining & 255n));
+			remaining >>= 8n;
+		}
+		while (bytes.length < 16) bytes.unshift(0);
+		return Buffer.from(bytes);
+	}
+};
+var StringTag = class StringTag extends Tag {
+	constructor(name, value, subtags = [], nameValue = name) {
+		super(name, 6, subtags, nameValue);
+		if (value !== void 0) this.setValue(value);
+	}
+	static withValue(name, value, subtags = []) {
+		return new StringTag(name, value, subtags);
+	}
+	parseValue(value) {
+		if (value[value.length - 1] !== 0) throw new Error("StringTag value must be null terminated");
+		this.setValue(value.toString("utf8", 0, value.length - 1));
+	}
+	encodeValue() {
+		return Buffer.concat([Buffer.from(this.getValue(), "utf8"), Buffer.from([0])]);
+	}
+};
+var DoubleTag = class DoubleTag extends Tag {
+	constructor(name, value, subtags = [], nameValue = name) {
+		super(name, 7, subtags, nameValue);
+		if (value !== void 0) this.setValue(value);
+	}
+	static withValue(name, value, subtags = []) {
+		return new DoubleTag(name, value, subtags);
+	}
+	parseValue(value) {
+		const numValue = value.length >= 8 ? value.readDoubleBE(0) : 0;
+		this.setValue(numValue);
+	}
+	encodeValue() {
+		const buf = Buffer.allocUnsafe(8);
+		buf.writeDoubleBE(this.getValue());
+		return buf;
+	}
+};
+var Ipv4Tag = class Ipv4Tag extends Tag {
+	constructor(name, value, subtags = [], nameValue = name) {
+		super(name, 8, subtags, nameValue);
+		if (value !== void 0) this.setValue(value);
+	}
+	static withValue(name, value, subtags = []) {
+		return new Ipv4Tag(name, value, subtags);
+	}
+	parseValue(value) {
+		if (value.length !== 6) throw new Error("Ipv4Tag value must be 6 bytes long");
+		const address = `${value[0]}.${value[1]}.${value[2]}.${value[3]}`;
+		const port = value.readUInt16BE(4);
+		this.setValue({
+			address,
+			port
+		});
+	}
+	encodeValue() {
+		const val = this.getValue();
+		const parts = val.address.split(".").map(Number);
+		const buf = Buffer.allocUnsafe(6);
+		buf[0] = parts[0];
+		buf[1] = parts[1];
+		buf[2] = parts[2];
+		buf[3] = parts[3];
+		buf.writeUInt16BE(val.port, 4);
+		return buf;
+	}
+};
+var Hash16Tag = class Hash16Tag extends Tag {
+	constructor(name, value, subtags = [], nameValue = name) {
+		super(name, 9, subtags, nameValue);
+		if (value !== void 0) this.setValue(value);
+	}
+	static withValue(name, value, subtags = []) {
+		return new Hash16Tag(name, value, subtags);
+	}
+	parseValue(value) {
+		if (value.length === 16) this.setValue(value);
+		else throw new Error("Hash16Tag value must be 16 bytes long");
+	}
+	encodeValue() {
+		return this.getValue();
+	}
+};
+function findTag(tags, name) {
+	return tags.find((tag) => tag.name === name);
+}
+function findNumericTag(tags, name) {
+	const tag = tags.find((tag) => tag.name === name);
+	if (tag && "getInt" in tag && "getShort" in tag && "getLong" in tag) return tag;
+}
+//#endregion
+export { ECSearchType as _, StringTag as a, ProtocolVersion as b, UInt128Tag as c, UShortTag as d, findNumericTag as f, ECSearchFileDownloadStatus as g, ECOpCode as h, Ipv4Tag as i, UIntTag as l, ECDetailLevel as m, DoubleTag as n, Tag as o, findTag as p, Hash16Tag as r, UByteTag as s, CustomTag as t, ULongTag as u, ECTagName as v, EcPrefs as y };

package/dist/{UpdateCategoryRequest-CzKJa_rC.js → UpdateCategoryRequest-Bu22YjOm.js}

@@ -1,6 +1,5 @@
-import { t as Request } from "./Request-C0UUuQIX.js";
-import "./Codes-CjiW7Pdl.js";
-import { a as StringTag, l as UIntTag, s as UByteTag } from "./Tag-CZF6BRMY.js";
+import { t as Request } from "./Request-BvScDpeu.js";
+import { a as StringTag, l as UIntTag, s as UByteTag } from "./Tag-B5gWV2XF.js";
 //#region src/request/UpdateCategoryRequest.ts
 /**
 * Update Category Request - Update an existing category

package/dist/{UpdateRequest-g2ReOQ5m.js → UpdateRequest-CaQ867p8.js}

@@ -1,6 +1,5 @@
-import { t as Request } from "./Request-C0UUuQIX.js";
-import "./Codes-CjiW7Pdl.js";
-import { s as UByteTag } from "./Tag-CZF6BRMY.js";
+import { t as Request } from "./Request-BvScDpeu.js";
+import { s as UByteTag } from "./Tag-B5gWV2XF.js";
 //#region src/request/UpdateRequest.ts
 /**
 * Update Request - Get incremental updates for files, clients, and servers

package/dist/UpdateState-Dn-SuAsj.js

@@ -0,0 +1,173 @@
+import { f as findNumericTag, p as findTag } from "./Tag-B5gWV2XF.js";
+import { a as toOptionalNumber, i as toOptionalIp, n as tagOwnNumericValue, r as toOptionalBool } from "./utils-CNoUroOI.js";
+import { a as rleDecode, i as extractPartFileStatusBuffers, o as sourceNameEntriesFromFileTag, r as computeChunkInfo, s as xorReconstruct, t as DownloadQueueResponseParser } from "./DownloadQueueResponse-C-5d4teB.js";
+import { t as SharedFilesResponseParser } from "./SharedFilesResponse-DE0cd1DT.js";
+import { t as ClientQueueResponseParser } from "./ClientQueueResponse-CXxY_9wU.js";
+import { t as ServerListResponseParser } from "./ServerListResponse-Do3iRai0.js";
+//#region src/response/UpdateResponse.ts
+var UpdateResponseParser = class {
+	static fromPacket(packet) {
+		const sharedFiles = SharedFilesResponseParser.fromPacket(packet).files;
+		const downloadQueue = DownloadQueueResponseParser.fromPacket(packet).files;
+		const clientContainer = findTag(packet.tags, 1536);
+		const clients = clientContainer && clientContainer.nestedTags ? ClientQueueResponseParser.fromTags(clientContainer.nestedTags).clients : [];
+		const serverContainer = findTag(packet.tags, 1280);
+		const servers = serverContainer && serverContainer.nestedTags ? ServerListResponseParser.fromTags(serverContainer.nestedTags).servers : [];
+		const friendContainer = findTag(packet.tags, 2048);
+		return {
+			sharedFiles,
+			downloadQueue,
+			clients,
+			servers,
+			friends: friendContainer && friendContainer.nestedTags ? this.parseFriends(friendContainer.nestedTags) : []
+		};
+	}
+	static parseFriends(tags) {
+		const friends = [];
+		const friendTags = tags.filter((t) => t.name === 2048);
+		for (const friendTag of friendTags) {
+			const nested = friendTag.nestedTags || [];
+			friends.push({
+				name: findTag(nested, 2049)?.getValue(),
+				userHashHexString: findTag(nested, 2050)?.getValue()?.toString("hex"),
+				ip: toOptionalIp(findNumericTag(nested, 2051)?.getInt()),
+				port: findNumericTag(nested, 2052)?.getInt(),
+				friendSlot: toOptionalBool(findNumericTag(nested, 2056)?.getInt()),
+				shared: toOptionalBool(findNumericTag(nested, 2057)?.getInt()),
+				client: ClientQueueResponseParser.fromTags(nested).clients[0]
+			});
+		}
+		return friends;
+	}
+};
+//#endregion
+//#region src/client/UpdateState.ts
+const STATUS_BUFFER_KEYS = [
+	"partStatus",
+	"gapStatus",
+	"reqStatus"
+];
+/**
+* Merge update fields into the existing object. Fields absent from an incremental
+* response are undefined after parsing and must not clobber previously known values.
+*/
+function mergeDefined(existing, updates) {
+	const result = { ...existing };
+	for (const [key, value] of Object.entries(updates)) if (value !== void 0) result[key] = value;
+	return result;
+}
+var UpdateState = class {
+	sessionGeneration;
+	downloads = /* @__PURE__ */ new Map();
+	sharedFiles = /* @__PURE__ */ new Map();
+	clients = /* @__PURE__ */ new Map();
+	statusBuffers = /* @__PURE__ */ new Map();
+	sourceNames = /* @__PURE__ */ new Map();
+	/**
+	* @param sessionGeneration Connection generation this state belongs to (see
+	* AmuleConnection.getSessionGeneration). The state is only valid while the
+	* connection that produced it is alive, since the daemon diffs per connection.
+	*/
+	constructor(sessionGeneration) {
+		this.sessionGeneration = sessionGeneration;
+	}
+	apply(packet) {
+		const parsed = UpdateResponseParser.fromPacket(packet);
+		for (const file of parsed.downloadQueue) {
+			delete file.chunkInfo;
+			delete file.sourceNames;
+		}
+		const downloadQueue = this.mergeCollection(this.downloads, parsed.downloadQueue);
+		const sharedFiles = this.mergeCollection(this.sharedFiles, parsed.sharedFiles);
+		const clients = this.mergeCollection(this.clients, parsed.clients);
+		for (const ecid of [...this.statusBuffers.keys()]) if (!this.downloads.has(ecid)) this.statusBuffers.delete(ecid);
+		for (const ecid of [...this.sourceNames.keys()]) if (!this.downloads.has(ecid)) this.sourceNames.delete(ecid);
+		this.reconstructFileDetails(packet);
+		this.attachSources();
+		return {
+			downloadQueue,
+			sharedFiles,
+			clients,
+			servers: parsed.servers,
+			friends: parsed.friends
+		};
+	}
+	mergeCollection(state, items) {
+		const seen = /* @__PURE__ */ new Set();
+		const result = [];
+		for (const item of items) {
+			if (item.ecid === void 0) {
+				result.push(item);
+				continue;
+			}
+			seen.add(item.ecid);
+			const existing = state.get(item.ecid);
+			const merged = existing ? mergeDefined(existing, item) : item;
+			state.set(item.ecid, merged);
+			result.push(merged);
+		}
+		for (const ecid of [...state.keys()]) if (!seen.has(ecid)) state.delete(ecid);
+		return result;
+	}
+	/**
+	* Reconstruct the incremental per-file details of each partfile in the packet:
+	* RLE-decode and XOR-reconstruct the status buffers (recomputing chunk info from the
+	* accumulated state), and apply the source-names map diffs (new entry / count change /
+	* removal when count is 0).
+	*/
+	reconstructFileDetails(packet) {
+		const partfileTags = packet.tags.filter((tag) => tag.name === 768);
+		for (const fileTag of partfileTags) {
+			const ecid = tagOwnNumericValue(fileTag);
+			if (ecid === void 0) continue;
+			const file = this.downloads.get(ecid);
+			if (!file) continue;
+			const raw = extractPartFileStatusBuffers(fileTag);
+			const state = this.statusBuffers.get(ecid) || {};
+			for (const key of STATUS_BUFFER_KEYS) {
+				const rawBuffer = raw[key];
+				if (!rawBuffer || rawBuffer.length === 0) continue;
+				const decoded = rleDecode(rawBuffer);
+				const previous = state[key];
+				state[key] = previous ? xorReconstruct(previous, decoded) : decoded;
+			}
+			this.statusBuffers.set(ecid, state);
+			if (file.sizeFull && file.sizeFull > 0) file.chunkInfo = computeChunkInfo(file.sizeFull, state);
+			const entries = sourceNameEntriesFromFileTag(fileTag);
+			if (entries) {
+				const nameMap = this.sourceNames.get(ecid) || /* @__PURE__ */ new Map();
+				for (const entry of entries) {
+					if (entry.count === 0) {
+						nameMap.delete(entry.id);
+						continue;
+					}
+					const existing = nameMap.get(entry.id);
+					if (existing) {
+						existing.count = entry.count;
+						if (entry.name !== void 0) existing.name = entry.name;
+					} else if (entry.name !== void 0) nameMap.set(entry.id, {
+						name: entry.name,
+						count: entry.count
+					});
+				}
+				this.sourceNames.set(ecid, nameMap);
+			}
+			const nameMap = this.sourceNames.get(ecid);
+			if (nameMap) file.sourceNames = [...nameMap.values()];
+		}
+	}
+	/**
+	* Group clients by the download they are requesting (client.requestFileId -> file.ecid).
+	*/
+	attachSources() {
+		for (const file of this.downloads.values()) file.sources = [];
+		for (const client of this.clients.values()) {
+			const requestFileId = toOptionalNumber(client.requestFileId);
+			if (requestFileId === void 0) continue;
+			const file = this.downloads.get(requestFileId);
+			if (file) file.sources.push(client);
+		}
+	}
+};
+//#endregion
+export { UpdateState };