amule-ec-client 0.5.2 → 0.6.1

package/dist/DownloadQueueRequest-Dil5hl3D.js

@@ -0,0 +1,15 @@
+import { t as Request } from "./Request-C0UUuQIX.js";
+import "./Codes-CjiW7Pdl.js";
+import { s as UByteTag } from "./Tag-CZF6BRMY.js";
+//#region src/request/DownloadQueueRequest.ts
+/**
+* Download Queue Request - Get download queue
+*/
+var DownloadQueueRequest = class extends Request {
+	constructor(detailLevel = 2) {
+		super(13);
+		this.addTag(new UByteTag(4, detailLevel));
+	}
+};
+//#endregion
+export { DownloadQueueRequest };

package/dist/DownloadQueueResponse-DUam_zNf.js

@@ -0,0 +1,259 @@
+import "./Codes-CjiW7Pdl.js";
+import { f as findNumericTag, p as findTag } from "./Tag-CZF6BRMY.js";
+import { n as PARTSIZE, t as ChunkStatus } from "./download-details-OM0FJUhZ.js";
+import { i as toOptionalNumber, n as toOptionalBool, t as formatIp } from "./utils-DBnUQnZ-.js";
+//#region src/response/DownloadDetailsResponse.ts
+function rleDecode(buf) {
+	const output = [];
+	let index = 0;
+	while (index < buf.length) if (index < buf.length - 2 && buf[index + 1] === buf[index]) {
+		const value = buf[index];
+		const count = buf[index + 2];
+		for (let i = 0; i < count; i++) output.push(value);
+		index += 3;
+	} else {
+		output.push(buf[index]);
+		index += 1;
+	}
+	return Buffer.from(output);
+}
+function decodePartStatus(buf) {
+	const decoded = rleDecode(buf);
+	const result = new Array(decoded.length);
+	for (let i = 0; i < decoded.length; i++) result[i] = decoded[i];
+	return result;
+}
+function decodeUint64Array(buf) {
+	const decoded = rleDecode(buf);
+	if (decoded.length === 0 || decoded.length % 8 !== 0) return [];
+	const valueCount = decoded.length / 8;
+	const values = new Array(valueCount);
+	for (let i = 0; i < valueCount; i++) {
+		let value = 0;
+		for (let byte = 7; byte >= 0; byte--) value = value * 256 + decoded[i + byte * valueCount];
+		values[i] = value;
+	}
+	return values;
+}
+function stringValue(tag) {
+	if (!tag) return "";
+	const value = tag.getValue();
+	return typeof value === "string" ? value : "";
+}
+function bufferValue(tag) {
+	if (!tag) return;
+	const value = tag.getValue();
+	return Buffer.isBuffer(value) ? value : void 0;
+}
+function nestedTag(parent, tagName) {
+	return parent.nestedTags ? findTag(parent.nestedTags, tagName) : void 0;
+}
+function nestedNumeric(parent, tagName) {
+	if (!parent.nestedTags) return 0;
+	const numeric = findNumericTag(parent.nestedTags, tagName);
+	if (numeric) return Number(numeric.getValue());
+	const tag = findTag(parent.nestedTags, tagName);
+	if (!tag) return 0;
+	const value = tag.getValue();
+	if (typeof value === "number") return value;
+	if (typeof value === "bigint") return Number(value);
+	return 0;
+}
+function nestedString(parent, tagName) {
+	if (!parent.nestedTags) return "";
+	return stringValue(findTag(parent.nestedTags, tagName));
+}
+function nestedIp(parent, tagName) {
+	const ipAsNumber = nestedNumeric(parent, tagName);
+	if (ipAsNumber === 0) return "";
+	return formatIp(ipAsNumber);
+}
+var DownloadChunkDetailsResponseParser = class {
+	static fromPacket(packet) {
+		const result = {};
+		const partfileTags = packet.tags.filter((tag) => tag.name === 768);
+		for (const fileTag of partfileTags) {
+			const hash = bufferValue(nestedTag(fileTag, 798));
+			if (!hash) continue;
+			const fileHash = hash.toString("hex");
+			const sizeFull = nestedNumeric(fileTag, 771);
+			const partCount = sizeFull > 0 ? Math.ceil(sizeFull / PARTSIZE) : 0;
+			const partStatusBuf = bufferValue(nestedTag(fileTag, 786));
+			const gapStatusBuf = bufferValue(nestedTag(fileTag, 787));
+			const reqStatusBuf = bufferValue(nestedTag(fileTag, 788));
+			const availability = new Array(partCount).fill(0);
+			if (partStatusBuf && partStatusBuf.length > 0) {
+				const decodedAvailability = decodePartStatus(partStatusBuf);
+				for (let i = 0; i < Math.min(decodedAvailability.length, partCount); i++) availability[i] = decodedAvailability[i];
+			}
+			const chunks = new Array(partCount).fill(ChunkStatus.COMPLETE);
+			if (partCount > 0 && gapStatusBuf && gapStatusBuf.length > 0) {
+				const gapValues = decodeUint64Array(gapStatusBuf);
+				for (let i = 0; i + 1 < gapValues.length; i += 2) {
+					const gapStart = gapValues[i];
+					const gapEnd = gapValues[i + 1];
+					if (gapStart > sizeFull || gapEnd > sizeFull || gapStart >= gapEnd) continue;
+					const startPart = Math.floor(gapStart / PARTSIZE);
+					const endPart = Math.min(Math.floor(gapEnd / PARTSIZE) + 1, partCount);
+					for (let part = startPart; part < endPart; part++) {
+						const chunkStart = part * PARTSIZE;
+						if (gapStart < Math.min((part + 1) * 9728e3, sizeFull) && gapEnd > chunkStart) chunks[part] = availability[part] > 0 ? ChunkStatus.AVAILABLE : ChunkStatus.UNAVAILABLE;
+					}
+				}
+			}
+			if (partCount > 0 && reqStatusBuf && reqStatusBuf.length > 0) {
+				const reqValues = decodeUint64Array(reqStatusBuf);
+				for (let i = 0; i + 1 < reqValues.length; i += 2) {
+					const reqStart = reqValues[i];
+					const reqEnd = reqValues[i + 1];
+					if (reqStart > sizeFull || reqEnd > sizeFull || reqStart >= reqEnd) continue;
+					const startPart = Math.floor(reqStart / PARTSIZE);
+					const endPart = Math.min(Math.floor(reqEnd / PARTSIZE) + 1, partCount);
+					for (let part = startPart; part < endPart; part++) {
+						if (chunks[part] === ChunkStatus.COMPLETE) continue;
+						const chunkStart = part * PARTSIZE;
+						if (reqStart < Math.min((part + 1) * 9728e3, sizeFull) && reqEnd > chunkStart) chunks[part] = ChunkStatus.DOWNLOADING;
+					}
+				}
+			}
+			result[fileHash] = {
+				chunks,
+				availability,
+				partCount,
+				sizeFull
+			};
+		}
+		return result;
+	}
+};
+var DownloadSourceDetailsResponseParser = class {
+	static fromPacket(packet) {
+		const result = {};
+		const partfileTags = packet.tags.filter((tag) => tag.name === 768);
+		for (const fileTag of partfileTags) {
+			const hash = bufferValue(nestedTag(fileTag, 798));
+			if (!hash) continue;
+			const fileHash = hash.toString("hex");
+			const sourceNames = [];
+			const sources = [];
+			for (const nested of fileTag.nestedTags || []) {
+				if (nested.name !== 1536) continue;
+				sources.push({
+					clientName: nestedString(nested, 256) || "Unknown",
+					userHash: bufferValue(nestedTag(nested, 1539))?.toString("hex") || "",
+					software: nestedString(nested, 1537),
+					softwareVersion: nestedString(nested, 1557),
+					score: nestedNumeric(nested, 1538),
+					uploadSpeed: nestedNumeric(nested, 1549),
+					downloadSpeed: nestedNumeric(nested, 1550),
+					uploadState: nestedNumeric(nested, 1564),
+					downloadState: nestedNumeric(nested, 1548),
+					ip: nestedIp(nested, 1552),
+					port: nestedNumeric(nested, 1553),
+					remoteQueueRank: nestedNumeric(nested, 1562),
+					waitingPosition: nestedNumeric(nested, 1558),
+					identState: nestedNumeric(nested, 1559),
+					obfuscationStatus: nestedNumeric(nested, 1560),
+					remoteFilename: nestedString(nested, 1575),
+					availableParts: nestedNumeric(nested, 1578),
+					sourceFrom: nestedNumeric(nested, 1551)
+				});
+			}
+			const namesTag = nestedTag(fileTag, 789);
+			const countsTag = nestedTag(fileTag, 796);
+			const nameTags = namesTag?.nestedTags || [];
+			const countTags = countsTag?.nestedTags || [];
+			for (let i = 0; i < nameTags.length; i++) {
+				const name = stringValue(nameTags[i]);
+				if (!name) continue;
+				const rawCount = countTags[i]?.getValue();
+				const count = typeof rawCount === "number" ? rawCount : typeof rawCount === "bigint" ? Number(rawCount) : 1;
+				sourceNames.push({
+					name,
+					count
+				});
+			}
+			result[fileHash] = {
+				sources,
+				sourceNames
+			};
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/response/DownloadQueueResponse.ts
+var DownloadQueueResponseParser = class {
+	static fromPacket(packet) {
+		const files = [];
+		const chunkDetailsByHash = DownloadChunkDetailsResponseParser.fromPacket(packet);
+		const sourceDetailsByHash = DownloadSourceDetailsResponseParser.fromPacket(packet);
+		const partfileTags = packet.tags.filter((tag) => tag.name === 768);
+		for (const fileTag of partfileTags) {
+			const tags = fileTag.nestedTags || [];
+			const hashTag = findTag(tags, 798);
+			const fileNameTag = findTag(tags, 769);
+			let a4afSources = void 0;
+			const a4afSourcesTag = findTag(tags, 802);
+			if (a4afSourcesTag) {
+				a4afSources = [];
+				a4afSourcesTag.nestedTags = a4afSourcesTag.nestedTags || [];
+				for (const sourceTag of a4afSourcesTag.nestedTags) if (sourceTag.name === 15) a4afSources.push(sourceTag.getValue());
+			}
+			const file = {
+				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(),
+				partMetID: findNumericTag(tags, 770)?.getShort(),
+				sizeXfer: toOptionalNumber(findNumericTag(tags, 772)?.getLong()),
+				sizeDone: toOptionalNumber(findNumericTag(tags, 774)?.getLong()),
+				fileStatus: findNumericTag(tags, 776)?.getInt(),
+				stopped: toOptionalBool(findNumericTag(tags, 791)?.getInt()),
+				sourceCount: findNumericTag(tags, 778)?.getShort(),
+				sourceNotCurrCount: findNumericTag(tags, 780)?.getShort(),
+				sourceXferCount: findNumericTag(tags, 781)?.getShort(),
+				sourceCountA4AF: findNumericTag(tags, 779)?.getShort(),
+				speed: toOptionalNumber(findNumericTag(tags, 775)?.getLong()),
+				downPrio: findNumericTag(tags, 777)?.getInt(),
+				fileCat: toOptionalNumber(findNumericTag(tags, 783)?.getLong()),
+				lastSeenComplete: toOptionalNumber(findNumericTag(tags, 785)?.getLong()),
+				lastDateChanged: toOptionalNumber(findNumericTag(tags, 784)?.getLong()),
+				downloadActiveTime: findNumericTag(tags, 792)?.getInt(),
+				availablePartCount: findNumericTag(tags, 797)?.getShort(),
+				a4AFAuto: toOptionalBool(findNumericTag(tags, 801)?.getInt()),
+				hashingProgress: toOptionalBool(findNumericTag(tags, 800)?.getInt()),
+				getLostDueToCorruption: toOptionalNumber(findNumericTag(tags, 793)?.getLong()),
+				getGainDueToCompression: toOptionalNumber(findNumericTag(tags, 794)?.getLong()),
+				totalPacketsSavedDueToICH: findNumericTag(tags, 795)?.getInt(),
+				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(),
+				a4afSources
+			};
+			if (file.fileHashHexString) {
+				file.chunkInfo = chunkDetailsByHash[file.fileHashHexString];
+				const sourceDetails = sourceDetailsByHash[file.fileHashHexString];
+				if (sourceDetails) {
+					file.sources = sourceDetails.sources;
+					file.sourceNames = sourceDetails.sourceNames;
+				}
+			}
+			files.push(file);
+		}
+		return { files };
+	}
+};
+//#endregion
+export { DownloadQueueResponseParser };

package/dist/GetPreferencesRequest-DsxlghqT.js

@@ -0,0 +1,16 @@
+import { t as Request } from "./Request-C0UUuQIX.js";
+import "./Codes-CjiW7Pdl.js";
+import { l as UIntTag, s as UByteTag } from "./Tag-CZF6BRMY.js";
+//#region src/request/GetPreferencesRequest.ts
+/**
+* Preferences Request - Get preferences
+*/
+var GetPreferencesRequest = class extends Request {
+	constructor(pref) {
+		super(63);
+		this.addTag(new UByteTag(4, 2));
+		this.addTag(new UIntTag(4096, pref));
+	}
+};
+//#endregion
+export { GetPreferencesRequest };

package/dist/PreferencesDetailsResponse-DapscVQi.js

@@ -0,0 +1,94 @@
+import "./Codes-CjiW7Pdl.js";
+import { f as findNumericTag, p as findTag } from "./Tag-CZF6BRMY.js";
+//#region src/response/PreferencesDetailsResponse.ts
+var PreferencesDetailsResponse = class {
+	preferences;
+	constructor(preferences) {
+		this.preferences = preferences;
+	}
+};
+function getNestedTag(parent, name) {
+	if (!parent?.nestedTags) return;
+	return findTag(parent.nestedTags, name);
+}
+function getNestedNumber(parent, name, fallback) {
+	if (!parent?.nestedTags) return fallback;
+	const numeric = findNumericTag(parent.nestedTags, name);
+	if (numeric) return Number(numeric.getValue());
+	const tag = findTag(parent.nestedTags, name);
+	if (!tag) return fallback;
+	const value = tag.getValue();
+	if (typeof value === "number") return value;
+	if (typeof value === "bigint") return Number(value);
+	return fallback;
+}
+function getNestedBool(parent, name, fallback) {
+	const tag = getNestedTag(parent, name);
+	if (!tag) return fallback;
+	const value = tag.getValue();
+	if (typeof value === "boolean") return value;
+	if (typeof value === "number") return value !== 0;
+	if (typeof value === "bigint") return value !== 0n;
+	if (Buffer.isBuffer(value)) return value.length === 0 || value.some((byte) => byte !== 0);
+	return true;
+}
+function getNestedString(parent, name, fallback) {
+	const tag = getNestedTag(parent, name);
+	if (!tag) return fallback;
+	const value = tag.getValue();
+	return typeof value === "string" ? value : fallback;
+}
+var PreferencesDetailsResponseParser = class {
+	static fromPacket(packet) {
+		const generalTag = findTag(packet.tags, 4608);
+		const connectionTag = findTag(packet.tags, 4864);
+		const serversTag = findTag(packet.tags, 5888);
+		const securityTag = findTag(packet.tags, 7168);
+		return new PreferencesDetailsResponse({
+			general: {
+				userNick: getNestedString(generalTag, 4609, ""),
+				checkNewVersion: getNestedBool(generalTag, 4612, false)
+			},
+			connection: {
+				uploadCapacity: getNestedNumber(connectionTag, 4866, 0),
+				downloadCapacity: getNestedNumber(connectionTag, 4865, 0),
+				maxUploadSpeed: getNestedNumber(connectionTag, 4868, 0),
+				maxDownloadSpeed: getNestedNumber(connectionTag, 4867, 0),
+				slotAllocation: getNestedNumber(connectionTag, 4869, 2),
+				tcpPort: getNestedNumber(connectionTag, 4870, 4662),
+				udpPort: getNestedNumber(connectionTag, 4871, 4672),
+				maxFileSources: getNestedNumber(connectionTag, 4873, 300),
+				maxConnections: getNestedNumber(connectionTag, 4874, 500),
+				autoconnect: getNestedBool(connectionTag, 4875, false),
+				reconnect: getNestedBool(connectionTag, 4876, false),
+				networkED2K: getNestedBool(connectionTag, 4877, true),
+				networkKademlia: getNestedBool(connectionTag, 4878, false)
+			},
+			servers: {
+				removeDead: getNestedBool(serversTag, 5889, true),
+				deadRetries: getNestedNumber(serversTag, 5890, 3),
+				useScoreSystem: getNestedBool(serversTag, 5895, true),
+				smartIdCheck: getNestedBool(serversTag, 5896, true),
+				updateUrl: getNestedString(serversTag, 5900, "")
+			},
+			security: {
+				canSeeShares: getNestedNumber(securityTag, 7169, 2),
+				ipFilterClients: getNestedBool(securityTag, 7170, true),
+				ipFilterServers: getNestedBool(securityTag, 7171, true),
+				ipFilterAutoUpdate: getNestedBool(securityTag, 7172, false),
+				ipFilterUpdateUrl: getNestedString(securityTag, 7173, ""),
+				ipFilterLevel: getNestedNumber(securityTag, 7174, 127),
+				filterLan: getNestedBool(securityTag, 7175, true),
+				useSecIdent: getNestedBool(securityTag, 7176, true),
+				obfuscationSupported: getNestedBool(securityTag, 7177, true),
+				obfuscationRequested: getNestedBool(securityTag, 7178, false),
+				obfuscationRequired: getNestedBool(securityTag, 7179, false)
+			}
+		});
+	}
+	static preferenceMaskForAllSections() {
+		return 2118;
+	}
+};
+//#endregion
+export { PreferencesDetailsResponseParser };

package/dist/PreferencesResponse-8n1STWUZ.js

@@ -0,0 +1,37 @@
+import "./Codes-CjiW7Pdl.js";
+import { f as findNumericTag, p as findTag } from "./Tag-CZF6BRMY.js";
+//#region src/response/PreferencesResponse.ts
+var PreferencesResponse = class {
+	categories;
+	constructor(categories) {
+		this.categories = categories;
+	}
+};
+var PreferencesResponseParser = class {
+	static fromPacket(packet) {
+		const categories = [];
+		const prefsCategoriesTag = findTag(packet.tags, 4352);
+		if (prefsCategoriesTag && prefsCategoriesTag.nestedTags) {
+			for (const categoryTag of prefsCategoriesTag.nestedTags) if (categoryTag.name === 4353) {
+				const nestedTags = categoryTag.nestedTags || [];
+				const idTag = categoryTag;
+				const nameTag = findTag(nestedTags, 4354);
+				const pathTag = findTag(nestedTags, 4355);
+				const commentTag = findTag(nestedTags, 4356);
+				const colorTag = findNumericTag(nestedTags, 4357);
+				const priorityTag = findNumericTag(nestedTags, 4358);
+				if (nameTag) categories.push({
+					id: idTag ? Number(idTag.getInt()) : 0,
+					name: nameTag.getValue() || "",
+					path: pathTag ? pathTag.getValue() : "",
+					comment: commentTag ? commentTag.getValue() : "",
+					color: colorTag ? Number(colorTag.getInt()) : 0,
+					priority: priorityTag ? Number(priorityTag.getInt()) : 0
+				});
+			}
+		}
+		return new PreferencesResponse(categories);
+	}
+};
+//#endregion
+export { PreferencesResponseParser };

package/dist/ReloadSharedFilesRequest-kt0Pxs8A.js

@@ -0,0 +1,13 @@
+import { t as Request } from "./Request-C0UUuQIX.js";
+import "./Codes-CjiW7Pdl.js";
+//#region src/request/ReloadSharedFilesRequest.ts
+/**
+* Reload Shared Files Request - Reload shared files list
+*/
+var ReloadSharedFilesRequest = class extends Request {
+	constructor() {
+		super(35);
+	}
+};
+//#endregion
+export { ReloadSharedFilesRequest };

package/dist/Request-C0UUuQIX.js

@@ -0,0 +1,158 @@
+//#region src/ec/packet/Flags.ts
+/**
+* Packet flags for EC protocol
+*/
+var Flags = class Flags {
+	static FLAG_ACCEPTS = 16;
+	static FLAG_ZLIB = 1;
+	static FLAG_UTF8_NUMBERS = 2;
+	static FLAG_ALWAYS_SET = 32;
+	flags;
+	constructor(flags) {
+		this.flags = flags ?? 0;
+	}
+	/**
+	* Create flags from buffer
+	*/
+	static fromBuffer(buffer, offset = 0) {
+		return new Flags(buffer.readUInt32BE(offset));
+	}
+	/**
+	* Write flags to buffer
+	*/
+	writeToBuffer(buffer, offset = 0) {
+		buffer.writeUInt32BE(this.flags, offset);
+	}
+	/**
+	* Check if UTF-8 number encoding is supported/accepted
+	*/
+	isUtf8NumbersAccepted() {
+		return (this.flags & Flags.FLAG_ACCEPTS) > 0 && (this.flags & Flags.FLAG_UTF8_NUMBERS) > 0;
+	}
+	/**
+	* Check if ZLIB compression is supported/accepted
+	*/
+	isZlibAccepted() {
+		return (this.flags & Flags.FLAG_ACCEPTS) > 0 && (this.flags & Flags.FLAG_ZLIB) > 0;
+	}
+	/**
+	* Check if UTF-8 number encoding is used
+	*/
+	isUtf8Numbers() {
+		return (this.flags & Flags.FLAG_UTF8_NUMBERS) > 0;
+	}
+	/**
+	* Check if ZLIB compression is used
+	*/
+	isZlib() {
+		return (this.flags & Flags.FLAG_ZLIB) > 0;
+	}
+	/**
+	* Create flags accepting UTF-8 numbers and ZLIB
+	*/
+	static accept() {
+		return new Flags(Flags.FLAG_ACCEPTS | Flags.FLAG_UTF8_NUMBERS | Flags.FLAG_ZLIB | Flags.FLAG_ALWAYS_SET);
+	}
+	/**
+	* Create flags using UTF-8 numbers
+	*/
+	static useUtf8Numbers() {
+		return new Flags(Flags.FLAG_UTF8_NUMBERS | Flags.FLAG_ALWAYS_SET);
+	}
+	/**
+	* Create flags without UTF-8 numbers (required for search)
+	*/
+	static noUtf8() {
+		return new Flags(Flags.FLAG_ALWAYS_SET);
+	}
+	/**
+	* Create flags using ZLIB compression
+	*/
+	static useZlib() {
+		return new Flags(Flags.FLAG_ZLIB | Flags.FLAG_ALWAYS_SET);
+	}
+	/**
+	* Get numeric value of flags
+	*/
+	getValue() {
+		return this.flags;
+	}
+};
+//#endregion
+//#region src/ec/packet/Packet.ts
+var Packet = class Packet {
+	opCode;
+	flags;
+	tags;
+	static EC_CURRENT_PROTOCOL_VERSION = 516;
+	constructor(opCode, flags = new Flags(), tags = []) {
+		this.opCode = opCode;
+		this.flags = flags;
+		this.tags = tags;
+	}
+	/**
+	* Add a tag to the packet
+	*/
+	addTag(tag) {
+		this.tags.push(tag);
+		return this;
+	}
+	/**
+	* Add multiple tags to the packet
+	*/
+	addTags(tags) {
+		this.tags.push(...tags);
+		return this;
+	}
+	/**
+	* Get protocol version
+	*/
+	static getProtocolVersion() {
+		return Packet.EC_CURRENT_PROTOCOL_VERSION;
+	}
+	/**
+	* Find a tag by name
+	*/
+	findTag(tagName) {
+		return this.tags.find((tag) => tag.name === tagName);
+	}
+	/**
+	* Get all tags with a specific name
+	*/
+	findAllTags(tagName) {
+		return this.tags.filter((tag) => tag.name === tagName);
+	}
+	/**
+	* Check if packet has a specific tag
+	*/
+	hasTag(tagName) {
+		return this.findTag(tagName) !== void 0;
+	}
+};
+//#endregion
+//#region src/request/Request.ts
+/**
+* Base Request class
+*/
+var Request = class {
+	opCode;
+	tags = [];
+	constructor(opCode) {
+		this.opCode = opCode;
+	}
+	/**
+	* Add a tag to the request
+	*/
+	addTag(tag) {
+		this.tags.push(tag);
+	}
+	/**
+	* Build the packet for this request
+	*/
+	buildPacket() {
+		const flags = Flags.useUtf8Numbers();
+		return new Packet(this.opCode, flags, this.tags);
+	}
+};
+//#endregion
+export { Packet as n, Flags as r, Request as t };

package/dist/SearchProgressResponse-C1CdzKnz.js

@@ -0,0 +1,15 @@
+import "./Codes-CjiW7Pdl.js";
+import { f as findNumericTag } from "./Tag-CZF6BRMY.js";
+//#region src/response/SearchProgressResponse.ts
+var SearchProgressResponse = class SearchProgressResponse {
+	progress;
+	constructor(progress) {
+		this.progress = progress;
+	}
+	static fromPacket(packet) {
+		const progressTag = findNumericTag(packet.tags, 1800);
+		return new SearchProgressResponse(progressTag ? Number(progressTag.getValue()) / 100 : 0);
+	}
+};
+//#endregion
+export { SearchProgressResponse };

package/dist/SearchRequest-DQnKfA5Z.js

@@ -0,0 +1,55 @@
+import { n as Packet, r as Flags, t as Request } from "./Request-C0UUuQIX.js";
+import "./Codes-CjiW7Pdl.js";
+import { a as StringTag, l as UIntTag, s as UByteTag, u as ULongTag } from "./Tag-CZF6BRMY.js";
+import "./index.js";
+//#region src/request/SearchRequest.ts
+/**
+* Search Request - Start a search
+*
+* In the EC protocol, search is structured as:
+* - EC_TAG_SEARCH_TYPE (UByte) containing subtag:
+*   - EC_TAG_SEARCH_NAME (String) with the search query
+* - Uses non-UTF8 flags (Flags.noUtf8())
+*/
+var SearchRequest = class extends Request {
+	query;
+	searchType;
+	filters;
+	constructor(query, searchType = 0, filters) {
+		super(38);
+		this.query = query;
+		this.searchType = searchType;
+		this.filters = filters;
+	}
+	/**
+	* Override buildPacket to use non-UTF8 flags and correct tag structure
+	*/
+	buildPacket() {
+		const flags = Flags.noUtf8();
+		const tags = this.buildTags();
+		return new Packet(this.opCode, flags, tags);
+	}
+	buildTags() {
+		const tags = [];
+		const searchTypeTag = new UByteTag(1793, this.convertSearchType(this.searchType), [new StringTag(1794, this.query)]);
+		tags.push(searchTypeTag);
+		if (this.filters) {
+			if (this.filters.minSize !== void 0) tags.push(new ULongTag(1795, BigInt(this.filters.minSize)));
+			if (this.filters.maxSize !== void 0) tags.push(new ULongTag(1796, BigInt(this.filters.maxSize)));
+			if (this.filters.fileType !== void 0) tags.push(new StringTag(1797, this.filters.fileType));
+			if (this.filters.extension !== void 0) tags.push(new StringTag(1798, this.filters.extension));
+			if (this.filters.availability !== void 0) tags.push(new UIntTag(1799, this.filters.availability));
+		}
+		return tags;
+	}
+	convertSearchType(searchType) {
+		switch (searchType) {
+			case 0: return 0;
+			case 1: return 1;
+			case 2: return 2;
+			case 3: return 3;
+		}
+	}
+};
+//#endregion
+export { SearchRequest };

package/dist/SearchResultsRequest-2ejFGQmQ.js

@@ -0,0 +1,13 @@
+import { t as Request } from "./Request-C0UUuQIX.js";
+import "./Codes-CjiW7Pdl.js";
+//#region src/request/SearchResultsRequest.ts
+/**
+* Search Results Request - Get search results
+*/
+var SearchResultsRequest = class extends Request {
+	constructor() {
+		super(40);
+	}
+};
+//#endregion
+export { SearchResultsRequest };