ai-fly 0.0.0 → 0.1.0

package/dist/serve-DuyQMeJh.mjs

@@ -0,0 +1,1665 @@
+import { a as FRAME_TYPE, c as REJECTED_CODE, l as RESP_META_HEADER_WHITELIST, n as ERROR_CODE, r as FORBIDDEN_REQ_HEADER_NAMES, t as loadSdk } from "./sdk-C6xDRbzg.mjs";
+import { n as FabricWireAdapter, r as DEFAULT_BODY_CHUNK_BYTES, t as WireSession } from "./mux-xHl9Jrbi.mjs";
+import { _ as expandUriTemplate, b as SECRET_NAME_SCHEMA, f as ProviderStore, g as parseUpstreamUrl, h as ensurePrivateDir, m as atomicWriteFileSync, p as StoreError, v as compileMatchPattern, x as routeLocalPrefix, y as matchRequestPath } from "./common-BULbPtYn.mjs";
+import { appendFileSync, existsSync, readFileSync, readdirSync, watch } from "node:fs";
+import "node:os";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+import WebSocket from "ws";
+import { connect } from "node:net";
+//#region src/provider/limits.ts
+const QUOTA_DAY_SCHEMA = z.strictObject({
+	date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+	counts: z.record(z.string(), z.number().int().min(0))
+});
+var LimitEnforcer = class LimitEnforcer {
+	dataDir;
+	now;
+	/** 分组限额配置（reload 时整体替换）。 */
+	limitsByGroup = /* @__PURE__ */ new Map();
+	/** 分组在途计数。 */
+	inflight = /* @__PURE__ */ new Map();
+	quotaDate = "";
+	quotaCounts = /* @__PURE__ */ new Map();
+	constructor(opts) {
+		this.dataDir = opts.dataDir;
+		this.now = opts.now ?? (() => /* @__PURE__ */ new Date());
+	}
+	static quotaFilePath(dataDir) {
+		return join(dataDir, "quota-day.json");
+	}
+	/** 引擎在 store（重）加载后同步分组限额配置。 */
+	syncFromStore(store) {
+		this.limitsByGroup = new Map(store.listGroups().map((g) => [g.name, g.limits ? { ...g.limits } : {}]));
+	}
+	setGroupLimits(group, limits) {
+		this.limitsByGroup.set(group, { ...limits });
+	}
+	/** 拨号前检查+占用（原子）：并发按分组计，日限按 keyId 计。 */
+	acquire(keyId, group) {
+		const limits = this.limitsByGroup.get(group) ?? {};
+		const current = this.inflight.get(group) ?? 0;
+		if (limits.maxConcurrency !== void 0 && current >= limits.maxConcurrency) return {
+			ok: false,
+			code: "rate_limited"
+		};
+		this.ensureQuotaLoaded();
+		const used = this.quotaCounts.get(keyId) ?? 0;
+		if (limits.dailyRequests !== void 0 && used >= limits.dailyRequests) return {
+			ok: false,
+			code: "quota_exceeded"
+		};
+		this.inflight.set(group, current + 1);
+		this.quotaCounts.set(keyId, used + 1);
+		this.persistQuota();
+		return { ok: true };
+	}
+	/** 请求终结时释放并发占用（幂等保护：下限 0）。 */
+	release(group) {
+		const current = this.inflight.get(group) ?? 0;
+		this.inflight.set(group, Math.max(0, current - 1));
+	}
+	inflightCount(group) {
+		return this.inflight.get(group) ?? 0;
+	}
+	dailyCount(keyId) {
+		this.ensureQuotaLoaded();
+		return this.quotaCounts.get(keyId) ?? 0;
+	}
+	today() {
+		return this.now().toISOString().slice(0, 10);
+	}
+	/** 加载/日界重置（懒加载：首次 acquire 或查询时）。 */
+	ensureQuotaLoaded() {
+		const today = this.today();
+		if (this.quotaDate === today) return;
+		let counts = /* @__PURE__ */ new Map();
+		const path = LimitEnforcer.quotaFilePath(this.dataDir);
+		if (existsSync(path)) try {
+			const parsed = QUOTA_DAY_SCHEMA.parse(JSON.parse(readFileSync(path, "utf8")));
+			if (parsed.date === today) counts = new Map(Object.entries(parsed.counts));
+		} catch {}
+		this.quotaDate = today;
+		this.quotaCounts = counts;
+	}
+	persistQuota() {
+		const payload = {
+			date: this.quotaDate,
+			counts: Object.fromEntries(this.quotaCounts)
+		};
+		atomicWriteFileSync(LimitEnforcer.quotaFilePath(this.dataDir), `${JSON.stringify(payload, null, 2)}\n`);
+	}
+};
+var UsageLog = class {
+	path;
+	dirReady = false;
+	constructor(dataDir) {
+		this.path = join(dataDir, "usage.jsonl");
+	}
+	append(record) {
+		if (!this.dirReady) {
+			ensurePrivateDir(dirname(this.path));
+			this.dirReady = true;
+		}
+		appendFileSync(this.path, `${JSON.stringify(record)}\n`, { mode: 384 });
+	}
+	pathOf() {
+		return this.path;
+	}
+};
+const ENV_REF_PREFIX = "$env:";
+/** $secret 引用前缀（密钥库名；与 $env 同样按引用整体掩码）。 */
+const SECRET_REF_PREFIX = "$secret:";
+function isEnvRef(value) {
+	return value.startsWith(ENV_REF_PREFIX);
+}
+function isSecretRef(value) {
+	return value.startsWith(SECRET_REF_PREFIX);
+}
+/** 引用型头值（$env:/$secret:）——披露时统一掩码（名与值都不出）。 */
+function isMaskedRef(value) {
+	return isEnvRef(value) || isSecretRef(value);
+}
+/** 前缀重写规则的披露形态：strip:/a 与 append:/b 的组合标记。 */
+function prefixDisclosure(service) {
+	const rewrite = service.rewrite;
+	if (rewrite === void 0) return void 0;
+	const tokens = [];
+	if (rewrite.pathPrefixStrip !== void 0) tokens.push(`strip:${rewrite.pathPrefixStrip}`);
+	if (rewrite.pathPrefixAppend !== void 0) tokens.push(`append:${rewrite.pathPrefixAppend}`);
+	return tokens.length === 0 ? void 0 : tokens.join(" ");
+}
+/** 服务完整配置的脱敏披露（$env 头值 -> ●，变量名不显示）。 */
+function buildServiceDetail(service) {
+	const rewrite = {};
+	if (service.rewrite !== void 0) {
+		if (service.rewrite.hostHeader !== void 0) rewrite.host = service.rewrite.hostHeader;
+		const prefix = prefixDisclosure(service);
+		if (prefix !== void 0) rewrite.prefix = prefix;
+		if (service.rewrite.headerSet !== void 0) rewrite.headerSet = Object.entries(service.rewrite.headerSet).map(([name, value]) => ({
+			name,
+			value: isMaskedRef(value) ? "●" : value
+		}));
+	}
+	return {
+		upstream: service.upstream,
+		match: service.match.map((m) => ({
+			type: m.type,
+			value: m.value
+		})),
+		rewrite,
+		...service.routes !== void 0 && service.routes.length > 0 ? { routes: service.routes.map((r) => r.mode === "pattern" ? {
+			forms: r.forms,
+			mode: "pattern",
+			matchPattern: r.matchPattern,
+			template: r.template
+		} : {
+			forms: r.forms,
+			localPrefix: routeLocalPrefix(r),
+			upstreamPrefix: r.upstreamPrefix ?? ""
+		}) } : {}
+	};
+}
+/** 目录服务条目（含 detail 脱敏披露）。 */
+function buildServiceEntry(service) {
+	return {
+		serviceId: service.serviceId,
+		name: service.name,
+		match: service.match.map((m) => ({
+			type: m.type,
+			value: m.value
+		})),
+		defaultPort: service.defaultPort,
+		detail: buildServiceDetail(service)
+	};
+}
+/**
+* detail 的 ASCII 展示形（CLI status --verbose 用；用户面文案码位 < 128，故 ●
+* 在终端侧替换为 <hidden>——$env 与 $secret 掩码同形，无法区分，用中性词）。
+*/
+function detailDisplayLines(detail) {
+	const lines = [`upstream: ${detail.upstream}`];
+	for (const m of detail.match) lines.push(`match: ${m.type} ${m.value}`);
+	for (const r of detail.routes ?? []) {
+		const forms = r.forms.length > 0 ? ` (${r.forms.join("+")})` : "";
+		if (r.mode === "pattern") lines.push(`route: ${r.matchPattern} => ${r.template}${forms}`);
+		else {
+			const to = r.upstreamPrefix === "" ? "(root)" : r.upstreamPrefix;
+			lines.push(`route: ${r.localPrefix} -> ${to}${forms}`);
+		}
+	}
+	if (detail.rewrite !== void 0) {
+		const r = detail.rewrite;
+		if (r.host !== void 0) lines.push(`host: ${r.host}`);
+		if (r.prefix !== void 0) lines.push(`prefix: ${r.prefix}`);
+		for (const h of r.headerSet ?? []) lines.push(`header-set: ${h.name}: ${h.value === "●" ? "<hidden>" : h.value}`);
+	}
+	return lines;
+}
+//#endregion
+//#region src/provider/auth.ts
+function authDirectoryFromStore(store, over = {}) {
+	return {
+		alias: over.alias ?? store.alias ?? "provider",
+		relayUrls: over.relayUrls ?? [],
+		verifyKey: (key) => store.verifyKey(key),
+		groupLimits: (group) => store.getGroup(group)?.limits,
+		groupServices: (group) => store.groupServices(group).map(buildServiceEntry)
+	};
+}
+/** 钥环逐一校验（去重后；rejected 上限 64 对齐 wire schema）。 */
+function evaluateKeyring(keys, dir) {
+	const seen = /* @__PURE__ */ new Set();
+	const valid = [];
+	const rejected = [];
+	for (const key of keys) {
+		if (seen.has(key)) continue;
+		seen.add(key);
+		const check = dir.verifyKey(key);
+		if (check.status === "valid") valid.push({
+			keyId: check.keyId,
+			group: check.group
+		});
+		else if (check.status === "revoked") {
+			if (rejected.length < 64) rejected.push({ code: REJECTED_CODE.key_revoked });
+		} else if (rejected.length < 64) rejected.push({ code: REJECTED_CODE.key_invalid });
+	}
+	return {
+		valid,
+		rejected
+	};
+}
+/** 每枚有效密钥 -> {keyId, group, limits, services[含 detail]} 视图。 */
+function buildAuthOk(valid, dir, opts = {}) {
+	const groups = valid.map((grant) => {
+		const limits = dir.groupLimits(grant.group) ?? {};
+		return {
+			keyId: grant.keyId,
+			group: grant.group,
+			limits,
+			services: dir.groupServices(grant.group)
+		};
+	});
+	const header = {
+		v: 1,
+		alias: dir.alias,
+		relayUrls: [...dir.relayUrls],
+		groups
+	};
+	if (opts.refresh === true) header.refresh = true;
+	return header;
+}
+/** AUTH 帧决策（纯）：全无效 -> err（调用方发送后断开）。 */
+function handleAuthFrame(header, dir) {
+	const { valid, rejected } = evaluateKeyring(header.keys, dir);
+	if (valid.length === 0) return {
+		kind: "err",
+		header: {
+			v: 1,
+			code: "key_all_invalid",
+			message: "all presented keys are invalid or revoked"
+		}
+	};
+	const ok = buildAuthOk(valid, dir);
+	if (rejected.length > 0) ok.rejected = rejected;
+	return {
+		kind: "ok",
+		header: ok,
+		valid,
+		keys: [...new Set(header.keys)]
+	};
+}
+var KeySessionIndex = class {
+	byKey = /* @__PURE__ */ new Map();
+	/** 登记/更新会话的 keyId 归属（重复 AUTH 以最后一次为准）。 */
+	track(binding) {
+		this.untrack(binding);
+		for (const keyId of binding.keyIds) {
+			let set = this.byKey.get(keyId);
+			if (set === void 0) {
+				set = /* @__PURE__ */ new Set();
+				this.byKey.set(keyId, set);
+			}
+			set.add(binding);
+		}
+	}
+	untrack(binding) {
+		for (const [keyId, set] of this.byKey) {
+			set.delete(binding);
+			if (set.size === 0) this.byKey.delete(keyId);
+		}
+	}
+	sessionsWithKey(keyId) {
+		return [...this.byKey.get(keyId) ?? []];
+	}
+	size() {
+		let total = /* @__PURE__ */ new Set();
+		for (const set of this.byKey.values()) total = /* @__PURE__ */ new Set([...total, ...set]);
+		return total.size;
+	}
+};
+//#endregion
+//#region src/provider/rewrite.ts
+/** 拼接/断言失败（protocol_error 语义）。 */
+var RewriteError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "RewriteError";
+	}
+};
+/**
+* 服务声明了路由表但请求路径未命中任何标准前缀（path_not_offered 语义，
+* 消费侧映射 404）：只转发声明的 API 标准面——防 /user、/balance 等
+* 个人信息端点被提供方凭据打穿（Owner 2026-09-10 裁决：路由表即白名单）。
+*/
+var PathNotOfferedError = class extends Error {
+	constructor() {
+		super("path is not offered by this service");
+		this.name = "PathNotOfferedError";
+	}
+};
+/**
+* `$secret:<name>` 引用未命中（secret_missing 语义）：该请求以 ERROR(secret_missing)
+* 拒绝。message 固定——MUST NOT 包含密钥名与值（错误帧会过网）。
+*/
+var SecretMissingError = class extends Error {
+	constructor() {
+		super("referenced secret is missing");
+		this.name = "SecretMissingError";
+	}
+};
+/**
+* 头值解析：literal 原样；`$secret:<name>` 优先于 `$env:` 判定——命中密钥库返回
+* 完整值，未命中（含空名/空值/未注入密钥源）抛 SecretMissingError（不回退空值、
+* 不省略该头）；`$env:<VAR>` 语义保持——空串/未设置返回 undefined（= 省略该头）。
+* 两者可并存于不同头（逐头独立解析）。
+*/
+function resolveHeaderValue(value, env, secrets) {
+	if (value.startsWith("$secret:")) {
+		const name = value.slice(8);
+		const resolved = secrets?.(name);
+		if (resolved === void 0 || resolved === "") throw new SecretMissingError();
+		return resolved;
+	}
+	if (!value.startsWith("$env:")) return value;
+	const name = value.slice(5);
+	if (name === "") return void 0;
+	const resolved = env[name];
+	return resolved === void 0 || resolved === "" ? void 0 : resolved;
+}
+/** 服务声明的全部 $env 变量名（启动横幅 WARNING 用）。 */
+function collectEnvVarNames(service) {
+	const names = /* @__PURE__ */ new Set();
+	const headerSet = service.rewrite?.headerSet;
+	if (headerSet === void 0) return [];
+	for (const value of Object.values(headerSet)) if (value.startsWith("$env:")) {
+		const name = value.slice(5);
+		if (name !== "") names.add(name);
+	}
+	return [...names];
+}
+/** HTTP hop-by-hop / 传输层自管头（普通 HTTP 转发路径剥离；WS 路径另行挑选）。 */
+const HOP_BY_HOP_HEADER_NAMES = /* @__PURE__ */ new Set([
+	"connection",
+	"keep-alive",
+	"proxy-connection",
+	"transfer-encoding",
+	"te",
+	"trailer",
+	"upgrade"
+]);
+/** 帧内头防御性剥离集合（wire schema 已拒绝；此处纵深防御）。 */
+const DEFENSIVE_STRIP = /* @__PURE__ */ new Set([
+	...FORBIDDEN_REQ_HEADER_NAMES,
+	...HOP_BY_HOP_HEADER_NAMES,
+	"content-length"
+]);
+/** 点段规范化（".", ".." 解析；不越出根，前缀断言兜底）。 */
+function normalizeDotSegments(path) {
+	const out = [];
+	for (const seg of path.split("/")) {
+		if (seg === "." || seg === "") continue;
+		if (seg === "..") {
+			out.pop();
+			continue;
+		}
+		out.push(seg);
+	}
+	return `/${out.join("/")}`;
+}
+function splitQuery(raw) {
+	const idx = raw.indexOf("?");
+	return idx < 0 ? {
+		path: raw,
+		query: ""
+	} : {
+		path: raw.slice(0, idx),
+		query: raw.slice(idx + 1)
+	};
+}
+/** 查询值解码（畸形序列原样保留；模板会重新编码）。 */
+function safeDecode(value) {
+	try {
+		return decodeURIComponent(value.replace(/\+/g, "%20"));
+	} catch {
+		return value;
+	}
+}
+/** 查询串 → 变量表（pattern 模板变量域；同名捕获组优先覆盖）。 */
+function parseQueryVars(query) {
+	const vars = {};
+	if (query === "") return vars;
+	for (const pair of query.split("&")) {
+		const eq = pair.indexOf("=");
+		if (eq < 0) {
+			if (pair !== "") vars[pair] = "";
+			continue;
+		}
+		vars[pair.slice(0, eq)] = safeDecode(pair.slice(eq + 1));
+	}
+	return vars;
+}
+/** 帧内 path 的纵深防御检查（schema 层已拒；双保险）。 */
+function assertFramePathShape(path) {
+	if (!path.startsWith("/") || path.startsWith("//") || path.startsWith("/\\")) throw new RewriteError("request path must start with a single '/'");
+	if (path.includes("\\")) throw new RewriteError("request path must not contain backslash");
+	const pathPart = splitQuery(path).path;
+	if (pathPart.includes("://")) throw new RewriteError("request path must not contain a scheme");
+	for (const seg of pathPart.split("/").slice(1)) if (seg === "." || seg === "..") throw new RewriteError("request path must not contain '.' or '..' segments");
+}
+/** connection 头 token 列表包含 upgrade 且 upgrade 头为 websocket（大小写不敏感）。 */
+function isWebSocketUpgradeRequest(headers) {
+	const connection = headers["connection"];
+	const upgrade = headers["upgrade"];
+	if (connection === void 0 || upgrade === void 0) return false;
+	return connection.split(",").map((t) => t.trim().toLowerCase()).includes("upgrade") && upgrade.trim().toLowerCase() === "websocket";
+}
+function buildUpstreamRequest(service, req, env = process.env, secrets) {
+	const upstream = parseUpstreamUrl(service.upstream);
+	assertFramePathShape(req.path);
+	const split = splitQuery(req.path);
+	let requestPath = split.path;
+	let query = split.query;
+	if (service.routes !== void 0 && service.routes.length > 0) {
+		let matched = false;
+		for (const route of service.routes) {
+			if (route.mode === "pattern") {
+				const groups = matchRequestPath(compileMatchPattern(route.matchPattern), requestPath, query);
+				if (groups === null) continue;
+				const vars = {
+					...parseQueryVars(query),
+					...groups
+				};
+				const assembled = expandUriTemplate(route.template, vars);
+				const qIdx = assembled.indexOf("?");
+				if (qIdx >= 0) {
+					requestPath = assembled.slice(0, qIdx);
+					query = assembled.slice(qIdx + 1);
+				} else requestPath = assembled;
+				matched = true;
+				break;
+			}
+			const local = routeLocalPrefix(route);
+			if (!(requestPath === local || requestPath.startsWith(local + "/"))) continue;
+			const rest = requestPath.slice(local.length);
+			const up = route.upstreamPrefix ?? "";
+			requestPath = rest === "" ? up === "" ? "/" : up : `${up}${rest}`;
+			matched = true;
+			break;
+		}
+		if (!matched) throw new PathNotOfferedError();
+	}
+	const strip = service.rewrite?.pathPrefixStrip;
+	if (strip !== void 0 && (requestPath === strip || requestPath.startsWith(strip + "/"))) {
+		requestPath = requestPath.slice(strip.length);
+		if (requestPath === "") requestPath = "/";
+	}
+	const append = service.rewrite?.pathPrefixAppend;
+	if (append !== void 0) {
+		const appendNormalized = normalizeDotSegments(append).replace(/\/+$/, "");
+		if (appendNormalized !== "") requestPath = appendNormalized + (requestPath === "/" ? "/" : requestPath);
+	}
+	const baseNormalized = normalizeDotSegments(upstream.pathname === "" ? "/" : upstream.pathname);
+	const finalPath = normalizeDotSegments(baseNormalized === "/" ? requestPath : `${baseNormalized.replace(/\/+$/, "")}${requestPath}`);
+	let url;
+	try {
+		url = new URL(finalPath + (query === "" ? "" : `?${query}`), upstream);
+	} catch {
+		throw new RewriteError("cannot build upstream URL from service config and request path");
+	}
+	if (url.origin !== upstream.origin) throw new RewriteError(`upstream origin assertion failed (${url.origin} != ${upstream.origin})`);
+	if (!pathHasPrefix(finalPath, baseNormalized)) throw new RewriteError("upstream base path prefix assertion failed");
+	const headers = {};
+	for (const [name, value] of Object.entries(req.headers ?? {})) {
+		if (DEFENSIVE_STRIP.has(name)) continue;
+		headers[name] = value;
+	}
+	if (req.contentType !== void 0 && req.contentType !== "") headers["content-type"] = req.contentType;
+	for (const name of service.rewrite?.headerRemove ?? []) delete headers[name];
+	const headerSet = service.rewrite?.headerSet;
+	if (headerSet !== void 0) for (const [name, value] of Object.entries(headerSet)) {
+		const resolved = resolveHeaderValue(value, env, secrets);
+		if (resolved === void 0) continue;
+		headers[name] = resolved;
+	}
+	const host = service.rewrite?.hostHeader ?? upstream.host;
+	return {
+		url,
+		headers,
+		host,
+		isWebSocketUpgrade: isWebSocketUpgradeRequest(req.headers ?? {})
+	};
+}
+/** 段边界前缀判定：base 为根恒真；否则 final === base 或以 base/ 开头。 */
+function pathHasPrefix(finalPath, basePath) {
+	if (basePath === "/" || basePath === "") return true;
+	if (finalPath === basePath) return true;
+	const base = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+	return finalPath.startsWith(`${base}/`);
+}
+//#endregion
+//#region src/provider/ws-upstream.ts
+/** http(s) URL -> ws(s) URL。 */
+function toWebSocketUrl(url) {
+	return `${url.protocol === "https:" ? "wss" : "ws"}:${url.href.slice(url.protocol.length)}`;
+}
+function headerGet(headers, name) {
+	const value = headers[name];
+	if (value === void 0) return null;
+	return Array.isArray(value) ? value.join(", ") : value;
+}
+async function forwardWsUpgrade(ctx, plan, t) {
+	const { session, id } = ctx;
+	let settled = false;
+	let opened = false;
+	let downSeq = 0;
+	let bytes = 0;
+	let acceptHeader = null;
+	/** 完成回调（await 完成Promise 的 resolve；close 与非 101 中继任一触发）。 */
+	let completion;
+	let sendChain = Promise.resolve();
+	const recordUsage = (status) => {
+		ctx.onUsage?.({
+			ts: Date.now(),
+			keyId: ctx.keyId,
+			serviceId: ctx.service.serviceId,
+			status,
+			bytes
+		});
+	};
+	const enqueue = (task) => {
+		sendChain = sendChain.then(task).catch(() => void 0);
+	};
+	const sendErrorFrame = (code, message) => {
+		if (settled) return;
+		settled = true;
+		enqueue(async () => {
+			try {
+				await session.send(FRAME_TYPE.ERROR, {
+					id,
+					code,
+					message
+				});
+			} catch {}
+		});
+	};
+	session.suspendProviderIdle(id);
+	const pingTimer = t.pingMs > 0 ? setInterval(() => {
+		session.send(FRAME_TYPE.PING, { id }).catch(() => void 0);
+	}, t.pingMs) : null;
+	const cleanup = () => {
+		if (pingTimer !== null) clearInterval(pingTimer);
+	};
+	const teardown = (code) => {
+		if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) code === void 0 ? ws.terminate() : ws.close(code);
+	};
+	const headers = {
+		...plan.headers,
+		host: plan.host
+	};
+	delete headers["sec-websocket-extensions"];
+	delete headers["sec-websocket-key"];
+	delete headers["sec-websocket-version"];
+	delete headers["content-type"];
+	delete headers["content-length"];
+	const protocolHeader = headers["sec-websocket-protocol"];
+	delete headers["sec-websocket-protocol"];
+	const protocols = protocolHeader === void 0 ? [] : protocolHeader.split(",").map((p) => p.trim()).filter((p) => p !== "");
+	const ws = new WebSocket(toWebSocketUrl(plan.url), protocols, {
+		headers,
+		handshakeTimeout: t.connectMs,
+		perMessageDeflate: false
+	});
+	const relay = {
+		pushUp(data) {
+			if (ws.readyState !== WebSocket.OPEN) return;
+			bytes += data.length;
+			ws.send(data, { binary: true });
+		},
+		closeByPeer() {
+			settled = true;
+			cleanup();
+			teardown();
+		},
+		abort(code, reply) {
+			if (reply) sendErrorFrame(code, `websocket relay aborted (${code})`);
+			else settled = true;
+			cleanup();
+			teardown();
+		}
+	};
+	ctx.onWsRelay?.(relay);
+	const onExternalAbort = () => {
+		const { code, reply } = abortCodeOf(ctx.signal);
+		relay.abort(code, reply);
+	};
+	if (ctx.signal.aborted) onExternalAbort();
+	else ctx.signal.addEventListener("abort", onExternalAbort, { once: true });
+	ws.on("upgrade", (res) => {
+		acceptHeader = headerGet(res.headers, "sec-websocket-accept");
+	});
+	ws.on("unexpected-response", (_req, res) => {
+		if (settled) return;
+		settled = true;
+		const status = res.statusCode ?? 500;
+		const contentType = headerGet(res.headers, "content-type") ?? "";
+		enqueue(async () => {
+			const meta = {
+				id,
+				status,
+				contentType
+			};
+			const picked = pickResponseWhitelist((name) => headerGet(res.headers, name));
+			if (picked !== void 0) meta.headers = picked;
+			try {
+				await session.send(FRAME_TYPE.RESP_META, meta);
+			} catch {
+				return;
+			}
+			let seq = 0;
+			res.on("data", (chunk) => {
+				bytes += chunk.length;
+				enqueue(async () => {
+					for (const piece of splitBodyChunks(new Uint8Array(chunk))) {
+						await session.waitOutboundQueue(id);
+						await session.send(FRAME_TYPE.RESP_CHUNK, {
+							id,
+							seq
+						}, piece);
+						seq += 1;
+					}
+				});
+			});
+			res.on("end", () => {
+				enqueue(async () => {
+					try {
+						await session.send(FRAME_TYPE.RESP_END, { id });
+					} finally {
+						completion?.();
+					}
+					recordUsage(status);
+				});
+			});
+			res.on("error", () => {
+				enqueue(async () => {
+					try {
+						await session.send(FRAME_TYPE.ERROR, {
+							id,
+							code: ERROR_CODE.upstream_unreachable,
+							message: "upstream error response stream failed"
+						});
+					} catch {} finally {
+						completion?.();
+					}
+				});
+			});
+			res.resume();
+		});
+	});
+	ws.on("open", () => {
+		opened = true;
+		enqueue(async () => {
+			const meta = {
+				id,
+				status: 101,
+				contentType: ""
+			};
+			if (acceptHeader !== null) meta.headers = { "sec-websocket-accept": acceptHeader };
+			try {
+				await session.send(FRAME_TYPE.RESP_META, meta);
+			} catch {
+				return;
+			}
+			recordUsage(101);
+		});
+	});
+	ws.on("message", (data) => {
+		const payload = Buffer.isBuffer(data) ? data : Array.isArray(data) ? Buffer.concat(data) : Buffer.from(data);
+		bytes += payload.length;
+		const pieces = splitBodyChunks(new Uint8Array(payload));
+		const startSeq = downSeq;
+		downSeq += pieces.length;
+		enqueue(async () => {
+			let seq = startSeq;
+			for (const piece of pieces) {
+				await session.waitOutboundQueue(id);
+				await session.send(FRAME_TYPE.DATA_DOWN, {
+					v: 1,
+					id,
+					seq
+				}, piece);
+				seq += 1;
+			}
+		});
+	});
+	ws.on("ping", () => {
+		session.send(FRAME_TYPE.PING, { id }).catch(() => void 0);
+	});
+	ws.on("close", (code) => {
+		cleanup();
+		if (settled) return;
+		settled = true;
+		enqueue(async () => {
+			const header = { id };
+			if (code >= 1e3 && code <= 65535) header.code = code;
+			try {
+				await session.send(FRAME_TYPE.CLOSE, header);
+			} catch {}
+			recordUsage(opened ? "ws-closed" : ERROR_CODE.upstream_unreachable);
+		});
+	});
+	ws.on("error", (err) => {
+		cleanup();
+		if (settled) return;
+		if (!opened) {
+			sendErrorFrame(ERROR_CODE.upstream_unreachable, `websocket handshake failed: ${err.message}`);
+			recordUsage(ERROR_CODE.upstream_unreachable);
+			return;
+		}
+		settled = true;
+		enqueue(async () => {
+			try {
+				await session.send(FRAME_TYPE.CLOSE, {
+					id,
+					code: 1011
+				});
+			} catch {}
+			recordUsage("ws-error");
+		});
+	});
+	await new Promise((resolve) => {
+		let completed = false;
+		const complete = () => {
+			if (completed) return;
+			completed = true;
+			resolve();
+		};
+		completion = complete;
+		ws.on("close", complete);
+		if (ws.readyState === WebSocket.CLOSED) complete();
+	});
+	completion = void 0;
+	cleanup();
+}
+//#endregion
+//#region src/provider/upstream.ts
+const DEFAULT_UPSTREAM_TIMEOUTS = {
+	connectMs: 1e4,
+	firstByteMs: 6e5,
+	stallMs: 12e4,
+	pingMs: 3e4
+};
+/** 引擎侧主动中止（abort reason）：code = 回送 ERROR 码；reply=false 不回帧。 */
+var UpstreamAbortError = class extends Error {
+	code;
+	reply;
+	constructor(code, reply = true) {
+		super(`upstream forward aborted: ${code}`);
+		this.name = "UpstreamAbortError";
+		this.code = code;
+		this.reply = reply;
+	}
+};
+/** 默认连接期探测：独立 TCP 连接探活（fetch 不暴露连接建立阶段；探测成功即销毁）。 */
+function defaultProbeConnect(url, ms) {
+	return new Promise((resolve, reject) => {
+		const port = url.port !== "" ? Number(url.port) : url.protocol === "https:" ? 443 : 80;
+		const socket = connect({
+			host: url.hostname,
+			port
+		});
+		let done = false;
+		const finish = (err) => {
+			if (done) return;
+			done = true;
+			socket.destroy();
+			if (err === void 0) resolve();
+			else reject(err);
+		};
+		socket.setTimeout(ms, () => finish(/* @__PURE__ */ new Error("connect timeout")));
+		socket.once("connect", () => finish());
+		socket.once("error", (err) => finish(err));
+	});
+}
+/** RESP_META 白名单头挑选（小写键）。 */
+function pickResponseWhitelist(get) {
+	const out = {};
+	for (const name of RESP_META_HEADER_WHITELIST) {
+		const value = get(name);
+		if (value !== null) out[name] = value;
+	}
+	return Object.keys(out).length === 0 ? void 0 : out;
+}
+/** 大分片拆为 ≤ 上限的帧序列（RESP_CHUNK / DATA_DOWN 共用）。 */
+function splitBodyChunks(data, limit = DEFAULT_BODY_CHUNK_BYTES) {
+	if (data.length <= limit) return [data];
+	const out = [];
+	for (let off = 0; off < data.length; off += limit) out.push(data.subarray(off, Math.min(off + limit, data.length)));
+	return out;
+}
+/** 信号 reason -> 回送码（缺省 aborted）。 */
+function abortCodeOf(signal) {
+	const reason = signal.reason;
+	if (reason instanceof UpstreamAbortError) return {
+		code: reason.code,
+		reply: reason.reply
+	};
+	return {
+		code: ERROR_CODE.aborted,
+		reply: true
+	};
+}
+function mergeTimeouts(overrides) {
+	return {
+		...DEFAULT_UPSTREAM_TIMEOUTS,
+		...overrides
+	};
+}
+async function forwardRequest(ctx) {
+	let plan;
+	try {
+		plan = buildUpstreamRequest(ctx.service, ctx.req, ctx.env ?? process.env, ctx.secrets);
+	} catch (err) {
+		const code = err instanceof SecretMissingError ? ERROR_CODE.secret_missing : err instanceof PathNotOfferedError ? ERROR_CODE.path_not_offered : ERROR_CODE.protocol_error;
+		const message = err instanceof RewriteError || err instanceof SecretMissingError || err instanceof PathNotOfferedError ? err.message : "request rewrite failed";
+		await sendError(ctx.session, ctx.id, code, message);
+		ctx.onUsage?.({
+			ts: Date.now(),
+			keyId: ctx.keyId,
+			serviceId: ctx.service.serviceId,
+			status: code,
+			bytes: 0
+		});
+		return;
+	}
+	if (plan.isWebSocketUpgrade) {
+		await forwardWsUpgrade(ctx, plan, mergeTimeouts(ctx.timeouts));
+		return;
+	}
+	await forwardHttp(ctx, plan, mergeTimeouts(ctx.timeouts));
+}
+async function sendError(session, id, code, message) {
+	try {
+		await session.send(FRAME_TYPE.ERROR, {
+			id,
+			code,
+			message
+		});
+	} catch {}
+}
+async function forwardHttp(ctx, plan, t) {
+	const { session, id } = ctx;
+	let settled = false;
+	let bytes = 0;
+	const recordUsage = (status) => {
+		ctx.onUsage?.({
+			ts: Date.now(),
+			keyId: ctx.keyId,
+			serviceId: ctx.service.serviceId,
+			status,
+			bytes
+		});
+	};
+	const finishWithError = async (code, message) => {
+		if (settled) return;
+		settled = true;
+		await sendError(session, id, code, message);
+		recordUsage(code);
+	};
+	if ((ctx.req.method === "GET" || ctx.req.method === "HEAD") && ctx.body.length > 0) {
+		await finishWithError(ERROR_CODE.protocol_error, "request body not allowed for GET/HEAD");
+		return;
+	}
+	const probe = ctx.probeConnect ?? defaultProbeConnect;
+	try {
+		await probe(plan.url, t.connectMs);
+	} catch {
+		await finishWithError(ERROR_CODE.upstream_unreachable, "upstream connect failed or timed out");
+		return;
+	}
+	const ctrl = new AbortController();
+	let firstByteTimer = null;
+	let stallTimer = null;
+	let pingTimer = null;
+	let localAbortCode;
+	const stopPing = () => {
+		if (pingTimer !== null) {
+			clearInterval(pingTimer);
+			pingTimer = null;
+		}
+	};
+	const clearTimers = () => {
+		if (firstByteTimer !== null) {
+			clearTimeout(firstByteTimer);
+			firstByteTimer = null;
+		}
+		if (stallTimer !== null) {
+			clearTimeout(stallTimer);
+			stallTimer = null;
+		}
+		stopPing();
+	};
+	const onExternalAbort = () => {
+		ctrl.abort();
+	};
+	if (ctx.signal.aborted) onExternalAbort();
+	else ctx.signal.addEventListener("abort", onExternalAbort, { once: true });
+	session.suspendProviderIdle(id);
+	if (t.pingMs > 0) pingTimer = setInterval(() => {
+		session.send(FRAME_TYPE.PING, { id }).catch(() => void 0);
+	}, t.pingMs);
+	const abortWith = (code) => {
+		if (localAbortCode === void 0) localAbortCode = code;
+		ctrl.abort();
+	};
+	firstByteTimer = setTimeout(() => abortWith(ERROR_CODE.idle_timeout), t.firstByteMs);
+	const fetchFn = ctx.fetchImpl ?? fetch;
+	const headers = {
+		...plan.headers,
+		host: plan.host
+	};
+	const init = {
+		method: ctx.req.method,
+		headers,
+		redirect: "manual",
+		signal: ctrl.signal
+	};
+	if (ctx.body.length > 0) init.body = ctx.body;
+	/** 中止分类：外部信号（ABORT/idle/断连）优先，其次本地超时码，否则网络失败。 */
+	const classifyAbort = () => {
+		if (!ctrl.signal.aborted) return void 0;
+		if (ctx.signal.aborted) return abortCodeOf(ctx.signal);
+		return {
+			code: localAbortCode ?? ERROR_CODE.aborted,
+			reply: true
+		};
+	};
+	let resp;
+	try {
+		resp = await fetchFn(plan.url, init);
+	} catch {
+		clearTimers();
+		const aborted = classifyAbort();
+		if (aborted !== void 0) {
+			if (aborted.reply) await finishWithError(aborted.code, `upstream request aborted (${aborted.code})`);
+			else settled = true;
+			return;
+		}
+		await finishWithError(ERROR_CODE.upstream_unreachable, "upstream request failed");
+		return;
+	}
+	clearTimers();
+	let reader;
+	try {
+		const metaHeader = {
+			id,
+			status: resp.status,
+			contentType: resp.headers.get("content-type") ?? ""
+		};
+		const picked = pickResponseWhitelist((name) => resp.headers.get(name));
+		if (picked !== void 0) metaHeader.headers = picked;
+		await session.send(FRAME_TYPE.RESP_META, metaHeader);
+		let seq = 0;
+		const armStall = () => {
+			if (stallTimer !== null) clearTimeout(stallTimer);
+			stallTimer = setTimeout(() => abortWith(ERROR_CODE.idle_timeout), t.stallMs);
+		};
+		armStall();
+		reader = resp.body?.getReader();
+		if (reader !== void 0) for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			armStall();
+			for (const piece of splitBodyChunks(value)) {
+				await session.waitOutboundQueue(id);
+				await session.send(FRAME_TYPE.RESP_CHUNK, {
+					id,
+					seq
+				}, piece);
+				seq += 1;
+				bytes += piece.length;
+			}
+		}
+		if (stallTimer !== null) {
+			clearTimeout(stallTimer);
+			stallTimer = null;
+		}
+		if (ctx.signal.aborted) {
+			const { code, reply } = abortCodeOf(ctx.signal);
+			if (reply) await finishWithError(code, `upstream request aborted (${code})`);
+			else settled = true;
+			return;
+		}
+		await session.send(FRAME_TYPE.RESP_END, { id });
+		settled = true;
+		recordUsage(resp.status);
+	} catch {
+		if (stallTimer !== null) {
+			clearTimeout(stallTimer);
+			stallTimer = null;
+		}
+		const aborted = classifyAbort();
+		if (aborted !== void 0) {
+			if (aborted.reply) await finishWithError(aborted.code, `upstream request aborted (${aborted.code})`);
+			else settled = true;
+			return;
+		}
+		await finishWithError(ERROR_CODE.upstream_unreachable, "upstream stream failed");
+	} finally {
+		clearTimers();
+		ctrl.abort();
+		if (reader !== void 0) reader.cancel().catch(() => void 0);
+		else resp.body?.cancel().catch(() => void 0);
+	}
+}
+//#endregion
+//#region src/provider/engine.ts
+var ProviderEngine = class {
+	fabric;
+	dataDir;
+	limitsEnforcer;
+	usageLog;
+	opts;
+	storeRef;
+	peers = /* @__PURE__ */ new Map();
+	keyIndex = new KeySessionIndex();
+	relayUrlsCache = [];
+	unsubscribeFabric = null;
+	stopped = false;
+	constructor(deps) {
+		this.fabric = deps.fabric;
+		this.storeRef = deps.store;
+		this.dataDir = deps.dataDir;
+		this.limitsEnforcer = deps.limits ?? new LimitEnforcer({ dataDir: deps.dataDir });
+		this.limitsEnforcer.syncFromStore(deps.store);
+		this.opts = deps.opts ?? {};
+		this.usageLog = this.opts.logUsage === true ? new UsageLog(deps.dataDir) : void 0;
+	}
+	get store() {
+		return this.storeRef;
+	}
+	get limits() {
+		return this.limitsEnforcer;
+	}
+	/** 订阅 fabric 事件并初始化 relay 缓存（幂等）。 */
+	async start() {
+		if (this.unsubscribeFabric !== null) return;
+		await this.refreshRelayUrls();
+		this.unsubscribeFabric = this.fabric.on((event) => {
+			if (this.stopped) return;
+			if (event.type === "peer-connected") this.addPeer(event.endpointId);
+			else if (event.type === "peer-disconnected") this.removePeer(event.endpointId, "peer-disconnected");
+			else if (event.type === "roster-updated") this.enforceMembership();
+			else if (event.type === "relay-online" || event.type === "relay-offline") this.refreshRelayUrls().then(() => this.broadcastRefresh());
+		});
+	}
+	async refreshRelayUrls() {
+		try {
+			const status = await this.fabric.relayStatus();
+			this.relayUrlsCache = [...status.urls];
+		} catch {}
+	}
+	sessionCount() {
+		return this.peers.size;
+	}
+	peerIds() {
+		return [...this.peers.keys()];
+	}
+	keySessionIndex() {
+		return this.keyIndex;
+	}
+	alias() {
+		return this.opts.alias ?? this.storeRef.alias ?? "provider";
+	}
+	directory() {
+		return authDirectoryFromStore(this.storeRef, {
+			alias: this.alias(),
+			relayUrls: this.relayUrlsCache
+		});
+	}
+	/** 服务变更/密钥撤销（CLI 写盘后由 watcher 触发）：重读存储并刷新在线会话。 */
+	async reloadStore() {
+		const fresh = ProviderStore.open(this.dataDir);
+		if (fresh.revision === this.storeRef.revision) return;
+		this.storeRef = fresh;
+		this.limitsEnforcer.syncFromStore(fresh);
+		await this.broadcastRefresh();
+	}
+	/** 全量刷新：视图变化推送 refresh AUTH_OK；全钥失效断会话。 */
+	async broadcastRefresh() {
+		for (const ps of [...this.peers.values()]) await this.refreshSession(ps);
+	}
+	async refreshSession(ps) {
+		if (!ps.session.authed) return;
+		const dir = this.directory();
+		const { valid } = evaluateKeyring(ps.keyring, dir);
+		if (valid.length === 0) {
+			this.removePeer(ps.peerId, "all keys invalid");
+			return;
+		}
+		const header = buildAuthOk(valid, dir, { refresh: true });
+		if (JSON.stringify(header) === ps.lastView) return;
+		await ps.pushRefresh(header);
+		ps.grants = valid;
+	}
+	addPeer(peerId) {
+		if (this.stopped) return;
+		if (this.peers.has(peerId)) this.removePeer(peerId, "replaced");
+		this.peers.set(peerId, new ProviderPeerSession(this, peerId, this.fabric, (reason) => this.removePeer(peerId, reason)));
+	}
+	removePeer(peerId, reason) {
+		const ps = this.peers.get(peerId);
+		if (ps === void 0) return;
+		this.peers.delete(peerId);
+		this.keyIndex.untrack(ps);
+		ps.disposeLocal(reason);
+	}
+	/** roster-updated 后复核在线 peer 成员资格：被 revoke 的成员即刻拆会话。 */
+	async enforceMembership() {
+		for (const peerId of [...this.peers.keys()]) try {
+			if (!await this.fabric.isMember(peerId)) {
+				this.removePeer(peerId, "revoked-from-roster");
+				try {
+					await this.fabric.disconnect(peerId);
+				} catch {}
+			}
+		} catch {}
+	}
+	/** 用量记录（forward 回调；--logUsage 关闭时引擎侧不挂回调）。 */
+	recordUsage(record) {
+		this.usageLog?.append(record);
+	}
+	/** 幂等关闭：断开全部会话（fabric 本身由 serve 层 shutdown）。 */
+	async shutdown() {
+		if (this.stopped) return;
+		this.stopped = true;
+		this.unsubscribeFabric?.();
+		this.unsubscribeFabric = null;
+		for (const peerId of [...this.peers.keys()]) this.removePeer(peerId, "engine shutdown");
+	}
+	/** 组内是否含该服务（授权判定）。 */
+	groupHasService(groupName, serviceId) {
+		const group = this.storeRef.getGroup(groupName);
+		return group !== void 0 && group.serviceIds.includes(serviceId);
+	}
+};
+var ProviderPeerSession = class {
+	peerId;
+	session;
+	adapter;
+	engine;
+	fabric;
+	removeSelf;
+	/** 最近一次 AUTH 呈交的钥环原文（仅内存；撤钥后重算用；MUST NOT 进日志）。 */
+	keyring = [];
+	grants = [];
+	lastView = "";
+	incoming = /* @__PURE__ */ new Map();
+	active = /* @__PURE__ */ new Map();
+	acquired = /* @__PURE__ */ new Map();
+	disposed = false;
+	constructor(engine, peerId, fabric, removeSelf) {
+		this.engine = engine;
+		this.peerId = peerId;
+		this.fabric = fabric;
+		this.removeSelf = removeSelf;
+		this.adapter = new FabricWireAdapter(fabric, peerId);
+		this.session = new WireSession({
+			role: "provider",
+			transport: this.adapter,
+			hooks: {
+				onFrame: (frame) => this.handleFrame(frame),
+				onPoison: () => this.removeSelf("protocol-seq poisoned"),
+				onIdleTimeout: (id) => this.handleIdleTimeout(id),
+				onDisconnect: () => this.removeSelf("transport closed"),
+				onTerminate: (id) => this.settle(id)
+			}
+		});
+	}
+	get keys() {
+		return this.keyring;
+	}
+	get keyIds() {
+		return new Set(this.grants.map((g) => g.keyId));
+	}
+	async pushRefresh(header) {
+		try {
+			await this.session.send(FRAME_TYPE.AUTH_OK, header);
+			this.lastView = JSON.stringify(header);
+		} catch {}
+	}
+	disconnect(reason) {
+		this.session.dispose(reason);
+	}
+	handleFrame(frame) {
+		switch (frame.type) {
+			case FRAME_TYPE.AUTH:
+				this.handleAuth(frame.header);
+				return;
+			case FRAME_TYPE.REQ:
+				this.handleReq(frame.header, frame.body);
+				return;
+			case FRAME_TYPE.REQ_BODY:
+				this.handleReqBody(frame.header, frame.body);
+				return;
+			case FRAME_TYPE.ABORT:
+				this.handleAbort(frame.header);
+				return;
+			case FRAME_TYPE.DATA_UP:
+				this.active.get(frame.header.id)?.ws?.pushUp(frame.body);
+				return;
+			case FRAME_TYPE.CLOSE:
+				this.handleClose(frame.header);
+				return;
+			default: return;
+		}
+	}
+	/** AUTH（重复 AUTH 以最后一次为准：钥环变更 = 重授权）。 */
+	async handleAuth(header) {
+		if (this.disposed) return;
+		const decision = handleAuthFrame(header, this.engine.directory());
+		if (decision.kind === "err") {
+			try {
+				await this.session.send(FRAME_TYPE.AUTH_ERR, decision.header);
+			} catch {}
+			this.disconnect("auth failed: all keys invalid");
+			return;
+		}
+		this.keyring = decision.keys;
+		this.grants = decision.valid;
+		this.session.markAuthed();
+		try {
+			await this.session.send(FRAME_TYPE.AUTH_OK, decision.header);
+			this.lastView = JSON.stringify(decision.header);
+			this.engine.keySessionIndex().track(this);
+		} catch {}
+	}
+	handleReq(header, body) {
+		if (this.grants.length === 0) return;
+		const service = this.engine.store.getService(header.serviceId);
+		const grant = service === void 0 ? void 0 : this.grants.find((g) => this.engine.groupHasService(g.group, header.serviceId));
+		if (service === void 0 || grant === void 0) {
+			this.sendError(header.id, ERROR_CODE.unknown_service, "service not available");
+			return;
+		}
+		const acquired = this.engine.limits.acquire(grant.keyId, grant.group);
+		if (!acquired.ok) {
+			this.sendError(header.id, acquired.code, acquired.code === "rate_limited" ? "group concurrency limit reached" : "daily request quota reached");
+			return;
+		}
+		this.acquired.set(header.id, {
+			keyId: grant.keyId,
+			group: grant.group
+		});
+		if (header.bodyLen === body.length) {
+			this.dispatch(header, body, grant.keyId, grant.group, service);
+			return;
+		}
+		if (header.bodyLen < body.length) {
+			this.sendError(header.id, ERROR_CODE.protocol_error, "request body length mismatch");
+			return;
+		}
+		this.incoming.set(header.id, {
+			req: header,
+			parts: [body],
+			keyId: grant.keyId,
+			group: grant.group
+		});
+	}
+	handleReqBody(header, body) {
+		const inc = this.incoming.get(header.id);
+		if (inc === void 0) return;
+		inc.parts.push(body);
+		const total = inc.parts.reduce((n, p) => n + p.length, 0);
+		if (total > inc.req.bodyLen) {
+			this.sendError(header.id, ERROR_CODE.protocol_error, "request body length mismatch");
+			return;
+		}
+		if (!header.end) return;
+		if (total !== inc.req.bodyLen) {
+			this.sendError(header.id, ERROR_CODE.protocol_error, "request body length mismatch");
+			return;
+		}
+		const merged = concatBytes(inc.parts);
+		const { req, keyId, group } = inc;
+		const service = this.engine.store.getService(req.serviceId);
+		this.incoming.delete(header.id);
+		if (service === void 0) {
+			this.sendError(header.id, ERROR_CODE.unknown_service, "service not available");
+			return;
+		}
+		this.dispatch(req, merged, keyId, group, service);
+	}
+	dispatch(req, body, keyId, group, service) {
+		const ctrl = new AbortController();
+		const act = {
+			ctrl,
+			keyId,
+			group,
+			ws: void 0
+		};
+		this.active.set(req.id, act);
+		forwardRequest({
+			session: this.session,
+			id: req.id,
+			service,
+			req,
+			body,
+			signal: ctrl.signal,
+			keyId,
+			timeouts: this.engine.opts.timeouts,
+			onUsage: this.engine.opts.logUsage === true ? (r) => this.engine.recordUsage(r) : void 0,
+			env: this.engine.opts.env,
+			secrets: this.engine.opts.secrets,
+			onWsRelay: (relay) => {
+				act.ws = relay;
+			}
+		}).catch(async () => {
+			if (this.active.has(req.id)) this.sendError(req.id, ERROR_CODE.internal, "internal forward failure");
+		});
+	}
+	handleAbort(header) {
+		const act = this.active.get(header.id);
+		if (act !== void 0) {
+			act.ctrl.abort(new UpstreamAbortError(ERROR_CODE.aborted, true));
+			return;
+		}
+		if (this.incoming.has(header.id)) this.sendError(header.id, ERROR_CODE.aborted, "request aborted by consumer");
+	}
+	handleClose(_header) {}
+	handleIdleTimeout(id) {
+		const act = this.active.get(id);
+		if (act !== void 0) {
+			act.ctrl.abort(new UpstreamAbortError(ERROR_CODE.idle_timeout, true));
+			return;
+		}
+		if (this.incoming.has(id)) this.sendError(id, ERROR_CODE.idle_timeout, "request idle timeout");
+	}
+	/** id 终结清理（幂等）：释放限额占用、中止上游（含 WS 关闭）、清表。 */
+	settle(id) {
+		const acquired = this.acquired.get(id);
+		if (acquired !== void 0) {
+			this.engine.limits.release(acquired.group);
+			this.acquired.delete(id);
+		}
+		this.incoming.delete(id);
+		const act = this.active.get(id);
+		if (act !== void 0) {
+			this.active.delete(id);
+			act.ctrl.abort(new UpstreamAbortError(ERROR_CODE.internal, false));
+		}
+	}
+	sendError(id, code, message) {
+		this.session.send(FRAME_TYPE.ERROR, {
+			id,
+			code,
+			message
+		}).catch(() => void 0);
+	}
+	/** 本地善后（断连/毒化/引擎关闭）：中止全部在途、释放限额、断开 fabric 会话。 */
+	disposeLocal(reason) {
+		if (this.disposed) return;
+		this.disposed = true;
+		for (const id of [...this.active.keys()]) this.settle(id);
+		for (const id of [...this.acquired.keys()]) this.settle(id);
+		this.adapter.dispose();
+		this.session.dispose(reason);
+		this.fabric.disconnect(this.peerId).catch(() => void 0);
+	}
+};
+function concatBytes(parts) {
+	const total = parts.reduce((n, p) => n + p.length, 0);
+	const out = new Uint8Array(total);
+	let off = 0;
+	for (const p of parts) {
+		out.set(p, off);
+		off += p.length;
+	}
+	return out;
+}
+//#endregion
+//#region src/provider/secrets.ts
+/** 文件形状：{ version: 1, secrets: { [name]: { value, createdAt, updatedAt, bearerPrefix } } }。
+*  旧文件无 bearerPrefix 字段按 true 读入（zod default，写入时补齐）。 */
+const SECRETS_FILE_SCHEMA = z.strictObject({
+	version: z.literal(1),
+	secrets: z.record(SECRET_NAME_SCHEMA, z.strictObject({
+		value: z.string().min(1).max(8192),
+		createdAt: z.number().int().min(0),
+		updatedAt: z.number().int().min(0),
+		bearerPrefix: z.boolean().default(true)
+	}))
+});
+const SECRETS_VALUE_MAX = 8192;
+var SecretsStore = class SecretsStore {
+	dataDir;
+	constructor(dataDir) {
+		this.dataDir = dataDir;
+	}
+	static filePath(dataDir) {
+		return join(dataDir, "secrets.json");
+	}
+	/** 打开（确保目录存在；文件不存在视为空库——首次 set 时落盘）。 */
+	static open(dataDir) {
+		ensurePrivateDir(dataDir);
+		return new SecretsStore(dataDir);
+	}
+	/** 读盘 + 校验（不存在 → 空库；损坏/非法抛 StoreError(corrupt)）。 */
+	read() {
+		const path = SecretsStore.filePath(this.dataDir);
+		if (!existsSync(path)) return {
+			version: 1,
+			secrets: {}
+		};
+		let raw;
+		try {
+			raw = readFileSync(path, "utf8");
+		} catch (err) {
+			throw new StoreError("corrupt", `error: cannot read ${path}: ${err.message}`);
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			throw new StoreError("corrupt", `error: ${path} is not valid JSON (fix or remove it manually)`);
+		}
+		const result = SECRETS_FILE_SCHEMA.safeParse(parsed);
+		if (!result.success) throw new StoreError("corrupt", `error: ${path} failed validation: ${result.error.message}`);
+		return result.data;
+	}
+	write(data) {
+		atomicWriteFileSync(SecretsStore.filePath(this.dataDir), `${JSON.stringify(data, null, 2)}\n`);
+	}
+	/** 清单（名称/时间戳/bearer 开关；按名称排序稳定输出）。 */
+	list() {
+		const { secrets } = this.read();
+		return Object.entries(secrets).map(([name, entry]) => ({
+			name,
+			createdAt: entry.createdAt,
+			updatedAt: entry.updatedAt,
+			bearerPrefix: entry.bearerPrefix
+		})).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+	}
+	/** 取值（未知名返回 undefined——由调用方决定失败语义，如 secret_missing）。 */
+	get(name) {
+		const entry = this.read().secrets[name];
+		return entry === void 0 ? void 0 : entry.value;
+	}
+	/** 解析为最终注入头值：bearerPrefix 开启时前拼 "Bearer "（幂等：值已以
+	*  Bearer 开头则不再重复拼）。$secret:/test 一律走这里，不直接用 get()。 */
+	resolve(name) {
+		const entry = this.read().secrets[name];
+		if (entry === void 0) return void 0;
+		const bare = entry.value;
+		return { headerValue: entry.bearerPrefix && !/^Bearer\s/i.test(bare) ? `Bearer ${bare}` : bare };
+	}
+	/** 新增/覆写（返回清单投影；createdAt 首次落定时固定，覆写只动 updatedAt）。 */
+	set(name, value, opts) {
+		if (!SECRET_NAME_SCHEMA.safeParse(name).success) throw new StoreError("invalid", "error: secret name must be 1..128 chars of lowercase letters, digits, dot, dash, underscore");
+		if (value === "" || value.length > SECRETS_VALUE_MAX) throw new StoreError("invalid", `error: secret value must be 1..${SECRETS_VALUE_MAX} chars`);
+		const data = this.read();
+		const now = Date.now();
+		const previous = data.secrets[name];
+		const bearerPrefix = opts?.bearerPrefix ?? previous?.bearerPrefix ?? true;
+		const entry = {
+			value,
+			createdAt: previous === void 0 ? now : previous.createdAt,
+			updatedAt: now,
+			bearerPrefix
+		};
+		data.secrets[name] = entry;
+		this.write(data);
+		return {
+			name,
+			createdAt: entry.createdAt,
+			updatedAt: entry.updatedAt,
+			bearerPrefix
+		};
+	}
+	/** 删除（不存在抛 StoreError(not-found)——RPC 边界映射 NOT_FOUND）。 */
+	remove(name) {
+		const data = this.read();
+		if (data.secrets[name] === void 0) throw new StoreError("not-found", `error: secret '${name}' not found`);
+		delete data.secrets[name];
+		this.write(data);
+	}
+};
+//#endregion
+//#region src/provider/serve.ts
+function providerFabricDir(dataDir) {
+	return join(dataDir, "fabric");
+}
+function fabricOptions(dataDir, relayUrls) {
+	const opts = { dataDir: providerFabricDir(dataDir) };
+	if (relayUrls !== void 0 && relayUrls.length > 0) opts.relay = {
+		mode: "custom",
+		urls: [relayUrls[0], ...relayUrls.slice(1)]
+	};
+	return opts;
+}
+function dirHasEntries(path) {
+	return existsSync(path) && readdirSync(path).length > 0;
+}
+/**
+* 打开（或首启创建 root）数据目录下的 Fabric。已存在 fabric 数据则 open 复入
+* （EndpointId/名册不变），否则 createRoot。
+*/
+async function openOrCreateFabric(dataDir, relayUrls) {
+	const { Fabric } = await loadSdk();
+	const opts = fabricOptions(dataDir, relayUrls);
+	if (dirHasEntries(providerFabricDir(dataDir))) try {
+		return await Fabric.open(opts);
+	} catch (err) {
+		return await Fabric.createRoot(opts).catch(() => Promise.reject(err instanceof Error ? err : new Error(String(err))));
+	}
+	try {
+		return await Fabric.createRoot(opts);
+	} catch (err) {
+		return await Fabric.open(opts).catch(() => Promise.reject(err instanceof Error ? err : new Error(String(err))));
+	}
+}
+/** 打开既有 fabric 身份（share/revoke/status 用；未初始化时抛错）。 */
+async function openExistingFabric(dataDir, relayUrls) {
+	if (!dirHasEntries(providerFabricDir(dataDir))) throw new Error(`error: no fabric identity under ${dataDir}; run 'ai-fly serve --data <dir>' first`);
+	const { Fabric } = await loadSdk();
+	return Fabric.open(fabricOptions(dataDir, relayUrls));
+}
+/** 扫描空/未设置的 $env 变量（已声明但为空 -> WARNING 列表）。 */
+function findEmptyEnvRefs(services, env = process.env) {
+	const out = [];
+	for (const service of services) {
+		const empty = collectEnvVarNames(service).filter((name) => {
+			const value = env[name];
+			return value === void 0 || value === "";
+		});
+		if (empty.length > 0) out.push({
+			service: service.name,
+			vars: empty
+		});
+	}
+	return out;
+}
+/** 启动横幅（英文 ASCII；用户面文案码位 < 128）。 */
+function composeStartupBanner(input) {
+	const lines = [];
+	lines.push("ai-fly provider daemon");
+	lines.push(`  EndpointId : ${input.endpointId}`);
+	lines.push(`  FabricId   : ${input.fabricIdHex}`);
+	lines.push(`  Data dir   : ${input.dataDir}`);
+	lines.push(`  Alias      : ${input.alias}`);
+	lines.push(`  Services   : ${input.serviceCount}`);
+	lines.push(`  Groups     : ${input.groupCount} (keys: ${input.activeKeyCount} active, ${input.revokedKeyCount} revoked)`);
+	if (input.relayUrls.length > 0) lines.push(`  Relay      : ${input.relayMode} ${input.relayUrls.join(", ")}`);
+	else lines.push(`  Relay      : ${input.relayMode} (none)`);
+	for (const ref of input.emptyEnvRefs) for (const name of ref.vars) lines.push(`  WARNING: $env variable '${name}' referenced by service '${ref.service}' is empty or unset`);
+	lines.push("Ready. Waiting for consumers (Ctrl+C to stop).");
+	return lines.join("\n");
+}
+async function startProviderDaemon(opts) {
+	const store = ProviderStore.open(opts.dataDir);
+	if (opts.alias !== void 0 && opts.alias !== store.alias) store.setAlias(opts.alias);
+	const limits = new LimitEnforcer({ dataDir: opts.dataDir });
+	const secretsStore = SecretsStore.open(opts.dataDir);
+	const secrets = opts.secrets ?? ((name) => secretsStore.resolve(name)?.headerValue);
+	const fabric = await openOrCreateFabric(opts.dataDir, opts.relayUrls);
+	const engine = new ProviderEngine({
+		fabric,
+		store,
+		dataDir: opts.dataDir,
+		limits,
+		opts: {
+			alias: opts.alias,
+			logUsage: opts.logUsage,
+			timeouts: opts.timeouts,
+			env: opts.env,
+			secrets
+		}
+	});
+	await engine.start();
+	const endpointId = fabric.endpointId;
+	const fabricIdHex = await fabric.fabricIdHex();
+	const relayStatus = await fabric.relayStatus();
+	const relayUrls = [...relayStatus.urls];
+	const banner = composeStartupBanner({
+		endpointId,
+		fabricIdHex,
+		dataDir: opts.dataDir,
+		alias: engine.alias(),
+		serviceCount: store.listServices().length,
+		groupCount: store.listGroups().length,
+		activeKeyCount: store.listKeys().filter((k) => k.revokedAt === void 0).length,
+		revokedKeyCount: store.listKeys().filter((k) => k.revokedAt !== void 0).length,
+		relayMode: relayStatus.mode,
+		relayUrls,
+		emptyEnvRefs: findEmptyEnvRefs(store.listServices(), opts.env ?? process.env)
+	});
+	let stopped = false;
+	let watcher = null;
+	let reloadTimer = null;
+	let pollTimer = null;
+	const reload = () => {
+		if (stopped) return;
+		engine.reloadStore().catch((err) => {
+			process.stderr.write(`warn: store reload failed: ${err.message}\n`);
+		}).finally(() => {
+			reloadTimer = null;
+		});
+	};
+	if (opts.watch !== false) {
+		ProviderStore.filePath(opts.dataDir);
+		const schedule = () => {
+			if (reloadTimer !== null) return;
+			reloadTimer = setTimeout(reload, 150);
+		};
+		try {
+			watcher = watch(opts.dataDir, (_event, filename) => {
+				if (filename === null || filename === "services.json" || String(filename).startsWith("services.json")) schedule();
+			});
+		} catch {
+			watcher = null;
+		}
+		pollTimer = setInterval(reload, 3e4);
+		pollTimer.unref?.();
+	}
+	const stop = async () => {
+		if (stopped) return;
+		stopped = true;
+		if (reloadTimer !== null) clearTimeout(reloadTimer);
+		if (pollTimer !== null) clearInterval(pollTimer);
+		watcher?.close();
+		await engine.shutdown();
+		await fabric.shutdown();
+	};
+	return {
+		engine,
+		fabric,
+		endpointId,
+		fabricIdHex,
+		relayUrls,
+		relayMode: relayStatus.mode,
+		banner,
+		stop
+	};
+}
+//#endregion
+export { detailDisplayLines as a, buildServiceEntry as i, startProviderDaemon as n, buildServiceDetail as r, openExistingFabric as t };