@stackstackstack/dsh-api-gateway 0.1.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# 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/api/gateway/README.md
+README.md: 7d41b607fbc2bf2ced6c2519314b5c6713722bc3
+README.zh.md: 869010d16d7a48185c57cc1f3fdc28e82e9ad038

package/README.md

@@ -0,0 +1,42 @@
+# @stackstackstack/dsh-api-gateway
+
+English | [中文](README.zh.md)
+
+Two-sided Typert RPC endpoint for Host and Client Cordis environments. The Host entry provides `ctx.typertGateway`, while `@stackstackstack/dsh-api-gateway/client` provides `ctx.remote`; both consume the same generated `InvocationDescriptor` contract and leave business selection to API Remotes and transport, request correlation, trust, and response envelopes to Connection.
+
+## Host service: `TypertGatewayService` (ctx key: `typertGateway`)
+
+`ctx.typertGateway.invoke()` resolves the current descriptor and Cordis Service for each call, validates exact named arguments, resolves registered object or Context identities, invokes the public business method, and validates its result. Business Services extend `TypertRemoteService` and mark methods with `@Remote` or `@RemoteScope` from [`dsh-typert-protocol`](../../typert/protocol/README.md); `bindTypertRemote()` remains available when another base class owns inheritance.
+
+Strict mode reads generated invocation descriptors from `ctx.typert.local`. Lookup parameters use the currently active resolver in `ctx.typert.lookups`: the business package registers the stable declaration and default policy, while Host composition can override resolution behavior with effect-scoped `configure()`; `@RemoteScope` resolves its receiver through a registered Host Context provider. SRC mode is a development fallback for endpoints that have never had a strict definition; it parses simple parameter names and accepts only JSON-safe values for non-lookup parameters. Withdrawing an observed strict definition fails instead of weakening validation.
+
+The Host entry registers a trusted-host interceptor on Connection's shared `/api` FetchHandler. Connection passes this composite handler through its HTTP bridge; the handler dispatches claimed endpoints to Gateway and unclaimed endpoints to API Proxy. Direct `invoke()` calls preserve business errors; `TypertGatewayError` distinguishes failures owned by dispatch, binding, providers, lookup, Context, arguments, and codecs. A resolver may use `TypertLookupFailure` to carry an existing RPC error, preserving its original error code for policy rejections such as cold-resume failures or ownership fences.
+
+A cancellation-aware Remote method declares `signal: AbortSignal` as its final Host parameter. The signal is descriptor metadata rather than a wire argument: Connection supplies it to the Gateway, and the Gateway injects it after decoded business parameters. SRC recognizes the reserved final name, while strict generation additionally requires the global `AbortSignal` type.
+
+## Client service: `ClientRemote` (ctx key: `remote`)
+
+`ctx.remote.$mount()` validates and registers a generated Host-for-Client contribution, then installs concrete direct and scoped methods for the calling Cordis fiber. Each namespace is a traced `remote.<namespace>` child Service and unloads after its last method is withdrawn. Duplicate endpoints, namespace collisions, and descriptors without strict generated codecs fail before methods become callable.
+
+Each call validates positional inputs, constructs the descriptor's exact named `args`, and sends it through `ctx.connection.rpc.call('/api', endpoint, ...)`. Generated cancellation-aware methods accept a final optional `AbortSignal`; the Client combines it with the contribution mount lifetime before calling Connection. The returned value is validated before reaching application code. Withdrawing a contribution removes its descriptors and methods together, aborts in-flight calls, and makes retained method handles reject.
+
+`ctx.remote.$on()` subscribes to one forwarded Host event. Its legal keys are exactly the Host assembly's forwarding selection, and the listener type is the owning package's own Cordis `Events` declaration, so no second signature can drift from it. Each subscription belongs to the calling fiber and disappears with it. Delivery is one-way and follows registration order; a listener that throws is logged and isolated from the remaining listeners, which never affects the frame pump. `ctx.remote.$dispatch()` is the other half of that surface, and it is the carrier's: the Client half owning the Host frame sink hands each decoded frame over, and an event name nobody subscribes to is dropped, since the wire carries whatever the Host selected. A consumer subscribes and never calls it.
+
+Generated declaration merges provide the TypeScript API through the shared `TypertClientRemote` contract. The Client entry contains no Host Service or Host Cordis interface merge, and method lookup and invocation use ordinary objects and functions rather than a JavaScript Proxy.
+
+## Model Experience
+
+None, as the package dispatches application calls and registers no prompt, tool, or session event.
+
+#### KV Cache effect
+
+No direct effect; invoked business Services own any model-visible result.
+
+## Known Limitations and Deferred Work
+
+- The Connection adapter maps ordinary dispatch failures and business exceptions to the RPC `internal` code with empty details; lookup-policy errors carried by `TypertLookupFailure` are returned unchanged. Structured `TypertGatewayError` categories remain available only to same-process callers.
+- SRC mode supports unique identifier parameters without destructuring, defaults, or rest parameters. It validates JSON safety rather than generated business types and never infers optional fields.
+- Only strict generated contributions can mount on the Client face. SRC markers have no Client codec or type projection.
+- The package dispatches unary methods only. Incremental Session data uses a separate named-stream protocol over the same Connection.
+- Lookup resolvers are configured per key; an individual Remote parameter or endpoint cannot currently select a live-only policy under the same `agent`/`session` key.
+- Forwarded events reach `$on` exactly as the Host emitted them: no payload projection or redaction, no Scope-bound subscription, and no replay after a reconnect.

package/README.zh.md

@@ -0,0 +1,42 @@
+# @stackstackstack/dsh-api-gateway
+
+[English](README.md) | 中文
+
+为 Host 与 Client 两侧的 Cordis 环境提供 Typert RPC endpoint。Host 入口提供 `ctx.typertGateway`，`@stackstackstack/dsh-api-gateway/client` 则提供 `ctx.remote`；两者使用同一份生成的 `InvocationDescriptor` 约定，并将业务选择交给 API Remotes，将传输、请求关联、信任和响应封装交给 Connection。
+
+## Host 服务：`TypertGatewayService`（ctx key：`typertGateway`）
+
+每次调用时，`ctx.typertGateway.invoke()` 都会解析当前的描述符和 Cordis 服务，校验具名参数是否完全匹配，解析已注册的对象或 Context 身份标识，调用公开的业务方法，并校验其结果。业务服务继承 [`dsh-typert-protocol`](../../typert/protocol/README.md) 的 `TypertRemoteService`，并用 `@Remote` 或 `@RemoteScope` 标记方法；已有其他基类时仍可改用 `bindTypertRemote()`。
+
+严格模式从 `ctx.typert.local` 读取生成的调用描述符。查找参数使用 `ctx.typert.lookups` 中当前有效的 resolver：业务包注册稳定声明与默认策略，Host 组合可用 effect-scoped `configure()` 覆盖解析行为；`@RemoteScope` 则通过已注册的 Host Context 提供方解析其接收者。SRC 模式是开发阶段的回退路径，适用于从未具备严格定义的端点；它解析简单参数名，并且只允许非查找参数使用可安全表示为 JSON 的值。已观测到的严格定义一旦撤回，系统会直接报错，而不会降低校验强度。
+
+Connection 可用时，Host 入口会在 Connection 共享的 `/api` FetchHandler 上注册 trusted-host interceptor。Connection 把这个复合 handler 交给 HTTP bridge；handler 将已认领 endpoint 分发给 Gateway，未认领 endpoint 则交给 API Proxy。直接调用 `invoke()` 会保留业务错误；`TypertGatewayError` 可区分分发、绑定、提供方、查找、Context、参数和编解码器各自负责的故障。resolver 可以用 `TypertLookupFailure` 携带既有 RPC error，使冷恢复失败或 ownership fence 等策略拒绝保持原错误码。
+
+支持取消的 Remote 方法会把 `signal: AbortSignal` 声明为最后一个 Host 参数。signal 是 descriptor 元数据，而不是 wire 参数：Connection 将它提供给 Gateway，Gateway 则在已解码的业务参数之后注入它。SRC 识别这个保留的末位参数名，严格生成还要求它具有全局 `AbortSignal` 类型。
+
+## Client 服务：`ClientRemote`（ctx key：`remote`）
+
+`ctx.remote.$mount()` 会校验并注册生成的 Host-for-Client 贡献项，然后为发起调用的 Cordis fiber 安装具体的直接方法和作用域方法。每个 namespace 都是可追踪的 `remote.<namespace>` 子 Service，并在最后一个方法撤回后卸载。重复端点、命名空间冲突，以及缺少生成的严格编解码器的描述符，都会在方法可调用前报错。
+
+每次调用都会校验位置参数，构造与描述符完全匹配的具名 `args`，再通过 `ctx.connection.rpc.call('/api', endpoint, ...)` 发送。生成的支持取消的方法接受最后一个可选 `AbortSignal`；Client 会在调用 Connection 前将它与贡献项的挂载生命周期合并。返回值经过校验后才会交给应用代码。撤回贡献项会同时移除其描述符和方法、中止正在进行的调用，并使外部仍持有的方法句柄在调用时返回拒绝。
+
+`ctx.remote.$on()` 订阅一条被转发的 Host 事件。它的合法键恰好等于 Host 装配声明的转发选择，listener 类型就是事件所属包自己的 Cordis `Events` 声明，因此不存在会与之漂移的第二份签名。每个订阅归属发起调用的 fiber，并随该 fiber 一起消失。投递是单向的，并按注册顺序进行；抛错的 listener 会被记录并与其余 listener 隔离，绝不影响帧泵。`ctx.remote.$dispatch()` 是该面的另一半，且属于载体：持有 Host 帧 sink 的 Client 半把每个解码后的帧交进来，收到无人订阅的事件名即丢弃，因为 wire 上出现什么取决于 Host 的转发选择。消费方只订阅，绝不调用它。
+
+生成的声明合并通过共享的 `TypertClientRemote` 约定提供 TypeScript API。Client 入口不包含 Host 服务或 Host Cordis 接口合并；方法查找和调用使用普通对象与函数，而不使用 JavaScript Proxy。
+
+## 模型体验
+
+无，因为该包分发应用调用，不注册任何提示词、工具或会话事件。
+
+#### KV Cache 影响
+
+无直接影响；被调用的业务服务负责产生任何模型可见结果。
+
+## 已知限制与延期工作
+
+- Connection 适配器将普通分发故障和业务异常映射为 RPC 的 `internal` 代码，且不附带详细信息；`TypertLookupFailure` 携带的 lookup 策略错误会原样返回。结构化的 `TypertGatewayError` 类别仅供同进程调用方使用。
+- SRC 模式仅支持名称唯一的标识符参数，不支持解构、默认值或剩余参数。它只校验值能否安全表示为 JSON，不校验生成的业务类型，也绝不会推断可选字段。
+- Client 侧只能挂载严格模式生成的贡献项。SRC 标记不具备 Client 编解码器或类型投影。
+- 该包只分发一元方法。增量会话数据通过同一个 Connection 上独立的具名流协议传输。
+- lookup resolver 按 key 配置；当前无法让单个 Remote 参数或 endpoint 在同一 `agent`/`session` key 下选择 live-only 策略。
+- 被转发的事件原样到达 `$on`：没有载荷投影或脱敏，不支持 Scope 化订阅，重连后也不重放。

package/lib/client.js

@@ -0,0 +1,420 @@
+window.__ModuleLoader__.load({
+	id: "@stackstackstack/dsh-api-gateway",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let _deepseek_ai_cordis = require("@deepseek-ai/cordis");
+		//#region lib/types/client/index.js
+		/**
+		* Client projection of generated Typert Remote descriptors. Contributions
+		* install traced `remote.<namespace>` services; no JavaScript Proxy
+		* participates in method lookup, invocation, or type exposure.
+		*/
+		/** Required Client services: the Typert registry and the existing Connection carrier. */
+		const inject = ["typert", "connection"];
+		/**
+		* Install the typed Client Remote service.
+		* @param ctx - Client Cordis root.
+		*/
+		function apply(ctx) {
+			new ClientRemoteService(ctx);
+		}
+		var ClientRemoteService = class extends _deepseek_ai_cordis.Service {
+			ownerCtx;
+			namespaces = /* @__PURE__ */ new Map();
+			subscriptions = /* @__PURE__ */ new Map();
+			mutations = Promise.resolve();
+			constructor(ctx) {
+				super(ctx, "remote");
+				this.ownerCtx = ctx;
+				ctx.effect(() => () => {
+					this.subscriptions.clear();
+				}, "api-gateway.client.subscriptions");
+			}
+			async $mount(contribution) {
+				const callerCtx = this.ctx;
+				const owned = callerCtx.effect(async () => {
+					const dispose = await this.enqueue(() => this.mountContribution(callerCtx, contribution));
+					return () => this.enqueue(dispose);
+				}, `api-gateway.client.$mount(${JSON.stringify(contribution.package)})`);
+				await owned;
+				return async () => {
+					await owned();
+				};
+			}
+			$on(event, listener) {
+				const subscription = { listener };
+				const owned = this.ctx.effect(() => {
+					const listeners = this.listeners(event);
+					listeners.push(subscription);
+					return () => {
+						const at = listeners.indexOf(subscription);
+						/* v8 ignore next -- listener */
+						if (at >= 0) listeners.splice(at, 1);
+					};
+				}, `api-gateway.client.$on(${JSON.stringify(event)})`);
+				return () => {
+					owned();
+				};
+			}
+			/**
+			* Deliver one forwarded event in registration order, isolating a listener
+			* that fails either synchronously or by rejecting a returned promise; see
+			* {@link TypertClientRemote.$dispatch} for the caller contract.
+			*/
+			$dispatch(event, args) {
+				const listeners = this.subscriptions.get(event);
+				if (listeners === void 0) return;
+				for (const { listener } of [...listeners]) {
+					const report = (error) => {
+						console.error(`client api: Remote event ${JSON.stringify(event)} listener threw:`, error);
+					};
+					try {
+						const settled = listener(...args);
+						if (settled instanceof Promise) settled.catch(report);
+					} catch (error) {
+						report(error);
+					}
+				}
+			}
+			/** Subscriptions for one event name; empty arrays are retained, bounded by the Host's selection. */
+			listeners(event) {
+				let listeners = this.subscriptions.get(event);
+				if (listeners === void 0) {
+					listeners = [];
+					this.subscriptions.set(event, listeners);
+				}
+				return listeners;
+			}
+			enqueue(operation) {
+				const result = this.mutations.then(operation, operation);
+				this.mutations = result.then(() => void 0, () => void 0);
+				return result;
+			}
+			async mountContribution(callerCtx, contribution) {
+				this.validateContribution(contribution);
+				const disposeRemote = callerCtx.typert.remotes.register(contribution);
+				const installed = [];
+				try {
+					for (const descriptor of contribution.descriptors) installed.push(await this.install(descriptor));
+				} catch (error) {
+					for (const dispose of installed.reverse()) await dispose();
+					await disposeRemote();
+					throw error;
+				}
+				return async () => {
+					for (const dispose of installed.reverse()) await dispose();
+					await disposeRemote();
+				};
+			}
+			validateContribution(contribution) {
+				const direct = /* @__PURE__ */ new Map();
+				const scoped = /* @__PURE__ */ new Map();
+				const add = (table, descriptor, kind) => {
+					const methods = table.get(descriptor.namespace) ?? /* @__PURE__ */ new Set();
+					if (methods.has(descriptor.method)) throw new Error(`client api: contribution repeats ${kind} method ${endpointOf(descriptor)}`);
+					methods.add(descriptor.method);
+					table.set(descriptor.namespace, methods);
+					if ((this.namespaces.get(descriptor.namespace)?.service)?.has(kind, descriptor.method) === true) throw new Error(`client api: ${kind} method ${endpointOf(descriptor)} is already mounted`);
+				};
+				for (const descriptor of contribution.descriptors) {
+					requireStrictDescriptor(descriptor);
+					if (descriptor.invocation.kind === "direct") add(direct, descriptor, "direct");
+					if (scopedProjection(descriptor) !== void 0) add(scoped, descriptor, "scoped");
+				}
+				const namespaces = new Set([...direct.keys(), ...scoped.keys()]);
+				for (const namespace of namespaces) {
+					const service = this.namespaces.get(namespace)?.service;
+					if (service === void 0) {
+						if (namespace in this) throw new Error(`client api: namespace ${JSON.stringify(namespace)} conflicts with the Remote service`);
+						const serviceKey = remoteServiceKey(namespace);
+						if (this.ownerCtx.reflect.props[serviceKey]?.type === "accessor" || this.ownerCtx.get(serviceKey) !== void 0) throw new Error(`client api: namespace ${JSON.stringify(namespace)} conflicts with an existing Remote namespace`);
+					}
+					for (const method of new Set([...direct.get(namespace) ?? [], ...scoped.get(namespace) ?? []])) if (service === void 0) RemoteNamespaceService.assertMethodAvailable(namespace, method);
+					else service.assertMethodAvailable(method);
+				}
+			}
+			async install(descriptor) {
+				const token = {
+					active: true,
+					abort: new AbortController()
+				};
+				const installed = [];
+				try {
+					if (descriptor.invocation.kind === "direct") installed.push(await this.installDirect(descriptor, token));
+					const projection = scopedProjection(descriptor);
+					if (projection !== void 0) installed.push(await this.installScoped(descriptor, projection, token));
+				} catch (error) {
+					token.active = false;
+					token.abort.abort();
+					for (const dispose of installed.reverse()) await dispose();
+					throw error;
+				}
+				return async () => {
+					/* v8 ignore next -- Cordis effect disposers are idempotent and invoke this cleanup at most once. */
+					if (!token.active) return;
+					token.active = false;
+					token.abort.abort();
+					for (const dispose of installed.reverse()) await dispose();
+				};
+			}
+			async installDirect(descriptor, token) {
+				const namespace = await this.namespace(descriptor.namespace);
+				try {
+					namespace.service.installDirect(descriptor, token);
+				} catch (error) {
+					await this.disposeNamespace(descriptor.namespace, namespace);
+					throw error;
+				}
+				return async () => {
+					namespace.service.remove("direct", descriptor.method, token);
+					await this.disposeNamespace(descriptor.namespace, namespace);
+				};
+			}
+			async installScoped(descriptor, projection, token) {
+				const namespace = await this.namespace(descriptor.namespace);
+				try {
+					namespace.service.installScoped(descriptor, projection, token);
+				} catch (error) {
+					await this.disposeNamespace(descriptor.namespace, namespace);
+					throw error;
+				}
+				return async () => {
+					namespace.service.remove("scoped", descriptor.method, token);
+					await this.disposeNamespace(descriptor.namespace, namespace);
+				};
+			}
+			async namespace(name) {
+				let namespace = this.namespaces.get(name);
+				if (namespace !== void 0) return namespace;
+				let service;
+				const fiber = this.ownerCtx.plugin({
+					name: remoteServiceKey(name),
+					apply: (ctx) => {
+						service = new RemoteNamespaceService(ctx, name, (direct, scoped, caller, args) => this.invokeMethod(direct, scoped, caller, args));
+					}
+				});
+				try {
+					await fiber;
+				} catch (error) {
+					await fiber.dispose();
+					throw error;
+				}
+				/* v8 ignore next -- a settled namespace fiber synchronously constructs its Service. */
+				if (service === void 0) throw new Error(`client api: namespace ${JSON.stringify(name)} did not start`);
+				namespace = {
+					service,
+					dispose: fiber.dispose
+				};
+				this.namespaces.set(name, namespace);
+				return namespace;
+			}
+			async disposeNamespace(name, namespace) {
+				if (!namespace.service.empty || this.namespaces.get(name) !== namespace) return;
+				this.namespaces.delete(name);
+				await namespace.dispose();
+			}
+			invokeMethod(direct, scoped, callerCtx, values) {
+				if (scoped !== void 0) {
+					const identity = this.ownerCtx.typert.contexts.getClient(scoped.projection.context)?.identity(callerCtx);
+					if (identity !== void 0) return this.invoke(scoped.descriptor, scoped.projection, scoped.token, callerCtx, values, { value: identity });
+				}
+				if (direct !== void 0) return this.invoke(direct.descriptor, void 0, direct.token, callerCtx, values);
+				if (scoped !== void 0) return this.invoke(scoped.descriptor, scoped.projection, scoped.token, callerCtx, values);
+				throw new Error("client api: Remote method is no longer mounted");
+			}
+			async invoke(descriptor, projection, token, callerCtx, values, boundIdentity) {
+				const endpoint = endpointOf(descriptor);
+				if (!token.active) return withdrawn(endpoint);
+				const expected = descriptor.parameters.length - (projection?.parameterIndex === void 0 ? 0 : 1);
+				const hasCallerSignal = descriptor.cancellation !== void 0 && values.length === expected + 1;
+				if (values.length !== expected && !hasCallerSignal) {
+					const contract = descriptor.cancellation === void 0 ? `${String(expected)} argument(s)` : `${String(expected)} business argument(s) plus an optional AbortSignal`;
+					throw new Error(`client api: ${endpoint} expected ${contract}, got ${String(values.length)}`);
+				}
+				const args = Object.create(null);
+				if (projection !== void 0) {
+					const binder = boundIdentity === void 0 ? this.ownerCtx.typert.contexts.getClient(projection.context) : void 0;
+					if (boundIdentity === void 0 && binder === void 0) throw new Error(`client api: ${endpoint} has no Client Context binder for ${JSON.stringify(projection.context)}`);
+					const identity = boundIdentity === void 0 ? binder?.identity(callerCtx) : boundIdentity.value;
+					if (identity === void 0) throw new Error(`client api: ${endpoint} requires a ${JSON.stringify(projection.context)} Context`);
+					args[projection.wire] = parse(projection.codec, identity, endpoint, projection.wire);
+				}
+				let valueIndex = 0;
+				descriptor.parameters.forEach((parameter, parameterIndex) => {
+					if (parameterIndex === projection?.parameterIndex) return;
+					const value = parse(parameter.codec, values[valueIndex], endpoint, parameter.wire);
+					if (value !== void 0) args[parameter.wire] = value;
+					valueIndex += 1;
+				});
+				const connection = this.ownerCtx.get("connection");
+				if (connection === void 0) throw new Error(`client api: ${endpoint} has no active Connection`);
+				const callerSignal = hasCallerSignal ? values[expected] : void 0;
+				const signal = callerSignal === void 0 ? token.abort.signal : AbortSignal.any([token.abort.signal, callerSignal]);
+				try {
+					const result = await connection.rpc.call("/api", endpoint, { args }, signal);
+					if (!mountActive(token)) return withdrawn(endpoint);
+					if (!result.ok) return {
+						ok: false,
+						error: result.error
+					};
+					return {
+						ok: true,
+						value: parse(descriptor.result, result.value, endpoint, "result")
+					};
+				} catch (error) {
+					return carrierFailure(endpoint, error);
+				}
+			}
+		};
+		var RemoteNamespaceService = class RemoteNamespaceService extends _deepseek_ai_cordis.Service {
+			invokeRemote;
+			methods = /* @__PURE__ */ new Map();
+			namespace;
+			static assertMethodAvailable(namespace, method) {
+				if (REMOTE_NAMESPACE_FIELDS.has(method) || method in RemoteNamespaceService.prototype) throw new Error(`client api: method ${JSON.stringify(`${namespace}/${method}`)} conflicts with its namespace service`);
+			}
+			constructor(ctx, name, invokeRemote) {
+				super(ctx, remoteServiceKey(name));
+				this.invokeRemote = invokeRemote;
+				this.namespace = name;
+			}
+			assertMethodAvailable(method) {
+				RemoteNamespaceService.assertMethodAvailable(this.namespace, method);
+				if (method in this && !this.methods.has(method)) throw new Error(`client api: method ${JSON.stringify(`${this.namespace}/${method}`)} conflicts with its namespace service`);
+			}
+			get empty() {
+				return this.methods.size === 0;
+			}
+			has(kind, method) {
+				return this.methods.get(method)?.[kind] !== void 0;
+			}
+			installDirect(descriptor, token) {
+				this.install(descriptor.method, "direct", {
+					descriptor,
+					token
+				});
+			}
+			installScoped(descriptor, projection, token) {
+				this.install(descriptor.method, "scoped", {
+					descriptor,
+					projection,
+					token
+				});
+			}
+			install(method, kind, value) {
+				this.assertMethodAvailable(method);
+				let record = this.methods.get(method);
+				const fresh = record === void 0;
+				record ??= {};
+				if (fresh) {
+					Object.defineProperty(this, method, {
+						configurable: true,
+						enumerable: true,
+						get: function() {
+							const callerCtx = this.ctx;
+							const current = this.methods.get(method);
+							const direct = current?.direct;
+							const scoped = current?.scoped;
+							return (...args) => {
+								return this.invokeRemote(direct, scoped, callerCtx, args);
+							};
+						}
+					});
+					this.methods.set(method, record);
+				}
+				if (kind === "direct") record.direct = value;
+				else record.scoped = value;
+			}
+			remove(kind, method, token) {
+				const record = this.methods.get(method);
+				const current = record?.[kind];
+				/* v8 ignore next -- duplicate live variants are rejected before installation, so no newer token can replace this one. */
+				if (record === void 0 || current?.token !== token) return;
+				if (kind === "direct") delete record.direct;
+				else delete record.scoped;
+				if (record.direct !== void 0 || record.scoped !== void 0) return;
+				this.methods.delete(method);
+				Reflect.deleteProperty(this, method);
+			}
+		};
+		const REMOTE_NAMESPACE_FIELDS = new Set([
+			"ctx",
+			"empty",
+			"invokeRemote",
+			"methods",
+			"name",
+			"namespace"
+		]);
+		function remoteServiceKey(namespace) {
+			return `remote.${namespace}`;
+		}
+		function endpointOf(descriptor) {
+			return `${descriptor.namespace}/${descriptor.method}`;
+		}
+		function mountActive(token) {
+			return token.active;
+		}
+		function scopedProjection(descriptor) {
+			if (descriptor.invocation.kind === "context") return {
+				context: descriptor.invocation.context,
+				wire: descriptor.invocation.wire,
+				codec: descriptor.invocation.codec
+			};
+			if (descriptor.scope === void 0) return void 0;
+			const lookupParameters = descriptor.parameters.map((parameter, index) => ({
+				parameter,
+				index
+			})).filter((candidate) => candidate.parameter.source === "lookup");
+			const selected = lookupParameters.length === 1 ? lookupParameters[0] : void 0;
+			if (selected === void 0 || selected.parameter.wire !== descriptor.scope.wire || selected.parameter.lookup !== descriptor.scope.context) throw new Error(`client api: generated Remote ${endpointOf(descriptor)} scope must select its only lookup parameter`);
+			return {
+				context: descriptor.scope.context,
+				wire: descriptor.scope.wire,
+				codec: selected.parameter.codec,
+				parameterIndex: selected.index
+			};
+		}
+		function requireStrictDescriptor(descriptor) {
+			const endpoint = endpointOf(descriptor);
+			requireStrictCodec(descriptor.result, endpoint, "result");
+			for (const parameter of descriptor.parameters) requireStrictCodec(parameter.codec, endpoint, parameter.wire);
+			if (descriptor.invocation.kind === "context") requireStrictCodec(descriptor.invocation.codec, endpoint, descriptor.invocation.wire);
+		}
+		function requireStrictCodec(codec, endpoint, field) {
+			if (codec.mode !== "strict") throw new Error(`client api: generated Remote ${endpoint} field ${JSON.stringify(field)} has no strict codec`);
+		}
+		function parse(codec, value, endpoint, field) {
+			if (codec.mode !== "strict") throw new Error(`client api: generated Remote ${endpoint} field ${JSON.stringify(field)} has no strict codec`);
+			try {
+				return codec.schema.parse(value);
+			} catch (cause) {
+				throw new Error(`client api: ${endpoint} rejected ${JSON.stringify(field)}`, { cause });
+			}
+		}
+		/** The namespace retired before or during the call, so no request outcome exists. */
+		function withdrawn(endpoint) {
+			return internalFailure(`client api: Remote method ${endpoint} is no longer mounted`);
+		}
+		function carrierFailure(endpoint, error) {
+			return internalFailure(`client api: ${endpoint} failed: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		function internalFailure(message) {
+			return {
+				ok: false,
+				error: {
+					code: "internal",
+					message,
+					details: {}
+				}
+			};
+		}
+		//#endregion
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map