@deepseek-ai/dsh-remote-mock 0.1.6-alpha.2 → 0.1.7-alpha.1

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/test-support/remote-mock/README.md
-README.md: 82979e37052aecee6ec716702f634d25c969f5ad
-README.zh.md: 201ca011410dd5a4d65b6ebdfb0c47f23742b0d3
+README.md: 7f76ce6217d7cc6f86923aa1ee4f7257ad30926e
+README.zh.md: b79849fe3b23b5135feff7095468f65809b0d506

package/README.md

@@ -73,7 +73,9 @@ mock.streams.fail('session/follow', new Error('gone'))
 await mock.streams.drained('session/follow')
 ```
 
-A failed stream rejects the consumer's next read with the given `Error`. Consumer cancellation (the opening signal or an early iterator `return()`) aborts `StreamHandle.signal`, ends the iteration without throwing, and logs the stream as `cancelled`.
+A failed stream rejects the consumer's next read with the given `Error`. Consumer cancellation (the opening signal or an early iterator `return()`) aborts `StreamHandle.signal`, ends the iteration without throwing, and logs the stream as `cancelled`. `StreamHandle.uplink` is what the script reads as the Client's uplink: through `rpc.open` it is the carrier's iterable; for a direct `mock.remote.<namespace>.<method>(...)` call it is fed by the returned handle, which is the `RemoteStreamHandle` a generated method returns (iterate it for the downlink, `send()` and `end()` feed the uplink, `dispose()` cancels the stream); `send()` rejects a non-lossless JSON item as the real handle does, and the uplink it owns closes once the stream settles, is cancelled, or the consumer leaves, so a later `send()` throws. The mock function is called with the method's own arguments only, so the uplink never appears in call assertions or logged args.
+
+A fake that stands in for a generated stream method returns the `RemoteStreamHandle` the generated method does. `streamHandle(source)` types an `AsyncIterable` as that handle with inert `send`, `end`, and `dispose`; `streamMethod<M>(generator)` lifts an async generator function written for the method's arguments into the method's own signature, for `vi.fn<M>()` and `mockImplementation`.
 
 ### Connect a client
 
@@ -108,7 +110,7 @@ A failed stream rejects the consumer's next read with the given `Error`. Consume
 | [`src/index.ts`](src/index.ts) | Public face re-exports |
 | [`src/remote-mock.ts`](src/remote-mock.ts) | `RemoteMock`: default responses, native mocks, Connection dispatch, controlled streams and missing-response checks; `ok` |
 | [`src/remote-proxy.ts`](src/remote-proxy.ts) | Namespace/method lookup and generated-map mock types |
-| [`src/streams.ts`](src/streams.ts) | `frames` / `openStream` scripts and `MockStream` (handle + `AsyncIterable`) |
+| [`src/streams.ts`](src/streams.ts) | `frames` / `openStream` scripts, `streamHandle` / `streamMethod` fake typing, and `MockStream` (handle + `AsyncIterable`) |
 | [`src/log.ts`](src/log.ts) | Log store with the shared `seq` counter |
 | — | No runtime invariant companion is published; this test-support library owns no production event stream or mutable process state, and its behavior is exercised by its package tests. |
 
@@ -130,7 +132,7 @@ None; this package neither assembles nor sends a provider request.
 <a id="known-limitations-and-deferred-work"></a>
 
 - **In-process carrier only** — `rpc` serves a Connection instance in the same realm; no HTTP or WebSocket carrier for browser-lane specs is provided.
-- **Values cross by reference** — answers and stream items reach the client unserialized, so a non-JSON value that the real wire would reject passes through unchanged.
+- **Values cross by reference** — answers and downlink items reach the client unserialized, so a non-JSON downlink value that the real wire would reject passes through unchanged; only the handle's `send()` applies the real uplink check.
 - **Values are not checked** — a unary answer must be the result the caller reads (`{ ok, value }` or `{ ok: false, error }`); the mock passes it through unchanged and does not check those fields.
 - **No payload matching** — rules match on endpoint only; discriminate on business arguments inside a handler.
 - **Native stream overrides own their iterable** — an override returning its own iterable bypasses scripted-stream logs, `requests`, `opened`, `drained`, and `push` / `end` / `fail`; the caller also owns cancellation. Native call assertions still work. Use a registered stream script when a scenario needs those controls.

package/README.zh.md

@@ -73,7 +73,9 @@ mock.streams.fail('session/follow', new Error('gone'))
 await mock.streams.drained('session/follow')
 ```
 
-失败的流让消费方的下一次读取以给定的 `Error` reject。消费方取消（打开时的 signal 或 iterator 提前 `return()`）会中止 `StreamHandle.signal`、结束迭代而不抛错，并把该流记为 `cancelled`。
+失败的流让消费方的下一次读取以给定的 `Error` reject。消费方取消（打开时的 signal 或 iterator 提前 `return()`）会中止 `StreamHandle.signal`、结束迭代而不抛错，并把该流记为 `cancelled`。`StreamHandle.uplink` 是脚本读到的 Client 上行：经 `rpc.open` 打开时它是载体传入的 iterable；直接调用 `mock.remote.<namespace>.<method>(...)` 时它由返回的句柄喂入——该句柄就是生成方法返回的 `RemoteStreamHandle`（迭代它读下行，`send()` 与 `end()` 喂上行，`dispose()` 取消流）；`send()` 像真实句柄一样拒绝非无损 JSON 项，它拥有的上行在流结束、取消或消费方离开时关闭，之后的 `send()` 抛错。mock 函数只以方法自己的参数被调用，上行不会出现在调用断言或记录的 args 里。
+
+替代生成流方法的假实现返回生成方法所返回的 `RemoteStreamHandle`。`streamHandle(source)` 把一个 `AsyncIterable` 标注为该句柄，其 `send`、`end`、`dispose` 为空操作；`streamMethod<M>(generator)` 把按方法参数编写的 async generator 函数提升为方法自己的签名，供 `vi.fn<M>()` 与 `mockImplementation` 使用。
 
 ### 接上客户端
 
@@ -108,7 +110,7 @@ await mock.streams.drained('session/follow')
 | [`src/index.ts`](src/index.ts) | 公开面转出 |
 | [`src/remote-mock.ts`](src/remote-mock.ts) | `RemoteMock`：默认响应、原生 mock、Connection 分发、受控流与缺失响应检查；`ok` |
 | [`src/remote-proxy.ts`](src/remote-proxy.ts) | 命名空间／方法查找与生成映射的 mock 类型 |
-| [`src/streams.ts`](src/streams.ts) | `frames` / `openStream` 脚本与 `MockStream`（句柄 + `AsyncIterable`） |
+| [`src/streams.ts`](src/streams.ts) | `frames` / `openStream` 脚本、`streamHandle` / `streamMethod` 假实现标注，以及 `MockStream`（句柄 + `AsyncIterable`） |
 | [`src/log.ts`](src/log.ts) | 带共享 `seq` 计数器的日志 |
 | — | 不发布运行时不变量伴生件；本测试支持库不拥有任何生产事件流或可变进程状态，其行为由本包测试覆盖。 |
 
@@ -130,7 +132,7 @@ await mock.streams.drained('session/follow')
 <a id="known-limitations-and-deferred-work"></a>
 
 - **仅进程内载体**——`rpc` 服务同一 realm 中的 Connection 实例；不提供给浏览器车道测试用的 HTTP 或 WebSocket 载体。
-- **值按引用传递**——应答与流项都未经序列化就到达客户端，真实线路会拒绝的非 JSON 值在这里原样通过。
+- **值按引用传递**——应答与下行项都未经序列化就到达客户端，真实线路会拒绝的非 JSON 下行值在这里原样通过；只有句柄的 `send()` 施加真实的上行校验。
 - **不校验值**——一元应答必须是调用方读取的结果（`{ ok, value }` 或 `{ ok: false, error }`）；mock 原样传递它，不检查这些字段。
 - **不做 payload 匹配**——规则只按端点匹配；在 handler 内按业务参数判别。
 - **原生流覆盖自行管理 iterable**——覆盖返回自有 iterable 时，不参与脚本流日志、`requests`、`opened`、`drained` 以及 `push` / `end` / `fail`；调用方也负责取消。原生调用断言仍然有效。需要这些控制能力的场景应使用已登记的流脚本。

package/lib/index.js

@@ -1,4 +1,5 @@
 import { fn } from "@vitest/spy";
+import { isRemoteUplinkItem } from "@deepseek-ai/dsh-typert-protocol";
 //#region lib/types/log.js
 /** What a `RemoteMock` saw: answered calls, opened streams, and requests without a rule. */
 /** The mock's log store. */
@@ -69,6 +70,30 @@ var MockLogStore = class {
 //#region lib/types/streams.js
 /** Stream scripts and the pushable, abort-aware stream a script drives. */
 /**
+* Type a fake stream method's result as the handle a generated Client method
+* returns. The uplink members are inert: a fake built on it drives the downlink only.
+* @param source - downlink items the fake yields.
+* @returns a handle that iterates `source`.
+*/
+function streamHandle(source) {
+	return {
+		[Symbol.asyncIterator]: () => source[Symbol.asyncIterator](),
+		send: () => void 0,
+		end: () => void 0,
+		dispose: () => void 0
+	};
+}
+/**
+* Lift a fake stream method written as an async generator function into the
+* signature of the generated method it stands in for.
+* @param method - fake taking the method's arguments and yielding its downlink items.
+* @returns the fake returning {@link streamHandle} of each call.
+*/
+function streamMethod(method) {
+	const lifted = (...args) => streamHandle(method(...args));
+	return lifted;
+}
+/**
 * Script yielding `items`, then ending.
 * @param items - items in order.
 * @returns the script.
@@ -93,6 +118,8 @@ function openStream(initial = []) {
 var MockStream = class {
 	record;
 	sourceSignal;
+	uplink;
+	release;
 	queue = [];
 	settled;
 	waiting;
@@ -110,10 +137,14 @@ var MockStream = class {
 	/**
 	* @param record - log entry this stream updates.
 	* @param sourceSignal - cancellation from the caller that opened the stream.
+	* @param uplink - the uplink the script reads.
+	* @param release - closes the uplink this stream owns; called once, when the stream settles, is cancelled, or the consumer leaves.
 	*/
-	constructor(record, sourceSignal) {
+	constructor(record, sourceSignal, uplink, release) {
 		this.record = record;
 		this.sourceSignal = sourceSignal;
+		this.uplink = uplink;
+		this.release = release;
 		if (sourceSignal.aborted) this.cancel(sourceSignal.reason);
 		else sourceSignal.addEventListener("abort", this.onAbort, { once: true });
 	}
@@ -140,6 +171,10 @@ var MockStream = class {
 			error
 		}, "failed");
 	}
+	/** The consumer left: cancel the stream and drop what it left. */
+	dispose() {
+		this.cancel(/* @__PURE__ */ new Error(`remote-mock: ${this.record.endpoint} stream disposed`));
+	}
 	/**
 	* Start `script` on this stream.
 	* @param script - the registered script.
@@ -214,6 +249,7 @@ var MockStream = class {
 		this.record.state = state;
 		this.settled = settled;
 		this.sourceSignal.removeEventListener("abort", this.onAbort);
+		this.release();
 		this.wakeDrained();
 		const waiting = this.waiting;
 		if (waiting === void 0) return;
@@ -228,6 +264,7 @@ var MockStream = class {
 			this.waiting = void 0;
 			this.queue.length = 0;
 			this.cancellation.abort(reason);
+			this.release();
 			waiting?.resolve({
 				value: void 0,
 				done: true
@@ -247,6 +284,104 @@ var MockStream = class {
 	}
 };
 /**
+* The uplink a direct handle owns: `send()` pushes, `end()` half-closes, and
+* `close()` ends it and drops unread items once the stream settles, is
+* cancelled, or the consumer leaves. The script reads it as `StreamHandle.uplink`.
+*/
+var HandleUplink = class {
+	items = [];
+	done = false;
+	waiter;
+	/**
+	* Queues one uplink item for the script, or completes the read waiting for it.
+	* @param item - the item the handle's `send()` carried.
+	* @throws {Error} after `end()`.
+	*/
+	push(item) {
+		if (this.done) throw new Error("remote-mock: uplink was ended");
+		const waiter = this.waiter;
+		this.waiter = void 0;
+		if (waiter === void 0) this.items.push(item);
+		else waiter({
+			value: item,
+			done: false
+		});
+	}
+	/** Half-closes the uplink: pending and later reads complete as done; repeated calls are no-ops. */
+	end() {
+		if (this.done) return;
+		this.done = true;
+		this.waiter?.({
+			value: void 0,
+			done: true
+		});
+		this.waiter = void 0;
+	}
+	/** Ends the uplink and drops unread items; the owning stream calls it on settle or cancel, the script's iterator on `return()`. */
+	close() {
+		this.items.length = 0;
+		this.end();
+	}
+	[Symbol.asyncIterator]() {
+		return {
+			next: () => {
+				if (this.items.length > 0) return Promise.resolve({
+					value: this.items.shift(),
+					done: false
+				});
+				if (this.done) return Promise.resolve({
+					value: void 0,
+					done: true
+				});
+				return new Promise((resolve) => {
+					this.waiter = resolve;
+				});
+			},
+			return: () => {
+				this.close();
+				return Promise.resolve({
+					value: void 0,
+					done: true
+				});
+			}
+		};
+	}
+};
+/**
+* The handle a direct `mock.remote` stream call returns, as a generated method
+* would: iterate it for the script's downlink, `send()` and `end()` feed
+* `StreamHandle.uplink`, `dispose()` cancels the stream. `send()` applies the
+* real handle's check, so a non-lossless JSON item throws and a top-level
+* `undefined` passes. A stream opened through `rpc.open` reads the carrier's
+* uplink instead, and this handle owns none.
+*/
+var MockClientStream = class {
+	stream;
+	uplink;
+	/**
+	* @param stream - the script-side stream.
+	* @param uplink - the uplink this handle feeds; absent when the carrier supplied one.
+	*/
+	constructor(stream, uplink) {
+		this.stream = stream;
+		this.uplink = uplink;
+	}
+	send(item) {
+		if (this.uplink === void 0) throw new Error(`remote-mock: ${this.stream.record.endpoint} uplink belongs to the carrier that opened the stream`);
+		if (!isRemoteUplinkItem(item)) throw new Error(`remote-mock: ${this.stream.record.endpoint} uplink item is not a lossless JSON value`);
+		this.uplink.push(item);
+	}
+	end() {
+		this.uplink?.end();
+	}
+	dispose() {
+		this.stream.dispose();
+	}
+	[Symbol.asyncIterator]() {
+		return this.stream[Symbol.asyncIterator]();
+	}
+};
+/**
 * The `Error` a thrown value stands for: itself, or a new Error carrying its string form.
 * @param reason - thrown value.
 * @returns the error.
@@ -318,6 +453,8 @@ var RemoteMock = class RemoteMock {
 	logStore = new MockLogStore();
 	unaryMocks = /* @__PURE__ */ new Map();
 	streamMocks = /* @__PURE__ */ new Map();
+	/** The carrier's uplink for the open in progress through {@link open}; a direct call has none. */
+	carrierUplink;
 	proxy = createRemoteProxy((endpoint) => this.modeOf(endpoint) === "stream" ? this.streamMock(endpoint) : this.unaryMock(endpoint));
 	/**
 	* Native mock functions for every namespace: configure answers and inspect calls without declaring method names.
@@ -361,7 +498,7 @@ var RemoteMock = class RemoteMock {
 			const pending = this.dispatch(endpoint, argsOf(endpoint, payload));
 			return await (signal === void 0 ? pending : settleOrAbort(pending, signal));
 		},
-		open: (_channel, endpoint, payload, signal) => this.open(endpoint, argsOf(endpoint, payload), signal)
+		open: (_channel, endpoint, payload, signal, uplink) => this.open(endpoint, argsOf(endpoint, payload), signal, uplink)
 	};
 	constructor() {}
 	unary(endpoint, rule) {
@@ -455,16 +592,25 @@ var RemoteMock = class RemoteMock {
 		return isRuleFn(rule) ? answerOf(rule, args) : rule;
 	}
 	/**
-	* Open through the endpoint's native mock; its default runs the registered script as a controlled stream.
-	* A native override returns its own iterable: the caller owns consumption and cancellation, outside `OpenStreams`.
+	* Open through the endpoint's native mock, which is called with the generated
+	* signature's arguments only; its default runs the registered script as a
+	* controlled stream. A native override returns its own iterable: the caller
+	* owns consumption and cancellation, outside `OpenStreams`.
 	* @param endpoint - endpoint.
 	* @param args - positional args.
 	* @param signal - consumer cancellation.
+	* @param uplink - the carrier's uplink for this open, which the script reads as `StreamHandle.uplink`;
+	*   absent for a direct call, whose returned handle owns the uplink.
 	* @returns the controlled script stream or the native override's caller-owned iterable.
 	* @throws {Error} when the default runs without a registered script (logged as unmatched).
 	*/
-	open(endpoint, args, signal) {
-		return this.streamMock(endpoint)(...args, signal);
+	open(endpoint, args, signal, uplink) {
+		this.carrierUplink = uplink;
+		try {
+			return this.streamMock(endpoint)(...args, signal);
+		} finally {
+			this.carrierUplink = void 0;
+		}
 	}
 	streamMock(endpoint) {
 		let mock = this.streamMocks.get(endpoint);
@@ -472,23 +618,31 @@ var RemoteMock = class RemoteMock {
 			mock = fn((...values) => {
 				const args = [...values];
 				const signal = args.at(-1) instanceof AbortSignal ? args.pop() : new AbortController().signal;
-				return this.openScript(endpoint, args, signal);
+				return this.openScript(endpoint, args, signal, this.carrierUplink);
 			});
 			this.streamMocks.set(endpoint, mock);
 		}
 		return mock;
 	}
-	openScript(endpoint, args, signal) {
+	openScript(endpoint, args, signal, carrierUplink) {
 		const script = this.scripts.get(endpoint);
 		if (script === void 0) {
 			this.logStore.miss(endpoint, "stream");
 			throw new Error(this.noRuleMessage(endpoint));
 		}
-		const stream = new MockStream(this.logStore.stream(endpoint, args), signal);
+		let uplink;
+		let owned;
+		if (carrierUplink === void 0) {
+			owned = new HandleUplink();
+			uplink = owned;
+		} else uplink = carrierUplink;
+		const stream = new MockStream(this.logStore.stream(endpoint, args), signal, uplink, () => {
+			owned?.close();
+		});
 		this.live.push(stream);
 		this.wakeOpened(endpoint);
 		stream.run(script, args);
-		return stream;
+		return new MockClientStream(stream, owned);
 	}
 	/** Throw when any request found no rule, naming the endpoints and the registered ones. */
 	assertNoUnmatched() {
@@ -554,4 +708,4 @@ function settleOrAbort(pending, signal) {
 	});
 }
 //#endregion
-export { RemoteMock, frames, ok, openStream };
+export { MockClientStream, RemoteMock, frames, ok, openStream, streamHandle, streamMethod };

package/lib/types/index.d.ts

@@ -10,8 +10,9 @@
  */
 export { RemoteMock, ok } from './remote-mock.ts';
 export type { OpenStreams, RemoteMockOptions, RemoteTable, StreamFilter, UnaryRuleFn } from './remote-mock.ts';
-export { frames, openStream } from './streams.ts';
+export { frames, openStream, streamHandle, streamMethod } from './streams.ts';
 export type { StreamHandle, StreamScript } from './streams.ts';
+export { MockClientStream } from './streams.ts';
 export type { LoggedCall, LoggedMiss, LoggedStream, MockLog } from './log.ts';
 export type { MockedRemote } from './remote-proxy.ts';
 //# sourceMappingURL=index.d.ts.map

package/lib/types/remote-mock.d.ts

@@ -90,6 +90,8 @@ export declare class RemoteMock {
     private readonly logStore;
     private readonly unaryMocks;
     private readonly streamMocks;
+    /** The carrier's uplink for the open in progress through {@link open}; a direct call has none. */
+    private carrierUplink;
     private readonly proxy;
     /**
      * Native mock functions for every namespace: configure answers and inspect calls without declaring method names.
@@ -162,15 +164,19 @@ export declare class RemoteMock {
     private unaryMock;
     private unaryAnswer;
     /**
-     * Open through the endpoint's native mock; its default runs the registered script as a controlled stream.
-     * A native override returns its own iterable: the caller owns consumption and cancellation, outside `OpenStreams`.
+     * Open through the endpoint's native mock, which is called with the generated
+     * signature's arguments only; its default runs the registered script as a
+     * controlled stream. A native override returns its own iterable: the caller
+     * owns consumption and cancellation, outside `OpenStreams`.
      * @param endpoint - endpoint.
      * @param args - positional args.
      * @param signal - consumer cancellation.
+     * @param uplink - the carrier's uplink for this open, which the script reads as `StreamHandle.uplink`;
+     *   absent for a direct call, whose returned handle owns the uplink.
      * @returns the controlled script stream or the native override's caller-owned iterable.
      * @throws {Error} when the default runs without a registered script (logged as unmatched).
      */
-    open(endpoint: string, args: readonly unknown[], signal: AbortSignal): AsyncIterable<unknown>;
+    open(endpoint: string, args: readonly unknown[], signal: AbortSignal, uplink?: AsyncIterable<unknown>): AsyncIterable<unknown>;
     private streamMock;
     private openScript;
     /** Throw when any request found no rule, naming the endpoints and the registered ones. */

package/lib/types/streams.d.ts

@@ -1,5 +1,22 @@
 /** Stream scripts and the pushable, abort-aware stream a script drives. */
+import { type RemoteStreamHandle } from '@deepseek-ai/dsh-typert-protocol';
 import type { StreamRecord } from './log.ts';
+/**
+ * Type a fake stream method's result as the handle a generated Client method
+ * returns. The uplink members are inert: a fake built on it drives the downlink only.
+ * @param source - downlink items the fake yields.
+ * @returns a handle that iterates `source`.
+ */
+export declare function streamHandle<Out, In = never>(source: AsyncIterable<Out>): RemoteStreamHandle<Out, In>;
+/** Downlink item type of one generated stream method. */
+type StreamItem<Method> = Method extends (...args: never[]) => RemoteStreamHandle<infer Out, unknown> ? Out : never;
+/**
+ * Lift a fake stream method written as an async generator function into the
+ * signature of the generated method it stands in for.
+ * @param method - fake taking the method's arguments and yielding its downlink items.
+ * @returns the fake returning {@link streamHandle} of each call.
+ */
+export declare function streamMethod<Method extends (...args: never[]) => RemoteStreamHandle<unknown, unknown>>(method: (...args: Parameters<Method>) => AsyncIterable<StreamItem<Method>>): Method;
 /** Test-side controls over one open stream. */
 export interface StreamHandle {
     /** Queue one item for the consumer. */
@@ -10,6 +27,12 @@ export interface StreamHandle {
     fail(error: Error): void;
     /** Aborts when the opening signal aborts or the consumer returns early. */
     readonly signal: AbortSignal;
+    /**
+     * Uplink items for the script: the carrier's iterable when the open came
+     * through `rpc.open`, otherwise what the returned handle's `send()` and
+     * `end()` feed.
+     */
+    readonly uplink: AsyncIterable<unknown>;
 }
 /**
  * How a stream endpoint answers an open: receives the open args and the
@@ -33,6 +56,8 @@ export declare function openStream(initial?: readonly unknown[]): StreamScript;
 export declare class MockStream implements StreamHandle, AsyncIterable<unknown> {
     readonly record: StreamRecord;
     private readonly sourceSignal;
+    readonly uplink: AsyncIterable<unknown>;
+    private readonly release;
     private readonly queue;
     private settled;
     private waiting;
@@ -46,11 +71,15 @@ export declare class MockStream implements StreamHandle, AsyncIterable<unknown>
     /**
      * @param record - log entry this stream updates.
      * @param sourceSignal - cancellation from the caller that opened the stream.
+     * @param uplink - the uplink the script reads.
+     * @param release - closes the uplink this stream owns; called once, when the stream settles, is cancelled, or the consumer leaves.
      */
-    constructor(record: StreamRecord, sourceSignal: AbortSignal);
+    constructor(record: StreamRecord, sourceSignal: AbortSignal, uplink: AsyncIterable<unknown>, release: () => void);
     push(item: unknown): void;
     end(): void;
     fail(error: Error): void;
+    /** The consumer left: cancel the stream and drop what it left. */
+    dispose(): void;
     /**
      * Start `script` on this stream.
      * @param script - the registered script.
@@ -72,10 +101,53 @@ export declare class MockStream implements StreamHandle, AsyncIterable<unknown>
     private isDrained;
     private wakeDrained;
 }
+/**
+ * The uplink a direct handle owns: `send()` pushes, `end()` half-closes, and
+ * `close()` ends it and drops unread items once the stream settles, is
+ * cancelled, or the consumer leaves. The script reads it as `StreamHandle.uplink`.
+ */
+export declare class HandleUplink implements AsyncIterable<unknown> {
+    private readonly items;
+    private done;
+    private waiter;
+    /**
+     * Queues one uplink item for the script, or completes the read waiting for it.
+     * @param item - the item the handle's `send()` carried.
+     * @throws {Error} after `end()`.
+     */
+    push(item: unknown): void;
+    /** Half-closes the uplink: pending and later reads complete as done; repeated calls are no-ops. */
+    end(): void;
+    /** Ends the uplink and drops unread items; the owning stream calls it on settle or cancel, the script's iterator on `return()`. */
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<unknown>;
+}
+/**
+ * The handle a direct `mock.remote` stream call returns, as a generated method
+ * would: iterate it for the script's downlink, `send()` and `end()` feed
+ * `StreamHandle.uplink`, `dispose()` cancels the stream. `send()` applies the
+ * real handle's check, so a non-lossless JSON item throws and a top-level
+ * `undefined` passes. A stream opened through `rpc.open` reads the carrier's
+ * uplink instead, and this handle owns none.
+ */
+export declare class MockClientStream implements RemoteStreamHandle<unknown, unknown> {
+    private readonly stream;
+    private readonly uplink;
+    /**
+     * @param stream - the script-side stream.
+     * @param uplink - the uplink this handle feeds; absent when the carrier supplied one.
+     */
+    constructor(stream: MockStream, uplink: HandleUplink | undefined);
+    send(item: unknown): void;
+    end(): void;
+    dispose(): void;
+    [Symbol.asyncIterator](): AsyncIterator<unknown>;
+}
 /**
  * The `Error` a thrown value stands for: itself, or a new Error carrying its string form.
  * @param reason - thrown value.
  * @returns the error.
  */
 export declare function toError(reason: unknown): Error;
+export {};
 //# sourceMappingURL=streams.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-remote-mock",
   "description": "Endpoint-named mock for Typert Remote traffic: unary answers and stream scripts per <namespace>/<method>, live stream control, a log, and the Connection carrier face whole-client specs install",
-  "version": "0.1.6-alpha.2",
+  "version": "0.1.7-alpha.1",
   "publishConfig": {
     "access": "public"
   },
@@ -26,14 +26,15 @@
     "@vitest/spy": "^4.1.8"
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.2"
+    "@deepseek-ai/cordis": "^4.0.3",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.7-alpha.1"
   },
   "devDependencies": {
     "typescript": "^6.0.3",
-    "@deepseek-ai/dsh-api-settings-controller": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-client-connection": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-typert-protocol": "^0.1.6-alpha.2",
-    "@deepseek-ai/cordis": "^4.0.2"
+    "@deepseek-ai/cordis": "^4.0.3",
+    "@deepseek-ai/dsh-api-settings-controller": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-client-connection": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.7-alpha.1"
   },
   "files": [
     "lib/index.js",