@deepseek-ai/dsh-api-remotes 0.0.1-rc.1 → 0.0.1-rc.2

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/api/remotes/README.md
-README.md: 3d9de0955faefe37c95ff8bb792d57c4fa1f1a3a
-README.zh.md: 12add6f8efc5b6af3e9b74b26a1abb2bb3936e0a
+README.md: cc903af7204ca715c6c7931cfe44823d4d5fc71e
+README.zh.md: fe34b8774c9864cef442ff8a58f22f541d40768a

package/README.md

@@ -6,21 +6,29 @@ Two-sided BFF for Host Remote capabilities selected by this application. The Hos
 
 `createApiRemoteAgentResolver()` reuses live Agents, resumes ordinary cold sessions, deduplicates concurrent resumes, preserves the subagent ownership fence, and configures the same resolver for TypeRT `agent` and `session` lookups. The standard Web API Proxy supplies its Agent defaults and scope setup, then uses the returned resolver for legacy methods, so migrated and unmigrated methods share one policy implementation.
 
-The current Client assembly mounts only the Goal Remote contribution. Cordis effect ownership withdraws every contribution when this assembly unloads, while `@deepseek-ai/dsh-api-gateway/client` owns descriptor validation, traced namespace Services, direct and scoped methods, invocation, and cancellation. The Client entry consumes the shared `TypeRTClientRemote` interface through Cordis and does not import the concrete Gateway.
+The current Client assembly mounts only the Goal Remote contribution. Cordis effect ownership withdraws every contribution when this assembly unloads, while `@deepseek-ai/dsh-api-gateway/client` owns descriptor validation, traced namespace Services, direct and scoped methods, invocation, and cancellation. The Client entry consumes the shared `TypeRTClientRemote` interface through Cordis and does not import the concrete Gateway. It re-exports the Gateway Client face's declaration merges type-only, so a consumer reaching the forwarded-event vocabulary through this facade gains no runtime edge to the Gateway implementation.
 
 This package contains no transport or Host service discovery logic. Its Client face can be reused by Web or a future TUI that provides the same React-free `ctx.remote` contract.
 
+## Forwarded Host events
+
+`src/remote-events.ts` holds `API_REMOTE_FORWARDED_EVENTS`, the allowlist of Host cordis events this application forwards to consumers verbatim — no projection, no redaction, no renaming — and therefore the legal key set of `ctx.remote.$on`; the type-only `src/types.ts` derives its selection face. Forwarding one more event is an entry in that array and nothing else: the type projection, the consumer key face, and the Host forwarding loop all derive from it.
+
+The listener signature is not restated here. Each allowlisted event's cordis `Events` declaration lives in its owner package's client-safe `./types` export (`dsh-agent-presets`, `dsh-commands`, `dsh-credentials`, `dsh-llm`, `dsh-settings`), and both faces of this package pull those declarations in, so "forwarded verbatim" holds by construction rather than by proof. The Host face additionally asserts the list against `TypeRTForwardableEvent`, which rejects a name that is not a declared event, one that binds an AgentScope, and one whose shape is not one-way.
+
 ## Build boundary
 
 An ordinary repository package belongs to one TypeScript face: Host packages are registered in the root `tsconfig.host.json`, and Client packages in the root `tsconfig.client.json`. `api-remotes` is the only deliberate exception because its Host entry must participate in the Host TypeRT graph, while `src/client/index.ts` cannot compile until Host tsdown has generated the business packages' `/remote` declarations.
 
-This package's root `tsconfig.json` is only a solution that references `tsconfig.host.json` and `tsconfig.client.json`. The Host aggregate and direct Host consumers reference the former, while the Client aggregate and direct Client consumers reference the latter; the package-root solution must not enter either aggregate's dependency graph. The two projects own disjoint source files and `.tsbuildinfo` files but share the `lib/types` output directory.
+This package's root `tsconfig.json` is only a solution that references `tsconfig.host.json` and `tsconfig.client.json`. The Host aggregate and direct Host consumers reference the former, while the Client aggregate and direct Client consumers reference the latter; the package-root solution must not enter either aggregate's dependency graph. The two projects own disjoint source files and `.tsbuildinfo` files but share the `lib/types` output directory, with one deliberate exception: `src/remote-events.ts` and `src/types.ts` are listed in BOTH faces' `files`, because the forwarded-event allowlist is the single control point over what a consumer can receive, and the Host forwarding loop and the Client `ctx.remote.$on` key face must read one declaration rather than two that could drift.
+
+That exception is not just a `files` entry. The root `tsconfig.base.json` maps `@deepseek-ai/dsh-api-remotes/types` to `src/types.ts` — the source plane, like every other workspace subpath and unlike the generated `/remote` artifacts, which have no `paths` entry and resolve through `exports` to built output. Both faces therefore admit the same allowlist and type projection into their own programs and emit byte-identical `remote-events` and `types` outputs into `lib/types`; the `.tsbuildinfo` files stay independent. No gate enforces the faces' source-file disjointness — `scripts/project-reference-faces.ts` only checks that a reference into a split project names the matching face — so this paragraph records why the double listing is intentional.
 
 The package-local `clientBundle(..., { hostPhase: true })` makes Host tsdown bundle the Host entry and the later Client tsdown bundle only the browser entry. Ordinary Client plugins remain single Client projects and produce both their Node loader entry and browser bundle during Client tsdown; do not copy this package's split merely because a package has both `src/index.ts` and `src/client/index.ts`.
 
 ## Model Experience
 
-None, as this BFF selects Remote application methods and identity policy but registers no model surface.
+None, as this BFF selects Remote application methods and identity policy but registers nothing model-facing.
 
 #### KV Cache effect
 

package/README.zh.md

@@ -6,15 +6,25 @@
 
 `createApiRemoteAgentResolver()` 会复用 live Agent、恢复普通冷会话、对并发恢复去重、保留 subagent ownership fence，并为 TypeRT `agent` 和 `session` lookup 配置同一个 resolver。标准 Web API Proxy 提供 Agent 默认值和 scope 设置，再将返回的 resolver 用于旧方法，使已迁移与未迁移方法共用同一份策略实现。
 
-当前 Client 组合仅挂载 Goal Remote 贡献。该组合卸载时，Cordis effect 的所有权机制会撤回所有贡献；`@deepseek-ai/dsh-api-gateway/client` 负责描述符校验、可追踪 namespace Service、直接与作用域方法、调用与取消。Client 入口通过 Cordis 消费共享的 `TypeRTClientRemote` 接口，不导入具体 Gateway。
+当前 Client 组合仅挂载 Goal Remote 贡献。该组合卸载时，Cordis effect 的所有权机制会撤回所有贡献；`@deepseek-ai/dsh-api-gateway/client` 负责描述符校验、可追踪 namespace Service、直接与作用域方法、调用与取消。Client 入口通过 Cordis 消费共享的 `TypeRTClientRemote` 接口，不导入具体 Gateway；它只以 type-only 形式重新导出 Gateway Client face 的声明合并，因此消费端经由本外观取到转发事件词汇时，运行时不会多出一条通往 Gateway 实现的边。
+
 
 本包不包含传输逻辑或 Host 服务发现逻辑。Web 或未来的 TUI 只要提供同一份不依赖 React 的 `ctx.remote` 约定，均可复用其 Client face。
 
+## 转发的 Host 事件
+
+`src/remote-events.ts` 持有 `API_REMOTE_FORWARDED_EVENTS`——本应用原样转发给消费端的 Host cordis 事件名单（无投影、无脱敏、无改名），它同时就是 `ctx.remote.$on` 的合法键集；只含类型的 `src/types.ts` 派生其选择面。多转发一个事件只需在该数组里加一行：类型投影、消费端键面与 Host 转发循环全部由它派生。
+
+监听器签名不在此处重写。名单内每条事件的 cordis `Events` 声明都住在其 owner 包 client-safe 的 `./types` 出口（`dsh-agent-presets`、`dsh-commands`、`dsh-credentials`、`dsh-llm`、`dsh-settings`），本包两个 face 都把那些声明纳入编译面，因此「原样转发」是构造性成立的，不需要另立证明。Host face 还额外把名单断言给 `TypeRTForwardableEvent`：未声明的事件名、绑定 AgentScope 的事件、以及形状不是单向的事件都会在此被拒绝。
+
 ## 构建边界
 
 仓库中的普通包只属于一个 TypeScript face：Host 包登记在根 `tsconfig.host.json`，Client 包登记在根 `tsconfig.client.json`。`api-remotes` 是唯一刻意拆分的特例，因为它的 Host 入口要参与 Host TypeRT 图，而 `src/client/index.ts` 必须等 Host tsdown 生成业务包的 `/remote` 声明后才能编译。
 
-本包根 `tsconfig.json` 只是引用 `tsconfig.host.json` 与 `tsconfig.client.json` 的 solution。Host aggregate 和 Host 直接消费方引用前者，Client aggregate 和 Client 直接消费方引用后者；禁止把包根 solution 放进任一 aggregate 的依赖图。两个 project 拥有互不重叠的源码和 `.tsbuildinfo`，但共享 `lib/types` 输出目录。
+本包根 `tsconfig.json` 只是引用 `tsconfig.host.json` 与 `tsconfig.client.json` 的 solution。Host aggregate 和 Host 直接消费方引用前者，Client aggregate 和 Client 直接消费方引用后者；禁止把包根 solution 放进任一 aggregate 的依赖图。两个 project 拥有互不重叠的源码和 `.tsbuildinfo`，但共享 `lib/types` 输出目录——只有一处刻意的例外：`src/remote-events.ts` 与 `src/types.ts` **同时**列进两个 face 的 `files`，因为转发事件名单是「消费端能收到什么」的唯一控制点，Host 转发循环与 Client 的 `ctx.remote.$on` 键面必须读同一份声明，而不是两份可能彼此漂移的声明。
+
+这条例外不止是一行 `files`。根 `tsconfig.base.json` 把 `@deepseek-ai/dsh-api-remotes/types` 映射到 `src/types.ts`——**源平面**，与其余所有 workspace 子路径一致，也与生成的 `/remote` 产物相反（后者没有 `paths` 条目，靠 `exports` 命中构建产物）。于是两个 face 都把同一份名单与类型投影收进各自的 program，并向 `lib/types` 发射逐字相同的 `remote-events` 与 `types` 输出；`.tsbuildinfo` 仍各自独立。没有任何门禁强制两个 face 的源文件互不重叠——`scripts/project-reference-faces.ts` 只校验「引用一个 split project 必须指到对应 face」——因此本段记录这次双列为何是有意的。
+
 
 包内 `clientBundle(..., { hostPhase: true })` 让 Host tsdown 打包 Host 入口，让后续 Client tsdown 只打包 browser 入口。普通 Client 插件仍使用单一 Client project，并在 Client tsdown 阶段一起生成 Node loader 入口和 browser bundle；不得因一个包同时存在 `src/index.ts` 与 `src/client/index.ts` 就复制本包的拆分。
 

package/lib/index.js

@@ -1,4 +1,28 @@
 import { TypeRTLookupFailure } from "@deepseek-ai/dsh-type-meta";
+//#region lib/types/remote-events.js
+/**
+* The one home of this application's forwarded-Host-event allowlist. Both
+* compiler faces list this file, so the Host forwarding loop and the consumer
+* `ctx.remote.$on` key face read one declaration instead of two copies that
+* could drift; `./types.ts` derives the type projection from it and stays
+* type-only.
+*/
+/**
+* Host events this application forwards to consumers verbatim: no projection,
+* no redaction, no renaming. The wire name is the Host cordis event name and
+* the payload is its argument list, so this array is simultaneously the whole
+* control point over what a consumer can receive and the legal key set of
+* `ctx.remote.$on`. Forwarding one more event is an entry here and nothing
+* else.
+*/
+const API_REMOTE_FORWARDED_EVENTS = [
+	"agent-preset/selected",
+	"commands/change",
+	"credentials/updated",
+	"llm/adapters-updated",
+	"settings/document-updated"
+];
+//#endregion
 //#region lib/types/agent-lookup.js
 /** Host BFF policy for resolving Remote Agent and Session identities. */
 /** Cold identity absent from the durable session store. */
@@ -139,4 +163,4 @@ function createApiRemoteAgentResolver(ctx, options) {
 /** Host plugin body; the selected contributions mount only in Client environments. */
 function apply() {}
 //#endregion
-export { ApiRemoteSessionNotFound, ApiRemoteSubagentSessionOwnership, apiRemoteSubagentOwnershipError, apply, createApiRemoteAgentResolver, hasApiRemoteSubagentOwner, inspectApiRemoteSession };
+export { API_REMOTE_FORWARDED_EVENTS, ApiRemoteSessionNotFound, ApiRemoteSubagentSessionOwnership, apiRemoteSubagentOwnershipError, apply, createApiRemoteAgentResolver, hasApiRemoteSubagentOwner, inspectApiRemoteSession };

package/lib/types/agent-lookup.js

@@ -0,0 +1,166 @@
+/** Host BFF policy for resolving Remote Agent and Session identities. */
+import { TypeRTLookupFailure } from '@deepseek-ai/dsh-type-meta';
+/** Cold identity absent from the durable session store. */
+export class ApiRemoteSessionNotFound extends Error {
+}
+/** Session identity whose lifecycle belongs to subagent routing. */
+export class ApiRemoteSubagentSessionOwnership extends Error {
+    sessionId;
+    /**
+     * Construct the ownership fence.
+     * @param sessionId - identity reserved to subagent routing.
+     */
+    constructor(sessionId) {
+        super(`session "${sessionId}" is a subagent session; use subagent delivery`);
+        this.sessionId = sessionId;
+    }
+}
+/**
+ * Test whether generic Host routing must leave an identity to subagent routing.
+ * @param ctx - Host Context carrying the live Agent registry.
+ * @param session - attached or live Session metadata.
+ * @param agent - live Agent when one is registered.
+ * @returns whether generic Remote and legacy API calls must reject the identity.
+ */
+export function hasApiRemoteSubagentOwner(ctx, session, agent) {
+    if (session.header.origin === 'subagent')
+        return true;
+    const parentId = session.header.parentSession;
+    if (parentId === undefined || agent === undefined)
+        return false;
+    const parent = ctx.agents.get(parentId);
+    return parent !== undefined && ctx.agents.isOwnedBy(agent.id, parent);
+}
+/**
+ * Build the stable caller-facing ownership rejection.
+ * @param sessionId - identity reserved to subagent routing.
+ * @returns the existing `agent-busy` RPC shape.
+ */
+export function apiRemoteSubagentOwnershipError(sessionId) {
+    return {
+        code: 'agent-busy',
+        message: `session "${sessionId}" is owned by subagent routing`,
+        details: { reason: 'use subagent delivery for this child session' },
+    };
+}
+/**
+ * Inspect one cold served session without repairing, resuming, or publishing it.
+ * @param ctx - Host Context carrying the optional persistence provider.
+ * @param sessionId - durable identity to inspect.
+ * @returns detached metadata and events for a servable session.
+ * @throws {@link ApiRemoteSessionNotFound} when the identity has no project-backed session.
+ */
+export async function inspectApiRemoteSession(ctx, sessionId) {
+    const persistence = ctx.get('sessionPersistence');
+    if (persistence === undefined) {
+        throw new Error('session persistence is not configured (load a dsh-session-persistence backend)');
+    }
+    const meta = (await persistence.list()).find(candidate => candidate.id === sessionId);
+    if (meta === undefined || meta.cwd === undefined) {
+        throw new ApiRemoteSessionNotFound(`session "${sessionId}" not found`);
+    }
+    const inspected = await persistence.inspect(sessionId);
+    if (inspected.meta.cwd === undefined) {
+        throw new ApiRemoteSessionNotFound(`session "${sessionId}" not found`);
+    }
+    return { meta: inspected.meta, events: [...inspected.events] };
+}
+/**
+ * Create the Host's shared Agent resolver and configure Agent/Session TypeRT lookups.
+ * Live Agents are reused, ordinary cold sessions resume once per identity, and
+ * subagent-owned identities retain the legacy `agent-busy` fence.
+ * @param ctx - owning Host Context.
+ * @param options - defaults and Agent-scope setup used only for cold resume.
+ * @returns resolver shared by legacy API Proxy methods and TypeRT lookups.
+ */
+export function createApiRemoteAgentResolver(ctx, options) {
+    const resumes = new Map();
+    const fencedLiveAgent = (sessionId) => {
+        const live = ctx.agents.get(sessionId);
+        if (live === undefined)
+            return undefined;
+        if (hasApiRemoteSubagentOwner(ctx, live.session, live)) {
+            return { error: apiRemoteSubagentOwnershipError(sessionId) };
+        }
+        return { agent: live };
+    };
+    const agentFor = async (sessionId) => {
+        const fenced = fencedLiveAgent(sessionId);
+        if (fenced !== undefined)
+            return fenced;
+        const attached = ctx.sessions.get(sessionId);
+        if (attached !== undefined && hasApiRemoteSubagentOwner(ctx, attached, undefined)) {
+            return { error: apiRemoteSubagentOwnershipError(sessionId) };
+        }
+        let resume = resumes.get(sessionId);
+        if (resume === undefined) {
+            resume = (async () => {
+                try {
+                    const inspected = await inspectApiRemoteSession(ctx, sessionId);
+                    if (hasApiRemoteSubagentOwner(ctx, { header: inspected.meta }, undefined)) {
+                        throw new ApiRemoteSubagentSessionOwnership(sessionId);
+                    }
+                    // Built from the inspected session before the published re-checks
+                    // below, so those stay adjacent to `resume` and a Host setup that
+                    // awaits (composing a preset, say) does not widen the collision
+                    // window.
+                    const setup = options.setup === undefined ? undefined : await options.setup(inspected);
+                    const publishedSession = ctx.sessions.get(sessionId);
+                    const publishedAgent = ctx.agents.get(sessionId);
+                    if (publishedSession !== undefined
+                        && hasApiRemoteSubagentOwner(ctx, publishedSession, publishedAgent)) {
+                        throw new ApiRemoteSubagentSessionOwnership(sessionId);
+                    }
+                    const handle = await ctx.agents.resume({
+                        resumeSessionId: sessionId,
+                        ...options.agentOptions === undefined ? {} : { agentOptions: options.agentOptions() },
+                        ...setup === undefined ? {} : { setup },
+                    });
+                    return handle.agent;
+                }
+                finally {
+                    resumes.delete(sessionId);
+                }
+            })();
+            resumes.set(sessionId, resume);
+        }
+        try {
+            return { agent: await resume };
+        }
+        catch (error) {
+            if (error instanceof ApiRemoteSessionNotFound) {
+                return { error: { code: 'session-not-found', message: error.message, details: { sessionId } } };
+            }
+            if (error instanceof ApiRemoteSubagentSessionOwnership) {
+                return { error: apiRemoteSubagentOwnershipError(error.sessionId) };
+            }
+            const fenced = fencedLiveAgent(sessionId);
+            if (fenced !== undefined)
+                return fenced;
+            const attached = ctx.sessions.get(sessionId);
+            if (attached !== undefined && hasApiRemoteSubagentOwner(ctx, attached, undefined)) {
+                return { error: apiRemoteSubagentOwnershipError(sessionId) };
+            }
+            return {
+                error: {
+                    code: 'internal',
+                    message: `resume failed for session "${sessionId}": ${String(error)}`,
+                    details: {},
+                },
+            };
+        }
+    };
+    ctx.inject(['typert'], (typeCtx) => {
+        const resolveAgent = async (sessionId) => {
+            const found = await agentFor(sessionId);
+            if ('error' in found)
+                throw new TypeRTLookupFailure(found.error);
+            return found.agent;
+        };
+        typeCtx.typert.lookups.configure('agent', resolveAgent);
+        typeCtx.typert.lookups.configure('session', async (sessionId) => (await resolveAgent(sessionId)).session);
+        typeCtx.typert.contexts.configureHost('agent', async (sessionId) => (await resolveAgent(sessionId)).ctx);
+    });
+    return agentFor;
+}
+//# sourceMappingURL=agent-lookup.js.map

package/lib/types/client/index.d.ts

@@ -3,6 +3,18 @@ import type { Context } from '@deepseek-ai/cordis';
 import type { TypeRTClientRemote } from '@deepseek-ai/dsh-type-meta';
 export type { TypeRTClientRemote as ClientRemote } from '@deepseek-ai/dsh-type-meta';
 export type {} from '@deepseek-ai/dsh-goal/remote';
+export type { ApiRemoteForwardedEvent } from '../types.ts';
+export type {} from '@deepseek-ai/dsh-commands/types';
+export type {} from '@deepseek-ai/dsh-credentials/types';
+export type {} from '@deepseek-ai/dsh-llm/types';
+export type {} from '@deepseek-ai/dsh-agent-presets/types';
+export type {} from '@deepseek-ai/dsh-settings/types';
+/**
+ * The Gateway Client face's own declaration merges, type-only: `ctx.remote` and
+ * with it the `$on`/`$dispatch` surface. Erased at emit, so this facade still
+ * carries no runtime edge to the Gateway implementation.
+ */
+export type {} from '@deepseek-ai/dsh-api-gateway/client';
 declare module '@deepseek-ai/cordis' {
     interface Context {
         /** Generated Remote namespaces selected by this Client assembly. */

package/lib/types/client/index.js

@@ -0,0 +1,13 @@
+/** Platform-neutral assembly of generated Host Remote contributions. */
+import goalsRemote from '@deepseek-ai/dsh-goal/remote';
+/** Required service: the typed Client Remote contribution mount. */
+export const inject = ['remote'];
+/**
+ * Mount the Host capabilities explicitly selected for this Client assembly.
+ * @param ctx - Client Cordis root carrying the typed API service.
+ * @returns disposer after every selected Remote namespace is ready.
+ */
+export async function apply(ctx) {
+    return await ctx.remote.$mount(goalsRemote);
+}
+//# sourceMappingURL=index.js.map

package/lib/types/index.d.ts

@@ -1,6 +1,8 @@
 /** Host BFF entry and Loader shell for the Remote contribution assembly. */
 export { ApiRemoteSessionNotFound, ApiRemoteSubagentSessionOwnership, apiRemoteSubagentOwnershipError, createApiRemoteAgentResolver, hasApiRemoteSubagentOwner, inspectApiRemoteSession, } from './agent-lookup.ts';
 export type { ApiRemoteAgentOptions, ApiRemoteAgentResult, ApiRemoteLookupError, } from './agent-lookup.ts';
+export { API_REMOTE_FORWARDED_EVENTS } from './remote-events.ts';
+export type { ApiRemoteForwardedEvent } from './types.ts';
 /** Host plugin body; the selected contributions mount only in Client environments. */
 export declare function apply(): void;
 //# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -0,0 +1,16 @@
+/** Host BFF entry and Loader shell for the Remote contribution assembly. */
+import { API_REMOTE_FORWARDED_EVENTS } from "./remote-events.js";
+export { ApiRemoteSessionNotFound, ApiRemoteSubagentSessionOwnership, apiRemoteSubagentOwnershipError, createApiRemoteAgentResolver, hasApiRemoteSubagentOwner, inspectApiRemoteSession, } from "./agent-lookup.js";
+export { API_REMOTE_FORWARDED_EVENTS } from "./remote-events.js";
+// Shape gate over the allowlist, kept in the Host face because the Host's event
+// vocabulary is the authoritative one. It pins three things at compile time:
+// every entry NAMES a declared event (the predicate is keyed on `keyof
+// Events`), no entry BINDS a Scope (a scoped event's `ThisParameterType` is not
+// `unknown`, which is how "must not depend on AgentScope" is stated statically),
+// and every entry is ONE-WAY (a waterfall or bail shape returns something other
+// than void and is excluded). Widening the array to an event that fails any of
+// these fails here, not on the wire.
+API_REMOTE_FORWARDED_EVENTS;
+/** Host plugin body; the selected contributions mount only in Client environments. */
+export function apply() { }
+//# sourceMappingURL=index.js.map

package/lib/types/invariant.js

@@ -0,0 +1,16 @@
+/** Package-owned invariant companion for `@deepseek-ai/dsh-api-remotes`. */
+const PACKAGE_NAME = '@deepseek-ai/dsh-api-remotes';
+/** Cordis companion plugin name. */
+export const name = 'api-remotes-invariant';
+/** Service required before the companion can reserve package ownership. */
+export const inject = ['invariants'];
+/** No runtime invariant: TypeRT and the Agent/Session registries own the observed relationships. */
+const install = () => { };
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+/* jscpd:ignore-end */
+//# sourceMappingURL=invariant.js.map

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

@@ -0,0 +1,17 @@
+/**
+ * The one home of this application's forwarded-Host-event allowlist. Both
+ * compiler faces list this file, so the Host forwarding loop and the consumer
+ * `ctx.remote.$on` key face read one declaration instead of two copies that
+ * could drift; `./types.ts` derives the type projection from it and stays
+ * type-only.
+ */
+/**
+ * Host events this application forwards to consumers verbatim: no projection,
+ * no redaction, no renaming. The wire name is the Host cordis event name and
+ * the payload is its argument list, so this array is simultaneously the whole
+ * control point over what a consumer can receive and the legal key set of
+ * `ctx.remote.$on`. Forwarding one more event is an entry here and nothing
+ * else.
+ */
+export declare const API_REMOTE_FORWARDED_EVENTS: readonly ["agent-preset/selected", "commands/change", "credentials/updated", "llm/adapters-updated", "settings/document-updated"];
+//# sourceMappingURL=remote-events.d.ts.map

package/lib/types/remote-events.js

@@ -0,0 +1,23 @@
+/**
+ * The one home of this application's forwarded-Host-event allowlist. Both
+ * compiler faces list this file, so the Host forwarding loop and the consumer
+ * `ctx.remote.$on` key face read one declaration instead of two copies that
+ * could drift; `./types.ts` derives the type projection from it and stays
+ * type-only.
+ */
+/**
+ * Host events this application forwards to consumers verbatim: no projection,
+ * no redaction, no renaming. The wire name is the Host cordis event name and
+ * the payload is its argument list, so this array is simultaneously the whole
+ * control point over what a consumer can receive and the legal key set of
+ * `ctx.remote.$on`. Forwarding one more event is an entry here and nothing
+ * else.
+ */
+export const API_REMOTE_FORWARDED_EVENTS = [
+    'agent-preset/selected',
+    'commands/change',
+    'credentials/updated',
+    'llm/adapters-updated',
+    'settings/document-updated',
+];
+//# sourceMappingURL=remote-events.js.map

package/lib/types/types.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Type face of the forwarded-Host-event allowlist: the consumer key projection
+ * and the selection seat it fills. The allowlist VALUE lives in
+ * `./remote-events.ts`, keeping this module type-only per the package
+ * convention; both compiler faces list both files, so the Host forwarding loop
+ * and the consumer `ctx.remote.$on` key face read one declaration instead of
+ * two copies that could drift.
+ *
+ * @module @deepseek-ai/dsh-api-remotes/types
+ */
+import type { API_REMOTE_FORWARDED_EVENTS } from './remote-events.ts';
+/** Type projection of the allowlist; the consumer and the Host read this one. */
+export type ApiRemoteForwardedEvent = typeof API_REMOTE_FORWARDED_EVENTS[number];
+declare module '@deepseek-ai/dsh-type-meta' {
+    interface TypeRTRemoteEventSelection extends Record<ApiRemoteForwardedEvent, true> {
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,12 @@
+/**
+ * Type face of the forwarded-Host-event allowlist: the consumer key projection
+ * and the selection seat it fills. The allowlist VALUE lives in
+ * `./remote-events.ts`, keeping this module type-only per the package
+ * convention; both compiler faces list both files, so the Host forwarding loop
+ * and the consumer `ctx.remote.$on` key face read one declaration instead of
+ * two copies that could drift.
+ *
+ * @module @deepseek-ai/dsh-api-remotes/types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-api-remotes",
   "description": "Remote BFF assembly and Host Agent/Session lookup policy",
-  "version": "0.0.1-rc.1",
+  "version": "0.0.1-rc.2",
   "publishConfig": {
     "access": "restricted"
   },
@@ -26,6 +26,10 @@
       "types": "./lib/types/client/index.d.ts",
       "default": "./lib/client.js"
     },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
     "./src/*": "./src/*",
     "./package.json": "./package.json"
   },
@@ -43,28 +47,41 @@
     "lib/index.js",
     "lib/invariant.js",
     "lib/client.js",
+    "lib/types/**/*.js",
     "lib/types/**/*.d.ts"
   ],
   "dependencies": {
-    "@deepseek-ai/dsh-type-meta": "^0.0.1-rc.1"
+    "@deepseek-ai/dsh-type-meta": "^0.0.1-rc.2"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-agent": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-goal": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-session": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-session-persistence": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-typert-registry": "^0.0.1-rc.1",
-    "@deepseek-ai/cordis": "^4.0.1-rc.1"
+    "@deepseek-ai/cordis": "^4.0.1-rc.1",
+    "@deepseek-ai/dsh-api-gateway": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-commands": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-credentials": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-goal": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-agent": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-session-persistence": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-settings": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-typert-registry": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-agent-presets": "^0.0.1-rc.2"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-agent": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-goal": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-session": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-session-persistence": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-typert-registry": "^0.0.1-rc.1",
-    "@deepseek-ai/cordis": "^4.0.1-rc.1"
+    "@deepseek-ai/dsh-api-gateway": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-agent": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-commands": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-credentials": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-goal": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-agent-presets": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-settings": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-typert-registry": "^0.0.1-rc.2",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1",
+    "@deepseek-ai/dsh-session-persistence": "^0.0.1-rc.2"
   },
   "scripts": {
     "bundle": "tsdown",