@deepseek-ai/dsh-api-remotes 0.1.1-rc.2 → 0.1.2-alpha.2

package/lib/index.js

@@ -1,4 +1,7 @@
-import { TypertLookupFailure } from "@deepseek-ai/dsh-typert-protocol";
+import { homedir } from "node:os";
+import { Deque } from "@deepseek-ai/dsh-deque";
+import { carrierKeyOf } from "@deepseek-ai/dsh-scope";
+import { isJsonValue } from "@deepseek-ai/dsh-util-values";
 //#region lib/types/remote-events.js
 /**
 * The one home of this application's forwarded-Host-event allowlist. Both
@@ -8,165 +11,192 @@ import { TypertLookupFailure } from "@deepseek-ai/dsh-typert-protocol";
 * 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.
+* Host events this application forwards without renaming. The explicit mode is
+* both the Host dispatch strategy and the legal key set of `ctx.remote.$on`.
 */
 const API_REMOTE_FORWARDED_EVENTS = [
-	"agent-preset/selected",
-	"commands/change",
-	"credentials/reference-updated",
-	"cordis/request-run",
-	"cordis/request-run-resolved",
-	"cordis/dynamic-package",
-	"cordis/dynamic-retract",
-	"cordis/inspect-query",
-	"cordis/inspect-query-resolved",
-	"llm/adapters-updated",
-	"settings/document-updated"
+	{
+		event: "agent-preset/selected",
+		mode: "emit"
+	},
+	{
+		event: "approval/request",
+		mode: "waterfall"
+	},
+	{
+		event: "api-session/activity",
+		mode: "emit"
+	},
+	{
+		event: "api-session/added",
+		mode: "emit"
+	},
+	{
+		event: "api-session/error",
+		mode: "emit"
+	},
+	{
+		event: "api-session/removed",
+		mode: "emit"
+	},
+	{
+		event: "api-session/status",
+		mode: "emit"
+	},
+	{
+		event: "commands/change",
+		mode: "emit"
+	},
+	{
+		event: "credentials/reference-updated",
+		mode: "emit"
+	},
+	{
+		event: "cordis/request-run",
+		mode: "emit"
+	},
+	{
+		event: "cordis/request-run-resolved",
+		mode: "emit"
+	},
+	{
+		event: "cordis/dynamic-package",
+		mode: "emit"
+	},
+	{
+		event: "cordis/dynamic-retract",
+		mode: "emit"
+	},
+	{
+		event: "cordis/inspect-query",
+		mode: "emit"
+	},
+	{
+		event: "cordis/inspect-query-resolved",
+		mode: "emit"
+	},
+	{
+		event: "llm/adapters-updated",
+		mode: "emit"
+	},
+	{
+		event: "settings/document-updated",
+		mode: "emit"
+	},
+	{
+		event: "user-questions/request",
+		mode: "waterfall"
+	}
 ];
 //#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. */
-var ApiRemoteSessionNotFound = class extends Error {};
-/** Session identity whose lifecycle belongs to subagent routing. */
-var ApiRemoteSubagentSessionOwnership = class 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.
-*/
-function hasApiRemoteSubagentOwner(ctx, session, agent) {
-	if (session.header.origin === "subagent") return true;
-	const parentId = session.header.parentSession;
-	if (parentId === void 0 || agent === void 0) return false;
-	const parent = ctx.agents.get(parentId);
-	return parent !== void 0 && 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.
-*/
-function apiRemoteSubagentOwnershipError(sessionId) {
-	return {
-		code: "agent-busy",
-		message: `session "${sessionId}" is owned by subagent routing`,
-		details: { reason: "use subagent delivery for this child session" }
-	};
+//#region lib/types/index.js
+/** Host BFF entry and Loader shell for the Remote contribution assembly. */
+/** Required Host service: the Gateway owns the physical Remote stream mux. */
+const inject = ["typertGateway"];
+/** Host plugin body registering this application's selected Cordis event source. */
+function apply(ctx) {
+	ctx.effect(() => ctx.typertGateway.registerRemoteEvents(remoteEventSource(ctx), { home: homedir() }), "api-remotes: forwarded Cordis event source");
 }
-/**
-* 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.
-*/
-async function inspectApiRemoteSession(ctx, sessionId) {
-	const persistence = ctx.get("sessionPersistence");
-	if (persistence === void 0) 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 === void 0 || meta.cwd === void 0) throw new ApiRemoteSessionNotFound(`session "${sessionId}" not found`);
-	const inspected = await persistence.inspect(sessionId);
-	if (inspected.meta.cwd === void 0) throw new ApiRemoteSessionNotFound(`session "${sessionId}" not found`);
-	return {
-		meta: inspected.meta,
-		events: [...inspected.events]
+/** Create the sole queue and listener set consumed by the registered Gateway. */
+function remoteEventSource(ctx) {
+	return (signal) => {
+		const queue = new RemoteEventQueue();
+		const disposers = API_REMOTE_FORWARDED_EVENTS.map(({ event, mode }) => {
+			if (mode === "emit") return ctx.on(event, ((...args) => {
+				queue.push({
+					event,
+					args: assertJsonArgs(event, args)
+				});
+			}));
+			return ctx.on(event, (function(request, next) {
+				const subject = carrierKeyOf(this);
+				if (subject === void 0) return next();
+				const value = Reflect.get(subject, "ctx");
+				if (typeof value !== "object" || value === null) throw new TypeError(`forwarded scoped event ${JSON.stringify(event)} has no live Context`);
+				return forwardWaterfall(queue, event, request, {
+					value,
+					subject
+				}, next);
+			}));
+		});
+		return queue.iterate(signal, () => {
+			for (const dispose of disposers) dispose();
+		});
 	};
 }
-/**
-* 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.
-*/
-function createApiRemoteAgentResolver(ctx, options) {
-	const resumes = /* @__PURE__ */ new Map();
-	const fencedLiveAgent = (sessionId) => {
-		const live = ctx.agents.get(sessionId);
-		if (live === void 0) return void 0;
-		if (hasApiRemoteSubagentOwner(ctx, live.session, live)) return { error: apiRemoteSubagentOwnershipError(sessionId) };
-		return { agent: live };
-	};
-	const agentFor = async (sessionId) => {
-		const fenced = fencedLiveAgent(sessionId);
-		if (fenced !== void 0) return fenced;
-		const attached = ctx.sessions.get(sessionId);
-		if (attached !== void 0 && hasApiRemoteSubagentOwner(ctx, attached, void 0)) return { error: apiRemoteSubagentOwnershipError(sessionId) };
-		let resume = resumes.get(sessionId);
-		if (resume === void 0) {
-			resume = (async () => {
-				try {
-					const inspected = await inspectApiRemoteSession(ctx, sessionId);
-					if (hasApiRemoteSubagentOwner(ctx, { header: inspected.meta }, void 0)) throw new ApiRemoteSubagentSessionOwnership(sessionId);
-					const setup = options.setup === void 0 ? void 0 : await options.setup(inspected);
-					const publishedSession = ctx.sessions.get(sessionId);
-					const publishedAgent = ctx.agents.get(sessionId);
-					if (publishedSession !== void 0 && hasApiRemoteSubagentOwner(ctx, publishedSession, publishedAgent)) throw new ApiRemoteSubagentSessionOwnership(sessionId);
-					return (await ctx.agents.resume({
-						resumeSessionId: sessionId,
-						...options.agentOptions === void 0 ? {} : { agentOptions: options.agentOptions() },
-						...setup === void 0 ? {} : { setup }
-					})).agent;
-				} finally {
-					resumes.delete(sessionId);
-				}
-			})();
-			resumes.set(sessionId, resume);
+/** One pull-driven queue bridging synchronous Cordis listeners to an AsyncIterable. */
+var RemoteEventQueue = class {
+	buffer = new Deque();
+	waiter;
+	done = false;
+	push(frame) {
+		if (this.done) return false;
+		this.buffer.pushBack(frame);
+		this.waiter?.();
+		return true;
+	}
+	end(reason) {
+		if (this.done) return;
+		this.done = true;
+		while (this.buffer.size > 0) {
+			const dispatch = this.buffer.popFront();
+			if ("context" in dispatch) dispatch.reject(reason);
 		}
+		this.waiter?.();
+	}
+	async *iterate(signal, cleanup) {
+		const abort = () => {
+			this.end(remoteEventSourceEndReason(signal));
+		};
+		signal.addEventListener("abort", abort, { once: true });
 		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 !== void 0) return fenced;
-			const attached = ctx.sessions.get(sessionId);
-			if (attached !== void 0 && hasApiRemoteSubagentOwner(ctx, attached, void 0)) return { error: apiRemoteSubagentOwnershipError(sessionId) };
-			return { error: {
-				code: "internal",
-				message: `resume failed for session "${sessionId}": ${String(error)}`,
-				details: {}
-			} };
+			while (true) {
+				if (this.done || signal.aborted) return;
+				while (this.buffer.size > 0) yield this.buffer.popFront();
+				await new Promise((resolve) => {
+					this.waiter = resolve;
+				});
+				this.waiter = void 0;
+			}
+		} finally {
+			signal.removeEventListener("abort", abort);
+			this.end(remoteEventSourceEndReason(signal));
+			cleanup();
 		}
+	}
+};
+/**
+* Normalize an event-source shutdown for pending Host waterfalls.
+* @param signal - source lifetime whose reason wins after cancellation.
+* @returns the cancellation reason or an unexpected-end failure.
+*/
+function remoteEventSourceEndReason(signal) {
+	if (signal.aborted) return signal.reason;
+	return /* @__PURE__ */ new Error("api-remotes: forwarded Remote event source ended");
+}
+/** Bridge one Cordis waterfall listener through the Gateway-owned pending event. */
+function forwardWaterfall(queue, event, request, context, next) {
+	const settled = Promise.withResolvers();
+	const dispatch = {
+		event,
+		request,
+		context,
+		resolve: (outcome) => {
+			if (outcome.kind === "result") {
+				settled.resolve(outcome.value);
+				return;
+			}
+			Promise.resolve().then(next).then(settled.resolve, settled.reject);
+		},
+		reject: settled.reject
 	};
-	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;
+	if (!queue.push(dispatch)) Promise.resolve().then(next).then(settled.resolve, settled.reject);
+	return settled.promise;
+}
+/** Reject an allowlisted event whose runtime arguments are not lossless JSON data. */
+function assertJsonArgs(event, args) {
+	for (const [index, arg] of args.entries()) if (!isJsonValue(arg)) throw new Error(`forwarded host event "${event}" argument ${String(index)} is not lossless JSON data`);
+	return args;
 }
 //#endregion
-//#region lib/types/index.js
-/** Host plugin body; the selected contributions mount only in Client environments. */
-function apply() {}
-//#endregion
-export { API_REMOTE_FORWARDED_EVENTS, ApiRemoteSessionNotFound, ApiRemoteSubagentSessionOwnership, apiRemoteSubagentOwnershipError, apply, createApiRemoteAgentResolver, hasApiRemoteSubagentOwner, inspectApiRemoteSession };
+export { API_REMOTE_FORWARDED_EVENTS, apply, inject };

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

@@ -1,14 +1,23 @@
 /** Platform-neutral assembly of generated Host Remote contributions. */
 import type { Context } from '@deepseek-ai/cordis';
-import type { TypertClientRemote } from '@deepseek-ai/dsh-typert-protocol';
-export type { TypertClientRemote as ClientRemote } from '@deepseek-ai/dsh-typert-protocol';
+import type { ClientRemote } from '@deepseek-ai/dsh-api-gateway/client';
+export type { ClientRemote } from '@deepseek-ai/dsh-api-gateway/client';
 export type { PluginInventorySnapshot } from '@deepseek-ai/dsh-host-plugin-inventory/types';
+export type {} from '@deepseek-ai/dsh-agent-presets/remote';
 export type {} from '@deepseek-ai/dsh-commands/remote';
-export type {} from '@deepseek-ai/dsh-file-reference/remote';
+export type {} from '@deepseek-ai/dsh-api-settings-controller/remote';
 export type {} from '@deepseek-ai/dsh-goal/remote';
+export type {} from '@deepseek-ai/dsh-llm/remote';
 export type {} from '@deepseek-ai/dsh-host-plugin-inventory/remote';
 export type {} from '@deepseek-ai/dsh-message-feedback/remote';
 export type {} from '@deepseek-ai/dsh-session-reference/remote';
+export type {} from '@deepseek-ai/dsh-subagent/remote';
+export type * from '@deepseek-ai/dsh-subagent/client';
+export type {} from '@deepseek-ai/dsh-api-session-controller/remote';
+export type * from '@deepseek-ai/dsh-api-session-controller/types';
+export type {} from '@deepseek-ai/dsh-api-workspace-controller/remote';
+export type * from '@deepseek-ai/dsh-api-workspace-controller/types';
+export type { SessionJob as JobView } from '@deepseek-ai/dsh-api-session-controller/types';
 export type { ApiRemoteForwardedEvent } from '../types.ts';
 export type {} from '@deepseek-ai/dsh-commands/types';
 export type {} from '@deepseek-ai/dsh-cordis-host-runner/types';
@@ -16,22 +25,29 @@ 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';
+export type {} from '@deepseek-ai/dsh-user-approval/types';
+export type {} from '@deepseek-ai/dsh-user-questions/types';
+export type {} from '@deepseek-ai/dsh-api-session-controller/types';
 /**
  * The carrier's Client-facing types, re-exported so a business package names one
  * assembly package instead of both this facade and the Connection plugin. Type-only:
  * the carrier's runtime values stay behind their own module edge.
  */
-export type { ClientResponse, ConfigurableProviderView, ConnectionHandle, ConnectionSinks, ContentBlock, CredentialView, DirectoryListing, DiscoveredModelView, HistoryEntry, HostFrame, IApiClient, MessageId, ModelCatalogFailure, ModelProviderGroup, ModelReasoningEffort, ModelSelection, MuxFrame, PromptContentPart, QuestionResponsePayload, QueueAction, RpcError, RpcId, RpcReceipt, RpcRequest, RpcResponse, RpcResult, SessionId, SessionModels, SessionSearchItem, SessionSummary, SettingsNamespaceView, SettingsPathOpView, SkillEntry, StreamChunk, SubagentAddress, SubagentCatalog, JobView, ToolCallView, ToolEventView, ToolResultView, WorkspaceId, WorkspaceView, } from '@deepseek-ai/dsh-client-connection/client';
+export type { ConnectionHandle, ConnectionSinks, ContentBlock, MessageId, RpcId, RpcRequest, RpcResponse, RpcResult, SessionId, StreamChunk, } from '@deepseek-ai/dsh-client-connection/client';
 export type {} from '@deepseek-ai/dsh-api-gateway/client';
 export type {} from '@deepseek-ai/dsh-cordis-host-runner/remote';
 export type { ApprovalRequestId, CordisHalfState, CordisDynamicPackageId, CordisDynamicPluginId, CordisDynamicPluginRunId, CordisDynamicRunMode, CordisInspectMethodManifest, CordisInspectPlatform, CordisInspectProviderManifest, CordisInspectProviderView, CordisInspectQueryRequest, CordisInspectQueryResolution, CordisInspectQueryResolved, CordisInspectRequestId, CordisInspectResolveAck, CordisRunDiagnostic, CordisRunStatus, DynamicCordisClientSource, DynamicCordisHostHalfResult, DynamicCordisInventoryRow, DynamicCordisInvokeResult, DynamicCordisPackage, DynamicCordisRequestResolved, DynamicCordisResolveAck, DynamicCordisRetracted, DynamicCordisRunRequest, DynamicCordisRunResolution, DynamicCordisRunAttempt, DynamicCordisRunResponse, DynamicCordisStopResponse, DynamicCordisUndefineReceipt, RequestRunOutcome, } from '@deepseek-ai/dsh-cordis-host-runner/types';
-export type { JsonValue } from '@deepseek-ai/dsh-session/types';
+export type { CredentialInfo } from '@deepseek-ai/dsh-credentials/types';
+export type { SettingsDescribeValue, SettingsNamespaceView, SettingsPathOpView, SettingsSecretView, } from '@deepseek-ai/dsh-settings/types';
+export type { LlmConfigurableProvider, LlmDiscoveredModel, LlmModelDiscoveryRequest, LlmProviderInfo, } from '@deepseek-ai/dsh-llm/types';
 export type { FileReferenceCandidate } from '@deepseek-ai/dsh-file-reference/types';
 export type { SessionReferenceMentionCandidate } from '@deepseek-ai/dsh-session-reference/types';
+export type { RemoteErrorCode, RemoteErrorDetailsMap, RemoteFailure, RemoteResult, } from '@deepseek-ai/dsh-typert-protocol';
+export type { RemoteHostFacts } from '@deepseek-ai/dsh-api-gateway/client';
 declare module '@deepseek-ai/cordis' {
     interface Context {
         /** Generated Remote namespaces selected by this Client assembly. */
-        remote: TypertClientRemote;
+        remote: ClientRemote;
     }
 }
 /** Required service: the typed Client Remote contribution mount. */

package/lib/types/client/index.js

@@ -1,11 +1,16 @@
 /** Platform-neutral assembly of generated Host Remote contributions. */
+import agentPresetsRemote from '@deepseek-ai/dsh-agent-presets/remote';
 import commandsRemote from '@deepseek-ai/dsh-commands/remote';
+import settingsControllerRemote from '@deepseek-ai/dsh-api-settings-controller/remote';
 import goalsRemote from '@deepseek-ai/dsh-goal/remote';
+import llmRemote from '@deepseek-ai/dsh-llm/remote';
 import dynamicRemote from '@deepseek-ai/dsh-cordis-host-runner/remote';
-import fileReferencesRemote from '@deepseek-ai/dsh-file-reference/remote';
 import pluginInventoryRemote from '@deepseek-ai/dsh-host-plugin-inventory/remote';
 import messageFeedbackRemote from '@deepseek-ai/dsh-message-feedback/remote';
 import sessionReferencesRemote from '@deepseek-ai/dsh-session-reference/remote';
+import subagentsRemote from '@deepseek-ai/dsh-subagent/remote';
+import sessionRemote from '@deepseek-ai/dsh-api-session-controller/remote';
+import workspaceRemote from '@deepseek-ai/dsh-api-workspace-controller/remote';
 /** Required service: the typed Client Remote contribution mount. */
 export const inject = ['remote'];
 /**
@@ -17,8 +22,9 @@ export async function apply(ctx) {
     const disposers = [];
     try {
         for (const contribution of [
-            commandsRemote, goalsRemote, dynamicRemote, fileReferencesRemote,
+            agentPresetsRemote, commandsRemote, settingsControllerRemote, goalsRemote, llmRemote, dynamicRemote,
             pluginInventoryRemote, messageFeedbackRemote, sessionReferencesRemote,
+            subagentsRemote, sessionRemote, workspaceRemote,
         ]) {
             disposers.push(await ctx.remote.$mount(contribution));
         }

package/lib/types/index.d.ts

@@ -1,8 +1,10 @@
 /** 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';
+import type { Context } from '@deepseek-ai/cordis';
+export type {} from '@deepseek-ai/dsh-api-session-controller/types';
 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;
+/** Required Host service: the Gateway owns the physical Remote stream mux. */
+export declare const inject: string[];
+/** Host plugin body registering this application's selected Cordis event source. */
+export declare function apply(ctx: Context): void;
 //# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -1,16 +1,123 @@
 /** Host BFF entry and Loader shell for the Remote contribution assembly. */
+import { homedir } from 'node:os';
+import { Deque } from '@deepseek-ai/dsh-deque';
+import { carrierKeyOf } from '@deepseek-ai/dsh-scope';
+import { isJsonValue } from '@deepseek-ai/dsh-util-values';
 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() { }
+/** Required Host service: the Gateway owns the physical Remote stream mux. */
+export const inject = ['typertGateway'];
+/** Host plugin body registering this application's selected Cordis event source. */
+export function apply(ctx) {
+    ctx.effect(() => ctx.typertGateway.registerRemoteEvents(remoteEventSource(ctx), { home: homedir() }), 'api-remotes: forwarded Cordis event source');
+}
+/** Create the sole queue and listener set consumed by the registered Gateway. */
+function remoteEventSource(ctx) {
+    return (signal) => {
+        const queue = new RemoteEventQueue();
+        const disposers = API_REMOTE_FORWARDED_EVENTS.map(({ event, mode }) => {
+            if (mode === 'emit') {
+                return ctx.on(event, ((...args) => {
+                    queue.push({ event, args: assertJsonArgs(event, args) });
+                }));
+            }
+            return ctx.on(event, (function (request, next) {
+                const subject = carrierKeyOf(this);
+                if (subject === undefined)
+                    return next();
+                const value = Reflect.get(subject, 'ctx');
+                if (typeof value !== 'object' || value === null) {
+                    throw new TypeError(`forwarded scoped event ${JSON.stringify(event)} has no live Context`);
+                }
+                return forwardWaterfall(queue, event, request, { value: value, subject }, next);
+            }));
+        });
+        return queue.iterate(signal, () => {
+            for (const dispose of disposers)
+                dispose();
+        });
+    };
+}
+/** One pull-driven queue bridging synchronous Cordis listeners to an AsyncIterable. */
+class RemoteEventQueue {
+    buffer = new Deque();
+    waiter;
+    done = false;
+    push(frame) {
+        if (this.done)
+            return false;
+        this.buffer.pushBack(frame);
+        this.waiter?.();
+        return true;
+    }
+    end(reason) {
+        if (this.done)
+            return;
+        this.done = true;
+        while (this.buffer.size > 0) {
+            const dispatch = this.buffer.popFront();
+            if ('context' in dispatch)
+                dispatch.reject(reason);
+        }
+        this.waiter?.();
+    }
+    async *iterate(signal, cleanup) {
+        const abort = () => { this.end(remoteEventSourceEndReason(signal)); };
+        signal.addEventListener('abort', abort, { once: true });
+        try {
+            while (true) {
+                if (this.done || signal.aborted)
+                    return;
+                while (this.buffer.size > 0)
+                    yield this.buffer.popFront();
+                await new Promise((resolve) => { this.waiter = resolve; });
+                this.waiter = undefined;
+            }
+        }
+        finally {
+            signal.removeEventListener('abort', abort);
+            this.end(remoteEventSourceEndReason(signal));
+            cleanup();
+        }
+    }
+}
+/**
+ * Normalize an event-source shutdown for pending Host waterfalls.
+ * @param signal - source lifetime whose reason wins after cancellation.
+ * @returns the cancellation reason or an unexpected-end failure.
+ */
+function remoteEventSourceEndReason(signal) {
+    if (signal.aborted)
+        return signal.reason;
+    return new Error('api-remotes: forwarded Remote event source ended');
+}
+/** Bridge one Cordis waterfall listener through the Gateway-owned pending event. */
+function forwardWaterfall(queue, event, request, context, next) {
+    const settled = Promise.withResolvers();
+    const dispatch = {
+        event,
+        request,
+        context,
+        resolve: (outcome) => {
+            if (outcome.kind === 'result') {
+                settled.resolve(outcome.value);
+                return;
+            }
+            void Promise.resolve().then(next).then(settled.resolve, settled.reject);
+        },
+        reject: settled.reject,
+    };
+    if (!queue.push(dispatch))
+        void Promise.resolve().then(next).then(settled.resolve, settled.reject);
+    return settled.promise;
+}
+/** Reject an allowlisted event whose runtime arguments are not lossless JSON data. */
+function assertJsonArgs(event, args) {
+    for (const [index, arg] of args.entries()) {
+        if (!isJsonValue(arg)) {
+            throw new Error(`forwarded host event "${event}" argument ${String(index)} is not lossless JSON data`);
+        }
+    }
+    return args;
+}
 //# sourceMappingURL=index.js.map