@jingyi0605/codingns4dsh 0.1.0

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

@@ -0,0 +1,254 @@
+import {} from './dsh-envelope.js';
+import { DshSession } from './dsh-session.js';
+import { createDshTransportDebugLogger } from './debug.js';
+export const DSH_GATEWAY_PATH = '/__dsh__/transport/v1';
+/** 将 DSH Session 后的 Envelope 按 streamId 路由到 FeatureRegistry 模块。 */
+export class DshGateway {
+    options;
+    session;
+    streams = new Map();
+    /**
+     * stream.open 的 feature 选择和本地资源创建可能异步完成。
+     * 取消帧可以在这段窗口内到达，必须先登记 opening，不能让取消穿透后又把旧流插入 streams。
+     */
+    opening = new Set();
+    cancelledOpening = new Set();
+    maxStreams;
+    features;
+    sequence = 0;
+    started = false;
+    unsubscribe;
+    debug;
+    constructor(options) {
+        this.options = options;
+        this.maxStreams = options.maxStreams ?? 128;
+        this.debug = options.debug ?? createDshTransportDebugLogger({ component: 'gateway' });
+        this.features = options.features ?? [];
+        this.session = options.session ?? new DshSession({
+            carrier: options.carrier,
+            role: 'host',
+            generation: options.generation,
+            hostScope: options.hostScope,
+            acceptInitialGeneration: true,
+            ...(options.dshVersion === undefined ? {} : { dshVersion: options.dshVersion }),
+            ...(options.sessionOptions ?? {}),
+            debug: this.debug,
+        });
+    }
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.debug.log('gateway.start', { generation: this.session.generation, hostId: this.options.hostScope.hostId });
+        this.unsubscribe = this.session.subscribe((envelope) => { void this.route(envelope); });
+        this.session.start();
+    }
+    async close(reason = 'DSH Gateway 已关闭') {
+        if (!this.started)
+            return;
+        this.started = false;
+        this.debug.log('gateway.close', { reason, streams: this.streams.size });
+        this.unsubscribe?.();
+        this.unsubscribe = undefined;
+        for (const active of this.streams.values()) {
+            try {
+                await active.feature.handleMessage?.(active.context, { ...active.envelope, type: 'stream.cancel', meta: { reason } });
+            }
+            catch {
+                // 关闭阶段不再向远端传播业务错误，但必须继续清理其他流。
+            }
+        }
+        this.streams.clear();
+        this.opening.clear();
+        this.cancelledOpening.clear();
+        this.session.close(reason);
+    }
+    get path() { return DSH_GATEWAY_PATH; }
+    async route(envelope) {
+        this.debug.log('gateway.receive', envelopeDebugFields(envelope));
+        if (envelope.generation !== this.session.generation
+            || envelope.hostScope.hostId !== this.options.hostScope.hostId
+            || envelope.hostScope.kind !== this.options.hostScope.kind) {
+            this.debug.log('gateway.scope.drop', { expectedGeneration: this.session.generation, expectedHostId: this.options.hostScope.hostId, expectedHostKind: this.options.hostScope.kind, ...envelopeDebugFields(envelope) });
+            this.sendError(envelope, 'RESOURCE_SCOPE_STALE', '资源属于已经失效的 HostScope');
+            return;
+        }
+        if (envelope.type === 'stream.open') {
+            await this.openStream(envelope);
+            return;
+        }
+        if (envelope.type === 'stream.cancel' || envelope.type === 'stream.close') {
+            const active = this.streams.get(envelope.streamId);
+            if (active) {
+                try {
+                    await active.feature.handleMessage?.(active.context, envelope);
+                }
+                catch (error) {
+                    this.sendError(envelope, 'STREAM_FAILED', error instanceof Error ? error.message : 'DSH 流清理失败');
+                }
+                finally {
+                    // Feature 清理失败也不能让已取消的流继续占用会话配额。
+                    this.streams.delete(envelope.streamId);
+                }
+            }
+            else if (this.opening.has(envelope.streamId)) {
+                // openStream 尚未完成时不能调用尚不存在的 context；记录取消，
+                // 由 openStream 在完成异步准备后丢弃资源并发送最终 close。
+                this.cancelledOpening.add(envelope.streamId);
+            }
+            this.send({ ...envelope, type: 'stream.close', sequence: this.nextSequence(), meta: {} });
+            return;
+        }
+        const active = this.streams.get(envelope.streamId);
+        if (active === undefined) {
+            this.sendError(envelope, 'STREAM_LOST', '流不存在或已经关闭');
+            return;
+        }
+        if (envelope.type === 'stream.window') {
+            await active.feature.handleWindow?.(active.context, envelope);
+            return;
+        }
+        await active.feature.handleMessage?.(active.context, envelope);
+    }
+    async openStream(envelope) {
+        if (this.streams.has(envelope.streamId)) {
+            this.sendError(envelope, 'MESSAGE_INVALID', 'streamId 已经使用');
+            return;
+        }
+        if (this.streams.size + this.opening.size >= this.maxStreams) {
+            this.debug.log('gateway.flow-control.rejected', {
+                activeStreams: this.streams.size,
+                openingStreams: this.opening.size,
+                maxStreams: this.maxStreams,
+                ...envelopeDebugFields(envelope),
+            });
+            this.sendError(envelope, 'FLOW_CONTROL_INVALID', '超过会话流数量上限');
+            return;
+        }
+        this.opening.add(envelope.streamId);
+        let streamHandlerStarted = false;
+        try {
+            const feature = await this.findFeature(envelope);
+            if (!feature) {
+                this.debug.log('gateway.feature.missing', envelopeDebugFields(envelope));
+                this.sendError(envelope, 'FEATURE_DISABLED', '没有启用匹配的 DSH 功能模块');
+                return;
+            }
+            if (this.cancelledOpening.delete(envelope.streamId)) {
+                // 取消发生在 feature 选择期间，不能再启动本地 WebSocket 或其它子资源。
+                this.send({ ...envelope, type: 'stream.close', sequence: this.nextSequence(), meta: {} });
+                return;
+            }
+            let context;
+            context = {
+                envelope,
+                session: this.session,
+                send: (type, meta = {}, body) => {
+                    const message = {
+                        ...envelope,
+                        messageId: `${envelope.streamId}_${this.nextSequence()}`,
+                        type,
+                        sequence: this.nextSequence(),
+                        meta,
+                        ...(body === undefined ? {} : { body }),
+                    };
+                    this.send(message);
+                },
+                close: () => {
+                    this.streams.delete(envelope.streamId);
+                    this.send({ ...envelope, type: 'stream.close', sequence: this.nextSequence(), meta: {} });
+                },
+            };
+            this.streams.set(envelope.streamId, { envelope, feature, context });
+            // 进入 streams 后已经完成异步初始化，不能再同时计入 opening。
+            // 否则一个正在处理的流会被计算两次，实际并发达到上限一半就会误报流控错误。
+            this.opening.delete(envelope.streamId);
+            this.debug.log('gateway.stream.accepted', { ...envelopeDebugFields(envelope), feature: feature.operation ?? feature.channel ?? 'custom' });
+            this.send({ ...envelope, type: 'stream.accepted', sequence: this.nextSequence(), meta: { channel: envelope.channel } });
+            if (!feature.handleStream)
+                return;
+            streamHandlerStarted = true;
+            const result = await feature.handleStream(context);
+            if (result && Symbol.asyncIterator in Object(result)) {
+                for await (const message of result)
+                    this.send(message);
+            }
+        }
+        catch (error) {
+            this.debug.log('gateway.stream.error', { ...envelopeDebugFields(envelope), error: error instanceof Error ? error.message : String(error) });
+            if (this.streams.has(envelope.streamId)) {
+                this.sendError(envelope, 'STREAM_FAILED', error instanceof Error ? error.message : 'DSH 流处理失败');
+                this.streams.delete(envelope.streamId);
+            }
+        }
+        finally {
+            this.opening.delete(envelope.streamId);
+            this.cancelledOpening.delete(envelope.streamId);
+            if (streamHandlerStarted && this.streams.delete(envelope.streamId)) {
+                // handleStream 正常返回但遗漏 context.close 时，网关仍必须收敛流状态。
+                try {
+                    this.send({ ...envelope, type: 'stream.close', sequence: this.nextSequence(), meta: {} });
+                }
+                catch {
+                    // 物理连接已关闭时，释放本地流状态优先于发送结束帧。
+                }
+            }
+        }
+    }
+    async findFeature(envelope) {
+        for (const feature of this.features) {
+            if (feature.channel && feature.channel !== envelope.channel)
+                continue;
+            if (feature.operation && feature.operation !== envelope.meta.operation)
+                continue;
+            if (!feature.canHandle || await feature.canHandle(envelope))
+                return feature;
+        }
+        if (!this.options.registry)
+            return undefined;
+        for (const module of this.options.registry.modules()) {
+            const candidate = module;
+            if (!candidate.canHandle && !candidate.handleStream && !candidate.handleMessage && !candidate.handleWindow)
+                continue;
+            if (candidate.channel && candidate.channel !== envelope.channel)
+                continue;
+            if (candidate.operation && candidate.operation !== envelope.meta.operation)
+                continue;
+            if (!candidate.canHandle || await candidate.canHandle(envelope))
+                return candidate;
+        }
+        return undefined;
+    }
+    sendError(envelope, code, detail) {
+        this.debug.log('gateway.error', { code, detail, ...envelopeDebugFields(envelope) });
+        this.send({
+            ...envelope,
+            messageId: `${envelope.messageId}_error`,
+            type: 'stream.error',
+            sequence: this.nextSequence(),
+            meta: { errorCode: code, detail, retryable: false },
+        });
+    }
+    send(envelope) {
+        this.session.send(envelope);
+    }
+    nextSequence() {
+        if (this.sequence >= Number.MAX_SAFE_INTEGER)
+            throw new Error('DSH Gateway sequence 已耗尽');
+        return ++this.sequence;
+    }
+}
+function envelopeDebugFields(envelope) {
+    return {
+        type: envelope.type,
+        channel: envelope.channel,
+        streamId: envelope.streamId,
+        sequence: envelope.sequence,
+        generation: envelope.generation,
+        hostId: envelope.hostScope.hostId,
+        hostKind: envelope.hostScope.kind,
+        operation: typeof envelope.meta.operation === 'string' ? envelope.meta.operation : undefined,
+        bodyBytes: envelope.body?.byteLength ?? 0,
+    };
+}
+//# sourceMappingURL=dsh-gateway.js.map

package/data/build/dist/transport/dsh-session.d.ts

@@ -0,0 +1,55 @@
+import type { CodingNsCarrier } from './carrier.js';
+import { type DshEnvelope, type DshHostScope } from './dsh-envelope.js';
+import { type DshTransportDebugLogger } from './debug.js';
+export type DshSessionRole = 'client' | 'host';
+export type DshSessionState = 'idle' | 'handshaking' | 'ready' | 'degraded' | 'closed';
+export interface DshSessionOptions {
+    carrier: CodingNsCarrier;
+    role: DshSessionRole;
+    generation: string;
+    hostScope: DshHostScope;
+    dshVersion?: string;
+    capabilities?: readonly string[];
+    protocol?: string;
+    heartbeatMs?: number;
+    onReady?(session: DshSession): void;
+    onEnvelope?(envelope: DshEnvelope): void;
+    onError?(error: Error): void;
+    /** Host 首个 session.hello 到达时采用对端 generation；后续帧仍严格校验。 */
+    acceptInitialGeneration?: boolean;
+    debug?: DshTransportDebugLogger;
+}
+/** 负责 DSH hello/ready、版本能力协商和心跳，不执行任何业务。 */
+export declare class DshSession {
+    private readonly options;
+    private stateValue;
+    private readonly listeners;
+    private readonly unsubscribe;
+    private heartbeat;
+    private messageCounter;
+    private remoteCapabilities;
+    private readyValue;
+    private readyResolve;
+    private readyReject;
+    private readonly debug;
+    private generationValue;
+    constructor(options: DshSessionOptions);
+    get state(): DshSessionState;
+    get ready(): boolean;
+    get capabilities(): readonly string[];
+    get generation(): string;
+    start(): void;
+    waitReady(signal?: AbortSignal): Promise<void>;
+    subscribe(listener: (envelope: DshEnvelope) => void): () => void;
+    send(envelope: DshEnvelope): void;
+    close(reason?: string): void;
+    private sendHello;
+    private sendReady;
+    private receive;
+    private receiveSession;
+    private validateScope;
+    private createEnvelope;
+    private startHeartbeat;
+    private fail;
+}
+//# sourceMappingURL=dsh-session.d.ts.map

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

@@ -0,0 +1,256 @@
+import { DSH_ENVELOPE_PROTOCOL, decodeDshEnvelope, encodeDshEnvelope, } from './dsh-envelope.js';
+import { DSH_VERSION } from '../shared/contracts/version.js';
+import { createDshTransportDebugLogger } from './debug.js';
+/** 负责 DSH hello/ready、版本能力协商和心跳，不执行任何业务。 */
+export class DshSession {
+    options;
+    stateValue = 'idle';
+    listeners = new Set();
+    unsubscribe;
+    heartbeat;
+    messageCounter = 0;
+    remoteCapabilities = [];
+    readyValue;
+    readyResolve;
+    readyReject;
+    debug;
+    generationValue;
+    constructor(options) {
+        this.options = options;
+        this.debug = options.debug ?? createDshTransportDebugLogger({ component: `session-${options.role}` });
+        this.generationValue = options.generation;
+        this.unsubscribe = options.carrier.subscribe((data) => this.receive(data));
+        if (options.onEnvelope)
+            this.listeners.add(options.onEnvelope);
+    }
+    get state() { return this.stateValue; }
+    get ready() { return this.stateValue === 'ready'; }
+    get capabilities() { return this.remoteCapabilities; }
+    get generation() { return this.generationValue; }
+    start() {
+        if (this.stateValue !== 'idle')
+            return;
+        this.stateValue = 'handshaking';
+        this.debug.log('session.start', { role: this.options.role, generation: this.generationValue, hostId: this.options.hostScope.hostId, hostKind: this.options.hostScope.kind });
+        this.readyValue = new Promise((resolve, reject) => {
+            this.readyResolve = resolve;
+            this.readyReject = reject;
+        });
+        // Host 侧通常只监听 onReady，不会调用 waitReady；即使远端作用域
+        // 无效，也不能让 ready Promise 变成 Node 的未处理拒绝。
+        void this.readyValue.catch(() => undefined);
+        if (this.options.role === 'client')
+            this.sendHello();
+        this.startHeartbeat();
+    }
+    waitReady(signal) {
+        if (this.ready)
+            return Promise.resolve();
+        if (this.stateValue === 'closed')
+            return Promise.reject(new Error('DSH Session 已关闭'));
+        if (!this.readyValue)
+            this.start();
+        const promise = this.readyValue;
+        if (!signal)
+            return promise;
+        if (signal.aborted)
+            return Promise.reject(signal.reason instanceof Error ? signal.reason : new Error('会话等待已取消'));
+        return Promise.race([
+            promise,
+            new Promise((_, reject) => signal.addEventListener('abort', () => reject(signal.reason instanceof Error ? signal.reason : new Error('会话等待已取消')), { once: true })),
+        ]);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    send(envelope) {
+        if (this.stateValue === 'closed')
+            throw new Error('DSH Session 已关闭');
+        const pending = this.options.carrier.send(encodeDshEnvelope(envelope));
+        this.debug.log('session.send', envelopeDebugFields(envelope));
+        if (pending && typeof pending.catch === 'function') {
+            void pending.catch((error) => this.fail(error instanceof Error ? error : new Error(String(error))));
+        }
+    }
+    close(reason = 'DSH Session 已关闭') {
+        if (this.stateValue === 'closed')
+            return;
+        this.stateValue = 'closed';
+        this.debug.log('session.close', { reason });
+        this.unsubscribe();
+        if (this.heartbeat)
+            clearInterval(this.heartbeat);
+        this.heartbeat = undefined;
+        this.readyReject?.(new Error(reason));
+        this.readyReject = undefined;
+        this.readyResolve = undefined;
+    }
+    sendHello() {
+        this.send(this.createEnvelope('session.hello', 'session', {
+            protocol: this.options.protocol ?? DSH_ENVELOPE_PROTOCOL,
+            dshVersion: this.options.dshVersion ?? DSH_VERSION,
+            capabilities: [...this.options.capabilities ?? []],
+        }));
+    }
+    sendReady(capabilities) {
+        this.send(this.createEnvelope('session.ready', 'session', {
+            protocol: this.options.protocol ?? DSH_ENVELOPE_PROTOCOL,
+            dshVersion: this.options.dshVersion ?? DSH_VERSION,
+            capabilities: [...capabilities],
+            byteCredit: 64 * 1024,
+            messageCredit: 32,
+        }));
+    }
+    receive(data) {
+        if (this.stateValue === 'closed')
+            return;
+        let envelope;
+        try {
+            envelope = decodeDshEnvelope(data);
+            this.validateScope(envelope);
+        }
+        catch (error) {
+            this.debug.log('session.receive.invalid', { bytes: data.byteLength, error: error instanceof Error ? error.message : String(error) });
+            this.fail(error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        this.debug.log('session.receive', { bytes: data.byteLength, ...envelopeDebugFields(envelope) });
+        if (envelope.channel === 'session') {
+            this.receiveSession(envelope);
+            return;
+        }
+        if (!this.ready) {
+            this.fail(new Error('SESSION_NOT_READY'));
+            return;
+        }
+        for (const listener of [...this.listeners])
+            listener(envelope);
+    }
+    receiveSession(envelope) {
+        if (envelope.type === 'session.hello') {
+            if (this.options.role !== 'host' || envelope.sequence !== 0 || this.stateValue === 'ready') {
+                this.fail(new Error('非法 session.hello'));
+                return;
+            }
+            const protocol = envelope.meta.protocol;
+            const dshVersion = envelope.meta.dshVersion;
+            if (protocol !== (this.options.protocol ?? DSH_ENVELOPE_PROTOCOL) || dshVersion !== (this.options.dshVersion ?? DSH_VERSION)) {
+                this.fail(new Error('PROTOCOL_VERSION_UNSUPPORTED'));
+                return;
+            }
+            const offered = readCapabilities(envelope.meta.capabilities);
+            const allowed = new Set(this.options.capabilities ?? offered);
+            this.remoteCapabilities = offered.filter((capability) => allowed.has(capability));
+            this.stateValue = 'ready';
+            this.debug.log('session.ready', { role: this.options.role, capabilities: this.remoteCapabilities });
+            this.sendReady(this.remoteCapabilities);
+            this.readyResolve?.();
+            this.options.onReady?.(this);
+            return;
+        }
+        if (envelope.type === 'session.ready') {
+            if (this.options.role !== 'client' || this.stateValue !== 'handshaking') {
+                this.fail(new Error('非法 session.ready'));
+                return;
+            }
+            const protocol = envelope.meta.protocol;
+            const dshVersion = envelope.meta.dshVersion;
+            if (protocol !== (this.options.protocol ?? DSH_ENVELOPE_PROTOCOL) || dshVersion !== (this.options.dshVersion ?? DSH_VERSION)) {
+                this.fail(new Error('PROTOCOL_VERSION_UNSUPPORTED'));
+                return;
+            }
+            this.remoteCapabilities = readCapabilities(envelope.meta.capabilities);
+            this.stateValue = 'ready';
+            this.debug.log('session.ready', { role: this.options.role, capabilities: this.remoteCapabilities });
+            this.readyResolve?.();
+            this.options.onReady?.(this);
+            return;
+        }
+        if (envelope.type === 'session.ping') {
+            this.send(this.createEnvelope('session.pong', 'session', { timestamp: Date.now() }));
+            return;
+        }
+        if (envelope.type === 'session.pong')
+            return;
+        if (envelope.type === 'session.close') {
+            this.close(typeof envelope.meta.reason === 'string' ? envelope.meta.reason : '远端关闭 DSH Session');
+            return;
+        }
+        this.fail(new Error('MESSAGE_INVALID'));
+    }
+    validateScope(envelope) {
+        const isInitialHello = this.options.role === 'host'
+            && this.options.acceptInitialGeneration === true
+            && this.stateValue === 'handshaking'
+            && envelope.channel === 'session'
+            && envelope.type === 'session.hello'
+            && envelope.sequence === 0;
+        if (envelope.hostScope.hostId !== this.options.hostScope.hostId
+            || envelope.hostScope.kind !== this.options.hostScope.kind
+            || (!isInitialHello && envelope.generation !== this.generationValue)) {
+            throw new Error('RESOURCE_SCOPE_STALE');
+        }
+        if (isInitialHello && envelope.generation !== this.generationValue) {
+            this.debug.log('session.generation.adopt', {
+                previousGeneration: this.generationValue,
+                generation: envelope.generation,
+                hostId: envelope.hostScope.hostId,
+            });
+            this.generationValue = envelope.generation;
+        }
+    }
+    createEnvelope(type, channel, meta) {
+        return {
+            version: 1,
+            messageId: `${this.options.role[0]}_${++this.messageCounter}`,
+            streamId: 'session',
+            channel,
+            type,
+            sequence: this.messageCounter - 1,
+            generation: this.generationValue,
+            hostScope: this.options.hostScope,
+            meta,
+        };
+    }
+    startHeartbeat() {
+        const interval = this.options.heartbeatMs ?? 30_000;
+        if (!Number.isFinite(interval) || interval <= 0)
+            return;
+        this.heartbeat = setInterval(() => {
+            if (this.stateValue === 'closed')
+                return;
+            try {
+                this.send(this.createEnvelope('session.ping', 'session', { timestamp: Date.now() }));
+            }
+            catch (error) {
+                this.fail(error instanceof Error ? error : new Error(String(error)));
+            }
+        }, interval);
+    }
+    fail(error) {
+        this.stateValue = 'degraded';
+        this.debug.log('session.error', { error: error.message });
+        this.readyReject?.(error);
+        this.options.onError?.(error);
+    }
+}
+function envelopeDebugFields(envelope) {
+    return {
+        type: envelope.type,
+        channel: envelope.channel,
+        streamId: envelope.streamId,
+        sequence: envelope.sequence,
+        generation: envelope.generation,
+        hostId: envelope.hostScope.hostId,
+        hostKind: envelope.hostScope.kind,
+        operation: typeof envelope.meta.operation === 'string' ? envelope.meta.operation : undefined,
+        bodyBytes: envelope.body?.byteLength ?? 0,
+    };
+}
+function readCapabilities(value) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== 'string'))
+        throw new Error('MESSAGE_INVALID');
+    return [...new Set(value)];
+}
+//# sourceMappingURL=dsh-session.js.map

package/data/build/dist/transport/dsh-transport.d.ts

@@ -0,0 +1,57 @@
+import type { CodingNsRpcRequest, CodingNsStreamRequest, CodingNsTransport, CodingNsTransportGeneration, CodingNsTransportHooks } from '../shared/index.js';
+import type { CodingNsCarrier } from './carrier.js';
+import type { TunnelFlowControl } from './multiplexer.js';
+import type { DshHostScope } from './dsh-envelope.js';
+import type { DshSession } from './dsh-session.js';
+import type { DshTransportDebugLogger } from './debug.js';
+export interface DshCodingNsTransportOptions {
+    carrier: CodingNsCarrier;
+    generation: CodingNsTransportGeneration;
+    ownsHost?: boolean;
+    streamBaseUrl?: string;
+    reconnect?: (signal?: AbortSignal) => Promise<void | CodingNsTransportGeneration>;
+    flowControl?: TunnelFlowControl;
+    hostScope?: DshHostScope;
+    session?: DshSession;
+    requireSessionReady?: boolean;
+    debug?: DshTransportDebugLogger;
+}
+/** 将 Tunnel Multiplexer 映射为 DSH ClientTransportHooks。 */
+export declare class DshCodingNsTransport implements CodingNsTransport {
+    private readonly options;
+    private readonly listeners;
+    private readonly multiplexer;
+    private currentCarrier;
+    private generation;
+    constructor(options: DshCodingNsTransportOptions);
+    rpc<TResponse = unknown, TPayload = unknown>(request: CodingNsRpcRequest<TPayload>): Promise<TResponse>;
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+    /** 向 Host 的 Remote Web Runtime 发送带明确 operation 的请求。 */
+    webRequest<TResponse = unknown, TPayload = unknown>(operation: string, payload: TPayload, signal?: AbortSignal): Promise<TResponse>;
+    /** 打开一个由 Remote Web Runtime 管理的 Web 流。 */
+    openWebStream<TChunk = unknown, TPayload = unknown>(operation: string, payload: TPayload, signal?: AbortSignal): AsyncIterable<TChunk>;
+    openWebStreamWithId<TChunk = unknown, TPayload = unknown>(operation: string, payload: TPayload, signal?: AbortSignal): {
+        streamId: string;
+        stream: AsyncIterable<TChunk>;
+    };
+    sendWebStream(streamId: string, type: string, body?: Uint8Array, meta?: Record<string, unknown>): void;
+    closeWebStream(streamId: string): void;
+    openStream<TChunk = unknown, TPayload = unknown>(request: CodingNsStreamRequest<TPayload>): AsyncIterable<TChunk>;
+    loadBundle(url: string): Promise<void>;
+    getGeneration(): CodingNsTransportGeneration | undefined;
+    onGenerationChange(listener: (generation: CodingNsTransportGeneration | undefined) => void): () => void;
+    reconnect(signal?: AbortSignal): Promise<void>;
+    /** 由启动胶水在建立新物理连接后提交新 generation。旧请求会立即失效。 */
+    updateGeneration(generation: CodingNsTransportGeneration): void;
+    /** 物理 WebRTC 重连后替换 carrier/session，并让 DSH Connection 看见新 generation。 */
+    replaceConnection(carrier: CodingNsCarrier, session: DshSession, generation: CodingNsTransportGeneration): void;
+    /** 物理连接失效时立即结束旧请求和旧 generation。 */
+    invalidateConnection(error?: Error): void;
+    close(): Promise<void>;
+    /** 给 pre-Cordis 启动胶水使用，不直接安装 DSH Connection。 */
+    asTransportHooks(): CodingNsTransportHooks & {
+        ownsHost?: boolean;
+        streamBaseUrl?: string;
+    };
+}
+//# sourceMappingURL=dsh-transport.d.ts.map