stitchkit 0.110.5 → 0.111.0

package/dist/{index-jk44mbqb.js → index-1y0arq4z.js}

@@ -14,10 +14,6 @@ import {
   withUploadProgress,
   parseApiErrorBody
 } from "./index-p6apg0jg.js";
-import {
-  abortReason,
-  untilAborted
-} from "./index-a5qr2rj6.js";
 import {
   inputIsQuery
 } from "./index-xhzq2qvj.js";
@@ -25,6 +21,9 @@ import {
   ApiError2,
   refuseLocally
 } from "./index-kfjkb396.js";
+import {
+  chunksOf
+} from "./index-cjbn98zt.js";
 import {
   assertPositiveSafeInteger
 } from "./index-0s4xebbg.js";
@@ -131,59 +130,6 @@ function createBoundedLineDecoder(maxLineBytes, requireFinalNewline = false) {
   const { push, end } = createLineSplitter(maxLineBytes, requireFinalNewline);
   return { push, end };
 }
-async function* chunksOf(source, signal) {
-  signal?.throwIfAborted();
-  const stream = source instanceof Response ? source.body : source;
-  if (stream === null)
-    return;
-  if (stream instanceof ReadableStream) {
-    const reader = stream.getReader();
-    const abort = () => {
-      if (signal)
-        reader.cancel(abortReason(signal)).catch(() => {
-          return;
-        });
-    };
-    signal?.addEventListener("abort", abort, { once: true });
-    try {
-      for (;; ) {
-        const chunk = await reader.read();
-        signal?.throwIfAborted();
-        if (chunk.done)
-          return;
-        yield chunk.value;
-      }
-    } finally {
-      signal?.removeEventListener("abort", abort);
-      await reader.cancel().catch(() => {
-        return;
-      });
-      reader.releaseLock();
-    }
-  }
-  const iterator = stream[Symbol.asyncIterator]();
-  let finished = false;
-  try {
-    for (;; ) {
-      const pending = iterator.next();
-      const next = await (signal ? untilAborted(pending, signal) : pending);
-      if (next.done) {
-        finished = true;
-        return;
-      }
-      yield next.value;
-    }
-  } finally {
-    if (!finished && signal?.aborted)
-      iterator.return?.().catch(() => {
-        return;
-      });
-    else if (!finished)
-      await iterator.return?.().catch(() => {
-        return;
-      });
-  }
-}
 async function* readBoundedUtf8Lines(source, maxLineBytes, requireFinalNewline = false, signal) {
   const splitter = createLineSplitter(maxLineBytes, requireFinalNewline);
   for await (const chunk of chunksOf(source, signal)) {

package/dist/{index-5pbtbce0.js → index-7c957abz.js}

@@ -19,7 +19,7 @@ import {
   appendEventIn,
   ArchiveProjectionSchema,
   createAgentRuntimeStore2
-} from "./index-mpg1t7nv.js";
+} from "./index-0z3kfphz.js";
 import {
   AgentConversationPageSchema2,
   AgentConversationMessagePageSchema2

package/dist/{index-e1sjcjfy.js → index-7r4knwf8.js}

@@ -23,6 +23,62 @@ import {
   assertPositiveSafeInteger
 } from "./index-0s4xebbg.js";
 
+// src/process/group-diagnostics.ts
+import { z } from "zod";
+var ObservationSchema = z.object({
+  failure: z.enum(["deadline", "observation"]),
+  groupId: z.number().int().positive(),
+  observations: z.number().int().nonnegative(),
+  lastStates: z.array(z.string().max(32)).max(16),
+  elapsedMs: z.number().int().nonnegative()
+});
+var observations = new WeakMap;
+
+class GroupSettlementError extends Error {
+  constructor(message, observation, cause = observation) {
+    super(`${message}: ${JSON.stringify(observation)}`, { cause });
+    observations.set(this, { ...observation, lastStates: [...observation.lastStates] });
+  }
+}
+function ownData(value, key) {
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  return descriptor && "value" in descriptor ? descriptor.value : undefined;
+}
+function groupSettlementDiagnostics(cause) {
+  const pending = [{ value: cause, depth: 0 }];
+  const seen = new Set;
+  const found = [];
+  for (let visited = 0;pending.length && visited < 32 && found.length < 4; visited++) {
+    const entry = pending.pop();
+    if (!entry || seen.has(entry.value))
+      continue;
+    seen.add(entry.value);
+    try {
+      if (entry.value instanceof Error) {
+        const observation = observations.get(entry.value);
+        if (observation)
+          found.push(observation);
+      }
+      if (!(entry.value instanceof Error) || entry.depth >= 8)
+        continue;
+      if (entry.value instanceof AggregateError) {
+        const errors = ownData(entry.value, "errors");
+        if (Array.isArray(errors)) {
+          for (let index = 0;index < 16; index++) {
+            const value = ownData(errors, String(index));
+            if (value !== undefined)
+              pending.push({ value, depth: entry.depth + 1 });
+          }
+        }
+      }
+      const nested = ownData(entry.value, "cause");
+      if (nested !== undefined)
+        pending.push({ value: nested, depth: entry.depth + 1 });
+    } catch {}
+  }
+  return found;
+}
+
 // src/process/group-presence.ts
 function processGroupExists(pid) {
   try {
@@ -57,36 +113,49 @@ function processGroups(timeoutMs) {
   return new Promise((resolve, reject) => {
     execFile("ps", ["-axo", "pgid=,stat="], { encoding: "utf8", timeout: timeoutMs, killSignal: "SIGKILL", maxBuffer: 1024 * 1024 }, (error, stdout) => {
       if (error)
-        reject(new Error("Could not observe command process group settlement", { cause: error }));
+        reject(error);
       else
         resolve(stdout);
     });
   });
 }
-async function waitForProcessGroupExit(pid, deadline) {
+async function waitForProcessGroupExit(pid, deadline, killLiveMembers) {
   if (pid === undefined)
     return;
   let observations = 0;
   let lastStates = [];
-  for (;; ) {
-    const remaining = Math.ceil(deadline - performance.now());
-    if (remaining <= 0)
-      throw new Error("Command process group settlement was not confirmed after SIGKILL", {
-        cause: { groupId: pid, observations, lastStates }
-      });
-    if (!processGroupExists(pid))
-      return;
-    const table = await processGroups(remaining);
-    observations++;
-    if (!hasLiveGroupMember(table, pid))
-      return;
-    lastStates = table.split(/\r?\n/).flatMap((row) => {
-      const fields = /^\s*(\d+)\s+(\S+)\s*$/.exec(row);
-      return Number(fields?.[1]) === pid ? [fields?.[2] ?? "unknown"] : [];
-    }).slice(0, 16);
-    if (!processGroupExists(pid))
-      return;
-    await sleep(Math.min(5, Math.max(0, deadline - performance.now())));
+  const startedAt = performance.now();
+  const observation = () => ({
+    groupId: pid,
+    observations,
+    lastStates,
+    elapsedMs: Math.max(0, Math.ceil(performance.now() - startedAt))
+  });
+  try {
+    for (;; ) {
+      const remaining = Math.ceil(deadline - performance.now());
+      if (remaining <= 0)
+        throw new GroupSettlementError("Command process group settlement was not confirmed after SIGKILL", { ...observation(), failure: "deadline" });
+      if (!processGroupExists(pid))
+        return;
+      const table = await processGroups(remaining);
+      observations++;
+      if (!hasLiveGroupMember(table, pid))
+        return;
+      lastStates = table.split(/\r?\n/).flatMap((row) => {
+        const fields = /^\s*(\d+)\s+(\S+)\s*$/.exec(row);
+        return Number(fields?.[1]) === pid ? [(fields?.[2] ?? "unknown").slice(0, 32)] : [];
+      }).slice(0, 16);
+      if (!processGroupExists(pid))
+        return;
+      if (killLiveMembers && performance.now() < deadline && !await killLiveMembers())
+        return;
+      await sleep(Math.min(5, Math.max(0, deadline - performance.now())));
+    }
+  } catch (cause) {
+    if (cause instanceof GroupSettlementError)
+      throw cause;
+    throw new GroupSettlementError("Could not observe command process group settlement", { ...observation(), failure: "observation" }, cause);
   }
 }
 
@@ -151,7 +220,7 @@ async function killAndSettleGroup(pid, deadline, cleanupTimeoutMs) {
   const cleanupDeadline = Math.min(deadline, performance.now() + cleanupTimeoutMs);
   const signalled = await signalUntilSettled(pid, "SIGKILL", cleanupDeadline);
   if (signalled)
-    await waitForProcessGroupExit(pid, cleanupDeadline);
+    await waitForProcessGroupExit(pid, cleanupDeadline, () => signalUntilSettled(pid, "SIGKILL", cleanupDeadline));
   return signalled;
 }
 async function stopCommandGroup(stop) {
@@ -235,7 +304,9 @@ async function stopLeaderAlone(stop) {
   return send("SIGKILL") || signalled;
 }
 function commandCleanupError(cause) {
-  return new NativeCommandError2("COMMAND_CLEANUP", "Command cleanup did not complete", {
+  const observations = groupSettlementDiagnostics(cause);
+  const message = observations.length ? `Command cleanup did not complete: ${JSON.stringify(observations)}` : "Command cleanup did not complete";
+  return new NativeCommandError2("COMMAND_CLEANUP", message, {
     cause
   });
 }

package/dist/index-cjbn98zt.js

@@ -0,0 +1,68 @@
+import {
+  abortReason,
+  untilAborted
+} from "./index-a5qr2rj6.js";
+
+// src/internal/stream-chunks.ts
+async function* chunksOf(source, signal) {
+  signal?.throwIfAborted();
+  const stream = source instanceof Response ? source.body : source;
+  if (stream === null)
+    return;
+  if (stream instanceof ReadableStream) {
+    const reader = stream.getReader();
+    const abort = () => {
+      if (signal)
+        reader.cancel(abortReason(signal)).catch(() => {
+          return;
+        });
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    try {
+      for (;; ) {
+        const pending = reader.read();
+        const chunk = await (signal ? untilAborted(pending, signal) : pending);
+        signal?.throwIfAborted();
+        if (chunk.done)
+          return;
+        yield chunk.value;
+      }
+    } finally {
+      signal?.removeEventListener("abort", abort);
+      if (signal?.aborted) {
+        reader.cancel(abortReason(signal)).catch(() => {
+          return;
+        });
+      } else {
+        await reader.cancel().catch(() => {
+          return;
+        });
+        reader.releaseLock();
+      }
+    }
+  }
+  const iterator = stream[Symbol.asyncIterator]();
+  let finished = false;
+  try {
+    for (;; ) {
+      const pending = iterator.next();
+      const next = await (signal ? untilAborted(pending, signal) : pending);
+      if (next.done) {
+        finished = true;
+        return;
+      }
+      yield next.value;
+    }
+  } finally {
+    if (!finished && signal?.aborted)
+      iterator.return?.().catch(() => {
+        return;
+      });
+    else if (!finished)
+      await iterator.return?.().catch(() => {
+        return;
+      });
+  }
+}
+
+export { chunksOf };

package/dist/{index-bm180f2d.js → index-ey15wx6j.js}

@@ -7,7 +7,7 @@ import {
 import {
   CommandStopped,
   startNativeCommand
-} from "./index-e1sjcjfy.js";
+} from "./index-7r4knwf8.js";
 import {
   NumericFileHandle,
   descriptorPath,

package/dist/{index-s0xbnpfh.js → index-kdnfe0sr.js}

@@ -5,7 +5,7 @@ import {
   fetchGuarded,
   PrivateAddressRefusal,
   readCapped
-} from "./index-3h0ztg0z.js";
+} from "./index-t65erk4z.js";
 import {
   writeFileAtomicSync2
 } from "./index-07dcf2yn.js";

package/dist/{index-s6d8zsha.js → index-krng2a5j.js}

@@ -27,6 +27,14 @@ import {
   bindContract,
   mediaTypeEssence
 } from "./index-pzw0fpek.js";
+import {
+  readBoundedChunks,
+  concatChunks,
+  readBoundedBody2
+} from "./index-qndsr7f0.js";
+import {
+  abortReason
+} from "./index-a5qr2rj6.js";
 import {
   assertPositiveSafeInteger
 } from "./index-0s4xebbg.js";
@@ -418,27 +426,10 @@ async function collectFile(part, stream) {
   });
 }
 async function readText(stream, maxBytes) {
-  const chunks = [];
-  const reader = stream.getReader();
-  let total = 0;
-  while (true) {
-    const result = await reader.read();
-    if (result.done)
-      break;
-    total += result.value.length;
-    if (total > maxBytes) {
-      await reader.cancel();
-      badRequest2(`Multipart text field exceeds ${maxBytes} bytes`);
-    }
-    chunks.push(result.value);
-  }
-  const value = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    value.set(chunk, offset);
-    offset += chunk.length;
-  }
-  return decoder.decode(value);
+  const result = await readBoundedChunks(stream, { maxBytes });
+  if (result.kind === "over-limit")
+    badRequest2(`Multipart text field exceeds ${maxBytes} bytes`);
+  return decoder.decode(concatChunks(result.chunks, result.total));
 }
 function required(policy) {
   return policy.required !== false;
@@ -896,63 +887,16 @@ function mergeContextContribution(ctx, value, scope) {
 }
 
 // src/server/request-body.ts
-function requestAbortReason(req) {
-  return req.signal.reason ?? new DOMException("The connection was closed", "AbortError");
-}
-function throwIfRequestAborted(req) {
-  if (req.signal.aborted)
-    throw requestAbortReason(req);
-}
 async function readRequestText(req, maxBytes) {
-  throwIfRequestAborted(req);
+  if (req.signal.aborted)
+    throw abortReason(req.signal);
   if (maxBytes === undefined)
     return req.text();
   assertPositiveSafeInteger("maxJsonBodyBytes", maxBytes, Error);
-  const reader = req.body?.getReader();
-  if (!reader)
-    return "";
-  const chunks = [];
-  let total = 0;
-  let rejectAbortedRead = (_reason) => {
-    return;
-  };
-  const abortedRead = new Promise((_resolve, reject) => {
-    rejectAbortedRead = reject;
-  });
-  const onAbort = () => {
-    const reason = requestAbortReason(req);
-    rejectAbortedRead(reason);
-    reader.cancel(reason).catch(() => {
-      return;
-    });
-  };
-  req.signal.addEventListener("abort", onAbort, { once: true });
-  if (req.signal.aborted)
-    onAbort();
-  try {
-    while (true) {
-      const { done, value } = await Promise.race([reader.read(), abortedRead]);
-      if (done)
-        break;
-      total += value.byteLength;
-      if (total > maxBytes) {
-        await reader.cancel();
-        badRequest2(`JSON body exceeds the ${maxBytes}-byte limit`);
-      }
-      chunks.push(value);
-    }
-  } finally {
-    req.signal.removeEventListener("abort", onAbort);
-    if (!req.signal.aborted)
-      reader.releaseLock();
-  }
-  const bytes = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return new TextDecoder().decode(bytes);
+  const result = await readBoundedChunks(req.body, { maxBytes, signal: req.signal });
+  if (result.kind === "over-limit")
+    badRequest2(`JSON body exceeds the ${maxBytes}-byte limit`);
+  return new TextDecoder().decode(concatChunks(result.chunks, result.total));
 }
 
 // src/server/context.ts
@@ -1979,13 +1923,25 @@ function logOutgoing(entry) {
 
 // src/server/request-completion.ts
 var BODY_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var DEFAULT_PAYLOAD_LOG_BYTES = 1024 * 1024;
+async function readPayload(clone, maxBytes) {
+  try {
+    const result = await readBoundedChunks(clone.body, { maxBytes, signal: clone.signal });
+    if (result.kind === "over-limit")
+      return { value: undefined, truncated: true };
+    return {
+      value: JSON.parse(new TextDecoder().decode(concatChunks(result.chunks, result.total))),
+      truncated: false
+    };
+  } catch {
+    return { value: undefined, truncated: false };
+  }
+}
 function openRequestCompletion(state, window) {
   const { logConfig, customLogger, useDefaultLog, observability } = state;
   const { req, url, traceId, startedAt, ipAddress } = window;
   const shouldLogRequest = logConfig !== null && shouldLog(url.pathname, req.method) && !shouldSkipLog(logConfig, req, url);
-  const payload = observability?.includePayload && BODY_METHODS.has(req.method) ? req.clone().json().catch(() => {
-    return;
-  }) : undefined;
+  const payloadRead = observability?.includePayload && BODY_METHODS.has(req.method) ? readPayload(req.clone(), observability.payloadMaxBytes ?? state.config.maxJsonBodyBytes ?? DEFAULT_PAYLOAD_LOG_BYTES) : undefined;
   const logFormat = resolveLogFormat(logConfig?.format);
   let reqLog;
   if (shouldLogRequest && useDefaultLog) {
@@ -2026,7 +1982,10 @@ function openRequestCompletion(state, window) {
           context,
           statusCode: status,
           durationMs,
-          payload,
+          ...payloadRead && {
+            payload: payloadRead.then((read) => read.value),
+            payloadTruncated: payloadRead.then((read) => read.truncated)
+          },
           ...outcome !== undefined && { outcome }
         });
       } catch {}
@@ -2367,6 +2326,23 @@ function bindProcessSignals2(handle, options = {}) {
   return { promise, close };
 }
 
+// src/server/request-ingress.ts
+function defineRequestIngress2(name) {
+  const values = new WeakMap;
+  return {
+    name,
+    attach(request, value) {
+      if (values.has(request)) {
+        throw new TypeError(`[stitchkit] request ingress ${JSON.stringify(name)} is already attached to this request`);
+      }
+      values.set(request, value);
+    },
+    from(source) {
+      return source.req && values.get(source.req);
+    }
+  };
+}
+
 // src/server/websocket.ts
 function webSocketLane2(lane) {
   const { match, handlers } = lane;
@@ -2630,39 +2606,17 @@ import {
 
 // src/server/unix-client-body.ts
 async function readBoundedRequestBody(request, maxBytes) {
-  const body = request.body;
-  if (!body)
+  if (!request.body)
     return;
+  const tooLarge = () => new UnixClientTransportError2("UNIX_REQUEST_TOO_LARGE", `Unix request body exceeds the ${maxBytes} byte limit`, "not-dispatched");
   const declared = request.headers.get("content-length");
-  if (declared !== null && Number(declared) > maxBytes) {
-    throw new UnixClientTransportError2("UNIX_REQUEST_TOO_LARGE", `Unix request body exceeds the ${maxBytes} byte limit`, "not-dispatched");
-  }
-  const reader = body.getReader();
-  const chunks = [];
-  let total = 0;
-  try {
-    for (;; ) {
-      if (request.signal.aborted)
-        throw request.signal.reason;
-      const chunk = await reader.read();
-      if (chunk.done)
-        break;
-      total += chunk.value.byteLength;
-      if (total > maxBytes) {
-        throw new UnixClientTransportError2("UNIX_REQUEST_TOO_LARGE", `Unix request body exceeds the ${maxBytes} byte limit`, "not-dispatched");
-      }
-      chunks.push(chunk.value);
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const result = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    result.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return result;
+  if (declared !== null && Number(declared) > maxBytes)
+    throw tooLarge();
+  return readBoundedBody2(request.body, {
+    maxBytes,
+    signal: request.signal,
+    limitError: tooLarge
+  });
 }
 function incomingResponseBody(response, maxBytes, onDone) {
   let finished = false;
@@ -3474,4 +3428,4 @@ function createUnixClientTransport2(config) {
   };
 }
 
-export { contextContributionDelta, prepareContextContribution, mergeContextContribution, parseMultipart2, DEFAULT_STREAM_HEARTBEAT_MS2, streamingRoute2, ndjsonRoute2, sseRoute2, createHandler2, createScopedImplementRegistry2, implementRegistry2, createImplementRegistry2, bindProcessSignals2, webSocketLane2, composeWebSocketHandlers2, createSocketIOServer2, socketIoLane2, UnixClientTransportError2, createUnixClientTransport2 };
+export { contextContributionDelta, prepareContextContribution, mergeContextContribution, parseMultipart2, DEFAULT_STREAM_HEARTBEAT_MS2, streamingRoute2, ndjsonRoute2, sseRoute2, createHandler2, createScopedImplementRegistry2, implementRegistry2, createImplementRegistry2, bindProcessSignals2, defineRequestIngress2, webSocketLane2, composeWebSocketHandlers2, createSocketIOServer2, socketIoLane2, UnixClientTransportError2, createUnixClientTransport2 };

package/dist/{index-9ket8wzx.js → index-mnk5vgdr.js}

@@ -17,7 +17,7 @@ import {
   replaceMessage,
   ArchiveSpillSchema,
   createAgentRuntimeStore2
-} from "./index-mpg1t7nv.js";
+} from "./index-0z3kfphz.js";
 
 // src/agent-runtime/store-memory.ts
 import { z as z2 } from "zod";

package/dist/index-qndsr7f0.js

@@ -0,0 +1,55 @@
+import {
+  chunksOf
+} from "./index-cjbn98zt.js";
+import {
+  abortReason
+} from "./index-a5qr2rj6.js";
+import {
+  assertPositiveSafeInteger
+} from "./index-0s4xebbg.js";
+
+// src/internal/bounded-body.ts
+async function readBoundedChunks(source, options) {
+  options.signal?.throwIfAborted();
+  const chunks = [];
+  let total = 0;
+  if (source === null)
+    return { kind: "complete", chunks, total };
+  for await (const chunk of chunksOf(source, options.signal)) {
+    if (!(chunk instanceof Uint8Array)) {
+      throw new TypeError("A bounded body source must yield bytes (Uint8Array chunks)");
+    }
+    total += chunk.byteLength;
+    options.onChunk?.(chunk);
+    if (total > options.maxBytes)
+      return { kind: "over-limit", total };
+    chunks.push(chunk);
+  }
+  return { kind: "complete", chunks, total };
+}
+function concatChunks(chunks, total) {
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+async function readBoundedBody2(source, options) {
+  assertPositiveSafeInteger("maxBytes", options.maxBytes);
+  let result;
+  try {
+    result = await readBoundedChunks(source, options);
+  } catch (error) {
+    const { signal, abortError } = options;
+    if (signal?.aborted && abortError)
+      throw abortError(abortReason(signal));
+    throw error;
+  }
+  if (result.kind === "over-limit")
+    throw options.limitError(result.total);
+  return concatChunks(result.chunks, result.total);
+}
+
+export { readBoundedChunks, concatChunks, readBoundedBody2 };

package/dist/{index-n7hrpngg.js → index-syzngt7v.js}

@@ -26,7 +26,7 @@ import {
 import {
   fetchGuarded,
   readCapped
-} from "./index-3h0ztg0z.js";
+} from "./index-t65erk4z.js";
 import {
   isWithinDir2
 } from "./index-5cc6r990.js";

package/dist/{index-3h0ztg0z.js → index-t65erk4z.js}

@@ -1,6 +1,9 @@
 import {
   raceAbort
 } from "./index-b0kddvzw.js";
+import {
+  readBoundedChunks
+} from "./index-qndsr7f0.js";
 
 // src/internal/secure-fetch.ts
 import { lookup } from "node:dns/promises";
@@ -259,27 +262,8 @@ async function fetchPinnedDocument(start, options) {
   throw new Error("too many redirects");
 }
 async function readCapped(res, max) {
-  const reader = res.body?.getReader();
-  if (!reader)
-    return Buffer.alloc(0);
-  const chunks = [];
-  let total = 0;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      total += value.length;
-      if (total > max) {
-        await reader.cancel();
-        return null;
-      }
-      chunks.push(value);
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  return Buffer.concat(chunks);
+  const result = await readBoundedChunks(res.body, { maxBytes: max });
+  return result.kind === "over-limit" ? null : Buffer.concat(result.chunks);
 }
 
 export { fetchGuarded, PrivateAddressRefusal, fetchPinnedDocument, readCapped };