ignotum 0.0.6 → 0.0.8

package/src/client/files.ts

@@ -0,0 +1,168 @@
+import {
+  FileId,
+  fileGrantUrlOf,
+  fileIdOf,
+  fileFormats,
+  fileLimits,
+  fileMimeTypes,
+  grantFileValue,
+  isFileValue,
+  makeFileValue,
+  type FileFormat,
+  type FileValue,
+  type RuntimeFileOccurrence,
+} from "@ignotum/contracts/schema/file";
+import { IdGenerator } from "@ignotum/shared/id";
+import { Effect, Predicate } from "effect";
+
+export const Files = {
+  url: (file: FileValue): string => {
+    const url = fileGrantUrlOf(file);
+    if (url === undefined) {
+      throw new Error("This FileValue has no active query grant.");
+    }
+    return url;
+  },
+} as const;
+
+const formatByMime: Partial<Record<string, FileFormat>> = {};
+for (const format of fileFormats) formatByMime[fileMimeTypes[format]] = format;
+
+interface NativeOccurrence {
+  readonly path: ReadonlyArray<string | number>;
+  readonly value: File;
+}
+
+const collectNativeFiles = (
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- This is the recursive parser for generated mutation arguments and native File values.
+  value: unknown,
+  path: ReadonlyArray<string | number>,
+  occurrences: Array<NativeOccurrence>,
+): void => {
+  if (value instanceof File) {
+    occurrences.push({ path, value });
+    return;
+  }
+  if (isFileValue(value) || Predicate.isDate(value)) return;
+  if (globalThis.Array.isArray(value)) {
+    for (const [index, child] of value.entries())
+      collectNativeFiles(child, [...path, index], occurrences);
+    return;
+  }
+  if (!Predicate.isObject(value)) return;
+  for (const [key, child] of Object.entries(value))
+    collectNativeFiles(child, [...path, key], occurrences);
+};
+
+const replaceNativeFiles = (
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Each node is classified before it is copied into the transport value.
+  value: unknown,
+  replacements: ReadonlyMap<File, FileValue>,
+  // oxlint-disable-next-line anti-slop/no-unknown-returns -- The generated function schema validates the reconstructed argument value on the server.
+): unknown => {
+  if (value instanceof File) return replacements.get(value);
+  if (isFileValue(value) || Predicate.isDate(value)) return value;
+  if (globalThis.Array.isArray(value))
+    return value.map((child) => replaceNativeFiles(child, replacements));
+  if (!Predicate.isObject(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, child]) => [key, replaceNativeFiles(child, replacements)]),
+  );
+};
+
+export interface PreparedMutationArguments {
+  readonly value: unknown;
+  readonly nativeFiles: ReadonlyMap<FileId, File>;
+  readonly occurrences: ReadonlyArray<RuntimeFileOccurrence>;
+}
+
+export const prepareMutationArguments = Effect.fn("SyncClient.prepareMutationArguments")(function* (
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Generated mutation argument types are erased only at this transport preparation boundary.
+  input: unknown,
+) {
+  const ids = yield* IdGenerator;
+  const native: NativeOccurrence[] = [];
+  collectNativeFiles(input, [], native);
+  const unique = new Set(native.map(({ value }) => value));
+  if (unique.size > fileLimits.filesPerMutation) {
+    throw new Error(`A mutation may upload at most ${fileLimits.filesPerMutation} files.`);
+  }
+  const totalBytes = [...unique].reduce((total, file) => total + file.size, 0);
+  if (totalBytes > fileLimits.mutationBytes) {
+    throw new Error(`Mutation uploads may total at most ${fileLimits.mutationBytes} bytes.`);
+  }
+  const replacements = new Map<File, FileValue>();
+  const nativeFiles = new Map<FileId, File>();
+  for (const file of unique) {
+    const format = formatByMime[file.type.toLowerCase()];
+    if (format === undefined) {
+      throw new Error(
+        `File '${file.name}' has unsupported media type '${file.type || "unknown"}'.`,
+      );
+    }
+    if (file.size === 0 || file.size > fileLimits.fileBytes) {
+      throw new Error(`File '${file.name}' must be between 1 and ${fileLimits.fileBytes} bytes.`);
+    }
+    if (new TextEncoder().encode(file.name).byteLength > fileLimits.filenameBytes) {
+      throw new Error(`File '${file.name}' has a filename that is too long.`);
+    }
+    const id = yield* ids.generate(FileId);
+    replacements.set(file, makeFileValue(id, { format, name: file.name, size: file.size }));
+    nativeFiles.set(id, file);
+  }
+  const value = replaceNativeFiles(input, replacements);
+  const occurrences = native.map(({ path, value: file }) => {
+    const replacement = replacements.get(file);
+    if (replacement === undefined) throw new Error("A native file replacement is missing.");
+    return {
+      path,
+      file: {
+        id: fileIdOf(replacement),
+        format: replacement.format,
+        name: replacement.name,
+        size: replacement.size,
+      },
+    } satisfies RuntimeFileOccurrence;
+  });
+  return { value, nativeFiles, occurrences } satisfies PreparedMutationArguments;
+});
+
+interface FileGrantOccurrence extends RuntimeFileOccurrence {
+  readonly url: string;
+}
+
+const pathKey = (path: ReadonlyArray<string | number>): string => JSON.stringify(path);
+
+// @effect-diagnostics-next-line missingPipeableSignature:off File grant attachment naturally takes the decoded value first.
+export const applyFileGrants = (
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Query result types are erased at the wire decoding boundary and checked against grant paths below.
+  value: unknown,
+  grants: ReadonlyArray<FileGrantOccurrence>,
+  // oxlint-disable-next-line anti-slop/no-unknown-returns -- The traversal preserves the decoded query result shape while attaching private symbols.
+): unknown => {
+  const byPath = new Map(grants.map((grant) => [pathKey(grant.path), grant] as const));
+  const visit = (
+    // oxlint-disable-next-line anti-slop/no-unknown-parameters -- This recursive visitor validates a grant and file ID before replacement.
+    current: unknown,
+    path: ReadonlyArray<string | number>,
+    // oxlint-disable-next-line anti-slop/no-unknown-returns -- Recursive branches preserve their input shape.
+  ): unknown => {
+    const grant = byPath.get(pathKey(path));
+    if (grant !== undefined) {
+      if (!isFileValue(current) || fileIdOf(current) !== grant.file.id) {
+        throw new Error("A query file grant does not match its result value.");
+      }
+      return grantFileValue(current, grant.url);
+    }
+    if (globalThis.Array.isArray(current)) {
+      return current.map((child, index) => visit(child, [...path, index]));
+    }
+    if (!Predicate.isObject(current) || Predicate.isDate(current) || isFileValue(current)) {
+      return current;
+    }
+    return Object.fromEntries(
+      Object.entries(current).map(([key, child]) => [key, visit(child, [...path, key])]),
+    );
+  };
+  return visit(value, []);
+};

package/src/client/hooks.ts

@@ -1,15 +1,16 @@
 import { Effect, Schema } from "effect";
-import { useDebugValue, useEffect, useMemo, useState } from "preact/hooks";
+import { useCallback, useDebugValue, useEffect, useMemo, useState } from "preact/hooks";
 
 import { functionPathOf, type FunctionReference } from "../internal/api.js";
-import { pending } from "@ignotum/contracts/runtime/result";
+import { inspectResult, pending, Result as RuntimeResult } from "@ignotum/contracts/runtime/result";
 import type { ErrorValue, QueryResult, SettledResult } from "@ignotum/contracts/runtime/result";
-import { encodeTransportObject } from "@ignotum/contracts/runtime/sync";
 import {
-  ClientInfrastructureError,
-  InvalidMutationArguments,
-  reportClientError,
-} from "./errors.js";
+  PaginationPageSize,
+  type PaginationOptions,
+  type PaginationPage,
+} from "@ignotum/contracts/runtime/pagination";
+import { encodeTransportObject } from "@ignotum/contracts/runtime/sync";
+import { ClientInfrastructureError } from "./errors.js";
 import { isQuerySkip, type QuerySkip } from "./query.js";
 import { SyncClient, syncClientInternals, syncRuntime } from "./sync.js";
 
@@ -102,6 +103,163 @@ export function useQuery<Args extends object, Success, Failure extends ErrorValu
   return result;
 }
 
+export type PaginationStatus = "CanLoadMore" | "Exhausted" | "LoadingMore";
+
+export interface PaginatedQueryValue<Item> {
+  readonly items: ReadonlyArray<Item>;
+  readonly loadMore: () => void;
+  readonly status: PaginationStatus;
+}
+
+export interface PaginatedQueryOptions {
+  readonly pageSize?: number;
+}
+
+type PaginationArguments = { readonly pagination: PaginationOptions };
+type ApplicationPaginationArguments<Args extends PaginationArguments> = Omit<Args, "pagination">;
+
+// @effect-diagnostics-next-line missingPipeableSignature:off React hooks are not pipeable functions.
+export function usePaginatedQuery<
+  Args extends PaginationArguments,
+  Item,
+  Failure extends ErrorValue,
+>(
+  reference: keyof ApplicationPaginationArguments<Args> extends never
+    ? FunctionReference<"Query", Args, PaginationPage<Item>, Failure>
+    : never,
+): QueryResult<PaginatedQueryValue<Item>, Failure>;
+export function usePaginatedQuery<
+  Args extends PaginationArguments,
+  Item,
+  Failure extends ErrorValue,
+>(
+  reference: FunctionReference<"Query", Args, PaginationPage<Item>, Failure>,
+  args: NoInfer<ApplicationPaginationArguments<Args>> | QuerySkip,
+  options?: PaginatedQueryOptions,
+): QueryResult<PaginatedQueryValue<Item>, Failure>;
+// @effect-diagnostics-next-line missingPipeableSignature:off React hooks must remain direct calls so hook order is statically visible.
+export function usePaginatedQuery<Args extends object, Item, Failure extends ErrorValue>(
+  reference: FunctionReference<"Query", Args & PaginationArguments, PaginationPage<Item>, Failure>,
+  args?: Args | QuerySkip,
+  options: PaginatedQueryOptions = {},
+): QueryResult<PaginatedQueryValue<Item>, Failure> {
+  const functionPath = functionPathOf(reference);
+  const skipped = isQuerySkip(args);
+  const input = args === undefined || skipped ? {} : args;
+  const jsonArgs = encodeTransportObject(input);
+  const pageSize = Schema.decodeSync(PaginationPageSize)(options.pageSize ?? 20);
+  const identity = skipped
+    ? `skip:${functionPath}`
+    : syncClientInternals.queryIdentity(functionPath, jsonArgs);
+  const [requestedPages, setRequestedPages] = useState(1);
+  const [refresh, setRefresh] = useState(0);
+  const [state, setState] = useState<{
+    readonly identity: string;
+    readonly result: QueryResult<PaginatedQueryValue<Item>, Failure> | ClientInfrastructureError;
+  }>(() => ({ identity, result: pending() }));
+  const loadMore = useCallback(() => setRequestedPages((count) => count + 1), []);
+
+  useDebugValue({ args: input, function: functionPath, result: state.result });
+
+  useEffect(() => {
+    setRequestedPages(1);
+    setState({ identity, result: pending() });
+  }, [identity, pageSize]);
+
+  useEffect(() => {
+    if (skipped) return;
+
+    let active = true;
+    const releases: Array<() => void> = [];
+
+    void syncRuntime
+      .runPromise(
+        Effect.gen(function* () {
+          const client = yield* SyncClient;
+          const items: Item[] = [];
+          let cursor: PaginationOptions["cursor"] = null;
+
+          for (let pageNumber = 0; pageNumber < requestedPages; pageNumber += 1) {
+            const pageArgs = encodeTransportObject({
+              ...input,
+              pagination: { cursor, pageSize },
+            });
+            const observer = yield* client.observe(functionPath, pageArgs);
+            if (!active) {
+              yield* observer.release;
+              return;
+            }
+            const releaseSubscription = observer.subscribe(() => {
+              if (active) setRefresh((version) => version + 1);
+            });
+            releases.push(() => {
+              releaseSubscription();
+              syncRuntime.runFork(observer.release);
+            });
+
+            const snapshot = observer.getSnapshot();
+            if (Schema.is(ClientInfrastructureError)(snapshot)) {
+              setState({ identity, result: snapshot });
+              return;
+            }
+            const inspected = inspectResult(snapshot);
+            if (inspected === undefined) {
+              setState({
+                identity,
+                result:
+                  items.length === 0
+                    ? pending()
+                    : RuntimeResult.succeed({ items, loadMore, status: "LoadingMore" }),
+              });
+              return;
+            }
+            if (inspected.type === "Failure") {
+              // SAFETY: pagination changes only the successful value. The
+              // failure channel is the generated query reference's Failure.
+              setState({
+                identity,
+                result: snapshot as QueryResult<PaginatedQueryValue<Item>, Failure>,
+              });
+              return;
+            }
+            // SAFETY: the generated reference and values.page validator couple
+            // this successful snapshot to PaginationPage<Item>.
+            const page = inspected.value as PaginationPage<Item>;
+            items.push(...page.items);
+            cursor = page.nextCursor;
+            if (cursor === null) {
+              setState({
+                identity,
+                result: RuntimeResult.succeed({ items, loadMore, status: "Exhausted" }),
+              });
+              return;
+            }
+          }
+
+          setState({
+            identity,
+            result: RuntimeResult.succeed({ items, loadMore, status: "CanLoadMore" }),
+          });
+        }),
+      )
+      .catch((error) => {
+        if (active && Schema.is(ClientInfrastructureError)(error)) {
+          setState({ identity, result: error });
+        }
+      });
+
+    return () => {
+      active = false;
+      for (const release of releases) release();
+    };
+  }, [functionPath, identity, loadMore, pageSize, refresh, requestedPages, skipped]);
+
+  if (skipped || state.identity !== identity) return pending();
+  const result = state.result;
+  if (Schema.is(ClientInfrastructureError)(result)) throw result;
+  return result;
+}
+
 type Mutation<Args, Success, Failure extends ErrorValue> = [Args] extends [void]
   ? () => Promise<SettledResult<Success, Failure>>
   : (args: Args) => Promise<SettledResult<Success, Failure>>;
@@ -116,19 +274,10 @@ export const useMutation = <Args extends object | void, Success, Failure extends
       return syncRuntime.runPromise<SettledResult<Success, Failure>, ClientInfrastructureError>(
         Effect.gen(function* () {
           const client = yield* SyncClient;
-          const jsonArgs = yield* Effect.try({
-            try: () => encodeTransportObject(input),
-            catch: (cause) =>
-              InvalidMutationArguments.make({
-                cause,
-                function: functionPath,
-                message: `Mutation arguments for ${functionPath} contain an unsupported value.`,
-              }),
-          }).pipe(Effect.tapError(reportClientError));
           // SAFETY: generated function references bind the runtime path to the
           // declared public result types validated by the server executor.
           // oxlint-disable-next-line anti-slop/no-chained-type-assertions -- The untyped sync transport deliberately erases the generated reference's result parameters.
-          return (yield* client.mutate(functionPath, jsonArgs)) as unknown as SettledResult<
+          return (yield* client.mutate(functionPath, input)) as unknown as SettledResult<
             Success,
             Failure
           >;

package/src/client/index.ts

@@ -9,7 +9,15 @@ export const Result = { match: contractResult.match };
 export type Result<Value, Error extends ErrorValue> = SettledResult<Value, Error>;
 export type QueryResult<Value, Error extends ErrorValue> = ContractQueryResult<Value, Error>;
 export type { InternalServerError } from "@ignotum/contracts/runtime/result";
-export { useMutation, useQuery } from "./hooks.js";
+export type {
+  FileFormat,
+  FileMetadata,
+  FileMimeType,
+  FileValue,
+} from "@ignotum/contracts/schema/file";
+export { Files } from "./files.js";
+export { useMutation, usePaginatedQuery, useQuery } from "./hooks.js";
+export type { PaginatedQueryOptions, PaginatedQueryValue, PaginationStatus } from "./hooks.js";
 export { Query } from "./query.js";
 export type { QuerySkip } from "./query.js";
 export { app } from "./app.js";

package/src/client/sync.ts

@@ -16,6 +16,7 @@ import * as BrowserCrypto from "@effect/platform-browser/BrowserCrypto";
 import { encodeCanonicalJson } from "@ignotum/contracts/json";
 import { type AppStateRevision } from "@ignotum/contracts/runtime/hosted";
 import { IdGenerator } from "@ignotum/shared/id";
+import { encodeTransportObject } from "@ignotum/contracts/runtime/sync";
 
 import type {
   ErrorValue,
@@ -42,10 +43,12 @@ import {
   InvalidClientMessage,
   InvalidServerMessage,
   ServerProtocolError,
+  InvalidMutationArguments,
   clientErrorReporterLayer,
   reportClientError,
 } from "./errors.js";
 import { syncPath } from "../internal/http-paths.js";
+import { applyFileGrants, prepareMutationArguments } from "./files.js";
 
 type Listener = () => void;
 type SocketWriter = (chunk: string) => Effect.Effect<void, Socket.SocketError>;
@@ -195,14 +198,19 @@ const makeQueryCache = (
   } satisfies QueryCache;
 };
 
-const resultFromWire = Effect.fn("SyncClient.resultFromWire")((wire: WireResult) =>
-  Effect.succeed(
-    wire.type === "Success"
-      ? Result.succeed(
-          wire.value === undefined ? undefined : decodeTransportValue(wire.value, wire.dates ?? []),
-        )
-      : failureFromWire(wire.error, wire.dates),
-  ),
+type SnapshotFiles = NonNullable<Extract<ServerMessage, { readonly type: "Snapshot" }>["files"]>;
+
+const resultFromWire = Effect.fn("SyncClient.resultFromWire")(
+  (wire: WireResult, files: SnapshotFiles = []) =>
+    Effect.succeed(
+      wire.type === "Success"
+        ? Result.succeed(
+            wire.value === undefined
+              ? undefined
+              : applyFileGrants(decodeTransportValue(wire.value, wire.dates ?? []), files),
+          )
+        : failureFromWire(wire.error, wire.dates),
+    ),
 );
 
 export const shouldReloadForCloseCode = (code: number): boolean =>
@@ -242,7 +250,8 @@ const socketUrl = (): string => {
 interface SyncClientService {
   readonly mutate: (
     functionAddress: FunctionAddress,
-    args: Schema.Json,
+    // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Generated reference argument types are deliberately erased at the client transport boundary.
+    args: unknown,
   ) => Effect.Effect<IgnotumResult<unknown, ErrorValue>, ClientInfrastructureError>;
   readonly observe: (
     functionAddress: FunctionAddress,
@@ -256,7 +265,11 @@ interface PendingInvocation {
     ClientInfrastructureError
   >;
   readonly function: FunctionAddress;
-  readonly message: Extract<ClientMessage, { readonly type: "Invoke" }>;
+  readonly message: Extract<ClientMessage, { readonly type: "Invoke" | "PrepareMutation" }>;
+  readonly prepared: Deferred.Deferred<
+    Extract<ServerMessage, { readonly type: "MutationPrepared" }>["uploads"],
+    ClientInfrastructureError
+  >;
 }
 
 export class SyncClient extends Context.Service<SyncClient, SyncClientService>()(
@@ -319,6 +332,7 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
         }
         invocations = HashMap.remove(invocations, id);
         return reportClientError(error).pipe(
+          Effect.andThen(Deferred.fail(pendingInvocation.prepared, error)),
           Effect.andThen(Deferred.fail(pendingInvocation.deferred, error)),
           Effect.asVoid,
         );
@@ -331,13 +345,20 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
           case "Snapshot": {
             const entry = queryCache.getById(message.id);
             if (entry === undefined) return;
-            yield* resultFromWire(message.result).pipe(
+            yield* resultFromWire(message.result, message.files ?? []).pipe(
               Effect.tap((result) =>
                 Effect.sync(() => queryCache.setResult(message.id, result, message.revision)),
               ),
             );
             return;
           }
+          case "MutationPrepared": {
+            const pendingInvocation = HashMap.getUnsafe(invocations, message.id);
+            if (pendingInvocation !== undefined) {
+              yield* Deferred.succeed(pendingInvocation.prepared, message.uploads);
+            }
+            return;
+          }
           case "Result": {
             const pendingInvocation = HashMap.getUnsafe(invocations, message.id);
             if (pendingInvocation === undefined) return;
@@ -488,31 +509,126 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
       const mutate: SyncClientService["mutate"] = Effect.fn("SyncClient.mutate")(
         function* (functionAddress, args) {
           const invocationId = yield* ids.generate(InvocationId);
+          const preparedArguments = yield* prepareMutationArguments(args).pipe(
+            Effect.provideService(IdGenerator, ids),
+            Effect.mapError((cause) =>
+              InvalidMutationArguments.make({
+                cause,
+                function: functionAddress,
+                message: `Mutation arguments for ${functionAddress} contain an unsupported file or value.`,
+              }),
+            ),
+            Effect.tapError(reportClientError),
+          );
+          const jsonArgs = yield* Effect.try({
+            try: () => encodeTransportObject(preparedArguments.value),
+            catch: (cause) =>
+              InvalidMutationArguments.make({
+                cause,
+                function: functionAddress,
+                message: `Mutation arguments for ${functionAddress} contain an unsupported value.`,
+              }),
+          }).pipe(Effect.tapError(reportClientError));
           const deferred = yield* Deferred.make<
             IgnotumResult<unknown, ErrorValue>,
             ClientInfrastructureError
           >();
-          const message: ClientMessage = {
+          const prepared = yield* Deferred.make<
+            Extract<ServerMessage, { readonly type: "MutationPrepared" }>["uploads"],
+            ClientInfrastructureError
+          >();
+          const invokeMessage: Extract<ClientMessage, { readonly type: "Invoke" }> = {
             type: "Invoke",
             id: invocationId,
             kind: "Mutation",
             function: functionAddress,
-            args,
+            args: jsonArgs,
           };
+          const message: PendingInvocation["message"] =
+            preparedArguments.occurrences.length === 0
+              ? invokeMessage
+              : {
+                  type: "PrepareMutation",
+                  id: invocationId,
+                  kind: "Mutation",
+                  function: functionAddress,
+                  args: jsonArgs,
+                  files: preparedArguments.occurrences,
+                };
           invocations = HashMap.set(invocations, invocationId, {
             deferred,
             function: functionAddress,
             message,
+            prepared,
           });
-          if (writer !== undefined) {
-            yield* sendWith(writer, message).pipe(
-              Effect.catchTags({
-                ConnectionUnavailable: reportClientError,
-                InvalidClientMessage: (error) => rejectInvocation(invocationId, error),
+          return yield* Effect.gen(function* () {
+            if (writer !== undefined) {
+              yield* sendWith(writer, message).pipe(
+                Effect.catchTags({
+                  ConnectionUnavailable: reportClientError,
+                  InvalidClientMessage: (error) => rejectInvocation(invocationId, error),
+                }),
+              );
+            }
+            if (message.type === "PrepareMutation") {
+              const uploads = yield* Deferred.await(prepared);
+              const uploaded = new Set<string>();
+              for (const upload of uploads) {
+                if (upload.url === undefined || uploaded.has(upload.file.id)) continue;
+                const uploadUrl = upload.url;
+                uploaded.add(upload.file.id);
+                const file = preparedArguments.nativeFiles.get(upload.file.id);
+                if (file === undefined) {
+                  return yield* InvalidServerMessage.make({
+                    cause: new Error(`Missing native file '${upload.file.id}'.`),
+                    message: "The server prepared an unknown application file.",
+                  });
+                }
+                const response = yield* Effect.tryPromise({
+                  try: () =>
+                    fetch(uploadUrl, {
+                      method: "PUT",
+                      body: file,
+                      headers: { "content-type": file.type },
+                    }),
+                  catch: (cause) =>
+                    ConnectionUnavailable.make({
+                      cause,
+                      message: `File '${file.name}' could not be uploaded.`,
+                    }),
+                });
+                if (!response.ok) {
+                  const detail = yield* Effect.promise(() => response.text());
+                  return yield* InvalidMutationArguments.make({
+                    cause: new Error(detail),
+                    function: functionAddress,
+                    message: `File '${file.name}' was rejected by application storage.`,
+                  });
+                }
+              }
+              const pendingInvocation = HashMap.getUnsafe(invocations, invocationId);
+              if (pendingInvocation === undefined) return yield* Deferred.await(deferred);
+              invocations = HashMap.set(invocations, invocationId, {
+                ...pendingInvocation,
+                message: invokeMessage,
+              });
+              if (writer !== undefined) {
+                yield* sendWith(writer, invokeMessage).pipe(
+                  Effect.catchTags({
+                    ConnectionUnavailable: reportClientError,
+                    InvalidClientMessage: (error) => rejectInvocation(invocationId, error),
+                  }),
+                );
+              }
+            }
+            return yield* Deferred.await(deferred);
+          }).pipe(
+            Effect.tapError(() =>
+              Effect.sync(() => {
+                invocations = HashMap.remove(invocations, invocationId);
               }),
-            );
-          }
-          return yield* Deferred.await(deferred);
+            ),
+          );
         },
       );