ai-fly 0.0.0 → 0.1.0

package/dist/key-CK77IYXp.mjs

@@ -0,0 +1,67 @@
+import { n as UsageError, r as reportCliError } from "./errors-BGtxPkM7.mjs";
+import { o as parseArgv } from "./config-CO3WyW2H.mjs";
+import { c as requireString, d as str, l as resolveDataDir, r as openStore } from "./common-BULbPtYn.mjs";
+import { homedir } from "node:os";
+//#region src/cli/commands/provider/key.ts
+const SPEC = {
+	data: {
+		type: "string",
+		tilde: true
+	},
+	group: { type: "string" }
+};
+const USAGE = `usage:
+  ai-fly key issue --group <name> [--data <dir>]
+  ai-fly key list [--data <dir>]
+  ai-fly key revoke <keyId> [--data <dir>]`;
+async function run(argv, ctx = {}) {
+	try {
+		const home = ctx.homedir ?? homedir();
+		const { options, positionals } = parseArgv(argv, SPEC, { homedir: home });
+		const sub = positionals[0];
+		if (sub === "issue") return issue(options, home);
+		if (sub === "list") return list(options, home);
+		if (sub === "revoke") return revoke(options, positionals, home);
+		if (sub === void 0) throw new UsageError(USAGE);
+		throw new UsageError(`error: unknown key subcommand '${sub}' (known: issue, list, revoke)`);
+	} catch (err) {
+		return reportCliError(err);
+	}
+}
+function issue(options, home) {
+	const group = requireString(str(options.group), "group");
+	const issued = openStore(resolveDataDir(str(options.data), home)).issueKey(group);
+	process.stdout.write([
+		`key issued for group '${group}'`,
+		`  keyId: ${issued.keyId}`,
+		`  key : ${issued.key}`,
+		"",
+		"This secret is shown only once. Store it now (password manager or share link).",
+		"Revoke with: ai-fly key revoke " + issued.keyId,
+		""
+	].join("\n"));
+	return 0;
+}
+function list(options, home) {
+	const keys = openStore(resolveDataDir(str(options.data), home)).listKeys();
+	if (keys.length === 0) {
+		process.stdout.write("no keys issued (see: ai-fly key issue --group <name>)\n");
+		return 0;
+	}
+	const lines = [];
+	for (const k of keys) {
+		const status = k.revokedAt === void 0 ? "active" : `revoked at ${new Date(k.revokedAt).toISOString()}`;
+		lines.push(`${k.keyId}  group=${k.group}  created=${new Date(k.createdAt).toISOString()}  ${status}`);
+	}
+	process.stdout.write(`${lines.join("\n")}\n`);
+	return 0;
+}
+function revoke(options, positionals, home) {
+	const keyId = positionals[1];
+	if (keyId === void 0) throw new UsageError("error: key revoke requires a <keyId> argument");
+	const record = openStore(resolveDataDir(str(options.data), home)).revokeKey(keyId);
+	process.stdout.write(record.revokedAt === void 0 ? `key revoked: ${keyId}\n` : `key was already revoked: ${keyId}\n`);
+	return 0;
+}
+//#endregion
+export { run };

package/dist/mux-xHl9Jrbi.mjs

@@ -0,0 +1,630 @@
+import { i as randomZ32 } from "./config-CO3WyW2H.mjs";
+import { a as FRAME_TYPE, d as classifySchemaFailure, f as isKnownFrameType, i as FRAME_HEADER_SCHEMAS, n as ERROR_CODE, o as FRAME_TYPE_NAME } from "./sdk-C6xDRbzg.mjs";
+//#region src/wire/codec.ts
+const WIRE_MAGIC_PREFIX = "aifly";
+const WIRE_MAGIC = "aifly1";
+/** 会话层帧上限（fabric MAX_FRAME 同值；含 9 字节本协议帧头）。 */
+const MAX_FRAME_BYTES = 1 << 20;
+/** JSON 头结构上限（spec「帧资源上限」）。 */
+const MAX_JSON_HEADER_BYTES = 16384;
+/** 正文分片默认上限（队头阻塞实证 → 远小于帧上限）。 */
+const DEFAULT_BODY_CHUNK_BYTES = 262144;
+/** 正文分片可配置上限的硬顶（spec：MUST ≤ 960 KiB）。 */
+const MAX_CONFIGURABLE_BODY_CHUNK_BYTES = 983040;
+const TEXT_ENCODER = new TextEncoder();
+const TEXT_DECODER = new TextDecoder();
+const MAGIC_PREFIX_BYTES = TEXT_ENCODER.encode(WIRE_MAGIC_PREFIX);
+const MAGIC_BYTES = TEXT_ENCODER.encode(WIRE_MAGIC);
+const EMPTY_BODY = /* @__PURE__ */ new Uint8Array(0);
+/** 本地编码断言失败（编程 / 配置错误，非对端可观测事件）。 */
+var WireEncodeError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "WireEncodeError";
+		this.code = code;
+	}
+};
+function assertChunkLimit(limit) {
+	if (!Number.isInteger(limit) || limit <= 0 || limit > 983040) throw new WireEncodeError("invalid_chunk_config", `body chunk limit must be an integer in (0, ${MAX_CONFIGURABLE_BODY_CHUNK_BYTES}], got ${limit}`);
+}
+/** 编码单帧。断言：JSON 头 ≤16KiB、正文 ≤ 分片上限、整帧 ≤1MiB。 */
+function encodeFrame(frame, opts = {}) {
+	const chunkLimit = opts.bodyChunkLimitBytes ?? 262144;
+	assertChunkLimit(chunkLimit);
+	if (!isKnownFrameType(frame.type)) throw new WireEncodeError("unknown_frame_type", `cannot encode unknown frame type 0x${frame.type.toString(16)}`);
+	const headerBytes = TEXT_ENCODER.encode(JSON.stringify(frame.header));
+	if (headerBytes.length > 16384) throw new WireEncodeError("json_header_too_large", `json header is ${headerBytes.length} bytes (max ${MAX_JSON_HEADER_BYTES})`);
+	const body = frame.body ?? EMPTY_BODY;
+	if (body.length > chunkLimit) throw new WireEncodeError("body_chunk_too_large", `body is ${body.length} bytes (chunk limit ${chunkLimit})`);
+	const total = 9 + headerBytes.length + body.length;
+	if (total > 1048576) throw new WireEncodeError("frame_too_large", `frame is ${total} bytes (max ${MAX_FRAME_BYTES})`);
+	const out = new Uint8Array(total);
+	out.set(MAGIC_BYTES, 0);
+	out[6] = frame.type;
+	out[7] = headerBytes.length >> 8 & 255;
+	out[8] = headerBytes.length & 255;
+	out.set(headerBytes, 9);
+	out.set(body, 9 + headerBytes.length);
+	return out;
+}
+/**
+* 解码单帧（每条 fabric envelope 即一个完整 buffer）。
+* - 非 "aifly" 家族 → null（静默忽略，混流共存）；
+* - 家族匹配但版本位非 '1'、或 JSON 头 v 字段 ≠1 → unknown-version（可回送
+*   protocol_version ERROR）；
+* - 版本匹配但类型号未定义 → unknown-type（记录并忽略，不影响后续帧）；
+* - 结构损坏（截断 / JSON 非法 / 头非对象 / 超长）→ malformed。
+*/
+function decodeFrame(buffer) {
+	if (buffer.length < MAGIC_PREFIX_BYTES.length) return null;
+	for (let i = 0; i < MAGIC_PREFIX_BYTES.length; i++) if (buffer[i] !== MAGIC_PREFIX_BYTES[i]) return null;
+	if (buffer.length > 1048576) return {
+		kind: "malformed",
+		reason: "frame_too_large"
+	};
+	if (buffer.length >= 6 && buffer[5] !== MAGIC_BYTES[5]) return { kind: "unknown-version" };
+	if (buffer.length < 9) return {
+		kind: "malformed",
+		reason: "truncated_header"
+	};
+	const type = buffer[6];
+	const jsonLen = buffer[7] << 8 | buffer[8];
+	if (jsonLen > 16384) return {
+		kind: "malformed",
+		reason: "json_header_too_large"
+	};
+	if (9 + jsonLen > buffer.length) return {
+		kind: "malformed",
+		reason: "truncated_json"
+	};
+	let header;
+	try {
+		header = JSON.parse(TEXT_DECODER.decode(buffer.subarray(9, 9 + jsonLen)));
+	} catch {
+		return {
+			kind: "malformed",
+			reason: "invalid_json"
+		};
+	}
+	if (typeof header !== "object" || header === null || Array.isArray(header)) return {
+		kind: "malformed",
+		reason: "header_not_object"
+	};
+	const v = header.v;
+	if (v !== void 0 && v !== 1) return { kind: "unknown-version" };
+	if (!isKnownFrameType(type)) return {
+		kind: "unknown-type",
+		type
+	};
+	return {
+		kind: "frame",
+		type,
+		header,
+		body: buffer.subarray(9 + jsonLen)
+	};
+}
+/**
+* 按 design A3「body 内联(≤分片上限)或空」拆分：超限正文的 REQ 帧体为空，
+* 全部字节经 REQ_BODY 分片承载；接收侧按 seq 从 0 重组（mux.ts 负责）。
+*/
+function splitBody(body, chunkLimitBytes = DEFAULT_BODY_CHUNK_BYTES) {
+	assertChunkLimit(chunkLimitBytes);
+	if (body.length <= chunkLimitBytes) return {
+		firstInline: true,
+		inlineBody: body,
+		chunks: []
+	};
+	const chunks = [];
+	for (let off = 0; off < body.length; off += chunkLimitBytes) {
+		const end = off + chunkLimitBytes >= body.length;
+		chunks.push({
+			seq: chunks.length,
+			end,
+			data: body.subarray(off, end ? body.length : off + chunkLimitBytes)
+		});
+	}
+	return {
+		firstInline: false,
+		inlineBody: EMPTY_BODY,
+		chunks
+	};
+}
+//#endregion
+//#region src/wire/fabric-adapter.ts
+var FabricWireAdapter = class {
+	fabric;
+	peerId;
+	frameCbs = /* @__PURE__ */ new Set();
+	closeCbs = /* @__PURE__ */ new Set();
+	unsubscribes = [];
+	closed = false;
+	constructor(fabric, peerId) {
+		this.fabric = fabric;
+		this.peerId = peerId;
+		this.unsubscribes.push(fabric.on((event) => {
+			if (event.type === "message" && event.from === peerId) {
+				const decoded = decodeFrame(new Uint8Array(event.data));
+				if (decoded === null) return;
+				for (const cb of this.frameCbs) cb(decoded);
+			} else if (event.type === "peer-disconnected" && event.endpointId === peerId) this.handleClose("peer-disconnected");
+		}));
+	}
+	get endpointId() {
+		return this.peerId;
+	}
+	async send(data) {
+		if (this.closed) throw new Error("transport closed");
+		await this.fabric.send(this.peerId, Buffer.from(data));
+	}
+	onFrame(cb) {
+		this.frameCbs.add(cb);
+	}
+	close(reason) {
+		this.handleClose(reason ?? "local-close");
+	}
+	onClose(cb) {
+		this.closeCbs.add(cb);
+	}
+	/** 释放事件订阅（进程退出路径）；不断开 fabric 连接本身。 */
+	dispose() {
+		for (const off of this.unsubscribes.splice(0)) off();
+	}
+	handleClose(reason) {
+		if (this.closed) return;
+		this.closed = true;
+		for (const off of this.unsubscribes.splice(0)) off();
+		for (const cb of this.closeCbs) cb(reason);
+	}
+};
+const NO_BODY = /* @__PURE__ */ new Uint8Array(0);
+/** 本地误用（出站方向违规 / 未知类型 / 已关闭后发送）。 */
+var WireSessionError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "WireSessionError";
+		this.code = code;
+	}
+};
+/** 帧方向表（spec：ERROR 仅提供方发出；CLOSE 双向；使用方侧终结均为本地动作）。 */
+const FRAME_META = {
+	[FRAME_TYPE.AUTH]: { dir: "c2p" },
+	[FRAME_TYPE.AUTH_OK]: { dir: "p2c" },
+	[FRAME_TYPE.AUTH_ERR]: { dir: "p2c" },
+	[FRAME_TYPE.REQ]: { dir: "c2p" },
+	[FRAME_TYPE.REQ_BODY]: {
+		dir: "c2p",
+		seqStream: "reqBody"
+	},
+	[FRAME_TYPE.RESP_META]: { dir: "p2c" },
+	[FRAME_TYPE.RESP_CHUNK]: {
+		dir: "p2c",
+		seqStream: "respChunk"
+	},
+	[FRAME_TYPE.RESP_END]: {
+		dir: "p2c",
+		terminal: true
+	},
+	[FRAME_TYPE.ERROR]: {
+		dir: "p2c",
+		terminal: true
+	},
+	[FRAME_TYPE.ABORT]: { dir: "c2p" },
+	[FRAME_TYPE.PING]: { dir: "p2c" },
+	[FRAME_TYPE.DATA_UP]: {
+		dir: "c2p",
+		seqStream: "dataUp"
+	},
+	[FRAME_TYPE.DATA_DOWN]: {
+		dir: "p2c",
+		seqStream: "dataDown"
+	},
+	[FRAME_TYPE.CLOSE]: {
+		dir: "both",
+		terminal: true
+	}
+};
+/** 提供方自动回送 ERROR 的脱敏 message（英文 ASCII，产品约定）。 */
+function autoErrorMessage(code) {
+	switch (code) {
+		case ERROR_CODE.forbidden_method: return "http method not allowed";
+		case ERROR_CODE.forbidden_header: return "http header not allowed";
+		case ERROR_CODE.protocol_seq: return "chunk sequence gap";
+		case ERROR_CODE.body_too_large: return "request body exceeds reassembly limit";
+		case ERROR_CODE.protocol_version: return "unsupported aifly protocol version";
+		default: return "wire protocol violation";
+	}
+}
+var WireSession = class {
+	role;
+	transport;
+	hooks;
+	idleTimeoutMs;
+	maxQueuedPerId;
+	reassemblyLimitBytes;
+	unauthFrameLimit;
+	ids = /* @__PURE__ */ new Map();
+	usedIds = /* @__PURE__ */ new Set();
+	globalLane = {
+		sendLane: Promise.resolve(),
+		queuedCount: 0,
+		slotWaiters: []
+	};
+	counters = {
+		unauthDropped: 0,
+		directionDropped: 0,
+		schemaDropped: 0,
+		unknownIdDropped: 0,
+		terminalDropped: 0,
+		malformedDropped: 0,
+		unknownTypeIgnored: 0,
+		unknownVersionDropped: 0,
+		poisonedDropped: 0
+	};
+	authedFlag = false;
+	authPending = false;
+	poisonedFlag = false;
+	deadFlag = false;
+	unauthClosed = false;
+	constructor(opts) {
+		this.role = opts.role;
+		this.transport = opts.transport;
+		this.hooks = opts.hooks ?? {};
+		this.idleTimeoutMs = opts.idleTimeoutMs ?? 3e5;
+		this.maxQueuedPerId = opts.maxQueuedPerId ?? 64;
+		this.reassemblyLimitBytes = opts.reassemblyLimitBytes ?? 8388608;
+		this.unauthFrameLimit = opts.unauthFrameLimit ?? 32;
+		this.transport.onFrame((frame) => this.handleIncoming(frame));
+		this.transport.onClose((reason) => this.handleClosed(reason));
+	}
+	/** AUTH_OK 交换完成后由上层调用（provider 发出 AUTH_OK 后 / consumer 收到并接受后）。 */
+	markAuthed() {
+		this.authedFlag = true;
+		this.authPending = false;
+	}
+	get authed() {
+		return this.authedFlag;
+	}
+	get poisoned() {
+		return this.poisonedFlag;
+	}
+	get dead() {
+		return this.deadFlag;
+	}
+	/** 观测计数（静默丢弃路径均有计数，供状态上报与测试断言）。 */
+	stats() {
+		return {
+			...this.counters,
+			authed: this.authedFlag,
+			poisoned: this.poisonedFlag,
+			dead: this.deadFlag
+		};
+	}
+	/** 关闭传输（触发双端 disconnected → 全量在途 id 终结）。 */
+	dispose(reason) {
+		this.transport.close(reason ?? "local-dispose");
+	}
+	/** 分配全局唯一 request-id（randomZ32(16)）；一经分配永不复用。 */
+	allocId() {
+		for (;;) {
+			const id = randomZ32(16);
+			if (!this.usedIds.has(id)) {
+				this.usedIds.add(id);
+				return id;
+			}
+		}
+	}
+	/** 显式本地终结（不发帧）：之后该 id 出入站帧均静默丢弃。 */
+	terminal(id) {
+		this.finishId(id, { source: "local" });
+	}
+	/**
+	* 发送一帧（编码断言失败抛 WireEncodeError；出站方向违规抛 WireSessionError）。
+	* - 同 id 帧经内部 promise 链顺序 await，保证交付顺序（不同 id 之间无顺序承诺）；
+	* - 该 id 在途未终结分片 ≥ maxQueuedPerId 时，本次 send 等待队列回落（上层可改用
+	*   waitOutboundQueue 实现“暂停读上游”）；
+	* - 终结帧（RESP_END / ERROR / CLOSE）发送即登记终结，且不受队列门控（必然出队）。
+	*/
+	async send(type, header, body = NO_BODY) {
+		if (this.deadFlag) throw new WireSessionError("closed", "wire session is closed");
+		const meta = FRAME_META[type];
+		if (meta === void 0) throw new WireSessionError("misuse", `unknown frame type 0x${type.toString(16)}`);
+		if (!this.outboundDirectionOk(meta)) throw new WireSessionError("misuse", `${FRAME_TYPE_NAME[type] ?? type} is not outbound for role '${this.role}'`);
+		if (type === FRAME_TYPE.AUTH && this.role === "consumer") this.authPending = true;
+		const rawId = header.id;
+		const id = typeof rawId === "string" ? rawId : void 0;
+		let ctx;
+		if (id !== void 0) {
+			ctx = this.ids.get(id);
+			if (ctx !== void 0 && ctx.terminal) {
+				this.counters.terminalDropped++;
+				return;
+			}
+			if (ctx === void 0 && !meta.terminal) ctx = this.registerId(id);
+			if (ctx !== void 0) {
+				if (this.role === "provider" && ctx.idleSuspended && (type === FRAME_TYPE.RESP_META || type === FRAME_TYPE.RESP_CHUNK || type === FRAME_TYPE.DATA_DOWN)) ctx.idleSuspended = false;
+				if (meta.terminal) this.finishId(id, { source: "local" });
+				else this.touchIdle(ctx);
+			}
+		}
+		const bytes = encodeFrame({
+			type,
+			header,
+			body
+		});
+		if (ctx !== void 0 && !meta.terminal) while (ctx.queuedCount >= this.maxQueuedPerId) {
+			if (this.deadFlag) throw new WireSessionError("closed", "wire session is closed");
+			await new Promise((resolve) => ctx.slotWaiters.push(resolve));
+			if (ctx.terminal) {
+				this.counters.terminalDropped++;
+				return;
+			}
+		}
+		await this.transmit(ctx ?? this.globalLane, bytes);
+	}
+	/** 该 id 在途未终结分片数（本地队列观测）。 */
+	outboundQueueDepth(id) {
+		return this.ids.get(id)?.queuedCount ?? 0;
+	}
+	/** 等待该 id 队列回落到 maxDepth 以下（默认上限-1；上层“暂停读上游”用）。 */
+	async waitOutboundQueue(id, maxDepth = this.maxQueuedPerId - 1) {
+		const ctx = this.ids.get(id);
+		if (ctx === void 0) return;
+		while (ctx.queuedCount > maxDepth) {
+			if (this.deadFlag) return;
+			await new Promise((resolve) => ctx.slotWaiters.push(resolve));
+		}
+	}
+	/**
+	* 挂起该 id 的空闲计时（provider 专用：请求已派发上游、等待首字节阶段；活度由
+	* PING 发送节奏与上游首字节超时管辖）。首个 RESP_META / RESP_CHUNK / DATA_DOWN
+	* 出站时自动恢复，也可显式 resumeProviderIdle。
+	*/
+	suspendProviderIdle(id) {
+		if (this.role !== "provider") return;
+		const ctx = this.ids.get(id);
+		if (ctx === void 0 || ctx.terminal) return;
+		ctx.idleSuspended = true;
+		if (ctx.idleTimer !== null) {
+			clearTimeout(ctx.idleTimer);
+			ctx.idleTimer = null;
+		}
+	}
+	/** 显式恢复该 id 的空闲计时（自恢复点重计完整窗口）。 */
+	resumeProviderIdle(id) {
+		if (this.role !== "provider") return;
+		const ctx = this.ids.get(id);
+		if (ctx === void 0 || ctx.terminal || !ctx.idleSuspended) return;
+		ctx.idleSuspended = false;
+		this.armIdle(ctx);
+	}
+	handleIncoming(frame) {
+		if (this.deadFlag) return;
+		if (this.poisonedFlag) {
+			this.counters.poisonedDropped++;
+			return;
+		}
+		if (frame.kind === "unknown-version") {
+			this.counters.unknownVersionDropped++;
+			if (this.role === "provider") this.replyError(ERROR_CODE.protocol_version, void 0);
+			return;
+		}
+		if (frame.kind === "unknown-type") {
+			this.counters.unknownTypeIgnored++;
+			return;
+		}
+		if (frame.kind === "malformed") {
+			this.counters.malformedDropped++;
+			return;
+		}
+		const meta = FRAME_META[frame.type];
+		if (meta === void 0) {
+			this.counters.unknownTypeIgnored++;
+			return;
+		}
+		const { type, header, body } = frame;
+		if (!this.authedFlag) {
+			if (!(this.role === "provider" ? type === FRAME_TYPE.AUTH : this.authPending && (type === FRAME_TYPE.AUTH_OK || type === FRAME_TYPE.AUTH_ERR))) {
+				this.counters.unauthDropped++;
+				if (this.counters.unauthDropped > this.unauthFrameLimit && !this.unauthClosed) {
+					this.unauthClosed = true;
+					this.hooks.onUnauthViolation?.(this.counters.unauthDropped);
+					this.transport.close("too-many-preauth-frames");
+				}
+				return;
+			}
+		}
+		if (!this.inboundDirectionOk(meta)) {
+			if (this.role === "provider") {
+				const rawId = header.id;
+				const id = typeof rawId === "string" ? rawId : void 0;
+				if (id !== void 0) this.finishId(id, { source: "local" });
+				this.replyError(ERROR_CODE.protocol_error, id);
+			}
+			this.counters.directionDropped++;
+			return;
+		}
+		const parsed = FRAME_HEADER_SCHEMAS[type].safeParse(header);
+		if (!parsed.success) {
+			const failure = classifySchemaFailure(type, header);
+			if (this.role === "provider") {
+				if (failure.id !== void 0) this.finishId(failure.id, { source: "local" });
+				this.replyError(failure.code, failure.id);
+			}
+			this.counters.schemaDropped++;
+			return;
+		}
+		const parsedHeader = parsed.data;
+		const rawId = parsedHeader.id;
+		const id = typeof rawId === "string" ? rawId : void 0;
+		if (id === void 0) {
+			this.deliver(type, parsedHeader, body);
+			return;
+		}
+		if (type === FRAME_TYPE.REQ) {
+			if (this.ids.has(id)) {
+				this.counters.unknownIdDropped++;
+				return;
+			}
+			const ctx = this.registerId(id);
+			if (parsedHeader.bodyLen > this.reassemblyLimitBytes || body.length > this.reassemblyLimitBytes) {
+				this.finishId(id, { source: "body-too-large" });
+				this.replyError(ERROR_CODE.body_too_large, id);
+				return;
+			}
+			ctx.reassembledBytes = body.length;
+			this.deliver(type, parsedHeader, body);
+			return;
+		}
+		const ctx = this.ids.get(id);
+		if (ctx === void 0) {
+			this.counters.unknownIdDropped++;
+			return;
+		}
+		if (ctx.terminal) {
+			this.counters.terminalDropped++;
+			return;
+		}
+		if (meta.seqStream !== void 0) {
+			const stream = meta.seqStream;
+			const expected = ctx.expectedSeq.get(stream) ?? 0;
+			if (parsedHeader.seq !== expected) {
+				this.finishId(id, { source: "protocol-seq" });
+				if (this.role === "provider") this.replyError(ERROR_CODE.protocol_seq, id);
+				this.markPoisoned(id);
+				return;
+			}
+			ctx.expectedSeq.set(stream, expected + 1);
+		}
+		if (type === FRAME_TYPE.REQ_BODY) {
+			ctx.reassembledBytes += body.length;
+			if (ctx.reassembledBytes > this.reassemblyLimitBytes) {
+				this.finishId(id, { source: "body-too-large" });
+				this.replyError(ERROR_CODE.body_too_large, id);
+				return;
+			}
+		}
+		this.touchIdle(ctx);
+		if (meta.terminal === true) this.finishId(id, {
+			source: "peer",
+			frameType: type
+		});
+		this.deliver(type, parsedHeader, body);
+	}
+	deliver(type, header, body) {
+		const frame = {
+			type,
+			header,
+			body
+		};
+		this.hooks.onFrame?.(frame);
+	}
+	markPoisoned(id) {
+		if (this.poisonedFlag) return;
+		this.poisonedFlag = true;
+		this.hooks.onPoison?.({
+			id,
+			reason: "protocol_seq"
+		});
+	}
+	registerId(id) {
+		const existing = this.ids.get(id);
+		if (existing !== void 0) return existing;
+		const ctx = {
+			id,
+			idleTimer: null,
+			idleSuspended: false,
+			terminal: false,
+			reassembledBytes: 0,
+			expectedSeq: /* @__PURE__ */ new Map(),
+			sendLane: Promise.resolve(),
+			queuedCount: 0,
+			slotWaiters: []
+		};
+		this.ids.set(id, ctx);
+		this.usedIds.add(id);
+		this.armIdle(ctx);
+		return ctx;
+	}
+	touchIdle(ctx) {
+		if (ctx.idleSuspended) return;
+		this.armIdle(ctx);
+	}
+	armIdle(ctx) {
+		if (ctx.idleTimer !== null) clearTimeout(ctx.idleTimer);
+		ctx.idleTimer = setTimeout(() => {
+			ctx.idleTimer = null;
+			if (this.deadFlag || ctx.terminal) return;
+			this.hooks.onIdleTimeout?.(ctx.id);
+		}, this.idleTimeoutMs);
+	}
+	finishId(id, cause) {
+		const ctx = this.ids.get(id);
+		if (ctx === void 0 || ctx.terminal) return;
+		ctx.terminal = true;
+		if (ctx.idleTimer !== null) {
+			clearTimeout(ctx.idleTimer);
+			ctx.idleTimer = null;
+		}
+		this.hooks.onTerminate?.(id, cause);
+	}
+	handleClosed(reason) {
+		if (this.deadFlag) return;
+		this.deadFlag = true;
+		const cause = reason === void 0 ? { source: "disconnected" } : {
+			source: "disconnected",
+			reason
+		};
+		for (const ctx of this.ids.values()) {
+			if (ctx.idleTimer !== null) {
+				clearTimeout(ctx.idleTimer);
+				ctx.idleTimer = null;
+			}
+			if (!ctx.terminal) {
+				ctx.terminal = true;
+				this.hooks.onTerminate?.(ctx.id, cause);
+			}
+		}
+		this.hooks.onDisconnect?.(reason);
+	}
+	inboundDirectionOk(meta) {
+		if (meta.dir === "both") return true;
+		return this.role === "provider" ? meta.dir === "c2p" : meta.dir === "p2c";
+	}
+	outboundDirectionOk(meta) {
+		if (meta.dir === "both") return true;
+		return this.role === "provider" ? meta.dir === "p2c" : meta.dir === "c2p";
+	}
+	/** 提供方自动回送 ERROR（无队列门控、经全局通道；发送失败静默——连接已坏时由关闭路径处置）。 */
+	replyError(code, id) {
+		const header = {
+			code,
+			message: autoErrorMessage(code)
+		};
+		if (id !== void 0) header.id = id;
+		const bytes = encodeFrame({
+			type: FRAME_TYPE.ERROR,
+			header
+		});
+		this.transmit(this.globalLane, bytes).catch(() => void 0);
+	}
+	transmit(lane, bytes) {
+		lane.queuedCount++;
+		const settled = lane.sendLane.then(() => this.transport.send(bytes)).then(() => {
+			this.slotReleased(lane);
+		}, (err) => {
+			this.slotReleased(lane);
+			throw err;
+		});
+		lane.sendLane = settled.catch(() => void 0);
+		return settled;
+	}
+	slotReleased(lane) {
+		lane.queuedCount--;
+		const waiters = lane.slotWaiters.splice(0);
+		for (const wake of waiters) wake();
+	}
+};
+//#endregion
+export { splitBody as i, FabricWireAdapter as n, DEFAULT_BODY_CHUNK_BYTES as r, WireSession as t };