@kitman-sh/cli 0.9.0 → 0.10.53

package/dist/{chunk-8z5b6fpd.js → chunk-x9dhxfts.js}

@@ -6,48 +6,53 @@ import {
   assignProperty,
   isNone,
   isSome,
-  map,
-  Service,
-  empty,
+  map4,
+  Service2,
+  empty3,
   add,
   getOrUndefinedUnsafe,
   getUnsafe,
-  get,
+  get4,
   Reference,
-  isSuccess,
   toMillis,
-  squash,
-  findError,
-  hasInterrupts,
-  interruptors,
-  failCause,
-  fail2,
-  die2,
-  interrupt,
+  isSuccess,
+  failCause2,
+  fail4,
+  die,
+  interrupt2,
+  void_2,
   isFailure2,
+  makeUnsafe5,
+  _await,
+  isDoneUnsafe,
+  succeed4,
   Scope,
   addFinalizerExit,
   addFinalizer,
-  succeed4,
+  succeed5,
   effect,
-  Clock,
-  min,
+  hasInterruptsOnly,
+  squash,
+  findError,
+  hasInterrupts2,
+  interruptors,
+  min2,
   exponential,
   spaced,
   forEach,
   whileLoop,
-  suspend,
-  sync,
-  void_2,
-  callback,
+  suspend3,
+  sync2,
+  void_3,
+  callback3,
   never,
   gen,
-  fail4,
-  withFiber,
-  flatMap2,
-  andThen,
-  map3,
-  catchCause,
+  fail7,
+  withFiber2,
+  flatMap3,
+  andThen2,
+  map8,
+  catchCause2,
   catchCauseIf,
   orDie,
   tapCause,
@@ -60,17 +65,19 @@ import {
   matchCauseEffect,
   context,
   contextWith,
-  provideContext,
+  provideContext2,
   serviceOption,
   updateService,
   scoped,
-  ensuring,
+  addFinalizer2,
+  ensuring2,
   onError,
   onExit,
-  interrupt2,
+  interrupt3,
   interruptible,
   onInterrupt,
-  uninterruptibleMask,
+  uninterruptible,
+  uninterruptibleMask2,
   forever,
   makeSpanScoped,
   useSpan,
@@ -81,37 +88,45 @@ import {
   fnUntraced,
   logError,
   annotateLogs,
-  interrupt3,
+  decodeUnknownEffect2,
+  decodeSync,
+  encodeEffect,
+  Void,
+  NonEmptyArray,
+  Defect,
+  Exit,
+  toCodecJson
+} from "./chunk-mbctzx7e.js";
+import {
+  interrupt,
   getCurrent,
-  makeUnsafe3,
+  makeUnsafe2,
   bounded,
   offerAll,
-  failCause3,
+  failCause,
   end,
   shutdownUnsafe,
   fromQueue,
-  unwrap,
-  empty2,
+  unwrap
+} from "./chunk-11p4wf6n.js";
+import {
+  Clock,
+  empty,
   fromInput,
-  merge2,
-  decodeUnknownEffect,
-  decodeSync,
-  encodeEffect,
-  NonEmptyArray,
-  Defect,
-  toCodecJson,
+  merge,
   Socket,
   SocketReadError,
   SocketError,
   isStreamSchema,
   getStreamSchemas,
   exitSchema,
+  ParseOptions,
   RpcClientDefect,
   RpcClientError
-} from "./chunk-3gxahgnq.js";
+} from "./chunk-wh1pa2aa.js";
 
-// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/workers/Transferable.js
-class Collector extends (/* @__PURE__ */ Service()("effect/workers/Transferable/Collector")) {
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/workers/Transferable.js
+class Collector extends (/* @__PURE__ */ Service2()("effect/workers/Transferable/Collector")) {
 }
 var makeCollectorUnsafe = () => {
   let tranferables = [];
@@ -126,15 +141,15 @@ var makeCollectorUnsafe = () => {
   };
   return Collector.of({
     addAllUnsafe: unsafeAddAll,
-    addAll: (transferables) => sync(() => unsafeAddAll(transferables)),
+    addAll: (transferables) => sync2(() => unsafeAddAll(transferables)),
     readUnsafe: unsafeRead,
-    read: sync(unsafeRead),
+    read: sync2(unsafeRead),
     clearUnsafe: unsafeClear,
-    clear: sync(unsafeClear)
+    clear: sync2(unsafeClear)
   });
 };
 
-// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/rpc/internal/tracing.js
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/rpc/internal/tracing.js
 var spanName = (spanPrefix, tag) => spanPrefix === undefined ? tag : `${spanPrefix}.${tag}`;
 var spanAttributes = (tag, attributes) => ({
   "rpc.system.name": "effect_rpc",
@@ -142,18 +157,18 @@ var spanAttributes = (tag, attributes) => ({
   ...attributes
 });
 
-// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/rpc/RpcMessage.js
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/rpc/RpcMessage.js
 var RequestId = (id) => id;
 var constPing = {
   _tag: "Ping"
 };
 
-// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/rpc/RpcSerialization.js
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/rpc/RpcSerialization.js
 var codecForJson = toCodecJson;
 var sharedTextDecoder;
 var decodeText = (bytes) => (sharedTextDecoder ??= new TextDecoder).decode(bytes);
 
-class RpcSerialization extends (/* @__PURE__ */ Service()("effect/rpc/RpcSerialization")) {
+class RpcSerialization extends (/* @__PURE__ */ Service2()("effect/rpc/RpcSerialization")) {
 }
 var defaultMaxBufferSize = 16 * 1024 * 1024;
 var json = /* @__PURE__ */ RpcSerialization.of({
@@ -169,10 +184,10 @@ var json = /* @__PURE__ */ RpcSerialization.of({
   })
 });
 var defaultSchemaBinaryMaxFrameSize = 16 * 1024 * 1024;
-var layerJson = /* @__PURE__ */ succeed4(RpcSerialization)(json);
+var layerJson = /* @__PURE__ */ succeed5(RpcSerialization)(json);
 
-// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/rpc/Utils.js
-var withRunClient = (f) => suspend(() => {
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/rpc/Utils.js
+var withRunClient = (f) => suspend3(() => {
   const clientIds = new Set;
   const clientBuffers = new Map;
   const clientWrites = new Map;
@@ -183,9 +198,9 @@ var withRunClient = (f) => suspend(() => {
       clientBuffers.set(clientId, buffer);
     }
     buffer.push([data, context]);
-    return void_2;
+    return void_3;
   });
-  return map3(f((clientId, data) => {
+  return map8(f((clientId, data) => {
     const clientWrite = clientWrites.get(clientId);
     if (clientWrite) {
       return clientWrite(data);
@@ -201,20 +216,20 @@ var withRunClient = (f) => suspend(() => {
         if (buffer) {
           clientBuffers.delete(clientId);
           for (const [args, context] of buffer) {
-            yield* provideContext(suspend(() => f(args)), context);
+            yield* provideContext2(suspend3(() => f(args)), context);
           }
         }
         return yield* onExit(never, () => {
           clientIds.delete(clientId);
           clientWrites.delete(clientId);
-          return void_2;
+          return void_3;
         });
       });
     }
   }));
 });
 
-// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/rpc/RpcClient.js
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/rpc/RpcClient.js
 var requestIdCounter = 0;
 var makeNoSerialization = /* @__PURE__ */ fnUntraced(function* (group, options) {
   const spanPrefix = options.spanPrefix;
@@ -222,29 +237,30 @@ var makeNoSerialization = /* @__PURE__ */ fnUntraced(function* (group, options)
   const disableTracing = options?.disableTracing ?? false;
   const generateRequestId = options?.generateRequestId ?? (() => requestIdCounter++);
   const services = yield* context();
-  const scope = get(services, Scope);
+  const scope = get4(services, Scope);
   const entries = new Map;
   let isShutdown = false;
-  yield* addFinalizer(scope, withFiber((parent) => {
+  yield* addFinalizer(scope, withFiber2((parent) => {
     isShutdown = true;
-    return clearEntries(interrupt(parent.id));
+    return clearEntries(interrupt2(parent.id));
   }));
   const clearEntries = fnUntraced(function* (exit) {
-    for (const [id, entry] of entries) {
-      entries.delete(id);
+    const pending = Array.from(entries.values());
+    entries.clear();
+    for (const entry of pending) {
       if (entry._tag === "Queue") {
-        yield* exit._tag === "Success" ? end(entry.queue) : failCause3(entry.queue, exit.cause);
+        yield* exit._tag === "Success" ? end(entry.queue) : failCause(entry.queue, exit.cause);
       } else {
         entry.resume(exit);
       }
     }
-  });
+  }, uninterruptible);
   const onRequest = (rpc) => {
     const isStream = isStreamSchema(rpc.successSchema);
     const middleware = getRpcClientMiddleware(rpc);
     return (payload, opts) => {
-      const headers = opts?.headers ? fromInput(opts.headers) : empty2;
-      const context = opts?.context ?? empty();
+      const headers = opts?.headers ? fromInput(opts.headers) : empty;
+      const context = opts?.context ?? empty3();
       if (!isStream) {
         const onRequest = (span) => onEffectRequest(rpc, middleware, span, rpc.payloadSchema.make(payload), headers, context, opts?.discard ?? false);
         return disableTracing ? onRequest(undefined) : useSpan(spanName(spanPrefix, rpc._tag), {
@@ -255,18 +271,17 @@ var makeNoSerialization = /* @__PURE__ */ fnUntraced(function* (group, options)
       const queue = onStreamRequest(rpc, middleware, rpc.payloadSchema.make(payload), headers, opts?.streamBufferSize ?? 16, context);
       if (opts?.asQueue)
         return queue;
-      return unwrap(map3(queue, fromQueue));
+      return unwrap(map8(queue, fromQueue));
     };
   };
-  const onEffectRequest = (rpc, middleware, span, payload, headers, context, discard) => withFiber((parentFiber) => {
+  const onEffectRequest = (rpc, middleware, span, payload, headers, context, discard) => withFiber2((parentFiber) => {
     if (isShutdown) {
-      return interrupt2;
+      return interrupt3;
     }
     const id = generateRequestId();
     const send = middleware((message) => options.onFromClient({
       message,
-      context,
-      discard
+      context
     }), {
       _tag: "Request",
       id,
@@ -277,18 +292,25 @@ var makeNoSerialization = /* @__PURE__ */ fnUntraced(function* (group, options)
         spanId: span.spanId,
         sampled: span.sampled
       } : {},
-      headers: merge2(parentFiber.getRef(CurrentHeaders), headers)
+      headers: merge(parentFiber.getRef(CurrentHeaders), headers),
+      ...discard ? {
+        discard: true
+      } : {}
     });
-    if (discard) {
-      return send;
-    }
     let fiber;
-    return onInterrupt(callback((resume) => {
+    return onInterrupt(callback3((resume) => {
+      let acked = false;
       const entry = {
         _tag: "Effect",
         rpc,
         context,
         resume(exit) {
+          if (discard && exit._tag === "Success") {
+            acked = true;
+            if (fiber?.pollUnsafe())
+              resume(void_2);
+            return;
+          }
           resume(exit);
           if (fiber && !fiber.pollUnsafe()) {
             parentFiber.currentDispatcher.scheduleTask(() => {
@@ -303,17 +325,20 @@ var makeNoSerialization = /* @__PURE__ */ fnUntraced(function* (group, options)
       }) : identity, runForkWith(parentFiber.context));
       fiber.addObserver((exit) => {
         if (exit._tag === "Failure") {
+          entries.delete(id);
           return resume(exit);
+        } else if (acked) {
+          return resume(void_2);
         }
       });
     }), (interruptors) => {
       entries.delete(id);
-      return andThen(interrupt3(fiber), sendInterrupt(id, Array.from(interruptors), context));
+      return andThen2(interrupt(fiber), sendInterrupt(id, Array.from(interruptors), context));
     });
   });
   const onStreamRequest = fnUntraced(function* (rpc, middleware, payload, headers, streamBufferSize, context) {
     if (isShutdown) {
-      return yield* interrupt2;
+      return yield* interrupt3;
     }
     const span = disableTracing ? undefined : yield* makeSpanScoped(spanName(spanPrefix, rpc._tag), {
       kind: "client",
@@ -326,7 +351,7 @@ var makeNoSerialization = /* @__PURE__ */ fnUntraced(function* (group, options)
     yield* addFinalizerExit(scope, (exit) => {
       shutdownUnsafe(queue);
       if (!entries.has(id))
-        return void_2;
+        return void_3;
       entries.delete(id);
       return sendInterrupt(id, isFailure2(exit) ? Array.from(interruptors(exit.cause)) : [], context);
     });
@@ -339,8 +364,7 @@ var makeNoSerialization = /* @__PURE__ */ fnUntraced(function* (group, options)
     });
     yield* middleware((message) => options.onFromClient({
       message,
-      context,
-      discard: false
+      context
     }), {
       _tag: "Request",
       id,
@@ -351,10 +375,14 @@ var makeNoSerialization = /* @__PURE__ */ fnUntraced(function* (group, options)
         spanId: span.spanId,
         sampled: span.sampled
       } : {},
-      headers: merge2(fiber.getRef(CurrentHeaders), headers)
+      headers: merge(fiber.getRef(CurrentHeaders), headers)
     }).pipe(span ? withParentSpan(span, {
       captureStackTrace: false
-    }) : identity, onError((cause) => failCause3(queue, cause)), interruptible, forkIn(scope, {
+    }) : identity, onError((cause) => {
+      if (!hasInterruptsOnly(cause))
+        entries.delete(id);
+      return failCause(queue, cause);
+    }), interruptible, forkIn(scope, {
       startImmediately: true
     }));
     return queue;
@@ -383,7 +411,7 @@ var makeNoSerialization = /* @__PURE__ */ fnUntraced(function* (group, options)
       });
     };
   };
-  const sendInterrupt = (requestId, interruptors, context) => callback((resume) => {
+  const sendInterrupt = (requestId, interruptors, context) => callback3((resume) => {
     const parentFiber = getCurrent();
     const fiber = options.onFromClient({
       message: {
@@ -391,11 +419,10 @@ var makeNoSerialization = /* @__PURE__ */ fnUntraced(function* (group, options)
         requestId,
         interruptors
       },
-      context,
-      discard: false
+      context
     }).pipe(timeout(1000), runForkWith(parentFiber.context));
     fiber.addObserver(() => {
-      resume(void_2);
+      resume(void_3);
     });
   });
   const write = (message) => {
@@ -404,33 +431,32 @@ var makeNoSerialization = /* @__PURE__ */ fnUntraced(function* (group, options)
         const requestId = message.requestId;
         const entry = entries.get(requestId);
         if (!entry || entry._tag !== "Queue")
-          return void_2;
-        return offerAll(entry.queue, message.values).pipe(supportsAck ? flatMap2(() => options.onFromClient({
+          return void_3;
+        return offerAll(entry.queue, message.values).pipe(supportsAck ? flatMap3((dropped) => dropped.length > 0 ? void_3 : options.onFromClient({
           message: {
             _tag: "Ack",
             requestId: message.requestId
           },
-          context: entry.context,
-          discard: false
-        })) : identity, catchCause((cause) => failCause3(entry.queue, cause)));
+          context: entry.context
+        })) : identity, catchCause2((cause) => failCause(entry.queue, cause)));
       }
       case "Exit": {
         const requestId = message.requestId;
         const entry = entries.get(requestId);
         if (!entry)
-          return void_2;
+          return void_3;
         entries.delete(requestId);
         if (entry._tag === "Effect") {
           entry.resume(message.exit);
-          return void_2;
+          return void_3;
         }
-        return message.exit._tag === "Success" ? end(entry.queue) : failCause3(entry.queue, message.exit.cause);
+        return message.exit._tag === "Success" ? end(entry.queue) : failCause(entry.queue, message.exit.cause);
       }
       case "Defect": {
-        return clearEntries(die2(message.defect));
+        return clearEntries(die(message.defect));
       }
       case "ClientEnd": {
-        return void_2;
+        return void_3;
       }
     }
   };
@@ -457,7 +483,7 @@ var makeNoSerialization = /* @__PURE__ */ fnUntraced(function* (group, options)
   };
 });
 var clientIdCounter = 0;
-var make4 = /* @__PURE__ */ fnUntraced(function* (group, options) {
+var make = /* @__PURE__ */ fnUntraced(function* (group, options) {
   const clientId = clientIdCounter++;
   const {
     codecFor,
@@ -469,9 +495,10 @@ var make4 = /* @__PURE__ */ fnUntraced(function* (group, options) {
   const rpcSchemas = makeRpcSchemas(codecFor);
   const decodeDefect = decodeSync(codecFor(Defect()));
   const entries = new Map;
+  const closing = makeUnsafe5();
   const interruptRequest = (requestId) => {
     if (!entries.has(requestId))
-      return void_2;
+      return void_3;
     entries.delete(requestId);
     return send(clientId, {
       _tag: "Interrupt",
@@ -495,20 +522,27 @@ var make4 = /* @__PURE__ */ fnUntraced(function* (group, options) {
           const entry = {
             rpc,
             context: collector ? add(fiber.context, Collector, collector) : fiber.context,
-            schemas: rpcSchemas(rpc)
+            schemas: rpcSchemas(rpc),
+            discard: message.discard === true
           };
           entries.set(message.id, entry);
-          return entry.schemas.encodePayload(message.payload).pipe(provideContext(entry.context), orDie, flatMap2((payload) => send(clientId, {
-            ...message,
-            id: message.id,
-            payload,
-            headers: Object.entries(message.headers)
-          }, collector && collector.readUnsafe())));
+          return entry.schemas.encodePayload(message.payload).pipe(provideContext2(entry.context), orDie, flatMap3((payload) => {
+            if (isDoneUnsafe(closing)) {
+              entries.delete(message.id);
+              return interrupt3;
+            }
+            return send(clientId, {
+              ...message,
+              id: message.id,
+              payload,
+              headers: Object.entries(message.headers)
+            }, collector && collector.readUnsafe());
+          }), onError((cause) => hasInterruptsOnly(cause) ? void_3 : sync2(() => entries.delete(message.id))));
         }
         case "Ack": {
           const entry = entries.get(message.requestId);
           if (!entry)
-            return void_2;
+            return void_3;
           return send(clientId, {
             _tag: "Ack",
             requestId: message.requestId
@@ -518,7 +552,7 @@ var make4 = /* @__PURE__ */ fnUntraced(function* (group, options) {
           return interruptRequest(message.requestId);
         }
         case "Eof": {
-          return void_2;
+          return void_3;
         }
       }
     }
@@ -529,9 +563,9 @@ var make4 = /* @__PURE__ */ fnUntraced(function* (group, options) {
         const requestId = RequestId(message.requestId);
         const entry = entries.get(requestId);
         if (!entry || isNone(entry.schemas.decodeChunk))
-          return void_2;
+          return void_3;
         const decodeChunk = entry.schemas.decodeChunk.value;
-        return uninterruptibleMask((restore) => restore(decodeChunk(message.values).pipe(provideContext(entry.context), orDie, flatMap2((chunk) => write({
+        return uninterruptibleMask2((restore) => restore(decodeChunk(message.values).pipe(provideContext2(entry.context), orDie, flatMap3((chunk) => write({
           _tag: "Chunk",
           clientId: 0,
           requestId,
@@ -540,16 +574,25 @@ var make4 = /* @__PURE__ */ fnUntraced(function* (group, options) {
           _tag: "Exit",
           clientId: 0,
           requestId,
-          exit: failCause(cause)
-        }).pipe(andThen(hasInterrupts(cause) ? void_2 : ignore(interruptRequest(requestId))))), catchCauseIf((cause) => !hasInterrupts(cause), () => void_2)));
+          exit: failCause2(cause)
+        }).pipe(andThen2(hasInterrupts2(cause) ? void_3 : raceFirst(ignore(interruptRequest(requestId)), _await(closing))))), catchCauseIf((cause) => !hasInterrupts2(cause), () => void_3)));
       }
       case "Exit": {
         const requestId = RequestId(message.requestId);
         const entry = entries.get(requestId);
         if (!entry)
-          return void_2;
+          return void_3;
         entries.delete(requestId);
-        return entry.schemas.decodeExit(message.exit).pipe(provideContext(entry.context), orDie, matchCauseEffect({
+        if (entry.discard && message.exit._tag === "Success") {
+          return write({
+            _tag: "Exit",
+            clientId: 0,
+            requestId,
+            exit: void_2
+          });
+        }
+        const decodeExit = entry.discard ? entry.schemas.decodeDiscardExit : entry.schemas.decodeExit;
+        return decodeExit(message.exit).pipe(provideContext2(entry.context), orDie, matchCauseEffect({
           onSuccess: (exit) => write({
             _tag: "Exit",
             clientId: 0,
@@ -560,11 +603,12 @@ var make4 = /* @__PURE__ */ fnUntraced(function* (group, options) {
             _tag: "Exit",
             clientId: 0,
             requestId,
-            exit: failCause(cause)
+            exit: failCause2(cause)
           })
         }));
       }
       case "Defect": {
+        entries.clear();
         return write({
           _tag: "Defect",
           clientId: 0,
@@ -572,19 +616,23 @@ var make4 = /* @__PURE__ */ fnUntraced(function* (group, options) {
         });
       }
       case "ClientProtocolError": {
-        const exit = fail2(message.error);
-        return forEach(Array.from(entries.keys()), (requestId) => write({
+        const exit = fail4(message.error);
+        const requestIds = message.requestIds === undefined ? Array.from(entries.keys()) : message.requestIds.map(RequestId).filter((requestId) => entries.has(requestId));
+        for (const requestId of requestIds)
+          entries.delete(requestId);
+        return forEach(requestIds, (requestId) => write({
           _tag: "Exit",
           clientId: 0,
           requestId,
           exit
-        }));
+        })).pipe(uninterruptible);
       }
       default: {
-        return void_2;
+        return void_3;
       }
     }
-  }).pipe(catchCause(logError), interruptible, forkScoped);
+  }).pipe(catchCause2(logError), interruptible, forkScoped);
+  yield* addFinalizer2(() => succeed4(closing, undefined));
   return client;
 });
 var makeRpcSchemas = (codecFor) => {
@@ -595,21 +643,25 @@ var makeRpcSchemas = (codecFor) => {
       return entry;
     }
     const streamSchemas = getStreamSchemas(rpc.successSchema);
+    const parseOptions = get4(rpc.annotations, ParseOptions);
+    const exitSchema2 = exitSchema(rpc);
+    let decodeDiscardExit;
     entry = {
-      decodeChunk: map(streamSchemas, (streamSchemas) => decodeUnknownEffect(codecFor(NonEmptyArray(streamSchemas.success)))),
-      encodePayload: encodeEffect(codecFor(rpc.payloadSchema)),
-      decodeExit: decodeUnknownEffect(codecFor(exitSchema(rpc)))
+      decodeChunk: map4(streamSchemas, (streamSchemas) => decodeUnknownEffect2(codecFor(NonEmptyArray(streamSchemas.success)), parseOptions)),
+      encodePayload: encodeEffect(codecFor(rpc.payloadSchema), parseOptions),
+      decodeExit: decodeUnknownEffect2(codecFor(exitSchema2), parseOptions),
+      decodeDiscardExit: (encoded) => (decodeDiscardExit ??= decodeUnknownEffect2(codecFor(Exit(Void, exitSchema2.error, exitSchema2.defect)), parseOptions))(encoded)
     };
     cache.set(rpc, entry);
     return entry;
   };
 };
 var CurrentHeaders = /* @__PURE__ */ Reference("effect/rpc/RpcClient/CurrentHeaders", {
-  defaultValue: () => empty2
+  defaultValue: () => empty
 });
-var withHeaders = /* @__PURE__ */ dual(2, (effect, headers) => updateService(effect, CurrentHeaders, merge2(fromInput(headers))));
+var withHeaders = /* @__PURE__ */ dual(2, (effect, headers) => updateService(effect, CurrentHeaders, merge(fromInput(headers))));
 
-class Protocol extends (/* @__PURE__ */ Service()("effect/rpc/RpcClient/Protocol")) {
+class Protocol extends (/* @__PURE__ */ Service2()("effect/rpc/RpcClient/Protocol")) {
   static make = withRunClient;
 }
 var makeProtocolSocket = (options) => Protocol.make(fnUntraced(function* (writeResponse, clientIds) {
@@ -619,13 +671,19 @@ var makeProtocolSocket = (options) => Protocol.make(fnUntraced(function* (writeR
   const requestClientMap = new Map;
   const writer = yield* socket.writer;
   let parser = serialization.makeUnsafe();
-  const pinger = yield* makePinger(suspend(() => writer.write(parser.encode(constPing))), options);
-  const onPingTimeout = ignoreCause(options?.onPingTimeout ?? void_2, {
+  const pinger = yield* makePinger(suspend3(() => writer.write(parser.encode(constPing))), options);
+  const onPingTimeout = ignoreCause(options?.onPingTimeout ?? void_3, {
     log: true,
     message: "RpcClient onPingTimeout hook failed"
   });
   let currentError;
-  const broadcast = (response) => forEach(clientIds, (clientId) => writeResponse(clientId, response));
+  const broadcast = (response) => {
+    const deliver = forEach(Array.from(clientIds), (clientId) => writeResponse(clientId, response));
+    if (response._tag !== "Defect" && response._tag !== "ClientProtocolError")
+      return deliver;
+    requestClientMap.clear();
+    return uninterruptible(deliver);
+  };
   const broadcastError = (error) => {
     currentError = error;
     return broadcast({
@@ -637,7 +695,7 @@ var makeProtocolSocket = (options) => Protocol.make(fnUntraced(function* (writeR
     try {
       const responses = parser.decode(data);
       if (responses.length === 0)
-        return void_2;
+        return void_3;
       pinger.onFrame();
       let i = 0;
       return whileLoop({
@@ -645,7 +703,7 @@ var makeProtocolSocket = (options) => Protocol.make(fnUntraced(function* (writeR
         body: () => {
           const response = responses[i++];
           if (response._tag === "Pong")
-            return void_2;
+            return void_3;
           if (Object.hasOwn(response, "requestId")) {
             const requestId = response.requestId;
             const clientId = requestClientMap.get(requestId);
@@ -672,7 +730,7 @@ var makeProtocolSocket = (options) => Protocol.make(fnUntraced(function* (writeR
       });
     }
   };
-  yield* suspend(() => {
+  yield* suspend3(() => {
     parser = serialization.makeUnsafe();
     pinger.reset();
     let connected = false;
@@ -691,12 +749,12 @@ var makeProtocolSocket = (options) => Protocol.make(fnUntraced(function* (writeR
           yield* processData(frames[i]);
         }
       }
-    }).pipe(scoped, raceFirst(pinger.timeout), andThen(() => connected ? onPingTimeout : void_2), andThen(() => fail4(new SocketError({
+    }).pipe(scoped, raceFirst(pinger.timeout), andThen2(() => connected ? onPingTimeout : void_3), andThen2(() => fail7(new SocketError({
       reason: new SocketReadError({
         cause: new Error("ping timeout")
       })
     }))));
-  }).pipe(isSome(hooks) ? ensuring(hooks.value.onDisconnect) : identity, tapCause((cause) => {
+  }).pipe(isSome(hooks) ? ensuring2(hooks.value.onDisconnect) : identity, tapCause((cause) => {
     const error = findError(cause);
     const hasError = isSuccess(error);
     const rpcError = new RpcClientError({
@@ -706,7 +764,7 @@ var makeProtocolSocket = (options) => Protocol.make(fnUntraced(function* (writeR
       })
     });
     if (options?.retryTransientErrors && hasError && error.success.reason._tag === "SocketOpenError") {
-      return (options.onTransientError?.(rpcError) ?? void_2).pipe(ignoreCause({
+      return (options.onTransientError?.(rpcError) ?? void_3).pipe(ignoreCause({
         log: true,
         message: "RpcClient onTransientError hook failed"
       }));
@@ -718,41 +776,47 @@ var makeProtocolSocket = (options) => Protocol.make(fnUntraced(function* (writeR
     module: "RpcClient",
     method: "makeProtocolSocket"
   }), forkScoped);
+  const write = (request) => suspend3(() => {
+    const encoded = parser.encode(request);
+    return encoded === undefined ? void_3 : orDie(writer.write(encoded));
+  });
   return {
     send(clientId, request) {
       if (currentError) {
-        return fail4(currentError);
-      }
-      if (request._tag === "Request") {
-        requestClientMap.set(request.id, clientId);
+        return fail7(currentError);
       }
-      const encoded = parser.encode(request);
-      if (encoded === undefined)
-        return void_2;
-      return orDie(writer.write(encoded));
+      if (request._tag === "Interrupt")
+        requestClientMap.delete(request.requestId);
+      if (request._tag !== "Request")
+        return write(request);
+      requestClientMap.set(request.id, clientId);
+      return onError(write(request), () => sync2(() => requestClientMap.delete(request.id)));
     },
     supportsAck: true,
     supportsTransferables: false,
     codecFor: serialization.codecFor
   };
 }));
-var defaultRetryPolicy = /* @__PURE__ */ min([/* @__PURE__ */ exponential(500, 1.5), /* @__PURE__ */ spaced(5000)]);
+var defaultRetryPolicy = /* @__PURE__ */ min2([/* @__PURE__ */ exponential(500, 1.5), /* @__PURE__ */ spaced(5000)]);
 var makePinger = /* @__PURE__ */ fnUntraced(function* (writePing, options) {
   const clock = yield* Clock;
   const interval = options?.pingInterval ?? "5 seconds";
   const timeoutMillis = toMillis(options?.pingTimeout ?? interval);
   let lastSeen = clock.currentTimeMillisUnsafe();
-  const latch = makeUnsafe3();
+  let awaitingResponse = false;
+  const latch = makeUnsafe2();
   const onFrame = () => {
     lastSeen = clock.currentTimeMillisUnsafe();
+    awaitingResponse = false;
   };
   const reset = () => {
     onFrame();
     latch.closeUnsafe();
   };
-  yield* suspend(() => {
-    if (clock.currentTimeMillisUnsafe() - lastSeen > timeoutMillis)
+  yield* suspend3(() => {
+    if (awaitingResponse && clock.currentTimeMillisUnsafe() - lastSeen > timeoutMillis)
       return latch.open;
+    awaitingResponse = true;
     return writePing;
   }).pipe(delay(interval), ignore, forever, interruptible, forkScoped);
   return {
@@ -762,7 +826,7 @@ var makePinger = /* @__PURE__ */ fnUntraced(function* (writePing, options) {
   };
 });
 var layerProtocolSocket = (options) => effect(Protocol)(makeProtocolSocket(options));
-class ConnectionHooks extends (/* @__PURE__ */ Service()("effect/rpc/RpcClient/ConnectionHooks")) {
+class ConnectionHooks extends (/* @__PURE__ */ Service2()("effect/rpc/RpcClient/ConnectionHooks")) {
 }
 
-export { layerJson, make4, withHeaders, layerProtocolSocket, ConnectionHooks };
+export { layerJson, make, withHeaders, layerProtocolSocket, ConnectionHooks };