xrootd 0.2.3 → 1.0.0-beta.2

package/dist/index.mjs

@@ -1,785 +1,1616 @@
-import { Readable, Writable } from "node:stream";
-import nodeGypBuild from "node-gyp-build";
-import path, { posix } from "node:path";
-import { URL } from "node:url";
-//#region lib/native.ts
-const nativeAddon = nodeGypBuild(path.resolve(import.meta.dirname, ".."));
-//#endregion
-//#region lib/enums.ts
-/**
-* XrdCl::OpenFlags - 文件打开选项
-* @see src/XProtocol/XProtocol.hh:XOpenRequestOption
-* @see src/XrdCl/XrdClFileSystem.hh:OpenFlags::Flags
-*/
+import net from "node:net";
+import tls from "node:tls";
+//#region src/protocol/constants.ts
+const RequestId = {
+	Auth: 3e3,
+	Query: 3001,
+	Chmod: 3002,
+	Close: 3003,
+	Dirlist: 3004,
+	Gpfile: 3005,
+	Protocol: 3006,
+	Login: 3007,
+	Mkdir: 3008,
+	Mv: 3009,
+	Open: 3010,
+	Ping: 3011,
+	Chkpoint: 3012,
+	Read: 3013,
+	Rm: 3014,
+	Rmdir: 3015,
+	Sync: 3016,
+	Stat: 3017,
+	Set: 3018,
+	Write: 3019,
+	Fattr: 3020,
+	Prepare: 3021,
+	Statx: 3022,
+	Endsess: 3023,
+	Bind: 3024,
+	ReadV: 3025,
+	PgWrite: 3026,
+	Locate: 3027,
+	Truncate: 3028,
+	Sigver: 3029,
+	PgRead: 3030,
+	WriteV: 3031,
+	Clone: 3032
+};
+const ResponseStatus = {
+	Ok: 0,
+	Oksofar: 4e3,
+	Attn: 4001,
+	Authmore: 4002,
+	Error: 4003,
+	Redirect: 4004,
+	Wait: 4005,
+	Waitresp: 4006,
+	Status: 4007
+};
+const ServerError = {
+	ArgInvalid: 3e3,
+	ArgMissing: 3001,
+	ArgTooLong: 3002,
+	FileLocked: 3003,
+	FileNotOpen: 3004,
+	FSError: 3005,
+	InvalidRequest: 3006,
+	IOError: 3007,
+	NoMemory: 3008,
+	NoSpace: 3009,
+	NotAuthorized: 3010,
+	NotFound: 3011,
+	ServerError: 3012,
+	Unsupported: 3013,
+	NoServer: 3014,
+	NotFile: 3015,
+	IsDirectory: 3016,
+	Cancelled: 3017,
+	ItExists: 3018,
+	CheckSumErr: 3019,
+	InProgress: 3020,
+	OverQuota: 3021,
+	SigVerErr: 3022,
+	DecryptErr: 3023,
+	Overloaded: 3024,
+	FsReadOnly: 3025,
+	BadPayload: 3026,
+	AttrNotFound: 3027,
+	TLSRequired: 3028,
+	NoReplicas: 3029,
+	AuthFailed: 3030,
+	Impossible: 3031,
+	Conflict: 3032,
+	TooManyErrs: 3033,
+	ReqTimedOut: 3034,
+	TimerExpired: 3035
+};
+const ClientError = {
+	Ok: 0,
+	InvalidArgs: 300,
+	NotFound: 301,
+	Permission: 302,
+	Serialization: 303,
+	CommandNotFound: 304,
+	HostNotFound: 305,
+	ServiceUnavail: 306,
+	InternalError: 307,
+	BadRequest: 308,
+	Timeout: 309,
+	InsufficientData: 310,
+	Uninitialized: 311,
+	Disconnected: 312,
+	Redirect: 313,
+	LossyRetry: 314,
+	TooManyRedirs: 315,
+	ChunkChecksumErr: 316,
+	UnexpectedResp: 317,
+	ClientSkipped: 318,
+	Failed: 501,
+	WinNetworkError: 601
+};
 const OpenFlags = {
-	None: 0,
-	Compress: 1,
+	Read: 16,
+	Write: 32,
+	Append: 512,
+	New: 8,
 	Delete: 2,
 	Force: 4,
-	New: 8,
-	Read: 16,
-	Update: 32,
+	Compress: 1,
+	Async: 64,
 	Refresh: 128,
-	MakePath: 256,
-	IntentDirList: 1024,
+	Mkpath: 256,
+	Retstat: 1024,
 	Replica: 2048,
-	POSC: 4096,
-	NoWait: 8192,
-	SeqIO: 16384,
-	Write: 32768,
-	PrefName: 256,
-	Dup: 65536,
-	Samefs: 131072
+	Posc: 4096,
+	Nowait: 8192,
+	Seqio: 16384,
+	Wrto: 32768
 };
-/**
-* XrdCl::Access - 文件访问权限模式
-* @see src/XProtocol/XProtocol.hh:XOpenRequestMode
-* @see src/XrdCl/XrdClFileSystem.hh:Access::Mode
-*/
-const AccessMode = {
-	None: 0,
-	UR: 256,
-	UW: 128,
-	UX: 64,
-	GR: 32,
-	GW: 16,
-	GX: 8,
-	OR: 4,
-	OW: 2,
-	OX: 1
+const PROTOCOL_VERSION = 1312;
+const REQUEST_HDR_SIZE = 24;
+const RESPONSE_HDR_SIZE = 8;
+const BODY_SIZE = 16;
+const SESS_ID_SIZE = 16;
+const FHANDLE_SIZE = 4;
+const REQUEST_OFFSET_STREAM_ID = 0;
+const REQUEST_OFFSET_REQUEST_ID = 2;
+const REQUEST_OFFSET_BODY = 4;
+const REQUEST_OFFSET_DLEN = 20;
+const RESPONSE_OFFSET_STREAM_ID = 0;
+const RESPONSE_OFFSET_STATUS = 2;
+const RESPONSE_OFFSET_DLEN = 4;
+const RESPONSE_OFFSET_BODY = 8;
+const HANDSHAKE_FIRST = 0;
+const HANDSHAKE_SECOND = 0;
+const HANDSHAKE_THIRD = 0;
+const HANDSHAKE_FOURTH = 4;
+const HANDSHAKE_FIFTH = 2012;
+const kXR_secreqs = 1;
+const kXR_ableTLS = 2;
+const kXR_wantTLS = 4;
+const kXR_bifreqs = 8;
+const kXR_ExpLogin = 1;
+const kXR_ExpBind = 2;
+const DEFAULT_PORT = 1094;
+const S_IFDIR = 16384;
+const S_IFLNK = 40960;
+const DirlistOptions = {
+	Online: 1,
+	Dstat: 2,
+	Dcksm: 4,
+	Dstatx: 8
 };
-/**
-* XrdCl::MkDirFlags - 目录创建选项
-* @see src/XrdCl/XrdClFileSystem.hh:MkDirFlags::Flags
-*/
-const MkDirFlags = {
-	None: 0,
-	MakePath: 1
+const CRED_TYPE = {
+	host: 0,
+	sss: 1,
+	unix: 2,
+	krb5: 3,
+	gsi: 4
 };
-const StatFlags = {
-	XBitSet: 1,
-	//!< Executable/searchable bit set
-	IsDir: 2,
-	//!< This is a directory
-	Other: 4,
-	//!< Neither a file nor a directory
-	Offline: 8,
-	//!< File is not online (ie. on disk)
-	POSCPending: 64,
-	//!< File opened with POST flag, not yet successfully closed
-	IsReadable: 16,
-	//!< Read access is allowed
-	IsWritable: 32,
-	//!< Write access is allowed
-	BackUpExists: 128
+//#endregion
+//#region src/url/url.ts
+var XRootDUrl = class XRootDUrl {
+	protocol;
+	user;
+	password;
+	host;
+	port;
+	path;
+	constructor(url) {
+		const normalized = url.startsWith("root://") || url.startsWith("roots://") ? url : `root://${url}`;
+		const parsed = new URL(normalized);
+		const protocol = parsed.protocol.replace(/:$/, "");
+		if (protocol !== "root" && protocol !== "roots") throw new Error(`Invalid XRootD URL protocol: ${protocol}`);
+		this.protocol = protocol;
+		this.host = parsed.hostname;
+		this.port = parsed.port ? parseInt(parsed.port, 10) : DEFAULT_PORT;
+		this.path = parsed.pathname || "/";
+		this.user = parsed.username || void 0;
+		this.password = parsed.password || void 0;
+	}
+	static parse(url) {
+		return new XRootDUrl(url);
+	}
+	toString() {
+		const auth = this.getAuthString();
+		const portStr = this.port === 1094 ? "" : `:${this.port}`;
+		return `${this.protocol}://${auth}${this.host}${portStr}${this.path}`;
+	}
+	isValid() {
+		return this.protocol === "root" || this.protocol === "roots";
+	}
+	isSecure() {
+		return this.protocol === "roots";
+	}
+	getHostId() {
+		return `${this.getAuthString()}${this.host}:${this.port}`;
+	}
+	getChannelId() {
+		return `${this.host}:${this.port}`;
+	}
+	getLocation() {
+		return `${this.protocol}://${this.host}:${this.port}${this.path}`;
+	}
+	getAuthString() {
+		if (!this.user) return "";
+		let auth = this.user;
+		if (this.password) auth += ":" + this.password;
+		return auth + "@";
+	}
 };
-//!< Back up copy exists
 //#endregion
-//#region lib/file.ts
-/**
-* XRootD File 客户端
-* 提供对远程文件的异步读写操作及 Node.js 风格的流式接口。
-*/
-var File = class {
-	_internal;
-	constructor(internalInstance) {
-		if (internalInstance) this._internal = internalInstance;
-		else {
-			if (!nativeAddon || !nativeAddon.File) throw new Error("Native addon not loaded properly.");
-			this._internal = new nativeAddon.File();
-		}
+//#region src/transport/transport.ts
+var Transport = class {
+	socket = null;
+	closeCallback = null;
+	errorCallback = null;
+	dataHandlers = [];
+	dataListenerInstalled = false;
+	async connect(host, port, useTls = false) {
+		this.socket = useTls ? await this.tlsConnect(host, port) : await this.tcpConnect(host, port);
+		this.socket.on("close", () => {
+			this.closeCallback?.();
+		});
+		this.socket.on("error", (err) => {
+			this.errorCallback?.(err);
+		});
+		this.socket.on("data", (chunk) => {
+			for (const handler of this.dataHandlers) handler(chunk);
+		});
+		this.dataListenerInstalled = true;
+	}
+	send(data) {
+		return new Promise((resolve, reject) => {
+			this.socket.write(data, (err) => err ? reject(err) : resolve());
+		});
+	}
+	onData(callback) {
+		this.dataHandlers.push(callback);
+	}
+	removeDataHandler(callback) {
+		const idx = this.dataHandlers.indexOf(callback);
+		if (idx >= 0) this.dataHandlers.splice(idx, 1);
+	}
+	onClose(callback) {
+		this.closeCallback = callback;
+	}
+	onError(callback) {
+		this.errorCallback = callback;
 	}
-	/**
-	* 打开远程文件
-	* @param url 目标地址 (如 root://server//path/to/file)
-	* @param flags 打开标志位
-	* @param mode 访问权限模式
-	*/
-	async open(url, flags = OpenFlags.None, mode = AccessMode.None) {
-		return this._internal.Open(url, flags, mode);
-	}
-	/**
-	* 关闭文件
-	*/
 	async close() {
-		return this._internal.Close();
+		this.destroy();
 	}
-	/**
-	* 获取文件状态
-	*/
-	async stat() {
-		return this._internal.Stat();
-	}
-	/**
-	* 读取文件块 (Zero-Copy from C++)
-	* @param offset 偏移量 (支持 >2GB)
-	* @param size 读取字节数
-	* @returns 包含数据的 Node.js Buffer
-	*/
-	async read(offset, size) {
-		return this._internal.Read(BigInt(offset), size);
-	}
-	async write(offset, arg1, arg2, arg3) {
-		if (Buffer.isBuffer(arg1)) return this._internal.Write(BigInt(offset), arg1);
-		else if (typeof arg1 === "number" && typeof arg2 === "number") return this._internal.WriteFd(BigInt(offset), arg1, arg2, arg3 !== void 0 ? BigInt(arg3) : void 0);
-		else throw new TypeError("Invalid arguments for write");
-	}
-	/**
-	* 从本地 fd 写入文件块 (直接映射)
-	* @param offset 写入的起始字节偏移量。
-	* @param size 写入大小。
-	* @param fd 本地文件描述符 (fd)。
-	* @param fdoff 可选，从本地 fd 中读取的起始偏移。
-	*/
-	async writeFd(offset, size, fd, fdoff) {
-		return this._internal.WriteFd(BigInt(offset), size, fd, fdoff !== void 0 ? BigInt(fdoff) : void 0);
-	}
-	/**
-	* 同步文件缓冲区到磁盘
-	*/
-	async sync() {
-		return this._internal.Sync();
+	destroy() {
+		this.socket?.destroy();
+		this.socket = null;
 	}
-	/**
-	* 截断文件
-	* @param size 目标大小
-	*/
-	async truncate(size) {
-		return this._internal.Truncate(BigInt(size));
-	}
-	/**
-	* 检查本地实例状态 (同步操作)
-	*/
-	isOpen() {
-		return this._internal.IsOpen();
-	}
-	async getProperty(name) {
-		const ret = this._internal.GetProperty(name);
-		if (ret.success) return ret.value;
-		throw new Error("TODO");
-	}
-	async setProperty(name, value) {
-		return this._internal.SetProperty(name, value);
-	}
-	/**
-	* 向量化读取 (Vector Read)
-	* 在单个请求中从文件的多个非连续区域读取数据，极大地减少网络往返开销。
-	* @param chunks 包含 offset 和 size 的读取请求数组
-	* @returns 与请求数组顺序对应的 Buffer 数组
-	*/
-	async vectorRead(chunks) {
-		const normalizedChunks = chunks.map((c) => ({
-			offset: BigInt(c.offset),
-			size: c.size
-		}));
-		return this._internal.VectorRead(normalizedChunks);
-	}
-	/**
-	* 读取块 (Read Chunks)
-	* 类似于 VectorRead，但底层实现可能利用更高级的预读或多路复用策略。
-	*/
-	async readChunks(chunks) {
-		const normalizedChunks = chunks.map((c) => ({
-			offset: BigInt(c.offset),
-			size: c.size
-		}));
-		return this._internal.ReadChunks(normalizedChunks);
-	}
-	/**
-	* 设置文件的扩展属性
-	*/
-	async setXAttrs(attrs) {
-		return this._internal.SetXAttr(attrs);
-	}
-	/**
-	* 设置文件的扩展属性
-	*/
-	async setXAttr(key, value) {
-		return (await this._internal.SetXAttr({ [key]: value }))[0].ok;
-	}
-	/**
-	* 获取文件的扩展属性
-	*/
-	async getXAttrs(keys) {
-		return this._internal.GetXAttr(keys);
-	}
-	async getXAttr(key) {
-		return (await this._internal.GetXAttr([key]))[key];
-	}
-	/**
-	* 删除文件的扩展属性
-	*/
-	async delXAttrs(keys) {
-		return this._internal.DelXAttr(keys);
-	}
-	async delXAttr(key) {
-		return (await this._internal.DelXAttr([key]))[0].ok;
-	}
-	/**
-	* 列出文件所有的扩展属性和内容
-	*/
-	async listXAttrs() {
-		return this._internal.ListXAttr();
-	}
-	/**
-	* 将其他文件的指定区间在服务器端克隆到当前文件
-	* 当前文件必须以写入/更新模式打开
-	*/
-	clone(locations) {
-		return this._internal.Clone(locations);
-	}
-	/**
-	* 创建一个可读流 (Readable Stream)
-	* 使得 XRootD 文件可以无缝 pipe 到其他 Node.js 流 (如本地 fs, HTTP response)
-	*/
-	createReadStream(options = {}) {
-		let currentOffset = options.start ?? 0n;
-		const endOffset = options.end;
-		const chunkSize = options.highWaterMark ?? 64 * 1024;
-		const self = this;
-		return new Readable({
-			highWaterMark: chunkSize,
-			async read(size) {
-				try {
-					let bytesToRead = size;
-					if (endOffset !== void 0) {
-						const remaining = endOffset - currentOffset + 1n;
-						if (remaining <= 0n) {
-							this.push(null);
-							return;
-						}
-						if (remaining < BigInt(bytesToRead)) bytesToRead = Number(remaining);
-					}
-					const buffer = await self.read(currentOffset, bytesToRead);
-					if (buffer.length === 0) this.push(null);
-					else {
-						currentOffset += BigInt(buffer.length);
-						this.push(buffer);
-					}
-				} catch (err) {
-					this.destroy(err instanceof Error ? err : new Error(String(err)));
-				}
-			}
+	tcpConnect(host, port) {
+		return new Promise((resolve, reject) => {
+			const socket = net.connect(port, host, () => resolve(socket));
+			socket.once("error", reject);
 		});
 	}
-	/**
-	* 创建一个可写流 (Writable Stream)
-	* 支持通过 pipe 将大量数据流式写入 XRootD 服务器
-	*/
-	createWriteStream(options = {}) {
-		let currentOffset = options.start ?? 0n;
-		const self = this;
-		return new Writable({
-			async write(chunk, encoding, callback) {
-				try {
-					const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
-					await self.write(currentOffset, buffer);
-					currentOffset += BigInt(buffer.length);
-					callback();
-				} catch (err) {
-					callback(err instanceof Error ? err : new Error(String(err)));
-				}
-			},
-			async writev(chunks, callback) {
-				try {
-					const buffers = chunks.map((c) => Buffer.isBuffer(c.chunk) ? c.chunk : Buffer.from(c.chunk, c.encoding));
-					const masterBuffer = Buffer.concat(buffers);
-					await self.write(currentOffset, masterBuffer);
-					currentOffset += BigInt(masterBuffer.length);
-					callback();
-				} catch (err) {
-					callback(err instanceof Error ? err : new Error(String(err)));
-				}
-			}
+	tlsConnect(host, port) {
+		return new Promise((resolve, reject) => {
+			const socket = tls.connect({
+				host,
+				port,
+				rejectUnauthorized: false
+			}, () => resolve(socket));
+			socket.once("error", reject);
 		});
 	}
 };
 //#endregion
-//#region lib/utils.ts
-function reverseStr(str) {
-	let reversed = "";
-	for (let i = str.length - 1; i >= 0; i--) reversed += str.charAt(i);
-	return reversed;
-}
-function isXrdError(e) {
-	return e instanceof Error && "xrdStatus" in e && typeof e.xrdStatus === "number" && e.xrdStatus > 0;
-}
-//#endregion
-//#region lib/filesystem.ts
+//#region src/transport/framer.ts
 /**
-* XRootD FileSystem 客户端
-* 提供对远程服务器目录和文件的通用管理操作。
+* Frame parser: handles TCP fragmentation, splits byte stream into complete XRootD response frames.
+*
+* XRootD response format:
+*   streamid[2] + status[2] + dlen[4] + body[dlen]
+*   Fixed header 8 bytes + variable body
 */
-var FileSystem = class {
-	_internal;
-	serverUrl;
-	/**
-	* 实例化一个 FileSystem 客户端
-	* @param url 服务器地址 (例如: 'root://eospublic.cern.ch')
-	*/
-	constructor(url) {
-		if (!nativeAddon || !nativeAddon.FileSystem) throw new Error("Native addon not loaded properly. Cannot instantiate FileSystem.");
-		this.serverUrl = url;
-		this._internal = new nativeAddon.FileSystem(url);
-	}
-	/**
-	* 内部辅助方法：确保路径是标准的 Unix 绝对路径
-	*/
-	_normalize(targetPath) {
-		const posixPath = posix.normalize(targetPath);
-		return posixPath.startsWith("/") ? posixPath : "/" + posixPath;
-	}
-	/**
-	* 定位文件在集群中的具体数据节点
-	* @param filePath 目标文件路径
-	* @param flags 定位标志位 (默认 0)
-	* @returns 包含主机、端口等信息的数组
-	*/
-	async locate(filePath, flags = 0) {
-		return this._internal.Locate(this._normalize(filePath), flags);
-	}
-	/**
-	* 获取文件或目录的状态信息
-	* @param targetPath 目标路径
-	*/
-	async stat(targetPath) {
-		const rawStat = await this._internal.Stat(this._normalize(targetPath));
-		return {
-			...rawStat,
-			get modeOctal() {
-				return reverseStr(rawStat.modeAsOctString);
-			},
-			get modeString() {
-				return reverseStr(rawStat.modeAsString);
-			},
-			get isFile() {
-				return (rawStat.flags & StatFlags.IsDir) === 0 && (rawStat.flags & StatFlags.Other) === 0;
-			},
-			get isDir() {
-				return (rawStat.flags & StatFlags.IsDir) !== 0;
-			},
-			get isOther() {
-				return (rawStat.flags & StatFlags.Other) !== 0;
-			},
-			get isOffline() {
-				return (rawStat.flags & StatFlags.Offline) !== 0;
-			},
-			get isPOSCPending() {
-				return (rawStat.flags & StatFlags.POSCPending) !== 0;
-			},
-			get isReadable() {
-				return (rawStat.flags & StatFlags.IsReadable) !== 0;
-			},
-			get isWritable() {
-				return (rawStat.flags & StatFlags.IsWritable) !== 0;
-			},
-			get isBackUpExists() {
-				return (rawStat.flags & StatFlags.BackUpExists) !== 0;
-			}
-		};
-	}
-	/**
-	* 删除远程文件
-	* @param filePath 要删除的文件路径
-	*/
-	async rm(filePath) {
-		return this._internal.Rm(this._normalize(filePath));
-	}
-	/**
-	* 创建远程目录
-	* @param dirPath 目录路径
-	* @param flags 标志位 (例如 MakePath，允许创建多级父目录)
-	* @param mode 访问权限模式 (默认 0755 对应的 AccessMode)
-	*/
-	async mkdir(dirPath, flags = MkDirFlags.None, mode = AccessMode.UR | AccessMode.UW | AccessMode.UX | AccessMode.GR | AccessMode.GX | AccessMode.OR | AccessMode.OX) {
-		return this._internal.MkDir(this._normalize(dirPath), flags, mode);
-	}
-	/**
-	* 删除远程目录 (目录必须为空)
-	* @param dirPath 要删除的目录路径
-	*/
-	async rmdir(dirPath) {
-		return this._internal.RmDir(this._normalize(dirPath));
-	}
-	/**
-	* 移动或重命名文件/目录
-	* @param source 源路径
-	* @param dest 目标路径
-	*/
-	async mv(source, dest) {
-		return this._internal.Mv(this._normalize(source), this._normalize(dest));
-	}
-	/**
-	* 列出目录下的所有文件和子目录名
-	* @param dirPath 目录路径
-	* @param flags 标志位 (例如是否显示隐藏文件)
-	*/
-	async dirList(dirPath, flags = 0) {
-		return this._internal.DirList(this._normalize(dirPath), flags);
-	}
-	/**
-	* 检查文件或目录是否存在
-	* (通过捕获 stat 的错误来实现，类似于老版本 Node 的 fs.exists)
-	* @param targetPath 目标路径
-	*/
-	async exists(targetPath) {
-		try {
-			await this.stat(targetPath);
-			return true;
-		} catch (err) {
-			debugger;
-			if (isXrdError(err)) {
-				if (err.xrdErrNo === 3011) return false;
-			}
-			throw err;
+var Framer = class {
+	pending = Buffer.alloc(0);
+	/** Feed raw bytes, return parsed complete frames (0 or more) */
+	feed(chunk) {
+		this.pending = Buffer.concat([this.pending, chunk]);
+		const frames = [];
+		while (this.pending.length >= 8) {
+			const dlen = this.pending.readUInt32BE(4);
+			if (this.pending.length < 8 + dlen) break;
+			frames.push({
+				streamId: this.pending.subarray(0, 2),
+				status: this.pending.readUInt16BE(2),
+				dlen,
+				body: this.pending.subarray(8, 8 + dlen)
+			});
+			this.pending = this.pending.subarray(8 + dlen);
 		}
-	}
-	/**
-	* 确保目录存在。如果目录不存在，则会自动创建它及其所有父目录。
-	* (类似于 fs-extra 的 ensureDir 或 mkdir -p)
-	* @param dirPath 目标目录
-	*/
-	async ensureDir(dirPath) {
-		if (!await this.exists(dirPath)) await this.mkdir(dirPath, MkDirFlags.MakePath);
-	}
-	/**
-	* 深度定位：返回包含所有数据节点副本的详细物理位置信息
-	*/
-	async deepLocate(filePath, flags = 0) {
-		return this._internal.DeepLocate(this._normalize(filePath), flags);
-	}
-	/**
-	* 在不打开文件的情况下，直接截断目标文件
-	*/
-	async truncate(filePath, size) {
-		return this._internal.Truncate(this._normalize(filePath), size);
-	}
-	/**
-	* 更改远程文件或目录的访问权限
-	*/
-	async chmod(targetPath, mode) {
-		return this._internal.ChMod(this._normalize(targetPath), mode);
-	}
-	/**
-	* 探活：检查远端文件系统服务是否响应
-	*/
-	async ping() {
-		return this._internal.Ping();
-	}
-	/**
-	* 获取虚拟文件系统(VFS)的状态（如磁盘总容量、剩余可用空间）
-	*/
-	async statVFS(targetPath) {
-		return this._internal.StatVFS(this._normalize(targetPath));
-	}
-	/**
-	* 获取当前连接协议的详细属性
-	*/
-	async protocol() {
-		return this._internal.Protocol();
-	}
-	/**
-	* 发送带外查询指令到数据节点 (通常用于 XRootD 的高级自定义插件)
-	*/
-	async query(queryCode, args) {
-		return this._internal.Query(queryCode, args);
-	}
-	/**
-	* 发送通用信息到服务器
-	*/
-	async sendInfo(info) {
-		return this._internal.SendInfo(info);
-	}
-	/**
-	* 发送缓存操作信息给集群
-	*/
-	async sendCache(info) {
-		return this._internal.SendCache(info);
-	}
-	/**
-	* 数据预热/暂存 (Staging)：
-	* 在处理海量物理数据时，通知存储集群将特定的冷数据（如磁带上的文件）提前拉取到磁盘缓存。
-	* @param targetPaths 需要预热的路径数组
-	* @param flags 预热策略标志
-	* @param priority 优先级
-	*/
-	async prepare(targetPaths, flags = 0, priority = 0) {
-		const normalizedPaths = targetPaths.map((p) => this._normalize(p));
-		return this._internal.Prepare(normalizedPaths, flags, priority);
-	}
-	/**
-	* 获取文件系统属性
-	*/
-	getProperty(name) {
-		return this._internal.GetProperty(name);
-	}
-	/**
-	* 设置文件系统属性
-	*/
-	setProperty(name, value) {
-		return this._internal.SetProperty(name, value);
-	}
-	/**
-	* 设置扩展属性
-	* @param targetPath 目标路径
-	* @param attrs 扩展属性键值对记录
-	*/
-	async setXAttrs(targetPath, attrs) {
-		return this._internal.SetXAttr(this._normalize(targetPath), attrs);
-	}
-	async setXAttr(targetPath, key, value) {
-		return (await this.setXAttrs(targetPath, { [key]: value }))[0].ok;
-	}
-	/**
-	* 获取扩展属性
-	* @param targetPath 目标路径
-	* @param keys 需要获取的属性名数组
-	*/
-	async getXAttrs(targetPath, keys) {
-		return this._internal.GetXAttr(this._normalize(targetPath), keys);
-	}
-	async getXAttr(targetPath, key) {
-		return (await this.getXAttrs(targetPath, [key]))[key];
-	}
-	/**
-	* 删除指定的扩展属性
-	* @param targetPath 目标路径
-	* @param keys 需要删除的属性名数组
-	*/
-	async delXAttrs(targetPath, keys) {
-		return this._internal.DelXAttr(this._normalize(targetPath), keys);
-	}
-	async delXAttr(targetPath, key) {
-		return (await this.delXAttrs(targetPath, [key]))[0].ok;
-	}
-	/**
-	* 列出目标文件或目录的所有扩展属性
-	*/
-	async listXAttr(targetPath) {
-		return this._internal.ListXAttr(this._normalize(targetPath));
+		return frames;
 	}
 };
 //#endregion
-//#region lib/copy.ts
-var CopyProcess = class {
-	nativeCp;
-	constructor() {
-		this.nativeCp = new nativeAddon.CopyProcess();
-	}
-	/**
-	* Add a job to the copy process synchronously
-	*/
-	addJob(config) {
-		this.nativeCp.AddJob(config);
-	}
-	/**
-	* Asynchronously prepare the jobs (resolve DNS, check endpoints, etc.)
-	*/
-	async prepare() {
-		return this.nativeCp.Prepare();
-	}
-	/**
-	* Run the copy process.
-	* @param onProgress Optional progress callback
-	* @returns Array of results corresponding to the jobs added
-	*/
-	async run(onProgress) {
-		if (onProgress) this.nativeCp.SetEventListener("progress", onProgress);
-		return this.nativeCp.Run();
-	}
-	/**
-	* Abort the running copy process.
-	*/
-	abort() {
-		this.nativeCp.CancelJob();
-	}
-	/**
-	* Abort the running copy process. (alias for abort)
-	*/
-	cancelJob() {
-		this.nativeCp.CancelJob();
+//#region src/protocol/message-class.ts
+/**
+* Message builder for constructing binary protocol messages.
+* Tracks offset automatically during writes.
+*/
+var Message = class {
+	buffer;
+	offset = 0;
+	constructor(size) {
+		this.buffer = Buffer.alloc(size);
+	}
+	writeInt32BE(value) {
+		this.buffer.writeInt32BE(value, this.offset);
+		this.offset += 4;
+	}
+	writeInt16BE(value) {
+		this.buffer.writeInt16BE(value, this.offset);
+		this.offset += 2;
+	}
+	writeUInt8(value) {
+		this.buffer.writeUInt8(value, this.offset);
+		this.offset += 1;
+	}
+	writeBytes(data) {
+		Buffer.from(data).copy(this.buffer, this.offset);
+		this.offset += data.length;
+	}
+	readInt32BE() {
+		const value = this.buffer.readInt32BE(this.offset);
+		this.offset += 4;
+		return value;
+	}
+	readInt16BE() {
+		const value = this.buffer.readInt16BE(this.offset);
+		this.offset += 2;
+		return value;
+	}
+	readBytes(length) {
+		const data = this.buffer.subarray(this.offset, this.offset + length);
+		this.offset += length;
+		return data;
+	}
+	getBuffer() {
+		return this.buffer.subarray(0, this.offset);
 	}
 };
 //#endregion
-//#region lib/url.ts
+//#region src/utils/bytes.ts
 /**
-* 纯 TypeScript 实现的 XRootD URL 解析器
-* 安全、轻量，避免跨越 C++ N-API 边界
+* Byte conversion utilities for the XRootD protocol.
 */
-var XRootDUrl = class XRootDUrl {
-	_url;
-	isValid;
-	constructor(urlString) {
-		this._url = new URL(urlString);
-		this.isValid = true;
-		if (![
-			"root",
-			"xrootd",
-			"xroot",
-			"file"
-		].includes(this.protocol)) {
-			console.error("Invalid XRootD URL protocol.");
-			this.isValid = false;
-		} else if (this.hostName.length === 0) this.isValid = false;
-	}
-	get protocol() {
-		return this._url.protocol.replace(/:$/, "");
+/** Convert a stream ID (uint16) to a 2-byte big-endian Uint8Array. */
+function streamIdToBytes(sid) {
+	return new Uint8Array([sid >> 8 & 255, sid & 255]);
+}
+/** Convert a string to UTF-8 bytes. */
+function strToBytes(str) {
+	return Buffer.from(str, "utf8");
+}
+/** Parse a stream ID from 2 big-endian bytes. */
+function bytesToStreamId(bytes) {
+	return bytes[0] << 8 | bytes[1];
+}
+//#endregion
+//#region src/protocol/builders.ts
+/**
+* Request builders for XRootD protocol messages.
+* Each function creates a Buffer ready to send on the wire.
+*/
+/**
+* Initial handshake (20 B) + kXR_protocol (24 B) merged into one 44-byte
+* buffer ready to send immediately after TCP connect.
+*
+* Layout:
+*   [0..19]  ClientInitHandShake
+*   [20..43] kXR_protocol request (streamid=0, body, dlen)
+*/
+function buildHandshakeAndProtocol(streamId, flags = 1, expect = 1) {
+	const msg = new Message(44);
+	msg.writeInt32BE(0);
+	msg.writeInt32BE(0);
+	msg.writeInt32BE(0);
+	msg.writeInt32BE(4);
+	msg.writeInt32BE(HANDSHAKE_FIFTH);
+	msg.writeBytes(streamIdToBytes(streamId));
+	msg.writeInt16BE(RequestId.Protocol);
+	msg.writeInt32BE(PROTOCOL_VERSION);
+	msg.writeUInt8(flags & 255);
+	msg.writeUInt8(expect & 255);
+	msg.writeBytes(/* @__PURE__ */ new Uint8Array(10));
+	msg.writeInt32BE(0);
+	return msg.getBuffer();
+}
+/**
+* kXR_login request (24 B header only, or 24 B + CGI string).
+*
+* Body layout (16 B):
+*   pid[4] + username[8] + ability2[1] + ability[1] + capver[1] + reserved[1]
+*/
+function buildLoginRequest(streamId, pid, username, ability = 0, cgi) {
+	const cgiBytes = cgi ? strToBytes(cgi) : void 0;
+	const msg = new Message(24 + (cgiBytes?.length ?? 0));
+	msg.writeBytes(streamIdToBytes(streamId));
+	msg.writeInt16BE(RequestId.Login);
+	msg.writeInt32BE(pid);
+	const u8 = strToBytes(username);
+	msg.writeBytes(u8.length > 8 ? u8.subarray(0, 8) : u8);
+	if (u8.length < 8) msg.writeBytes(new Uint8Array(8 - u8.length));
+	msg.writeUInt8(0);
+	msg.writeUInt8(ability & 255);
+	msg.writeUInt8(4);
+	msg.writeUInt8(0);
+	msg.writeInt32BE(cgiBytes?.length ?? 0);
+	if (cgiBytes && cgiBytes.length > 0) msg.writeBytes(cgiBytes);
+	return msg.getBuffer();
+}
+/**
+* kXR_open request (24 B header + path string).
+*
+* Body layout (16 B):
+*   mode[2] + options[2] + optiont[2] + reserved[6] + fhtemplt[4]
+*/
+function buildOpenRequest(streamId, path, options, mode = 0) {
+	const pathBytes = strToBytes(path);
+	const msg = new Message(24 + pathBytes.length);
+	msg.writeBytes(streamIdToBytes(streamId));
+	msg.writeInt16BE(RequestId.Open);
+	msg.writeInt16BE(mode & 65535);
+	msg.writeInt16BE(options & 65535);
+	msg.writeInt16BE(0);
+	msg.writeBytes(/* @__PURE__ */ new Uint8Array(6));
+	msg.writeBytes(/* @__PURE__ */ new Uint8Array(4));
+	msg.writeInt32BE(pathBytes.length);
+	msg.writeBytes(pathBytes);
+	return msg.getBuffer();
+}
+/**
+* kXR_read request (24 B header, no extra data).
+*
+* Body layout (16 B):
+*   fhandle[4] + offset[8] + rlen[4]
+*/
+function buildReadRequest(streamId, fhandle, offset, rlen) {
+	const msg = new Message(24);
+	msg.writeBytes(streamIdToBytes(streamId));
+	msg.writeInt16BE(RequestId.Read);
+	msg.writeBytes(fhandle);
+	msg.writeInt32BE(Math.floor(offset / 4294967296));
+	msg.writeInt32BE(offset >>> 0);
+	msg.writeInt32BE(rlen);
+	msg.writeInt32BE(0);
+	return msg.getBuffer();
+}
+/**
+* kXR_write request (24 B header + data bytes).
+*
+* Body layout (16 B):
+*   fhandle[4] + offset[8] + pathid[1] + reserved[3]
+*/
+function buildWriteRequest(streamId, fhandle, offset, data) {
+	const msg = new Message(24 + data.length);
+	msg.writeBytes(streamIdToBytes(streamId));
+	msg.writeInt16BE(RequestId.Write);
+	msg.writeBytes(fhandle);
+	msg.writeInt32BE(Math.floor(offset / 4294967296));
+	msg.writeInt32BE(offset >>> 0);
+	msg.writeUInt8(0);
+	msg.writeBytes(/* @__PURE__ */ new Uint8Array(3));
+	msg.writeInt32BE(data.length);
+	msg.writeBytes(data);
+	return msg.getBuffer();
+}
+/**
+* kXR_close request (24 B header, no extra data).
+*
+* Body layout (16 B):
+*   fhandle[4] + reserved[12]
+*/
+function buildCloseRequest(streamId, fhandle) {
+	const msg = new Message(24);
+	msg.writeBytes(streamIdToBytes(streamId));
+	msg.writeInt16BE(RequestId.Close);
+	msg.writeBytes(fhandle);
+	msg.writeBytes(/* @__PURE__ */ new Uint8Array(12));
+	msg.writeInt32BE(0);
+	return msg.getBuffer();
+}
+/**
+* kXR_stat request (24 B header + optional path string).
+*
+* Body layout (16 B):
+*   options[1] + reserved[7] + wants[4] + fhandle[4]
+*/
+function buildStatRequest(streamId, path, fhandle) {
+	const pathBytes = strToBytes(path);
+	const msg = new Message(24 + pathBytes.length);
+	msg.writeBytes(streamIdToBytes(streamId));
+	msg.writeInt16BE(RequestId.Stat);
+	if (fhandle) {
+		msg.writeUInt8(0);
+		msg.writeBytes(/* @__PURE__ */ new Uint8Array(7));
+		msg.writeBytes(/* @__PURE__ */ new Uint8Array(4));
+		msg.writeBytes(fhandle);
+		msg.writeInt32BE(0);
+	} else {
+		msg.writeUInt8(0);
+		msg.writeBytes(/* @__PURE__ */ new Uint8Array(7));
+		msg.writeBytes(/* @__PURE__ */ new Uint8Array(4));
+		msg.writeBytes(/* @__PURE__ */ new Uint8Array(4));
+		msg.writeInt32BE(pathBytes.length);
+		msg.writeBytes(pathBytes);
+	}
+	return msg.getBuffer();
+}
+/**
+* kXR_sync request (24 B header, no extra data).
+*
+* Body layout (16 B):
+*   fhandle[4] + reserved[12]
+*/
+function buildSyncRequest(streamId, fhandle) {
+	const msg = new Message(24);
+	msg.writeBytes(streamIdToBytes(streamId));
+	msg.writeInt16BE(RequestId.Sync);
+	msg.writeBytes(fhandle);
+	msg.writeBytes(/* @__PURE__ */ new Uint8Array(12));
+	msg.writeInt32BE(0);
+	return msg.getBuffer();
+}
+/**
+* kXR_truncate request (24 B header + 8 B size).
+*
+* Body layout (16 B):
+*   fhandle[4] + reserved[12]
+* Extra data:
+*   size[8] (int64 BE)
+*/
+function buildTruncateRequest(streamId, fhandle, size) {
+	const msg = new Message(32);
+	msg.writeBytes(streamIdToBytes(streamId));
+	msg.writeInt16BE(RequestId.Truncate);
+	msg.writeBytes(fhandle);
+	msg.writeBytes(/* @__PURE__ */ new Uint8Array(12));
+	msg.writeInt32BE(8);
+	msg.writeInt32BE(Math.floor(size / 4294967296));
+	msg.writeInt32BE(size >>> 0);
+	return msg.getBuffer();
+}
+/**
+* kXR_dirlist request (24 B header + path string).
+*
+* Body layout (16 B):
+*   reserved[15] + options[1]
+*/
+function buildDirlistRequest(streamId, path, options = 0) {
+	const pathBytes = strToBytes(path);
+	const msg = new Message(24 + pathBytes.length);
+	msg.writeBytes(streamIdToBytes(streamId));
+	msg.writeInt16BE(RequestId.Dirlist);
+	msg.writeBytes(/* @__PURE__ */ new Uint8Array(15));
+	msg.writeUInt8(options & 255);
+	msg.writeInt32BE(pathBytes.length);
+	msg.writeBytes(pathBytes);
+	return msg.getBuffer();
+}
+/**
+* kXR_mkdir request (24 B header + path string).
+*
+* Body layout (16 B):
+*   mode[2] + reserved[14]
+*/
+function buildMkdirRequest(streamId, path, mode = 493) {
+	const pathBytes = strToBytes(path);
+	const msg = new Message(24 + pathBytes.length);
+	msg.writeBytes(streamIdToBytes(streamId));
+	msg.writeInt16BE(RequestId.Mkdir);
+	msg.writeInt16BE(mode & 65535);
+	msg.writeBytes(/* @__PURE__ */ new Uint8Array(14));
+	msg.writeInt32BE(pathBytes.length);
+	msg.writeBytes(pathBytes);
+	return msg.getBuffer();
+}
+/**
+* kXR_rmdir request (24 B header + path string).
+*
+* Body layout (16 B):
+*   reserved[16]
+*/
+function buildRmdirRequest(streamId, path) {
+	const pathBytes = strToBytes(path);
+	const msg = new Message(24 + pathBytes.length);
+	msg.writeBytes(streamIdToBytes(streamId));
+	msg.writeInt16BE(RequestId.Rmdir);
+	msg.writeBytes(/* @__PURE__ */ new Uint8Array(16));
+	msg.writeInt32BE(pathBytes.length);
+	msg.writeBytes(pathBytes);
+	return msg.getBuffer();
+}
+/**
+* kXR_rm request (24 B header + path string).
+*
+* Body layout (16 B):
+*   reserved[16]
+*/
+function buildRmRequest(streamId, path) {
+	const pathBytes = strToBytes(path);
+	const msg = new Message(24 + pathBytes.length);
+	msg.writeBytes(streamIdToBytes(streamId));
+	msg.writeInt16BE(RequestId.Rm);
+	msg.writeBytes(/* @__PURE__ */ new Uint8Array(16));
+	msg.writeInt32BE(pathBytes.length);
+	msg.writeBytes(pathBytes);
+	return msg.getBuffer();
+}
+/**
+* kXR_mv request (24 B header + source + target).
+*
+* Body layout (16 B):
+*   reserved[14] + arg1len[2]
+* Extra data:
+*   source[arg1len] + target[dlen - arg1len]
+*/
+function buildMvRequest(streamId, source, target) {
+	const srcBytes = strToBytes(source);
+	const tgtBytes = strToBytes(target);
+	const msg = new Message(24 + srcBytes.length + tgtBytes.length);
+	msg.writeBytes(streamIdToBytes(streamId));
+	msg.writeInt16BE(RequestId.Mv);
+	msg.writeBytes(/* @__PURE__ */ new Uint8Array(14));
+	msg.writeInt16BE(srcBytes.length & 65535);
+	msg.writeInt32BE(srcBytes.length + tgtBytes.length);
+	msg.writeBytes(srcBytes);
+	msg.writeBytes(tgtBytes);
+	return msg.getBuffer();
+}
+/**
+* kXR_endsess request (24 B header, no extra data).
+*
+* Body layout (16 B):
+*   sessid[16]
+*/
+function buildEndsessRequest(streamId, sessid) {
+	const msg = new Message(24);
+	msg.writeBytes(streamIdToBytes(streamId));
+	msg.writeInt16BE(RequestId.Endsess);
+	msg.writeBytes(sessid);
+	msg.writeInt32BE(0);
+	return msg.getBuffer();
+}
+//#endregion
+//#region src/protocol/codec.ts
+/**
+* Big-endian encoding / decoding utilities for the XRootD protocol.
+*
+* Every multi-byte field in XRootD is transmitted in network byte order
+* (big-endian).  The helpers below keep offset tracking explicit so
+* callers never forget to advance.
+*/
+/** Write `value` as uint16 BE at `offset`, return new offset. */
+function put16(buf, offset, value) {
+	buf.writeUInt16BE(value, offset);
+	return offset + 2;
+}
+/** Read uint16 BE at `offset`, return `[value, newOffset]`. */
+function get16(buf, offset) {
+	return [buf.readUInt16BE(offset), offset + 2];
+}
+/** Write `value` as uint32 BE at `offset`, return new offset. */
+function put32(buf, offset, value) {
+	buf.writeUInt32BE(value, offset);
+	return offset + 4;
+}
+/** Read uint32 BE at `offset`, return `[value, newOffset]`. */
+function get32(buf, offset) {
+	return [buf.readUInt32BE(offset), offset + 4];
+}
+/**
+* Write `str` bytes into `buf` starting at `offset`, padded with zeros
+* up to `maxLen`.  Returns the new offset (always `offset + maxLen`).
+*/
+function putString(buf, offset, str, maxLen) {
+	const bytes = Buffer.from(str, "utf8");
+	const len = Math.min(bytes.length, maxLen);
+	bytes.copy(buf, offset, 0, len);
+	buf.fill(0, offset + len, offset + maxLen);
+	return offset + maxLen;
+}
+/**
+* Read a fixed-length string from `buf` at `offset` for `length` bytes.
+* Trailing NUL bytes are stripped.
+*/
+function getString(buf, offset, length) {
+	return [buf.toString("utf8", offset, offset + length).replace(/\0+$/, ""), offset + length];
+}
+/** Copy `data` into `buf` at `offset`, return new offset. */
+function putBytes(buf, offset, data) {
+	Buffer.from(data).copy(buf, offset);
+	return offset + data.length;
+}
+/** Slice `length` bytes from `buf` at `offset`, return `[slice, newOffset]`. */
+function getBytes(buf, offset, length) {
+	return [buf.subarray(offset, offset + length), offset + length];
+}
+//#endregion
+//#region src/protocol/parsers.ts
+/**
+* Response parsers for XRootD protocol messages.
+* Each function parses a response body Buffer into a typed object.
+*/
+/**
+* Parse kXR_protocol OK response body.
+*
+* Body layout:
+*   pval[4] + flags[4] + secReqs (remaining bytes, NUL-terminated) +
+*   bifReqs (remaining bytes, NUL-terminated)
+*/
+function parseProtocolResponse(body) {
+	let off = 0;
+	const [pval, o1] = get32(body, off);
+	off = o1;
+	const [flags, o2] = get32(body, off);
+	off = o2;
+	let secReqs;
+	let bifReqs;
+	if (off < body.length) {
+		const [s, o3] = getString(body, off, body.length - off);
+		off = o3;
+		if (s) secReqs = s;
+	}
+	if (off < body.length) {
+		const [b] = getString(body, off, body.length - off);
+		if (b) bifReqs = b;
+	}
+	return {
+		pval,
+		flags,
+		secReqs,
+		bifReqs
+	};
+}
+/**
+* Parse kXR_login OK response body.
+*
+* Body layout:
+*   sessid[16] + optional secToken (remaining bytes)
+*/
+function parseLoginResponse(body) {
+	const [sessid] = getBytes(body, 0, 16);
+	let secToken;
+	if (body.length > 16) {
+		const [tok] = getBytes(body, 16, body.length - 16);
+		secToken = tok;
+	}
+	return {
+		sessid: new Uint8Array(sessid),
+		secToken,
+		needsAuth: body.length > 16
+	};
+}
+/**
+* Parse kXR_open OK response body.
+*
+* Body layout:
+*   fhandle[4] + cpsize[4] + cptype[4] + optional stat
+*/
+function parseOpenResponse(body) {
+	const [fhandle] = getBytes(body, 0, 4);
+	let cpsize = 0;
+	let cptype = "";
+	if (body.length >= 8) {
+		const [v] = get32(body, 4);
+		cpsize = v;
+	}
+	if (body.length >= 12) {
+		const [raw] = getBytes(body, 8, 4);
+		cptype = Buffer.from(raw).toString("utf8").replace(/\0+$/, "");
+	}
+	return {
+		fhandle: new Uint8Array(fhandle),
+		cpsize,
+		cptype
+	};
+}
+/**
+* Parse kXR_error response body.
+*
+* Body layout:
+*   errnum[4] + errmsg[variable, NUL-terminated]
+*/
+function parseErrorResponse(body) {
+	const [errnum, off] = get32(body, 0);
+	const [errmsg] = getString(body, off, body.length - off);
+	return {
+		errnum,
+		errmsg
+	};
+}
+/**
+* Parse kXR_redirect response body.
+*
+* Body layout:
+*   port[4] + host[variable, NUL-terminated]
+*/
+function parseRedirectResponse(body) {
+	const [port, off] = get32(body, 0);
+	const [host] = getString(body, off, body.length - off);
+	return {
+		port,
+		host
+	};
+}
+/**
+* Parse kXR_wait / kXR_waitresp response body.
+*
+* Body layout:
+*   seconds[4] + infomsg[variable, NUL-terminated]
+*/
+function parseWaitResponse(body) {
+	const [seconds, off] = get32(body, 0);
+	const [infomsg] = getString(body, off, body.length - off);
+	return {
+		seconds,
+		infomsg
+	};
+}
+const DSTAT_PREFIX = ".\n0 0 0 0";
+/**
+* Parse kXR_dirlist response body.
+*
+* Two possible formats depending on options:
+* 1. Names-only (kXR_online, default): `name1\nname2\nname3\0` — newline-separated, last entry null-terminated
+* 2. With stat info (kXR_dstat): `.\n0 0 0 0\nname1\n<statinfo1>\nname2\n<statinfo2>\n...\0`
+*    statinfo format: `<devid> <size> <flags> <mtime> <ctime> <atime> <mode> <owner> <group>`
+*/
+function parseDirlistResponse(body) {
+	const entries = [];
+	if (body.length === 0) return { entries };
+	const text = body.toString("utf8").replace(/\0$/, "");
+	if (text.startsWith(DSTAT_PREFIX)) {
+		const lines = text.slice(10).split("\n").filter((l) => l.length > 0);
+		for (let i = 0; i < lines.length - 1; i += 2) {
+			const name = lines[i];
+			const statFields = lines[i + 1]?.split(/\s+/);
+			if (statFields && statFields.length >= 4) entries.push({
+				name,
+				size: parseInt(statFields[1], 10) || 0,
+				flags: parseInt(statFields[2], 10) || 0,
+				mtime: parseInt(statFields[3], 10) || 0
+			});
+		}
+	} else {
+		const names = text.split("\n");
+		for (const name of names) {
+			const trimmed = name.trim();
+			if (trimmed.length > 0) entries.push({
+				name: trimmed,
+				size: 0,
+				flags: 0,
+				mtime: 0
+			});
+		}
 	}
-	set protocol(protocol) {
-		this._url.protocol = protocol;
+	return { entries };
+}
+//#endregion
+//#region src/api/errors.ts
+const codeMessages = {
+	[ServerError.ArgInvalid]: "Invalid argument",
+	[ServerError.ArgMissing]: "Missing argument",
+	[ServerError.ArgTooLong]: "Argument too long",
+	[ServerError.FileLocked]: "File locked",
+	[ServerError.FileNotOpen]: "File not open",
+	[ServerError.FSError]: "File system error",
+	[ServerError.InvalidRequest]: "Invalid request",
+	[ServerError.IOError]: "I/O error",
+	[ServerError.NoMemory]: "No memory",
+	[ServerError.NoSpace]: "No space",
+	[ServerError.NotAuthorized]: "Not authorized",
+	[ServerError.NotFound]: "File not found",
+	[ServerError.ServerError]: "Server error",
+	[ServerError.Unsupported]: "Unsupported",
+	[ServerError.NoServer]: "No server",
+	[ServerError.NotFile]: "Not a file",
+	[ServerError.IsDirectory]: "Is a directory",
+	[ServerError.Cancelled]: "Operation cancelled",
+	[ServerError.ItExists]: "File already exists",
+	[ServerError.CheckSumErr]: "Checksum error",
+	[ServerError.InProgress]: "Operation in progress",
+	[ServerError.OverQuota]: "Over quota",
+	[ServerError.SigVerErr]: "Signature verification error",
+	[ServerError.DecryptErr]: "Decryption error",
+	[ServerError.Overloaded]: "Server overloaded",
+	[ServerError.FsReadOnly]: "File system read-only",
+	[ServerError.BadPayload]: "Bad payload",
+	[ServerError.AttrNotFound]: "Attribute not found",
+	[ServerError.TLSRequired]: "TLS required",
+	[ServerError.NoReplicas]: "No replicas",
+	[ServerError.AuthFailed]: "Authentication failed",
+	[ServerError.Impossible]: "Impossible",
+	[ServerError.Conflict]: "Conflict",
+	[ServerError.TooManyErrs]: "Too many errors",
+	[ServerError.ReqTimedOut]: "Request timed out",
+	[ServerError.TimerExpired]: "Timer expired",
+	[ClientError.Ok]: "OK",
+	[ClientError.InvalidArgs]: "Invalid arguments",
+	[ClientError.NotFound]: "Not found",
+	[ClientError.Permission]: "Permission denied",
+	[ClientError.Serialization]: "Serialization error",
+	[ClientError.CommandNotFound]: "Command not found",
+	[ClientError.HostNotFound]: "Host not found",
+	[ClientError.ServiceUnavail]: "Service unavailable",
+	[ClientError.InternalError]: "Internal error",
+	[ClientError.BadRequest]: "Bad request",
+	[ClientError.Timeout]: "Timeout",
+	[ClientError.InsufficientData]: "Insufficient data",
+	[ClientError.Uninitialized]: "Client not connected",
+	[ClientError.Disconnected]: "Disconnected",
+	[ClientError.Redirect]: "Redirect",
+	[ClientError.LossyRetry]: "Lossy retry",
+	[ClientError.TooManyRedirs]: "Too many redirects",
+	[ClientError.ChunkChecksumErr]: "Chunk checksum error",
+	[ClientError.UnexpectedResp]: "Unexpected response",
+	[ClientError.ClientSkipped]: "Client skipped",
+	[ClientError.Failed]: "Failed",
+	[ClientError.WinNetworkError]: "Windows network error"
+};
+var XRootDError = class XRootDError extends Error {
+	code;
+	errno;
+	constructor(code, message, errno) {
+		super(message ?? XRootDError.codeToMessage(code));
+		this.name = "XRootDError";
+		this.code = code;
+		this.errno = errno;
+	}
+	static codeToMessage(code) {
+		return codeMessages[code] ?? `Unknown error (${code})`;
 	}
-	get hostName() {
-		return this._url.hostname;
+};
+//#endregion
+//#region src/transport/multiplexer.ts
+/**
+* Layer 3 Multiplexer
+*
+* Maintains streamId → Promise mapping.
+* Generates incremental stream IDs, stores pending requests in Map,
+* resolves when Framer delivers matching response frames.
+*/
+var Multiplexer = class {
+	transport;
+	framer;
+	pending = /* @__PURE__ */ new Map();
+	nextStreamId = 0;
+	timeout = 3e4;
+	sweepTimer = null;
+	closed = false;
+	redirectCount = 0;
+	maxRedirects;
+	onRedirect;
+	constructor(transport, options) {
+		this.transport = transport;
+		this.framer = new Framer();
+		this.maxRedirects = options?.maxRedirects ?? 16;
+		this.onRedirect = options?.onRedirect;
+		this.sweepTimer = globalThis.setInterval(() => this.sweepTimeouts(), 1e3);
+		this.sweepTimer.unref();
+		this.transport.onData((chunk) => {
+			const frames = this.framer.feed(chunk);
+			for (const frame of frames) this.handleFrame(frame);
+		});
+		this.transport.onClose(() => {
+			this.rejectAll(/* @__PURE__ */ new Error("Connection closed"));
+		});
+		this.transport.onError((err) => {
+			this.rejectAll(err);
+		});
 	}
-	set hostName(hostName) {
-		this._url.hostname = hostName;
+	allocateStreamId() {
+		let sid = this.nextStreamId;
+		while (this.pending.has(sid)) {
+			sid = sid + 1 & 65535;
+			if (sid === this.nextStreamId) throw new XRootDError(ClientError.InternalError, "Max concurrent requests (65535) reached");
+		}
+		this.nextStreamId = sid + 1 & 65535;
+		return sid;
+	}
+	async request(requestId, body, data) {
+		if (this.closed) throw new XRootDError(ClientError.InternalError, "Multiplexer is closed");
+		const sid = this.allocateStreamId();
+		const bodyBuf = Buffer.alloc(16);
+		Buffer.from(body).copy(bodyBuf);
+		const msg = new Message(24 + (data?.length ?? 0));
+		msg.writeBytes(streamIdToBytes(sid));
+		msg.writeInt16BE(requestId);
+		msg.writeBytes(bodyBuf);
+		msg.writeInt32BE(data?.length ?? 0);
+		if (data && data.length > 0) msg.writeBytes(data);
+		return new Promise((resolve, reject) => {
+			this.pending.set(sid, {
+				resolve,
+				reject,
+				expiresAt: Date.now() + this.timeout,
+				requestId,
+				body,
+				data
+			});
+			this.transport.send(msg.getBuffer()).catch(reject);
+		});
 	}
-	get port() {
-		return this._url.port ? parseInt(this._url.port, 10) : 1094;
+	handleFrame(frame) {
+		const sid = bytesToStreamId(frame.streamId);
+		if (frame.status === ResponseStatus.Wait || frame.status === ResponseStatus.Waitresp) {
+			this.handleWaitResponse(sid, frame);
+			return;
+		}
+		if (frame.status === ResponseStatus.Redirect) {
+			this.handleRedirectResponse(sid, frame);
+			return;
+		}
+		const pending = this.pending.get(sid);
+		if (!pending) return;
+		this.pending.delete(sid);
+		pending.resolve(frame);
+	}
+	handleWaitResponse(sid, frame) {
+		const seconds = frame.body.readInt32BE(0);
+		const pending = this.pending.get(sid);
+		if (pending) {
+			pending.expiresAt = Date.now() + seconds * 1e3 + this.timeout;
+			globalThis.setTimeout(() => this.retryRequest(sid), seconds * 1e3);
+		}
 	}
-	set port(port) {
-		this._url.port = port.toString();
+	handleRedirectResponse(sid, frame) {
+		const pending = this.pending.get(sid);
+		if (!pending) return;
+		if (this.redirectCount >= this.maxRedirects) {
+			this.pending.delete(sid);
+			pending.reject(/* @__PURE__ */ new Error(`Too many redirects (max ${this.maxRedirects})`));
+			return;
+		}
+		this.redirectCount++;
+		const { host, port } = parseRedirectResponse(frame.body);
+		if (this.onRedirect) this.onRedirect(host, port).then(() => {
+			this.retryRequest(sid);
+		}).catch((err) => {
+			this.pending.delete(sid);
+			pending.reject(err);
+		});
+		else {
+			this.pending.delete(sid);
+			pending.reject(/* @__PURE__ */ new Error(`Redirect to ${host}:${port} but no onRedirect handler configured`));
+		}
 	}
-	get userName() {
-		return this._url.username;
+	retryRequest(sid) {
+		const pending = this.pending.get(sid);
+		if (!pending) return;
+		this.pending.delete(sid);
+		this.request(pending.requestId, pending.body, pending.data).then(pending.resolve).catch(pending.reject);
+	}
+	sweepTimeouts() {
+		const now = Date.now();
+		for (const [sid, req] of this.pending.entries()) if (now > req.expiresAt) {
+			this.pending.delete(sid);
+			req.reject(/* @__PURE__ */ new Error(`Request timeout: streamid=${sid}`));
+		}
 	}
-	set userName(userName) {
-		this._url.username = userName;
+	setTimeout(ms) {
+		this.timeout = ms;
 	}
-	get password() {
-		return this._url.password;
+	resetRedirectCount() {
+		this.redirectCount = 0;
 	}
-	set password(password) {
-		this._url.password = password;
+	getTransport() {
+		return this.transport;
 	}
-	get hostId() {
-		const u = this._url.username;
-		if (u.length === 0) return this._url.host;
-		else if (this._url.password.length > 0) return `${u}:${this._url.password}@${this._url.host}`;
-		else return `${u}@${this._url.host}`;
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		if (this.sweepTimer) {
+			globalThis.clearInterval(this.sweepTimer);
+			this.sweepTimer = null;
+		}
+		this.rejectAll(/* @__PURE__ */ new Error("Multiplexer closed"));
 	}
-	set pathWithParams(path) {
-		const [p, s] = path.split("?", 2);
-		this._url.pathname = "/" + p;
-		this._url.search = s ?? "";
+	rejectAll(err) {
+		for (const [, req] of this.pending.entries()) req.reject(err);
+		this.pending.clear();
 	}
-	get pathWithParams() {
-		return this.path + this._url.search;
+};
+//#endregion
+//#region src/utils/frame-reader.ts
+/**
+* Creates a persistent frame reader that registers ONE onData handler
+* before any data is sent, avoiding the race condition where the
+* Multiplexer's handler consumes frames before the handshake can read them.
+*
+* Uses a queue pattern: incoming frames are queued, and nextFrame()
+* resolves the next available frame (or waits for one to arrive).
+*/
+function createFrameReader(transport) {
+	const framer = new Framer();
+	const frameQueue = [];
+	const waiters = [];
+	const handler = (chunk) => {
+		const frames = framer.feed(chunk);
+		for (const frame of frames) if (waiters.length > 0) waiters.shift()(frame);
+		else frameQueue.push(frame);
+	};
+	transport.onData(handler);
+	return {
+		nextFrame() {
+			if (frameQueue.length > 0) return Promise.resolve(frameQueue.shift());
+			return new Promise((resolve) => {
+				waiters.push(resolve);
+			});
+		},
+		close() {
+			transport.removeDataHandler(handler);
+		}
+	};
+}
+//#endregion
+//#region src/session/handshake.ts
+/**
+* Perform XRootD connection handshake:
+* 1. Send ClientInitHandShake(20B) + kXR_protocol(24B) merged = 44 bytes
+* 2. Receive handshake response frame (16B: ServerResponseHeader 8B with
+*    dlen/msglen shared with ServerInitHandShake)
+* 3. Receive kXR_ok + Protocol Response
+* 4. Send kXR_login request
+* 5. Receive kXR_ok + Login Response (sessid[16] + optional secToken)
+* 6. [Optional] kXR_auth multi-round authentication
+*/
+async function handshake(mux, url, options) {
+	const username = options?.username ?? "";
+	const pid = options?.pid ?? process.pid;
+	const handshakeBuf = buildHandshakeAndProtocol(0, 9, 1);
+	const transport = mux.getTransport();
+	const reader = createFrameReader(transport);
+	try {
+		await transport.send(handshakeBuf);
+		await reader.nextFrame();
+		const protoFrame = await reader.nextFrame();
+		if (protoFrame.status === ResponseStatus.Error) {
+			const err = parseErrorResponse(protoFrame.body);
+			throw new XRootDError(ClientError.InternalError, `Protocol handshake error: ${err.errmsg} (${err.errnum})`);
+		}
+		if (protoFrame.status !== ResponseStatus.Ok) throw new XRootDError(ClientError.InternalError, `Unexpected protocol response status: ${protoFrame.status}`);
+		const protoResp = parseProtocolResponse(protoFrame.body);
+		const loginBuf = buildLoginRequest(0, pid, username);
+		await transport.send(loginBuf);
+		const loginFrame = await reader.nextFrame();
+		if (loginFrame.status === ResponseStatus.Error) {
+			const err = parseErrorResponse(loginFrame.body);
+			throw new XRootDError(ClientError.InternalError, `Login error: ${err.errmsg} (${err.errnum})`);
+		}
+		if (loginFrame.status === ResponseStatus.Redirect) {
+			const redir = parseRedirectResponse(loginFrame.body);
+			throw new XRootDError(ClientError.Redirect, `Login redirect to ${redir.host}:${redir.port}`);
+		}
+		if (loginFrame.status !== ResponseStatus.Ok) throw new XRootDError(ClientError.InternalError, `Unexpected login response status: ${loginFrame.status}`);
+		return {
+			sessid: parseLoginResponse(loginFrame.body).sessid,
+			protocolVersion: protoResp.pval,
+			secReqs: protoResp.secReqs,
+			bifReqs: protoResp.bifReqs
+		};
+	} finally {
+		reader.close();
 	}
-	set searchParams(params) {
-		this._url.search = params;
+}
+//#endregion
+//#region src/session/auth.ts
+const authProtocols = /* @__PURE__ */ new Map();
+function registerAuthProtocol(name, factory) {
+	authProtocols.set(name, factory);
+}
+async function doAuthentication(mux, secReqs, params) {
+	if (!secReqs || secReqs.trim().length === 0) return {
+		prot: "",
+		uid: 0,
+		gid: 0
+	};
+	const supportedProtocols = secReqs.split(",").map((s) => s.trim());
+	for (const protoName of supportedProtocols) {
+		const factory = authProtocols.get(protoName);
+		if (!factory) continue;
+		return await executeAuth(mux, factory(), params);
+	}
+	throw new XRootDError(ServerError.AuthFailed, `No supported authentication protocol. Server requires: ${secReqs}`);
+}
+async function executeAuth(mux, protocol, params) {
+	const creds = await protocol.getCredentials(params);
+	const credType = getCredType(protocol.name);
+	const body = /* @__PURE__ */ new Uint8Array(16);
+	body[12] = credType >> 24 & 255;
+	body[13] = credType >> 16 & 255;
+	body[14] = credType >> 8 & 255;
+	body[15] = credType & 255;
+	let frame = await mux.request(RequestId.Auth, body, creds);
+	while (frame.status === ResponseStatus.Authmore) {
+		const challenge = frame.body;
+		const response = await protocol.processChallenge(challenge);
+		frame = await mux.request(RequestId.Auth, body, response);
+	}
+	if (frame.status !== ResponseStatus.Ok) {
+		const { errnum, errmsg } = parseErrorResponse(frame.body);
+		throw new XRootDError(errnum || ServerError.AuthFailed, errmsg || `Authentication failed with protocol: ${protocol.name}`);
+	}
+	return protocol.getEntity();
+}
+function getCredType(name) {
+	const credType = CRED_TYPE[name];
+	if (credType === void 0) throw new XRootDError(ClientError.BadRequest, `Unknown auth protocol: ${name}`);
+	return credType;
+}
+//#endregion
+//#region src/security/host.ts
+var HostAuth = class {
+	name = "host";
+	entity = {
+		prot: "host",
+		uid: 0,
+		gid: 0
+	};
+	complete = false;
+	async getCredentials(params) {
+		const hostname = params.host || "unknown";
+		return new TextEncoder().encode(hostname);
+	}
+	async processChallenge(_challenge) {
+		this.complete = true;
+		return /* @__PURE__ */ new Uint8Array(0);
+	}
+	isComplete() {
+		return this.complete;
+	}
+	getEntity() {
+		return this.entity;
 	}
-	get searchParams() {
-		return this._url.search;
+};
+//#endregion
+//#region src/api/types.ts
+const StatFlags = {
+	XBitSet: 1,
+	IsDir: 2,
+	Other: 4,
+	Offline: 8,
+	Readable: 16,
+	Writable: 32,
+	POSCPending: 64,
+	BackUpExists: 128,
+	CacheResp: 512
+};
+/**
+* Parse XRootD stat response string.
+*
+* Format: "<id> <size> <flags> <mtime> <ctime> <atime> <mode> <owner> <group>"
+*   - id:     opaque 64-bit device id (string to avoid precision loss)
+*   - size:   uint64 file size (bigint)
+*   - flags:  XRootD flags bitmask (StatFlags)
+*   - mtime:  modification time (epoch seconds)
+*   - ctime:  change time (epoch seconds)
+*   - atime:  access time (epoch seconds)
+*   - mode:   POSIX mode (octal string, e.g. "100644")
+*   - owner:  file owner
+*   - group:  file group
+*/
+function createStatInfo(data) {
+	const parts = data.trim().split(/\s+/);
+	const id = parts[0] ?? "0";
+	const size = BigInt(parts[1] ?? "0");
+	const serverFlags = parseInt(parts[2] ?? "0", 10) || 0;
+	const mtime = parseInt(parts[3] ?? "0", 10) || 0;
+	const ctime = parseInt(parts[4] ?? "0", 10) || 0;
+	const atime = parseInt(parts[5] ?? "0", 10) || 0;
+	const modeStr = parts[6] ?? "0";
+	const mode = parseInt(modeStr, 8) || 0;
+	return {
+		id,
+		size,
+		flags: serverFlags,
+		mtime,
+		ctime,
+		atime,
+		mode,
+		owner: parts[7] ?? "",
+		group: parts[8] ?? "",
+		get isDirectory() {
+			return (mode & S_IFDIR) !== 0;
+		},
+		get isLink() {
+			return (mode & S_IFLNK) === S_IFLNK;
+		},
+		get isOffline() {
+			return (serverFlags & StatFlags.Offline) !== 0;
+		},
+		get isCached() {
+			return (serverFlags & StatFlags.CacheResp) !== 0;
+		}
+	};
+}
+//#endregion
+//#region src/utils/request.ts
+/** Extract the 16-byte request body. */
+function extractBody(buf) {
+	return new Uint8Array(buf.subarray(4, 20));
+}
+/** Extract extra data based on dlen. */
+function extractExtraData(buf) {
+	const dlen = extractDataLength(buf);
+	if (dlen === 0) return void 0;
+	return new Uint8Array(buf.subarray(24, 24 + dlen));
+}
+/** Extract the request ID (uint16 BE). */
+function extractRequestId(buf) {
+	return buf.readUInt16BE(2);
+}
+/** Extract the data length (uint32 BE). */
+function extractDataLength(buf) {
+	return buf.readUInt32BE(20);
+}
+/**
+* Send a request through the multiplexer, extracting fields from the buffer.
+* This is a convenience wrapper used by File and FileSystem classes.
+*/
+async function sendRequest(mux, buf, data) {
+	const requestId = extractRequestId(buf);
+	const body = extractBody(buf);
+	const dlen = extractDataLength(buf);
+	const extraData = data ?? (dlen > 0 ? new Uint8Array(buf.subarray(24, 24 + dlen)) : void 0);
+	return mux.request(requestId, body, extraData);
+}
+//#endregion
+//#region src/api/file.ts
+var File = class {
+	mux;
+	session;
+	fhandle = null;
+	_isOpen = false;
+	constructor(mux, session) {
+		this.mux = mux;
+		this.session = session;
+	}
+	get isOpen() {
+		return this._isOpen;
+	}
+	async open(path, options) {
+		if (this._isOpen) throw new XRootDError(ServerError.FileNotOpen, "File is already open");
+		const buf = buildOpenRequest(0, path, options?.flags ?? OpenFlags.Read, options?.mode ?? 0);
+		const frame = await sendRequest(this.mux, buf, Buffer.from(path));
+		if (frame.status === ResponseStatus.Error) {
+			const { errnum, errmsg } = parseErrorResponse(frame.body);
+			throw new XRootDError(errnum, errmsg);
+		}
+		if (frame.status === ResponseStatus.Ok) {
+			const resp = parseOpenResponse(frame.body);
+			this.fhandle = resp.fhandle;
+			this._isOpen = true;
+			return;
+		}
+		throw new XRootDError(ServerError.ServerError, `Unexpected open response status: ${frame.status}`);
 	}
-	set anchor(anchor) {
-		this._url.hash = anchor;
+	async read(offset, size) {
+		if (!this._isOpen || !this.fhandle) throw new XRootDError(ServerError.FileNotOpen, "File is not open");
+		const buf = buildReadRequest(0, this.fhandle, offset, size);
+		const frame = await sendRequest(this.mux, buf);
+		if (frame.status === ResponseStatus.Error) {
+			const { errnum, errmsg } = parseErrorResponse(frame.body);
+			throw new XRootDError(errnum, errmsg);
+		}
+		if (frame.status === ResponseStatus.Ok) return new Uint8Array(frame.body);
+		throw new XRootDError(ServerError.ServerError, `Unexpected read response status: ${frame.status}`);
+	}
+	async write(offset, data) {
+		if (!this._isOpen || !this.fhandle) throw new XRootDError(ServerError.FileNotOpen, "File is not open");
+		const buf = buildWriteRequest(0, this.fhandle, offset, data);
+		const frame = await sendRequest(this.mux, buf, data);
+		if (frame.status === ResponseStatus.Error) {
+			const { errnum, errmsg } = parseErrorResponse(frame.body);
+			throw new XRootDError(errnum, errmsg);
+		}
+		if (frame.status === ResponseStatus.Ok) return frame.dlen;
+		throw new XRootDError(ServerError.ServerError, `Unexpected write response status: ${frame.status}`);
 	}
-	get anchor() {
-		return this._url.hash;
+	async close() {
+		if (!this._isOpen || !this.fhandle) return;
+		const buf = buildCloseRequest(0, this.fhandle);
+		const frame = await sendRequest(this.mux, buf);
+		this.fhandle = null;
+		this._isOpen = false;
+		if (frame.status === ResponseStatus.Error) {
+			const { errnum, errmsg } = parseErrorResponse(frame.body);
+			throw new XRootDError(errnum, errmsg);
+		}
 	}
-	set path(path) {
-		this._url.pathname = "/" + path;
+	async stat() {
+		if (!this._isOpen || !this.fhandle) throw new XRootDError(ServerError.FileNotOpen, "File is not open");
+		const buf = buildStatRequest(0, "", this.fhandle);
+		const frame = await sendRequest(this.mux, buf);
+		if (frame.status === ResponseStatus.Error) {
+			const { errnum, errmsg } = parseErrorResponse(frame.body);
+			throw new XRootDError(errnum, errmsg);
+		}
+		if (frame.status === ResponseStatus.Ok) return parseStatInfo(frame.body);
+		throw new XRootDError(ServerError.ServerError, `Unexpected stat response status: ${frame.status}`);
 	}
-	get path() {
-		return this._url.pathname.replace(/^\/+/, "/");
+	async sync() {
+		if (!this._isOpen || !this.fhandle) throw new XRootDError(ServerError.FileNotOpen, "File is not open");
+		const buf = buildSyncRequest(0, this.fhandle);
+		const frame = await sendRequest(this.mux, buf);
+		if (frame.status === ResponseStatus.Error) {
+			const { errnum, errmsg } = parseErrorResponse(frame.body);
+			throw new XRootDError(errnum, errmsg);
+		}
 	}
-	getParams() {
-		const params = {};
-		for (const [key, value] of this._url.searchParams.entries()) params[key] = value;
-		return params;
+	async truncate(size) {
+		if (!this._isOpen || !this.fhandle) throw new XRootDError(ServerError.FileNotOpen, "File is not open");
+		const buf = buildTruncateRequest(0, this.fhandle, size);
+		const frame = await sendRequest(this.mux, buf);
+		if (frame.status === ResponseStatus.Error) {
+			const { errnum, errmsg } = parseErrorResponse(frame.body);
+			throw new XRootDError(errnum, errmsg);
+		}
 	}
-	toString() {
-		return this._url.toString();
+};
+function parseStatInfo(body) {
+	return createStatInfo(body.toString("utf-8"));
+}
+//#endregion
+//#region src/api/filesystem.ts
+var FileSystem = class {
+	mux;
+	constructor(mux) {
+		this.mux = mux;
+	}
+	async stat(path) {
+		const req = buildStatRequest(0, path);
+		const frame = await this.mux.request(RequestId.Stat, extractBody(req), extractExtraData(req));
+		this.handleError(frame);
+		return createStatInfo(frame.body.toString("utf8"));
+	}
+	async readdir(path) {
+		const req = buildDirlistRequest(0, path);
+		const frame = await this.mux.request(RequestId.Dirlist, extractBody(req), extractExtraData(req));
+		this.handleError(frame);
+		const { entries } = parseDirlistResponse(frame.body);
+		return {
+			name: path,
+			entries
+		};
 	}
-	static isValid(urlString) {
-		try {
-			return new XRootDUrl(urlString).isValid;
-		} catch {
-			return false;
+	async mkdir(path, mode = 493) {
+		const req = buildMkdirRequest(0, path, mode);
+		const frame = await this.mux.request(RequestId.Mkdir, extractBody(req), extractExtraData(req));
+		this.handleError(frame);
+	}
+	async rmdir(path) {
+		const req = buildRmdirRequest(0, path);
+		const frame = await this.mux.request(RequestId.Rmdir, extractBody(req), extractExtraData(req));
+		this.handleError(frame);
+	}
+	async rm(path) {
+		const req = buildRmRequest(0, path);
+		const frame = await this.mux.request(RequestId.Rm, extractBody(req), extractExtraData(req));
+		this.handleError(frame);
+	}
+	async mv(source, target) {
+		const req = buildMvRequest(0, source, target);
+		const frame = await this.mux.request(RequestId.Mv, extractBody(req), extractExtraData(req));
+		this.handleError(frame);
+	}
+	handleError(frame) {
+		if (frame.status === ResponseStatus.Error) {
+			const { errnum, errmsg } = parseErrorResponse(frame.body);
+			throw new XRootDError(errnum, errmsg);
 		}
 	}
 };
 //#endregion
-//#region lib/env.ts
-function checkIntRange(key, value) {
-	const num = Number(value);
-	if (num < -2147483648 || num > 2147483647) console.warn(`[xrootd] Warning: value ${value} for key "${key}" is out of 32-bit signed integer range [-2147483648, 2147483647]. It will be truncated.`);
-}
-var XRootDEnvironment = class {
-	constructor() {}
-	/**
-	* 设置整数配置项，返回是否设置成功。
-	*/
-	putInt(key, intVal) {
-		checkIntRange(key, intVal);
-		const success = nativeAddon.Env.PutInt(key, Number(intVal));
-		if (!success) console.warn(`[xrootd] Warning: Failed to set integer configuration "${key}"=${intVal}. It might have been overridden by a system environment variable.`);
-		return success;
-	}
-	putString(key, strVal) {
-		if (key === "SecProtocol") {
-			process.env.XrdSecPROTOCOL = strVal;
-			process.env.XRD_SECPROTOCOL = strVal;
-			return true;
+//#region src/client.ts
+var XRootDClient = class {
+	url;
+	options;
+	transport = null;
+	mux = null;
+	session = null;
+	fs = null;
+	constructor(url, options = {}) {
+		this.url = XRootDUrl.parse(url);
+		this.options = options;
+	}
+	async connect() {
+		await this.doConnect(this.url);
+	}
+	async doConnect(url) {
+		this.transport = new Transport();
+		await this.transport.connect(url.host, url.port);
+		this.mux = new Multiplexer(this.transport, {
+			maxRedirects: this.options.maxRedirects ?? 16,
+			onRedirect: (host, port) => this.handleRedirect(host, port)
+		});
+		if (this.options.timeout) this.mux.setTimeout(this.options.timeout);
+		this.session = await handshake(this.mux, url, { username: this.options.credentials?.username });
+		registerAuthProtocol("host", () => new HostAuth());
+		if (this.session.secReqs && this.options.credentials) {
+			const secEntity = await doAuthentication(this.mux, this.session.secReqs, {
+				host: url.host,
+				port: url.port,
+				username: this.options.credentials.username,
+				password: this.options.credentials.password,
+				sessid: this.session.sessid
+			});
+			this.session.secEntity = secEntity;
 		}
-		const success = nativeAddon.Env.PutString(key, strVal);
-		if (!success) console.warn(`[xrootd] Warning: Failed to set string configuration "${key}"="${strVal}". It might have been overridden by a system environment variable.`);
-		return success;
-	}
-	/**
-	* 设置布尔配置项，返回是否设置成功。
-	*/
-	putBoolean(key, boolVal) {
-		if (typeof boolVal === "boolean") boolVal = boolVal ? "true" : "false";
-		return this.putString(key, boolVal);
-	}
-	/**
-	* 获取整数配置项。
-	*/
-	getInt(key) {
-		return nativeAddon.Env.GetInt(key) ?? void 0;
-	}
-	/**
-	* 获取字符串配置项。
-	*/
-	getString(key) {
-		if (key === "SecProtocol") return process.env.XrdSecPROTOCOL ?? process.env.XRD_SECPROTOCOL ?? void 0;
-		return nativeAddon.Env.GetString(key) ?? void 0;
-	}
-	/**
-	* 批量安全地设置 XRootD 底层参数
-	*/
-	configure(config) {
-		for (const [key, value] of Object.entries(config)) {
-			if (value === void 0 || value === null) continue;
-			let success = true;
-			if (key === "SecProtocol") {
-				process.env.XrdSecPROTOCOL = String(value);
-				process.env.XRD_SECPROTOCOL = String(value);
-				continue;
-			}
-			if (typeof value === "number" || typeof value === "bigint") {
-				checkIntRange(key, value);
-				success = nativeAddon.Env.PutInt(key, Number(value));
-			} else if (typeof value === "string") success = nativeAddon.Env.PutString(key, value);
-			else if (typeof value === "boolean") success = nativeAddon.Env.PutString(key, value ? "true" : "false");
-			else {
-				console.warn(`[xrootd] Unhandled type ${typeof value} for key ${key}.`);
-				success = nativeAddon.Env.PutString(key, value.toString());
-			}
-			if (!success) console.warn(`[xrootd] Warning: Failed to set configuration "${key}"=${value}. It might have been overridden by a system environment variable.`);
+		this.fs = new FileSystem(this.mux);
+	}
+	async handleRedirect(host, port) {
+		if (this.session && this.mux) try {
+			const endsessBody = buildEndsessRequest(0, this.session.sessid);
+			await this.mux.request(RequestId.Endsess, new Uint8Array(endsessBody));
+		} catch {}
+		if (this.mux) {
+			this.mux.close();
+			this.mux = null;
 		}
+		if (this.transport) {
+			await this.transport.close();
+			this.transport = null;
+		}
+		const newUrl = XRootDUrl.parse(`root://${host}:${port}`);
+		await this.doConnect(newUrl);
+	}
+	async open(path, options) {
+		this.ensureConnected();
+		const file = new File(this.mux, this.session);
+		await file.open(path, options);
+		return file;
+	}
+	async stat(path) {
+		this.ensureConnected();
+		const file = new File(this.mux, this.session);
+		await file.open(path, { flags: OpenFlags.Read });
+		try {
+			return await file.stat();
+		} finally {
+			await file.close();
+		}
+	}
+	async statFilesystem(path) {
+		this.ensureFileSystem();
+		return this.fs.stat(path);
+	}
+	async readdir(path) {
+		this.ensureFileSystem();
+		return this.fs.readdir(path);
+	}
+	async mkdir(path, mode) {
+		this.ensureFileSystem();
+		return this.fs.mkdir(path, mode);
+	}
+	async rmdir(path) {
+		this.ensureFileSystem();
+		return this.fs.rmdir(path);
+	}
+	async rm(path) {
+		this.ensureFileSystem();
+		return this.fs.rm(path);
+	}
+	async mv(source, target) {
+		this.ensureFileSystem();
+		return this.fs.mv(source, target);
+	}
+	async close() {
+		if (this.mux) {
+			this.mux.close();
+			this.mux = null;
+		}
+		if (this.transport) {
+			await this.transport.close();
+			this.transport = null;
+		}
+		this.session = null;
+		this.fs = null;
+	}
+	get isConnected() {
+		return this.session !== null;
+	}
+	get location() {
+		return this.url.getLocation();
+	}
+	ensureConnected() {
+		if (!this.mux || !this.session) throw new XRootDError(ClientError.Uninitialized, "Client not connected");
 	}
-	get(key) {
-		if (key === "SecProtocol") return process.env.XrdSecPROTOCOL ?? process.env.XRD_SECPROTOCOL ?? void 0;
-		return nativeAddon.Env.GetInt(key) ?? nativeAddon.Env.GetString(key) ?? void 0;
+	ensureFileSystem() {
+		if (!this.fs) throw new XRootDError(ClientError.Uninitialized, "Client not connected");
 	}
 };
-const Env = new XRootDEnvironment();
-Env.configure({
-	RequestTimeout: 30,
-	WorkerThreads: 4
-});
 //#endregion
-export { AccessMode, CopyProcess, Env, File, FileSystem, MkDirFlags, OpenFlags, XRootDUrl as URL };
+export { BODY_SIZE, CRED_TYPE, ClientError, DEFAULT_PORT, DirlistOptions, FHANDLE_SIZE, File, FileSystem, Framer, HANDSHAKE_FIFTH, HANDSHAKE_FIRST, HANDSHAKE_FOURTH, HANDSHAKE_SECOND, HANDSHAKE_THIRD, Message, Multiplexer, OpenFlags, PROTOCOL_VERSION, REQUEST_HDR_SIZE, REQUEST_OFFSET_BODY, REQUEST_OFFSET_DLEN, REQUEST_OFFSET_REQUEST_ID, REQUEST_OFFSET_STREAM_ID, RESPONSE_HDR_SIZE, RESPONSE_OFFSET_BODY, RESPONSE_OFFSET_DLEN, RESPONSE_OFFSET_STATUS, RESPONSE_OFFSET_STREAM_ID, RequestId, ResponseStatus, SESS_ID_SIZE, S_IFDIR, S_IFLNK, ServerError, StatFlags, Transport, XRootDClient, XRootDError, XRootDUrl, buildCloseRequest, buildHandshakeAndProtocol, buildLoginRequest, buildOpenRequest, buildReadRequest, buildStatRequest, buildWriteRequest, createStatInfo, get16, get32, getBytes, getString, handshake, kXR_ExpBind, kXR_ExpLogin, kXR_ableTLS, kXR_bifreqs, kXR_secreqs, kXR_wantTLS, parseErrorResponse, parseLoginResponse, parseOpenResponse, parseProtocolResponse, parseRedirectResponse, parseWaitResponse, put16, put32, putBytes, putString };
+
+//# sourceMappingURL=index.mjs.map