@efffrida/rpc 0.0.27 → 0.0.29

package/src/frida/FridaRpcClient.ts

@@ -6,150 +6,90 @@
  */
 
 import "@efffrida/polyfills";
-import type * as RpcMessage from "@effect/rpc/RpcMessage";
-import type * as Duration from "effect/Duration";
+
 import type * as Scope from "effect/Scope";
+import type * as RpcMessage from "effect/unstable/rpc/RpcMessage";
 
-import * as RpcClient from "@effect/rpc/RpcClient";
-import * as RpcSerialization from "@effect/rpc/RpcSerialization";
-import * as FridaStream from "@efffrida/platform/Stream";
-import * as Cause from "effect/Cause";
-import * as Deferred from "effect/Deferred";
+import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as ParseResult from "effect/ParseResult";
-import * as Predicate from "effect/Predicate";
-import * as Schema from "effect/Schema";
-import * as Stream from "effect/Stream";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import * as RpcClientError from "effect/unstable/rpc/RpcClientError";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 
-import * as constants from "../shared/constants.ts";
-import * as sharedPredicates from "../shared/predicates.ts";
+import * as constants from "../shared/Constants.ts";
 
 /**
  * @since 1.0.0
  * @category Protocol
  */
-export const makeProtocolFrida = (
-    options?:
-        | {
-              readonly generateExportName?: (() => string) | undefined;
-              readonly receivingStreamShareOptions?:
-                  | {
-                        readonly capacity: "unbounded";
-                        readonly replay?: number | undefined;
-                        readonly idleTimeToLive?: Duration.DurationInput | undefined;
-                    }
-                  | {
-                        readonly capacity: number;
-                        readonly strategy?: "sliding" | "dropping" | "suspend" | undefined;
-                        readonly replay?: number | undefined;
-                        readonly idleTimeToLive?: Duration.DurationInput | undefined;
-                    }
-                  | undefined;
-          }
-        | undefined
-): Effect.Effect<RpcClient.Protocol["Type"], never, RpcSerialization.RpcSerialization | Scope.Scope> =>
+export const makeProtocolFrida = (): Effect.Effect<
+    RpcClient.Protocol["Service"],
+    never,
+    Crypto.Crypto | RpcSerialization.RpcSerialization | Scope.Scope
+> =>
     RpcClient.Protocol.make(
-        Effect.fnUntraced(function* (writeResponse) {
+        Effect.fnUntraced(function* (writeResponse, clientIds) {
             const serialization = yield* RpcSerialization.RpcSerialization;
+            const crypto = yield* Crypto.Crypto;
 
             const encoder = new TextEncoder();
-            const parser = serialization.unsafeMake();
-
-            /**
-             * Once the server has acknowledged our initiation request and sent
-             * use a client id to identify ourselves, this deferred will
-             * complete.
-             */
-            const clientIdDeferred = yield* Deferred.make<number, ParseResult.ParseError>();
+            const parser = serialization.makeUnsafe();
+            const requestClientMap = new Map<string, number>();
 
-            /**
-             * Setup the receiving handler for the client id. We receive the
-             * client id over a script export instead of over the receiving
-             * stream since there could be multiple clients in this frida script
-             * and multiple could request client ids at the same time. This
-             * could be mitigated with a nonce of some kind in the request
-             * message, but receiving over a script export is full-proof so long
-             * as the exports are unique.
-             */
-            const exportName = options?.generateExportName?.() ?? constants.generateClientCallbackExportNameForServer();
-            yield* Effect.addFinalizer(() => Effect.sync(() => delete rpc.exports[exportName]));
-            rpc.exports[exportName] = (maybeIncomingClientId: unknown): void => {
-                const parsedClientId = Schema.decodeUnknown(Schema.Number)(maybeIncomingClientId);
-                Deferred.unsafeDone(clientIdDeferred, parsedClientId);
-            };
-
-            /**
-             * Request a client id from the node side and wait for the response,
-             * handling any transient errors that might occur by retrying with
-             * the retry policy.
-             */
+            const exportName = yield* crypto.randomUUIDv4.pipe(Effect.orDie);
             const connectionRequest = constants.nodeRpcClientMakeConnectionRequestForServer(exportName);
-            const connectionRequestTimeout: Duration.DurationInput = "1 second";
-            const clientId = yield* Effect.sync(() => send(connectionRequest)).pipe(
-                Effect.flatMap(() => Deferred.await(clientIdDeferred)),
-                Effect.timeout(connectionRequestTimeout),
-                Effect.catchIf(ParseResult.isParseError, () => Effect.dieMessage("Failed to parse client ID")),
-                Effect.catchIf(Cause.isTimeoutException, () => Effect.dieMessage("Timed out too many times"))
-            );
 
-            /**
-             * Attach to the receiving stream, where all future messages will
-             * come in at, and filter for only our messages.
-             */
-            const receivingPredicate = sharedPredicates.isTaggedForClient(clientId);
-            const receiveStream = yield* FridaStream.receiveStream(
-                options?.receivingStreamShareOptions ?? {
-                    replay: 100,
-                    capacity: "unbounded",
-                }
-            );
+            const broadcast = (response: RpcMessage.FromServerEncoded) =>
+                Effect.forEach(clientIds, (id) => writeResponse(id, response), { discard: true });
 
-            /**
-             * For every response message received, decode it and send it the
-             * response back to the implementation.
-             */
-            yield* receiveStream.pipe(
-                Stream.filterMap((unfiltered) => {
-                    if (receivingPredicate(unfiltered.message)) return Option.fromNullable(unfiltered.data);
-                    else return Option.none<Uint8Array<ArrayBufferLike>>();
-                }),
-                Stream.runForEach((filtered) => {
-                    try {
-                        const responses = parser.decode(filtered) as Array<RpcMessage.FromServerEncoded>;
-                        if (responses.length === 0) return Effect.void;
-                        let i = 0;
-                        return Effect.whileLoop({
-                            while: () => i < responses.length,
-                            body: () => writeResponse(responses[i++]),
-                            step: Function.constVoid,
-                        });
-                    } catch (defect) {
-                        return writeResponse({ _tag: "Defect", defect });
-                    }
-                }),
-                Effect.interruptible,
-                Effect.forkScoped
-            );
+            yield* Effect.addFinalizer(() => Effect.sync(() => delete rpc.exports[exportName]));
+            rpc.exports[exportName] = (data: string | Uint8Array): Promise<void> => {
+                try {
+                    const responses = parser.decode(data) as Array<RpcMessage.FromServerEncoded>;
+                    if (responses.length === 0) return Promise.resolve();
+                    let i = 0;
+                    return Effect.whileLoop({
+                        step: Function.constVoid,
+                        while: () => i < responses.length,
+                        body: () => {
+                            const response = responses[i++]!;
+                            if ("requestId" in response) {
+                                const clientId = requestClientMap.get(response.requestId)!;
+                                if (response._tag === "Exit") requestClientMap.delete(response.requestId);
+                                return writeResponse(clientId, response);
+                            } else return broadcast(response);
+                        },
+                    }).pipe(Effect.runPromise);
+                } catch (defect) {
+                    return broadcast({
+                        _tag: "ClientProtocolError",
+                        error: new RpcClientError.RpcClientError({
+                            reason: new RpcClientError.RpcClientDefect({
+                                message: "Error decoding message",
+                                cause: defect,
+                            }),
+                        }),
+                    }).pipe(Effect.runPromise);
+                }
+            };
 
-            /**
-             * Sending messages is as simple as encoding them, then sending them
-             * to the node side tagged with our client id so it knows where to
-             * send them back to.
-             */
-            const sendHelper = Effect.fnUntraced(function* (message: RpcMessage.FromClientEncoded) {
-                const encoded = parser.encode(message);
-                if (Predicate.isUndefined(encoded)) return;
-                const transformed = typeof encoded === "string" ? encoder.encode(encoded) : encoded;
-                send({ clientId }, (transformed as Uint8Array<ArrayBuffer>).buffer);
-            });
+            send(connectionRequest);
 
             return {
-                send: sendHelper,
                 supportsAck: true,
                 supportsTransferables: false,
+                send(clientId, request) {
+                    if (request._tag === "Request") {
+                        requestClientMap.set(request.id, clientId);
+                    }
+
+                    const encoded = parser.encode(request);
+                    if (encoded === undefined) return Effect.void;
+                    const transformed = typeof encoded === "string" ? encoder.encode(encoded) : encoded;
+                    return Effect.sync(() => send(exportName, (transformed as Uint8Array<ArrayBuffer>).buffer));
+                },
             };
         })
     );
@@ -158,24 +98,8 @@ export const makeProtocolFrida = (
  * @since 1.0.0
  * @category Layers
  */
-export const layerProtocolFrida = (
-    options?:
-        | {
-              readonly generateExportName?: (() => string) | undefined;
-              readonly receivingStreamShareOptions?:
-                  | {
-                        readonly capacity: "unbounded";
-                        readonly replay?: number | undefined;
-                        readonly idleTimeToLive?: Duration.DurationInput | undefined;
-                    }
-                  | {
-                        readonly capacity: number;
-                        readonly strategy?: "sliding" | "dropping" | "suspend" | undefined;
-                        readonly replay?: number | undefined;
-                        readonly idleTimeToLive?: Duration.DurationInput | undefined;
-                    }
-                  | undefined;
-          }
-        | undefined
-): Layer.Layer<RpcClient.Protocol, never, RpcSerialization.RpcSerialization> =>
-    Layer.scoped(RpcClient.Protocol, makeProtocolFrida(options));
+export const layerProtocolFrida: Layer.Layer<
+    RpcClient.Protocol,
+    never,
+    Crypto.Crypto | RpcSerialization.RpcSerialization
+> = Layer.effect(RpcClient.Protocol, makeProtocolFrida());

package/src/frida/FridaRpcServer.ts

@@ -6,22 +6,22 @@
  */
 
 import "@efffrida/polyfills";
-import * as RpcMessage from "@effect/rpc/RpcMessage";
-import * as RpcSerialization from "@effect/rpc/RpcSerialization";
-import * as RpcServer from "@effect/rpc/RpcServer";
+
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
-import * as Mailbox from "effect/Mailbox";
-import * as Predicate from "effect/Predicate";
+import * as Queue from "effect/Queue";
+import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import * as RpcServer from "effect/unstable/rpc/RpcServer";
 
-import * as constants from "../shared/constants.ts";
+import * as constants from "../shared/Constants.ts";
 
 /**
  * @since 1.0.0
  * @category Protocol
  */
-export const makeProtocolFrida = (
+export const makeProtocolFridaNoSendRecv = (
     options?:
         | {
               /** Generates server listener rpc exports for individual clients. */
@@ -30,71 +30,66 @@ export const makeProtocolFrida = (
         | undefined
 ): Effect.Effect<
     {
-        readonly protocol: RpcServer.Protocol["Type"];
-        readonly rpcExport: () => Promise<number>;
+        readonly protocol: RpcServer.Protocol["Service"];
+        readonly rpcExport: () => Promise<string>;
     },
     never,
     RpcSerialization.RpcSerialization
 > =>
     Effect.gen(function* () {
-        const encoder = new TextEncoder();
-        const disconnects = yield* Mailbox.make<number>();
         const serialization = yield* RpcSerialization.RpcSerialization;
 
+        const disconnects = yield* Queue.unbounded<number>();
+        const parser = serialization.makeUnsafe();
+        const encoder = new TextEncoder();
+
         let clientId = 0;
         const clientIds = new Set<number>();
-        const clients = new Map<number, { readonly write: (bytes: RpcMessage.FromServerEncoded) => void }>();
+        const clients = new Map<
+            number,
+            {
+                readonly write: (bytes: RpcMessage.FromServerEncoded) => void;
+            }
+        >();
 
         let writeRequest!: (clientId: number, message: RpcMessage.FromClientEncoded) => Effect.Effect<void>;
         const makeExportName = options?.generateExportName ?? constants.generateServerExportNameForClient;
 
-        // Listen for new clients on the main rpc export
-        const rpcExport = Effect.gen(function* () {
-            const id = ++clientId;
-            const parser = serialization.unsafeMake();
+        const writeRaw = (data: string | Uint8Array): void => {
+            const transformed = typeof data === "string" ? encoder.encode(data) : data;
+            return send(void 0, (transformed as Uint8Array<ArrayBuffer>).buffer);
+        };
 
-            const writeRaw = (data: string | Uint8Array): void => {
-                const transformed = typeof data === "string" ? encoder.encode(data) : data;
-                return send({ clientId: id }, (transformed as Uint8Array<ArrayBuffer>).buffer);
-            };
-            const write = (response: RpcMessage.FromServerEncoded): void => {
-                try {
-                    const encoded = parser.encode(
-                        // TODO: handle defects on the node client better
-                        response._tag === "Defect" && response.defect instanceof Error
-                            ? RpcMessage.ResponseDefectEncoded({
-                                  stack: response.defect.stack,
-                                  cause: response.defect.cause,
-                                  ...response.defect,
-                              })
-                            : response
-                    );
-                    if (Predicate.isNotUndefined(encoded)) {
-                        return writeRaw(encoded);
-                    }
-                } catch (cause) {
-                    const encoded = parser.encode(RpcMessage.ResponseDefectEncoded(cause))!;
-                    return writeRaw(encoded);
-                }
-            };
+        const write = (response: RpcMessage.FromServerEncoded): void => {
+            try {
+                const encoded = parser.encode(response);
+                if (encoded === undefined) return;
+                return writeRaw(encoded);
+            } catch (cause) {
+                const encoded = parser.encode(RpcMessage.ResponseDefectEncoded(cause))!;
+                return writeRaw(encoded);
+            }
+        };
 
-            clientIds.add(id);
+        // @effect-diagnostics-next-line runEffectInsideEffect:off
+        const rpcExport = Effect.gen(function* () {
+            const id = ++clientId;
             clients.set(id, { write });
+            clientIds.add(id);
 
             const onMessage = (input: string | Record<number, string>): Effect.Effect<void, never, never> => {
-                const data = typeof input === "string" ? input : Uint8Array.from(Object.values(input));
-
                 try {
+                    const data = typeof input === "string" ? input : Uint8Array.from(Object.values(input));
                     const decoded = parser.decode(data) as ReadonlyArray<RpcMessage.FromClientEncoded>;
                     if (decoded.length === 0) return Effect.void;
                     let i = 0;
                     return Effect.whileLoop({
                         while: () => i < decoded.length,
+                        step: Function.constVoid,
                         body() {
                             const message = decoded[i++];
                             return writeRequest(id, message);
                         },
-                        step: Function.constVoid,
                     });
                 } catch (cause) {
                     return Effect.sync(() => writeRaw(parser.encode(RpcMessage.ResponseDefectEncoded(cause))!));
@@ -104,8 +99,8 @@ export const makeProtocolFrida = (
             rpc.exports[makeExportName(id)] = (data: string | Record<number, string>): Promise<void> =>
                 Effect.runPromise(onMessage(data));
 
-            return id;
-        });
+            return makeExportName(id);
+        }).pipe((export_) => () => Effect.runPromise(export_));
 
         const protocol = yield* RpcServer.Protocol.make((writeRequest_) => {
             writeRequest = writeRequest_;
@@ -117,9 +112,6 @@ export const makeProtocolFrida = (
                     return Effect.sync(() => client.write(response));
                 },
                 end(clientId) {
-                    clientIds.delete(clientId); // TODO: Is this required?
-                    clients.delete(clientId); // TODO: Is this required?
-                    const makeExportName = options?.generateExportName ?? constants.generateServerExportNameForClient;
                     delete rpc.exports[makeExportName(clientId)];
                     return Effect.void;
                 },
@@ -133,7 +125,7 @@ export const makeProtocolFrida = (
 
         return {
             protocol,
-            rpcExport: () => Effect.runPromise(rpcExport),
+            rpcExport,
         };
     });
 
@@ -141,7 +133,7 @@ export const makeProtocolFrida = (
  * @since 1.0.0
  * @category Protocol
  */
-export const makeProtocolFridaWithExport = (
+export const makeProtocolFrida = (
     options?:
         | {
               /**
@@ -154,9 +146,10 @@ export const makeProtocolFridaWithExport = (
               readonly generateExportName?: ((clientId: number) => string) | undefined;
           }
         | undefined
-): Effect.Effect<RpcServer.Protocol["Type"], never, RpcSerialization.RpcSerialization> =>
+): Effect.Effect<RpcServer.Protocol["Service"], never, RpcSerialization.RpcSerialization> =>
     Effect.gen(function* () {
-        const { protocol, rpcExport } = yield* makeProtocolFrida({ generateExportName: options?.generateExportName });
+        const protocolOptions = { generateExportName: options?.generateExportName };
+        const { protocol, rpcExport } = yield* makeProtocolFridaNoSendRecv(protocolOptions);
         rpc.exports[options?.exportName ?? constants.defaultServerMainExportName] = rpcExport;
         return protocol;
     });
@@ -179,4 +172,4 @@ export const layerProtocolFrida = (
           }
         | undefined
 ): Layer.Layer<RpcServer.Protocol, never, RpcSerialization.RpcSerialization> =>
-    Layer.effect(RpcServer.Protocol, makeProtocolFridaWithExport(options));
+    Layer.effect(RpcServer.Protocol, makeProtocolFrida(options));

package/src/node/FridaRpcClient.ts

@@ -5,23 +5,26 @@
  * @since 1.0.0
  */
 
-import type * as RpcMessage from "@effect/rpc/RpcMessage";
-import type * as FridaSessionError from "@efffrida/frida-tools/FridaSessionError";
 import type * as Scope from "effect/Scope";
+import type * as RpcMessage from "effect/unstable/rpc/RpcMessage";
 
-import * as RpcClient from "@effect/rpc/RpcClient";
-import * as RpcSerialization from "@effect/rpc/RpcSerialization";
-import * as FridaScript from "@efffrida/frida-tools/FridaScript";
+import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
-import * as ParseResult from "effect/ParseResult";
-import * as Predicate from "effect/Predicate";
+import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
 import * as Stream from "effect/Stream";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import * as RpcClientError from "effect/unstable/rpc/RpcClientError";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+
+import type * as FridaSessionError from "@efffrida/frida-tools/FridaSessionError";
+
+import * as FridaScript from "@efffrida/frida-tools/FridaScript";
 
-import * as constants from "../shared/constants.ts";
+import * as constants from "../shared/Constants.ts";
 
 /**
  * @since 1.0.0
@@ -35,84 +38,97 @@ export const makeProtocolFrida = (
                * connecting to.
                */
               readonly exportName?: string | undefined;
-
-              /** Generates server listener rpc exports for individual clients. */
-              readonly generateExportName?: ((clientId: number) => string) | undefined;
           }
         | undefined
 ): Effect.Effect<
-    RpcClient.Protocol["Type"],
+    RpcClient.Protocol["Service"],
     FridaSessionError.FridaSessionError,
     RpcSerialization.RpcSerialization | FridaScript.FridaScript | Scope.Scope
 > =>
     RpcClient.Protocol.make(
-        Effect.fnUntraced(function* (writeResponse) {
+        Effect.fnUntraced(function* (writeResponse, clientIds) {
             const script = yield* FridaScript.FridaScript;
             const serialization = yield* RpcSerialization.RpcSerialization;
 
-            const parser = serialization.unsafeMake();
             const mainExportName = options?.exportName ?? constants.defaultServerMainExportName;
-            const makeExportName = options?.generateExportName ?? constants.generateServerExportNameForClient;
-
-            /**
-             * Obtain a client id from the frida script export, this will allow
-             * us to filter future messages for ours since the script channels
-             * are shared.
-             */
-            const clientId = yield* Effect.catchIf(
-                script.callExport(mainExportName, Schema.Number)(),
-                ParseResult.isParseError,
-                () => Effect.dieMessage("Failed to obtain client ID from Frida script export")
-            );
+            const informServerToSetupExport = script.callExport(mainExportName, Schema.String);
+            const clientExportName = yield* Effect.orDie(informServerToSetupExport());
 
-            const isClientId = Predicate.compose(Predicate.isNumber, (id) => id === clientId);
-            const receivingPredicate = Predicate.compose(
-                Predicate.isUnknown,
-                Predicate.struct({ clientId: isClientId })
-            );
+            const parser = serialization.makeUnsafe();
+            const requestClientMap = new Map<string, number>();
+            let currentError: RpcClientError.RpcClientError | undefined = undefined;
 
-            /**
-             * Start listening for responses to our requests, decode them, and
-             * send the responses back to the implementation.
-             */
-            yield* script.stream.pipe(
-                Stream.filterMap((unfiltered) => {
-                    if (receivingPredicate(unfiltered.message)) return unfiltered.data;
-                    else return Option.none<Buffer<ArrayBufferLike>>();
-                }),
-                Stream.runForEach((filtered) => {
-                    try {
-                        const responses = parser.decode(filtered) as Array<RpcMessage.FromServerEncoded>;
-                        if (responses.length === 0) return Effect.void;
-                        let i = 0;
-                        return Effect.whileLoop({
-                            while: () => i < responses.length,
-                            body: () => writeResponse(responses[i++]),
-                            step: Function.constVoid,
-                        });
-                    } catch (defect) {
-                        return writeResponse({ _tag: "Defect", defect });
-                    }
+            const broadcast = (response: RpcMessage.FromServerEncoded) =>
+                Effect.forEach(clientIds, (clientId) => writeResponse(clientId, response));
+
+            yield* Stream.runForEach(script.stream, (message) => {
+                if (Option.isNone(message.data)) {
+                    return Effect.void;
+                }
+
+                try {
+                    const responses = parser.decode(message.data.value) as Array<RpcMessage.FromServerEncoded>;
+                    if (responses.length === 0) return Effect.void;
+                    let i = 0;
+                    return Effect.whileLoop({
+                        step: Function.constVoid,
+                        while: () => i < responses.length,
+                        body: () => {
+                            const response = responses[i++]!;
+                            if ("requestId" in response) {
+                                const clientId = requestClientMap.get(response.requestId)!;
+                                if (response._tag === "Exit") requestClientMap.delete(response.requestId);
+                                return writeResponse(clientId, response);
+                            } else return broadcast(response);
+                        },
+                    });
+                } catch (defect) {
+                    return broadcast({
+                        _tag: "ClientProtocolError",
+                        error: new RpcClientError.RpcClientError({
+                            reason: new RpcClientError.RpcClientDefect({
+                                message: "Error decoding message",
+                                cause: defect,
+                            }),
+                        }),
+                    });
+                }
+            }).pipe(
+                Effect.tapCause((cause) => {
+                    const error = Cause.findError(cause);
+                    const hasError = Result.isSuccess(error);
+                    const defect = hasError
+                        ? new RpcClientError.RpcClientDefect({
+                              message: error.success.message,
+                              cause: error.success.cause,
+                          })
+                        : new RpcClientError.RpcClientDefect({
+                              message: "Unknown error in Frida RPC client stream",
+                              cause: Cause.squash(cause),
+                          });
+
+                    currentError = new RpcClientError.RpcClientError({ reason: defect });
+                    return broadcast({ _tag: "ClientProtocolError", error: currentError });
                 }),
-                Effect.interruptible,
                 Effect.forkScoped
             );
 
-            /**
-             * Sending messages is as simple as encoding them, then posting them
-             * to the frida side tagged with our client id so it knows where to
-             * send them back to.
-             */
-            const send = Effect.fnUntraced(function* (message: RpcMessage.FromClientEncoded) {
-                const encoded = parser.encode(message);
-                if (Predicate.isUndefined(encoded)) return;
-                yield* script.callExport(makeExportName(clientId), Schema.Void)(encoded).pipe(Effect.orDie);
-            });
-
             return {
-                send,
                 supportsAck: true,
                 supportsTransferables: false,
+                send(clientId, request) {
+                    if (currentError) {
+                        return Effect.fail(currentError);
+                    }
+
+                    if (request._tag === "Request") {
+                        requestClientMap.set(request.id, clientId);
+                    }
+
+                    const encoded = parser.encode(request);
+                    if (encoded === undefined) return Effect.void;
+                    return Effect.orDie(script.callExport(clientExportName)(encoded));
+                },
             };
         })
     );
@@ -126,16 +142,13 @@ export const layerProtocolFrida = (
         | {
               /**
                * Name for the main rpc export that all clients start by
-               * connecting to.
+               * connecting to to inform the script of their client id.
                */
               readonly exportName?: string | undefined;
-
-              /** Generates server listener rpc exports for individual clients. */
-              readonly generateExportName?: ((clientId: number) => string) | undefined;
           }
         | undefined
 ): Layer.Layer<
     RpcClient.Protocol,
     FridaSessionError.FridaSessionError,
     RpcSerialization.RpcSerialization | FridaScript.FridaScript
-> => Layer.scoped(RpcClient.Protocol, makeProtocolFrida(options));
+> => Layer.effect(RpcClient.Protocol, makeProtocolFrida(options));