@jingyi0605/codingns4dsh 0.1.0

package/data/build/dist/transport/dsh-transport.js

@@ -0,0 +1,125 @@
+import { DshTunnelMultiplexer } from './multiplexer.js';
+/** 将 Tunnel Multiplexer 映射为 DSH ClientTransportHooks。 */
+export class DshCodingNsTransport {
+    options;
+    listeners = new Set();
+    multiplexer;
+    currentCarrier;
+    generation;
+    constructor(options) {
+        this.options = options;
+        this.currentCarrier = options.carrier;
+        this.generation = options.generation;
+        this.multiplexer = new DshTunnelMultiplexer(options.carrier, {
+            idPrefix: `g${options.generation.id}`,
+            generation: String(options.generation.id),
+            ...(options.hostScope ? { hostScope: options.hostScope } : {}),
+            ...(options.session ? { session: options.session } : {}),
+            ...(options.requireSessionReady === undefined ? {} : { requireSessionReady: options.requireSessionReady }),
+            ...(options.flowControl ? { flowControl: options.flowControl } : {}),
+            ...(options.debug ? { debug: options.debug } : {}),
+        });
+    }
+    rpc(request) {
+        return this.multiplexer.request('rpc', request, request.signal);
+    }
+    async fetch(input, init) {
+        const result = await this.multiplexer.request('fetch', {
+            input: String(input),
+            init: init ? { method: init.method, headers: [...new Headers(init.headers).entries()], body: typeof init.body === 'string' ? init.body : undefined } : undefined,
+        }, init?.signal ?? undefined);
+        return new Response(result.body, { status: result.status, headers: result.headers });
+    }
+    /** 向 Host 的 Remote Web Runtime 发送带明确 operation 的请求。 */
+    webRequest(operation, payload, signal) {
+        return this.multiplexer.requestOperation('web', operation, payload, signal);
+    }
+    /** 打开一个由 Remote Web Runtime 管理的 Web 流。 */
+    openWebStream(operation, payload, signal) {
+        return this.multiplexer.openStreamOperation('web', operation, payload, signal);
+    }
+    openWebStreamWithId(operation, payload, signal) {
+        return this.multiplexer.openStreamOperationWithId('web', operation, payload, signal);
+    }
+    sendWebStream(streamId, type, body, meta = {}) {
+        this.multiplexer.sendStreamMessage(streamId, 'web', type, meta, body);
+    }
+    closeWebStream(streamId) {
+        this.multiplexer.closeStream(streamId, 'web');
+    }
+    openStream(request) {
+        return this.multiplexer.openStream(request, request.signal);
+    }
+    loadBundle(url) {
+        return this.multiplexer.request('control', { method: 'loadBundle', url }).then(() => undefined);
+    }
+    getGeneration() { return this.generation; }
+    onGenerationChange(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async reconnect(signal) {
+        if (!this.options.reconnect)
+            throw new Error('未配置 Transport reconnect');
+        const nextGeneration = await this.options.reconnect(signal);
+        if (nextGeneration)
+            this.updateGeneration(nextGeneration);
+    }
+    /** 由启动胶水在建立新物理连接后提交新 generation。旧请求会立即失效。 */
+    updateGeneration(generation) {
+        const previous = this.generation;
+        if (previous?.id === generation.id)
+            return;
+        this.multiplexer.rotateGeneration(`g${generation.id}`);
+        this.generation = generation;
+        for (const listener of [...this.listeners])
+            listener(generation);
+    }
+    /** 物理 WebRTC 重连后替换 carrier/session，并让 DSH Connection 看见新 generation。 */
+    replaceConnection(carrier, session, generation) {
+        this.multiplexer.replaceCarrier(carrier);
+        this.multiplexer.setSession(session);
+        this.currentCarrier = carrier;
+        this.updateGeneration(generation);
+    }
+    /** 物理连接失效时立即结束旧请求和旧 generation。 */
+    invalidateConnection(error = new Error('WebRTC connection closed')) {
+        this.multiplexer.invalidate(error);
+        const previous = this.generation;
+        this.generation = undefined;
+        if (previous)
+            for (const listener of [...this.listeners])
+                listener(undefined);
+    }
+    close() {
+        this.multiplexer.close();
+        const previous = this.generation;
+        this.generation = undefined;
+        if (previous)
+            for (const listener of [...this.listeners])
+                listener(undefined);
+        return this.currentCarrier.close();
+    }
+    /** 给 pre-Cordis 启动胶水使用，不直接安装 DSH Connection。 */
+    asTransportHooks() {
+        // DSH 0.1.6-alpha.2 的 ClientTransportHooks.rpc 是 ClientConnectionRpc
+        // 对象，不是插件内部的 `rpc(request)` 函数。具体适配在 dsh-connection-adapter
+        // 中完成；这里仅保留旧的内部 hooks 形状，避免把未确认的线路协议写进核心传输。
+        const hooks = {
+            rpc: this.rpc.bind(this),
+            fetch: this.fetch.bind(this),
+            openStream: this.openStream.bind(this),
+            loadBundle: this.loadBundle.bind(this),
+            generation: this.getGeneration.bind(this),
+            onGenerationChange: this.onGenerationChange.bind(this),
+            reconnect: this.reconnect.bind(this),
+            close: this.close.bind(this),
+        };
+        if (this.options.ownsHost !== undefined)
+            hooks.ownsHost = this.options.ownsHost;
+        if (this.options.streamBaseUrl !== undefined)
+            hooks.streamBaseUrl = this.options.streamBaseUrl;
+        return hooks;
+    }
+}
+//# sourceMappingURL=dsh-transport.js.map

package/data/build/dist/transport/frame.d.ts

@@ -0,0 +1,132 @@
+export declare const TUNNEL_WIRE_VERSION = 1;
+export declare const TUNNEL_PROTOCOL_VERSION = 1;
+export declare const TUNNEL_FRAME_HEADER_BYTES = 10;
+export declare const TUNNEL_MAX_META_BYTES: number;
+export declare const TUNNEL_MAX_FRAME_BODY_BYTES: number;
+export declare const DEFAULT_MAX_TUNNEL_FRAME_BYTES: number;
+export declare const TUNNEL_FRAME_TYPE_CODES: {
+    readonly 'http.request': 1;
+    readonly 'http.response.start': 2;
+    readonly 'http.response.chunk': 3;
+    readonly 'http.response.end': 4;
+    readonly 'ws.open': 5;
+    readonly 'ws.opened': 6;
+    readonly 'ws.message': 7;
+    readonly 'ws.closed': 8;
+    readonly error: 9;
+    readonly hello: 10;
+    readonly ping: 11;
+    readonly pong: 12;
+    readonly 'http.request.chunk': 13;
+    readonly 'http.request.end': 14;
+    readonly 'ws.message.chunk': 15;
+    readonly 'ws.message.end': 16;
+};
+export type TunnelFrameType = keyof typeof TUNNEL_FRAME_TYPE_CODES;
+export type TunnelFrameCode = (typeof TUNNEL_FRAME_TYPE_CODES)[TunnelFrameType];
+export type TunnelChannel = never;
+export type TunnelFrameKind = never;
+export interface TunnelFrameCodecOptions {
+    maxBytes?: number;
+}
+export interface TunnelClientContext {
+    userAgent: string | null;
+    runtimePlatform: string | null;
+    systemPlatform: string | null;
+    language: string | null;
+    timezone: string | null;
+    forwardedFor: string | null;
+}
+interface Base {
+    streamId: string;
+}
+export type TunnelFrame = (Base & {
+    type: 'http.request';
+    method: string;
+    path: string;
+    headers: Record<string, string>;
+    body: Uint8Array;
+}) | (Base & {
+    type: 'http.request.chunk';
+    body: Uint8Array;
+}) | (Base & {
+    type: 'http.request.end';
+}) | (Base & {
+    type: 'http.response.start';
+    status: number;
+    headers: Record<string, string>;
+}) | (Base & {
+    type: 'http.response.chunk';
+    body: Uint8Array;
+}) | (Base & {
+    type: 'http.response.end';
+}) | (Base & {
+    type: 'ws.open';
+    path: string;
+    headers: Record<string, string>;
+    protocols: string[];
+}) | (Base & {
+    type: 'ws.opened';
+    selectedProtocol: string | null;
+}) | (Base & {
+    type: 'ws.message';
+    binary: boolean;
+    body: Uint8Array;
+}) | (Base & {
+    type: 'ws.message.chunk';
+    binary: boolean;
+    body: Uint8Array;
+}) | (Base & {
+    type: 'ws.message.end';
+}) | (Base & {
+    type: 'ws.closed';
+    code: number;
+    reason: string | null;
+}) | {
+    type: 'error';
+    streamId: string | null;
+    errorCode: string;
+    detail: string;
+} | {
+    type: 'hello';
+    clientContext: TunnelClientContext | null;
+    protocolVersion: string;
+} | {
+    type: 'ping' | 'pong';
+    at: string;
+};
+export declare class TunnelFrameError extends Error {
+    readonly code: 'FRAME_TOO_SHORT' | 'UNSUPPORTED_VERSION' | 'UNKNOWN_FRAME_TYPE' | 'META_TOO_LARGE' | 'META_NOT_JSON' | 'META_INVALID' | 'BODY_NOT_ALLOWED' | 'BODY_TOO_LARGE';
+    constructor(message: string, code: 'FRAME_TOO_SHORT' | 'UNSUPPORTED_VERSION' | 'UNKNOWN_FRAME_TYPE' | 'META_TOO_LARGE' | 'META_NOT_JSON' | 'META_INVALID' | 'BODY_NOT_ALLOWED' | 'BODY_TOO_LARGE');
+}
+export declare function encodeFrame(frame: TunnelFrame): Uint8Array;
+export declare function decodeFrame(bytes: Uint8Array): TunnelFrame | null;
+export declare function decodeFrames(bytes: Uint8Array): {
+    frames: TunnelFrame[];
+    rest: Uint8Array;
+};
+export interface TunnelFrameDecoder {
+    push(chunk: Uint8Array): TunnelFrame[];
+    readonly bufferedBytes: number;
+    reset(): void;
+}
+export declare function createFrameDecoder(): TunnelFrameDecoder;
+/** 旧 API 的兼容形状；仅用于升级期间的调用方，不是 Connect 数据面格式。 */
+interface LegacyTunnelFrame {
+    version: number;
+    channel: 'rpc' | 'fetch' | 'control' | 'stream' | 'event';
+    id: string;
+    sequence: number;
+    kind: 'open' | 'data' | 'close' | 'cancel' | 'window' | 'error';
+    payload?: unknown;
+}
+/**
+ * 旧函数名的二进制兼容入口。
+ * 新代码必须使用 encodeFrame；这里把旧对象转换成 DSH Envelope 字节，绝不恢复 JSON 字符串帧。
+ */
+export declare function encodeTunnelFrame(frame: TunnelFrame | LegacyTunnelFrame, options?: TunnelFrameCodecOptions): Uint8Array | string;
+export declare function decodeTunnelFrame(data: Uint8Array | string, options?: TunnelFrameCodecOptions): TunnelFrame | LegacyTunnelFrame;
+export declare function tunnelFrameByteLength(value: Uint8Array): number;
+export declare function validateTunnelFrame(value: unknown): asserts value is TunnelFrame;
+export {};
+//# sourceMappingURL=frame.d.ts.map

package/data/build/dist/transport/frame.js

@@ -0,0 +1,168 @@
+/** Codingns4DSH Relay Tunnel 二进制线协议（与父仓库 relay-tunnel-wire 一致）。 */
+import { decodeDshEnvelope } from './dsh-envelope.js';
+export const TUNNEL_WIRE_VERSION = 1;
+export const TUNNEL_PROTOCOL_VERSION = TUNNEL_WIRE_VERSION;
+export const TUNNEL_FRAME_HEADER_BYTES = 10;
+export const TUNNEL_MAX_META_BYTES = 1024 * 1024;
+export const TUNNEL_MAX_FRAME_BODY_BYTES = 48 * 1024;
+export const DEFAULT_MAX_TUNNEL_FRAME_BYTES = TUNNEL_MAX_FRAME_BODY_BYTES;
+export const TUNNEL_FRAME_TYPE_CODES = {
+    'http.request': 1, 'http.response.start': 2, 'http.response.chunk': 3, 'http.response.end': 4,
+    'ws.open': 5, 'ws.opened': 6, 'ws.message': 7, 'ws.closed': 8, error: 9, hello: 10, ping: 11, pong: 12,
+    'http.request.chunk': 13, 'http.request.end': 14, 'ws.message.chunk': 15, 'ws.message.end': 16,
+};
+export class TunnelFrameError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'TunnelFrameError';
+    }
+}
+const byCode = new Map(Object.entries(TUNNEL_FRAME_TYPE_CODES).map(([k, v]) => [v, k]));
+const encoder = new TextEncoder();
+const decoder = new TextDecoder('utf-8');
+const empty = new Uint8Array(0);
+export function encodeFrame(frame) {
+    const code = TUNNEL_FRAME_TYPE_CODES[frame.type];
+    if (typeof code !== 'number')
+        throw new TunnelFrameError(`未知的帧类型：${String(frame.type)}`, 'UNKNOWN_FRAME_TYPE');
+    const meta = encoder.encode(JSON.stringify(metaOf(frame)));
+    const body = bodyOf(frame);
+    if (meta.byteLength > TUNNEL_MAX_META_BYTES)
+        throw new TunnelFrameError(`帧 ${frame.type} 的 meta 超过上限`, 'META_TOO_LARGE');
+    if (body.byteLength > TUNNEL_MAX_FRAME_BODY_BYTES)
+        throw new TunnelFrameError(`帧 ${frame.type} 的 body 超过单帧上限`, 'BODY_TOO_LARGE');
+    const output = new Uint8Array(TUNNEL_FRAME_HEADER_BYTES + meta.byteLength + body.byteLength);
+    const view = new DataView(output.buffer);
+    view.setUint8(0, TUNNEL_WIRE_VERSION);
+    view.setUint8(1, code);
+    view.setUint32(2, meta.byteLength);
+    view.setUint32(6, body.byteLength);
+    output.set(meta, TUNNEL_FRAME_HEADER_BYTES);
+    output.set(body, TUNNEL_FRAME_HEADER_BYTES + meta.byteLength);
+    return output;
+}
+export function decodeFrame(bytes) { return readFrame(bytes)?.frame ?? null; }
+export function decodeFrames(bytes) { const frames = []; let offset = 0; while (offset < bytes.byteLength) {
+    const parsed = readFrame(bytes.subarray(offset));
+    if (!parsed)
+        break;
+    frames.push(parsed.frame);
+    offset += parsed.consumed;
+} return { frames, rest: offset === 0 ? bytes : bytes.subarray(offset) }; }
+export function createFrameDecoder() { let pending = new Uint8Array(0); return { push(chunk) { if (chunk.byteLength)
+        pending = concat(pending, chunk); const result = decodeFrames(pending); if (result.frames.length)
+        pending = new Uint8Array(result.rest); return result.frames; }, get bufferedBytes() { return pending.byteLength; }, reset() { pending = new Uint8Array(0); } }; }
+function readFrame(bytes) { if (bytes.byteLength < TUNNEL_FRAME_HEADER_BYTES)
+    return null; const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength); if (view.getUint8(0) !== TUNNEL_WIRE_VERSION)
+    throw new TunnelFrameError('线协议版本不支持', 'UNSUPPORTED_VERSION'); const type = byCode.get(view.getUint8(1)); if (!type)
+    throw new TunnelFrameError('未知的帧类型编号', 'UNKNOWN_FRAME_TYPE'); const metaLength = view.getUint32(2); const bodyLength = view.getUint32(6); if (metaLength > TUNNEL_MAX_META_BYTES)
+    throw new TunnelFrameError('meta 超过上限', 'META_TOO_LARGE'); const total = TUNNEL_FRAME_HEADER_BYTES + metaLength + bodyLength; if (bytes.byteLength < total)
+    return null; const metaBytes = bytes.subarray(TUNNEL_FRAME_HEADER_BYTES, TUNNEL_FRAME_HEADER_BYTES + metaLength); const body = new Uint8Array(bytes.subarray(TUNNEL_FRAME_HEADER_BYTES + metaLength, total)); return { frame: frameFromMeta(type, metaBytes, body), consumed: total }; }
+function metaOf(frame) { switch (frame.type) {
+    case 'http.request': return { streamId: frame.streamId, method: frame.method, path: frame.path, headers: frame.headers };
+    case 'http.response.start': return { streamId: frame.streamId, status: frame.status, headers: frame.headers };
+    case 'http.request.chunk':
+    case 'http.request.end':
+    case 'http.response.chunk':
+    case 'http.response.end':
+    case 'ws.message.end': return { streamId: frame.streamId };
+    case 'ws.open': return { streamId: frame.streamId, path: frame.path, headers: frame.headers, protocols: frame.protocols };
+    case 'ws.opened': return { streamId: frame.streamId, selectedProtocol: frame.selectedProtocol };
+    case 'ws.message':
+    case 'ws.message.chunk': return { streamId: frame.streamId, binary: frame.binary };
+    case 'ws.closed': return { streamId: frame.streamId, code: frame.code, reason: frame.reason };
+    case 'error': return { streamId: frame.streamId, errorCode: frame.errorCode, detail: frame.detail };
+    case 'hello': return { clientContext: frame.clientContext, protocolVersion: frame.protocolVersion };
+    case 'ping':
+    case 'pong': return { at: frame.at };
+} }
+function bodyOf(frame) { return 'body' in frame ? frame.body : empty; }
+function frameFromMeta(type, bytes, body) { let meta; try {
+    const parsed = JSON.parse(decoder.decode(bytes));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        throw new Error('对象');
+    meta = parsed;
+}
+catch {
+    throw new TunnelFrameError(`帧 ${type} 的 meta 不是合法 JSON`, 'META_NOT_JSON');
+} const str = (name) => { const value = meta[name]; if (typeof value !== 'string')
+    throw new TunnelFrameError(`帧 ${type} 的 meta.${name} 无效`, 'META_INVALID'); return value; }; const headers = () => (meta.headers && typeof meta.headers === 'object' && !Array.isArray(meta.headers)) ? meta.headers : {}; switch (type) {
+    case 'http.request': return { type, streamId: str('streamId'), method: str('method'), path: str('path'), headers: headers(), body };
+    case 'http.request.chunk': return { type, streamId: str('streamId'), body };
+    case 'http.request.end': return { type, streamId: str('streamId') };
+    case 'http.response.start': return { type, streamId: str('streamId'), status: Number(meta.status), headers: headers() };
+    case 'http.response.chunk': return { type, streamId: str('streamId'), body };
+    case 'http.response.end': return { type, streamId: str('streamId') };
+    case 'ws.open': return { type, streamId: str('streamId'), path: str('path'), headers: headers(), protocols: Array.isArray(meta.protocols) ? meta.protocols.filter((v) => typeof v === 'string') : [] };
+    case 'ws.opened': return { type, streamId: str('streamId'), selectedProtocol: typeof meta.selectedProtocol === 'string' ? meta.selectedProtocol : null };
+    case 'ws.message':
+    case 'ws.message.chunk': return { type, streamId: str('streamId'), binary: meta.binary === true, body };
+    case 'ws.message.end': return { type, streamId: str('streamId') };
+    case 'ws.closed': return { type, streamId: str('streamId'), code: Number(meta.code), reason: typeof meta.reason === 'string' ? meta.reason : null };
+    case 'error': return { type, streamId: typeof meta.streamId === 'string' ? meta.streamId : null, errorCode: str('errorCode'), detail: typeof meta.detail === 'string' ? meta.detail : '' };
+    case 'hello': return { type, clientContext: parseContext(meta.clientContext), protocolVersion: typeof meta.protocolVersion === 'string' ? meta.protocolVersion : '1' };
+    case 'ping':
+    case 'pong': return { type, at: str('at') };
+} }
+function parseContext(value) { if (!value || typeof value !== 'object' || Array.isArray(value))
+    return null; const r = value; const pick = (k) => typeof r[k] === 'string' && r[k].trim() ? r[k] : null; return { userAgent: pick('userAgent'), runtimePlatform: pick('runtimePlatform'), systemPlatform: pick('systemPlatform'), language: pick('language'), timezone: pick('timezone'), forwardedFor: pick('forwardedFor') }; }
+function concat(a, b) { const out = new Uint8Array(a.byteLength + b.byteLength); out.set(a); out.set(b, a.byteLength); return out; }
+/**
+ * 旧函数名的二进制兼容入口。
+ * 新代码必须使用 encodeFrame；这里把旧对象转换成 DSH Envelope 字节，绝不恢复 JSON 字符串帧。
+ */
+export function encodeTunnelFrame(frame, options = {}) {
+    if (isLegacyFrame(frame)) {
+        const encoded = JSON.stringify(frame);
+        if (options.maxBytes !== undefined && encoder.encode(encoded).byteLength > options.maxBytes)
+            throw new Error('Tunnel Frame 超过大小限制');
+        return encoded;
+    }
+    return encodeFrame(frame);
+}
+export function decodeTunnelFrame(data, options = {}) {
+    if (typeof data === 'string') {
+        if (options.maxBytes !== undefined && encoder.encode(data).byteLength > options.maxBytes)
+            throw new Error('Tunnel Frame 超过大小限制');
+        const parsed = JSON.parse(data);
+        if (!isLegacyFrame(parsed))
+            throw new TunnelFrameError('Tunnel Frame 无效', 'META_INVALID');
+        if (parsed.version !== TUNNEL_WIRE_VERSION)
+            throw new TunnelFrameError('Tunnel Frame 版本不兼容', 'UNSUPPORTED_VERSION');
+        return parsed;
+    }
+    if (!(data instanceof Uint8Array))
+        throw new TypeError('Tunnel Frame 必须是 Uint8Array');
+    if (data[0] === 0x44 && data[1] === 0x53 && data[2] === 0x48 && data[3] === 0x01) {
+        const envelope = decodeDshEnvelope(data, options.maxBytes === undefined ? {} : { maxBytes: options.maxBytes });
+        const payload = envelope.body && envelope.body.byteLength > 0
+            ? JSON.parse(new TextDecoder().decode(envelope.body))
+            : undefined;
+        const [channel, kind] = envelope.type.split('.', 2);
+        if (!['rpc', 'fetch', 'control', 'stream', 'event'].includes(channel ?? '')
+            || !['open', 'data', 'close', 'cancel', 'window', 'error'].includes(kind ?? '')) {
+            throw new TunnelFrameError('兼容 Tunnel Frame 类型无效', 'META_INVALID');
+        }
+        return {
+            version: 1,
+            channel: channel,
+            id: envelope.streamId,
+            sequence: envelope.sequence,
+            kind: kind,
+            ...(payload === undefined ? {} : { payload }),
+        };
+    }
+    const decoded = decodeFrame(data);
+    if (decoded === null)
+        throw new TunnelFrameError('Tunnel Frame 数据不完整', 'FRAME_TOO_SHORT');
+    return decoded;
+}
+function isLegacyFrame(value) {
+    return typeof value === 'object' && value !== null && 'kind' in value && 'channel' in value;
+}
+export function tunnelFrameByteLength(value) { return value.byteLength; }
+export function validateTunnelFrame(value) { if (!value || typeof value !== 'object' || !('type' in value))
+    throw new TunnelFrameError('Tunnel Frame 无效', 'META_INVALID'); }
+//# sourceMappingURL=frame.js.map

package/data/build/dist/transport/index.d.ts

@@ -0,0 +1,11 @@
+export { createDataChannelCarrier, createRelayTunnelHostCarrier, TUNNEL_DATA_CHANNEL_LABEL, DATA_CHANNEL_FRAGMENT_PAYLOAD_BYTES, DATA_CHANNEL_FRAGMENT_HEADER_BYTES, DATA_CHANNEL_MAX_REASSEMBLY_BYTES, type CodingNsCarrier, type DataChannelLike, type DataChannelCarrierOptions } from './carrier.js';
+export { encodeFrame, decodeFrame, decodeFrames, createFrameDecoder, decodeTunnelFrame, encodeTunnelFrame, TUNNEL_WIRE_VERSION, TUNNEL_FRAME_HEADER_BYTES, TUNNEL_MAX_META_BYTES, TUNNEL_MAX_FRAME_BODY_BYTES, TUNNEL_FRAME_TYPE_CODES, TUNNEL_PROTOCOL_VERSION, validateTunnelFrame, tunnelFrameByteLength, DEFAULT_MAX_TUNNEL_FRAME_BYTES, type TunnelChannel, type TunnelFrame, type TunnelFrameKind, type TunnelFrameCodecOptions, type TunnelFrameType, type TunnelClientContext, } from './frame.js';
+export { DshTunnelMultiplexer, type DshTunnelMultiplexerOptions, type TunnelFlowControl } from './multiplexer.js';
+export { createDshTransportDebugLogger, resolveDshTransportDebugEnabled, type DshTransportDebugLogger, type DshTransportDebugOptions, type DshTransportDebugSide } from './debug.js';
+export { DshCodingNsTransport, type DshCodingNsTransportOptions } from './dsh-transport.js';
+export { DSH_ENVELOPE_PROTOCOL, DSH_ENVELOPE_VERSION, DEFAULT_MAX_DSH_ENVELOPE_BYTES, DEFAULT_MAX_DSH_META_BYTES, decodeDshEnvelope, encodeDshEnvelope, validateDshEnvelope, type DshChannel, type DshEnvelope, type DshEnvelopeCodecOptions, type DshEnvelopeFlags, type DshHostScope, } from './dsh-envelope.js';
+export { DshSession, type DshSessionOptions, type DshSessionRole, type DshSessionState, } from './dsh-session.js';
+export { DshGateway, DSH_GATEWAY_PATH, type DshGatewayFeature, type DshGatewayOptions, type DshStreamContext, } from './dsh-gateway.js';
+export { assertDtlsFingerprint, connectWebRtcClient, createSignalingUrl, extractDtlsFingerprint, waitForSignalingRegistered, waitForPeerReady, type PeerConnectionLike, type SignalingSocketLike, type WebRtcClientConnection, type WebRtcClientConnectorOptions, } from './webrtc-client.js';
+export { acceptWebRtcHost, createHostSignalingTicketRequest, requestHostSignalingTicket, type HostPeerConnectionLike, type HostSignalingTicketRequest, type WebRtcHostAcceptor, type WebRtcHostAcceptorOptions, type WebRtcHostSession, } from './webrtc-host.js';
+//# sourceMappingURL=index.d.ts.map

package/data/build/dist/transport/index.js

@@ -0,0 +1,11 @@
+export { createDataChannelCarrier, createRelayTunnelHostCarrier, TUNNEL_DATA_CHANNEL_LABEL, DATA_CHANNEL_FRAGMENT_PAYLOAD_BYTES, DATA_CHANNEL_FRAGMENT_HEADER_BYTES, DATA_CHANNEL_MAX_REASSEMBLY_BYTES } from './carrier.js';
+export { encodeFrame, decodeFrame, decodeFrames, createFrameDecoder, decodeTunnelFrame, encodeTunnelFrame, TUNNEL_WIRE_VERSION, TUNNEL_FRAME_HEADER_BYTES, TUNNEL_MAX_META_BYTES, TUNNEL_MAX_FRAME_BODY_BYTES, TUNNEL_FRAME_TYPE_CODES, TUNNEL_PROTOCOL_VERSION, validateTunnelFrame, tunnelFrameByteLength, DEFAULT_MAX_TUNNEL_FRAME_BYTES, } from './frame.js';
+export { DshTunnelMultiplexer } from './multiplexer.js';
+export { createDshTransportDebugLogger, resolveDshTransportDebugEnabled } from './debug.js';
+export { DshCodingNsTransport } from './dsh-transport.js';
+export { DSH_ENVELOPE_PROTOCOL, DSH_ENVELOPE_VERSION, DEFAULT_MAX_DSH_ENVELOPE_BYTES, DEFAULT_MAX_DSH_META_BYTES, decodeDshEnvelope, encodeDshEnvelope, validateDshEnvelope, } from './dsh-envelope.js';
+export { DshSession, } from './dsh-session.js';
+export { DshGateway, DSH_GATEWAY_PATH, } from './dsh-gateway.js';
+export { assertDtlsFingerprint, connectWebRtcClient, createSignalingUrl, extractDtlsFingerprint, waitForSignalingRegistered, waitForPeerReady, } from './webrtc-client.js';
+export { acceptWebRtcHost, createHostSignalingTicketRequest, requestHostSignalingTicket, } from './webrtc-host.js';
+//# sourceMappingURL=index.js.map

package/data/build/dist/transport/multiplexer.d.ts

@@ -0,0 +1,63 @@
+import type { CodingNsCarrier } from './carrier.js';
+import { type DshEnvelope, type DshHostScope } from './dsh-envelope.js';
+import type { DshSession } from './dsh-session.js';
+import { type DshTransportDebugLogger } from './debug.js';
+export interface TunnelFlowControl {
+    maxFrameBytes?: number;
+    maxQueueBytes?: number;
+    canSend?(bytes: number, frame: DshEnvelope): boolean;
+    onSend?(bytes: number, frame: DshEnvelope): void;
+    onReceive?(bytes: number, frame: DshEnvelope): void;
+}
+export interface DshTunnelMultiplexerOptions {
+    idPrefix?: string;
+    generation?: string;
+    hostScope?: DshHostScope;
+    session?: DshSession;
+    requireSessionReady?: boolean;
+    flowControl?: TunnelFlowControl;
+    debug?: DshTransportDebugLogger;
+}
+/** DSH Envelope 层多路复用器；逻辑 API 保持 rpc/openStream，物理线路只发送二进制 Envelope。 */
+export declare class DshTunnelMultiplexer {
+    private carrier;
+    private readonly pending;
+    private readonly streams;
+    private sequence;
+    private nextId;
+    private disposed;
+    private unsubscribe;
+    private idPrefix;
+    private readonly flowControl;
+    private generation;
+    private readonly hostScope;
+    private session;
+    private readonly requireSessionReady;
+    private readonly debug;
+    constructor(carrier: CodingNsCarrier, options?: DshTunnelMultiplexerOptions);
+    request<T>(channel: 'rpc' | 'fetch' | 'control', payload: unknown, signal?: AbortSignal): Promise<T>;
+    requestOperation<T>(channel: 'rpc' | 'fetch' | 'control' | 'web', operation: string, payload: unknown, signal?: AbortSignal): Promise<T>;
+    openStream<T>(payload: unknown, signal?: AbortSignal): AsyncIterable<T>;
+    openStreamOperation<T>(channel: 'rpc' | 'web', operation: string, payload: unknown, signal?: AbortSignal): AsyncIterable<T>;
+    openStreamOperationWithId<T>(channel: 'rpc' | 'web', operation: string, payload: unknown, signal?: AbortSignal): {
+        streamId: string;
+        stream: AsyncIterable<T>;
+    };
+    sendStreamMessage(streamId: string, channel: 'rpc' | 'web', type: string, meta?: Record<string, unknown>, body?: Uint8Array): void;
+    closeStream(streamId: string, channel?: 'rpc' | 'web'): void;
+    close(error?: Error): void;
+    invalidate(error?: Error): void;
+    /** 替换物理 carrier；逻辑请求已在 invalidate 中失败，后续请求使用新线路。 */
+    replaceCarrier(carrier: CodingNsCarrier): void;
+    setSession(session: DshSession | undefined): void;
+    rotateGeneration(idPrefix: string, error?: Error): void;
+    private receive;
+    private receiveStream;
+    private finishStream;
+    private send;
+    private nextSequence;
+    private nextRequestId;
+    private closedStream;
+    private ensureOpen;
+}
+//# sourceMappingURL=multiplexer.d.ts.map