@opendatalabs/personal-server-ts-server 1.35.5 → 1.36.0

package/dist/ui/ps-lite-debug.js

@@ -123780,14 +123780,14 @@ function parsePayload(value) {
     grantId: payload["grantId"]
   };
 }
-function parseWeb3SignedHeader(headerValue) {
-  if (!headerValue) {
+function parseWeb3SignedHeader(headerValue2) {
+  if (!headerValue2) {
     throw new MissingAuthError();
   }
-  if (!headerValue.startsWith(WEB3_SIGNED_PREFIX)) {
+  if (!headerValue2.startsWith(WEB3_SIGNED_PREFIX)) {
     throw new InvalidSignatureError2({ reason: "Missing Web3Signed prefix" });
   }
-  const value = headerValue.slice(WEB3_SIGNED_PREFIX.length);
+  const value = headerValue2.slice(WEB3_SIGNED_PREFIX.length);
   const dotIndex = value.indexOf(".");
   if (dotIndex === -1 || dotIndex === 0 || dotIndex === value.length - 1) {
     throw new InvalidSignatureError2({ reason: "Invalid header format" });
@@ -146023,8 +146023,8 @@ function canonicalJsonBytes(value) {
 // ../core/dist/auth/proof-id.js
 var MAX_PROOF_LIFETIME_SEC = 15 * 60;
 var PROOF_CLOCK_SKEW_SEC = 60;
-async function web3SignedProofId(headerValue, signer) {
-  const { payloadBase64 } = parseWeb3SignedHeader(headerValue);
+async function web3SignedProofId(headerValue2, signer) {
+  const { payloadBase64 } = parseWeb3SignedHeader(headerValue2);
   const bytes2 = new TextEncoder().encode(`${signer.toLowerCase()}
 ${payloadBase64}`);
   const digest6 = await crypto.subtle.digest("SHA-256", bytes2);
@@ -146113,8 +146113,8 @@ async function signedBytesFor(request2, bodyBytes) {
   });
 }
 async function verifyWriterAttribution(input) {
-  const headerValue = input.request.headers.get(WRITE_SIGNATURE_HEADER) ?? void 0;
-  if (!headerValue) {
+  const headerValue2 = input.request.headers.get(WRITE_SIGNATURE_HEADER) ?? void 0;
+  if (!headerValue2) {
     throw new ProtocolError(401, "WRITE_ATTRIBUTION_REQUIRED", `Session writes must carry a builder-signed payload proof in ${WRITE_SIGNATURE_HEADER}`);
   }
   const url2 = new URL(input.request.url);
@@ -146122,7 +146122,7 @@ async function verifyWriterAttribution(input) {
   const expectedUri = canonicalSignedUri(url2.pathname, url2.search);
   let expectedPath = expectedUri;
   try {
-    const claimedUri = parseWeb3SignedHeader(headerValue).payload.uri;
+    const claimedUri = parseWeb3SignedHeader(headerValue2).payload.uri;
     if (canonicalizeSignedUri(claimedUri) === expectedUri) {
       expectedPath = claimedUri;
     }
@@ -146131,7 +146131,7 @@ async function verifyWriterAttribution(input) {
   let verified;
   try {
     verified = await verifyWeb3Signed({
-      headerValue,
+      headerValue: headerValue2,
       expectedOrigin: resolveOrigin(input.serverOrigin),
       expectedMethod: input.request.method,
       expectedPath,
@@ -146147,7 +146147,7 @@ async function verifyWriterAttribution(input) {
     throw new ProtocolError(401, "WRITE_ATTRIBUTION_GRANT_MISMATCH", "Payload proof must carry the write session's grantId as a signed claim", { expected: input.grantId, actual: verified.payload.grantId ?? null });
   }
   const expiresAtMs = boundedProofExpiry(verified.payload, "WRITE_ATTRIBUTION_LIFETIME");
-  const { payloadBase64, signature } = parseWeb3SignedHeader(headerValue);
+  const { payloadBase64, signature } = parseWeb3SignedHeader(headerValue2);
   const nonce = signedNonce(payloadBase64);
   if (!isBodylessMethod(input.request.method) && bodyBytes.byteLength > 0 && isJsonContentType(input.request)) {
     assertCanonicalJsonBody(bodyBytes);
@@ -146155,7 +146155,7 @@ async function verifyWriterAttribution(input) {
   let releaseProof;
   if (input.replayStore) {
     const store = input.replayStore;
-    const proofId = nonce === void 0 ? await web3SignedProofId(headerValue, verified.signer) : await hashConnectionToken(`nonce:${input.builderAddress.toLowerCase()}:${nonce}`);
+    const proofId = nonce === void 0 ? await web3SignedProofId(headerValue2, verified.signer) : await hashConnectionToken(`nonce:${input.builderAddress.toLowerCase()}:${nonce}`);
     const replayed = await store.consume(proofId, expiresAtMs);
     if (replayed) {
       throw new ProtocolError(401, "WRITE_ATTRIBUTION_REPLAY", nonce === void 0 ? "Payload proof already used; sign a fresh proof for each call (or add a unique nonce claim so repeated reads stay distinct)" : "Payload proof nonce already used; each nonce is single use");
@@ -147395,10 +147395,10 @@ function decodeBase64(input) {
   }
   throw new Error("Base64 decoding is not available in this runtime");
 }
-function parseOAuthBasicAuth(headerValue) {
-  if (!headerValue?.startsWith("Basic "))
+function parseOAuthBasicAuth(headerValue2) {
+  if (!headerValue2?.startsWith("Basic "))
     return null;
-  const decoded = decodeBase64(headerValue.slice(6));
+  const decoded = decodeBase64(headerValue2.slice(6));
   const separatorIndex = decoded.indexOf(":");
   if (separatorIndex === -1)
     return null;
@@ -149826,12 +149826,12 @@ function base64decode(input) {
   const bytes2 = Uint8Array.from(binString, (c10) => c10.codePointAt(0) ?? 0);
   return new TextDecoder().decode(bytes2);
 }
-function parsePaymentHeader(headerValue) {
-  if (!headerValue)
+function parsePaymentHeader(headerValue2) {
+  if (!headerValue2)
     return null;
   let decoded;
   try {
-    decoded = base64decode(headerValue.trim());
+    decoded = base64decode(headerValue2.trim());
   } catch {
     return null;
   }
@@ -150274,8 +150274,8 @@ async function handleX402Cycle(input) {
       now: deps.now
     });
   }
-  const headerValue = input.request.headers.get("x-payment");
-  const parsed = parsePaymentHeader(headerValue);
+  const headerValue2 = input.request.headers.get("x-payment");
+  const parsed = parsePaymentHeader(headerValue2);
   if (!parsed) {
     return { kind: "challenge", body: await buildFreshChallenge() };
   }
@@ -150792,6 +150792,37 @@ async function handlePersonalServerScopeUploadAppend(request2, deps, batch) {
     return handleScopeUploadRequest(request2, deps, parts, batch);
   });
 }
+var READ_GRANTEE_OBSERVER = /* @__PURE__ */ Symbol.for("@opendatalabs/personal-server-ts-core/read-grantee-observer");
+function attachPersonalServerReadGranteeObserver(request2, observer) {
+  Object.defineProperty(request2, READ_GRANTEE_OBSERVER, {
+    value: observer,
+    configurable: true
+  });
+}
+function readGranteeObserverOf(request2) {
+  const observer = request2[READ_GRANTEE_OBSERVER];
+  return typeof observer === "function" ? observer : void 0;
+}
+async function granteeRefFor(authResult) {
+  if (authResult?.grantId === "owner" || authResult?.grantId === "policy-bypass") {
+    return "owner";
+  }
+  const builder = authResult?.builder;
+  if (typeof builder !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(builder)) {
+    return void 0;
+  }
+  const digest6 = await sha256Hex(new TextEncoder().encode(builder.toLowerCase()));
+  return digest6.slice(2, 14);
+}
+function notifyReadGrantee(request2, authResult) {
+  const observer = readGranteeObserverOf(request2);
+  if (!observer)
+    return;
+  try {
+    observer(granteeRefFor(authResult).catch(() => void 0));
+  } catch {
+  }
+}
 async function handlePersonalServerDataRequest(request2, deps, options = {}) {
   const logContext = {
     logger: deps.logger,
@@ -151029,6 +151060,7 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
         fileId: fileIdParam ?? selectedEntry?.fileId ?? void 0,
         at: atParam
       });
+      notifyReadGrantee(request2, authResult);
       const latest = fileIdParam === void 0 && atParam === void 0 && view === null ? await deps.legacyScopeView?.readLatest(scopeResult.scope) : void 0;
       const canonicalOwned = latest !== void 0 && deletionHistoryOf(latest) === "canonical";
       await assertScopeNotDeleted(deps, scopeResult.scope, canonicalOwned ? void 0 : selectedEntry, canonicalOwned ? "canonical" : "file");
@@ -151808,10 +151840,10 @@ function safeCompare(a10, b10) {
   }
   return diff === 0;
 }
-function getBearerToken(headerValue) {
-  if (!headerValue?.startsWith("Bearer "))
+function getBearerToken(headerValue2) {
+  if (!headerValue2?.startsWith("Bearer "))
     return null;
-  return headerValue.slice(7);
+  return headerValue2.slice(7);
 }
 async function cacheRequestBodyBytes(request2, maxBytes = DEFAULT_SIGNED_BODY_MAX_BYTES, consumeBody = false) {
   if (request2.method === "GET" || request2.method === "HEAD")
@@ -173915,6 +173947,9 @@ function buildRequest2(origin, bridgeRequest) {
 }
 async function handlePsLiteBridgeRequest(runtime, bridgeRequest, options = {}) {
   const request2 = buildRequest2(options.origin ?? "https://ps-lite.local", bridgeRequest);
+  if (options.onReadGrantee) {
+    attachPersonalServerReadGranteeObserver(request2, options.onReadGrantee);
+  }
   const response = await runtime.fetch(request2);
   const bytes2 = new Uint8Array(await response.arrayBuffer());
   return {
@@ -174562,8 +174597,9 @@ var DEFAULT_PUBLIC_SUFFIX2 = "34.16.49.200.sslip.io";
 var DEFAULT_ORIGIN = "https://ps-lite.local";
 var RELAY_CLOSE_SESSION_REPLACED = 1012;
 var HEARTBEAT_LATE_FIRE_FACTOR = 2;
-function psLiteRelayControlUrl(sessionId, controlUrl = DEFAULT_CONTROL_URL) {
-  return `${controlUrl.replace(/\/+$/, "")}/browser/${sessionId}`;
+function psLiteRelayControlUrl(sessionId, controlUrl = DEFAULT_CONTROL_URL, connTag) {
+  const base2 = `${controlUrl.replace(/\/+$/, "")}/browser/${sessionId}`;
+  return connTag ? `${base2}?tag=${encodeURIComponent(connTag)}` : base2;
 }
 function psLiteRelayPublicUrl(sessionId, publicSuffix = DEFAULT_PUBLIC_SUFFIX2) {
   return `https://${sessionId}.${publicSuffix.replace(/^\./, "")}`;
@@ -174603,7 +174639,146 @@ function startPsLiteRelayClient(options) {
   let unansweredPingSentAt;
   let lastHeartbeatCheckAt = 0;
   let heartbeatGraceUsed = false;
+  let connTag = randomConnTag();
   const log = (line) => options.logger?.(line);
+  const emitStatus = (status2, detail) => options.onStatus?.(status2, { ...detail, connTag });
+  const logHookError = (error51) => log(`relay read event hook failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+  const readQueue = [];
+  let readFlushTimer;
+  let droppedReadEvents = 0;
+  const flushReadEvents = () => {
+    readFlushTimer = void 0;
+    const batch = readQueue.splice(0);
+    const hook = options.onReadEvent;
+    if (closed || !hook)
+      return;
+    if (droppedReadEvents > 0) {
+      log(`relay read events dropped (queue full): ${droppedReadEvents}`);
+      droppedReadEvents = 0;
+    }
+    for (const produce of batch) {
+      void Promise.resolve().then(produce).then((event) => closed ? void 0 : hook(event)).catch(logHookError);
+    }
+  };
+  const dispatchReadEvent = (produce) => {
+    if (closed || !options.onReadEvent)
+      return;
+    if (readQueue.length >= MAX_QUEUED_READ_EVENTS) {
+      readQueue.shift();
+      droppedReadEvents += 1;
+    }
+    readQueue.push(produce);
+    readFlushTimer ??= setTimeout(flushReadEvents, 0);
+  };
+  const stopReadEvents = () => {
+    readQueue.length = 0;
+    if (readFlushTimer !== void 0) {
+      clearTimeout(readFlushTimer);
+      readFlushTimer = void 0;
+    }
+  };
+  const appVisibility = () => {
+    try {
+      const state = options.appVisibility ? options.appVisibility() : documentVisibility();
+      return state === "visible" || state === "hidden" ? state : "unknown";
+    } catch {
+      return "unknown";
+    }
+  };
+  const sampleHidden = (tracker) => {
+    const visibility = appVisibility();
+    if (visibility === "hidden")
+      tracker.hiddenDuring = true;
+    else if (visibility === "visible")
+      tracker.hiddenDuring ??= false;
+    return visibility;
+  };
+  const beginRead = (stream, request2) => {
+    const seq = stream.requestSeq;
+    stream.requestSeq += 1;
+    const scope = relayReadScope(request2);
+    if (scope === void 0)
+      return void 0;
+    const tracker = {
+      ids: {
+        readRef: `${stream.streamRef ?? crypto.randomUUID()}:${seq}`,
+        ...stream.streamRef ? { streamRef: stream.streamRef } : {},
+        connTag: stream.connTag,
+        scope,
+        method: request2.method.toUpperCase()
+      },
+      startedAt: Date.now(),
+      hiddenDuring: void 0,
+      done: false
+    };
+    const visibility = sampleHidden(tracker);
+    stream.activeRead = tracker;
+    const received = {
+      type: "ps_read_received",
+      at: tracker.startedAt,
+      ...tracker.ids,
+      appVisibility: visibility
+    };
+    dispatchReadEvent(() => received);
+    return tracker;
+  };
+  const finishRead = (tracker, result) => {
+    if (!tracker || tracker.done)
+      return;
+    tracker.done = true;
+    sampleHidden(tracker);
+    const finishedAt = Date.now();
+    const durationMs = Math.max(0, finishedAt - tracker.startedAt);
+    const hiddenDuring = tracker.hiddenDuring;
+    const emptyCheckBody = result.body && result.body.length <= EMPTY_CHECK_MAX_BYTES ? result.body : void 0;
+    const { status: status2, contentType, granteeRef: granteeRefPromise } = result;
+    const outcomeOrClassify = result.outcome;
+    const bytesOut = result.bytesOut ?? 0;
+    const gzip = result.gzip ?? false;
+    dispatchReadEvent(async () => {
+      const outcome = outcomeOrClassify === "classify" ? classifyReadOutcome(status2 ?? 0, emptyCheckBody, contentType) : outcomeOrClassify;
+      const granteeRef = validGranteeRef(granteeRefPromise ? await withTimeout3(granteeRefPromise, GRANTEE_REF_WAIT_MS) : void 0);
+      return {
+        type: "ps_read_finished",
+        at: finishedAt,
+        ...tracker.ids,
+        ...granteeRef ? { granteeRef } : {},
+        ...status2 !== void 0 ? { status: status2 } : {},
+        outcome,
+        bytesOut,
+        gzip,
+        durationMs,
+        ...hiddenDuring !== void 0 ? { hiddenDuring } : {}
+      };
+    });
+  };
+  const visibilityDocument = options.appVisibility ? void 0 : readVisibilityDocument();
+  const onVisibilityChange = () => {
+    if (visibilityDocument?.visibilityState !== "hidden")
+      return;
+    for (const stream of streams.values()) {
+      if (stream.activeRead && !stream.activeRead.done) {
+        stream.activeRead.hiddenDuring = true;
+      }
+    }
+  };
+  let visibilityListening = false;
+  if (visibilityDocument) {
+    try {
+      visibilityDocument.addEventListener("visibilitychange", onVisibilityChange);
+      visibilityListening = true;
+    } catch {
+    }
+  }
+  const stopVisibilityListener = () => {
+    if (!visibilityListening || !visibilityDocument)
+      return;
+    visibilityListening = false;
+    try {
+      visibilityDocument.removeEventListener("visibilitychange", onVisibilityChange);
+    } catch {
+    }
+  };
   const isLive = (stream) => !closed && !stream.closed && stream.socket === socket && socket.readyState === socket.OPEN && streams.get(stream.streamId) === stream;
   const sendText = (message, target = socket) => {
     if (!closed && target === socket && target.readyState === target.OPEN) {
@@ -174619,6 +174794,7 @@ function startPsLiteRelayClient(options) {
     if (stream.closed)
       return;
     stream.closed = true;
+    finishRead(stream.activeRead, { outcome: "stream_closed" });
     if (streams.get(stream.streamId) === stream) {
       streams.delete(stream.streamId);
       pendingStreamData.delete(stream.streamId);
@@ -174640,17 +174816,17 @@ function startPsLiteRelayClient(options) {
   };
   const writePlaintextResponse = (stream, responseBytes) => {
     if (!isLive(stream))
-      return;
+      return false;
     if (!stream.tls) {
       for (const chunk of chunks(responseBytes, RESPONSE_CHUNK_BYTES)) {
         sendData(stream, chunk);
       }
-      return;
+      return isLive(stream);
     }
     const responseChunks = chunks(responseBytes, RESPONSE_CHUNK_BYTES);
     for (let index2 = 0; index2 < responseChunks.length; index2 += 1) {
       if (!isLive(stream))
-        return;
+        return false;
       const step = stream.tls.writePlaintext(responseChunks[index2], index2 === responseChunks.length - 1);
       for (const chunk of chunks(step.tls, RESPONSE_CHUNK_BYTES)) {
         if (chunk.length > 0) {
@@ -174658,6 +174834,7 @@ function startPsLiteRelayClient(options) {
         }
       }
     }
+    return isLive(stream);
   };
   const drainHttpRequests = async (stream) => {
     while (isLive(stream)) {
@@ -174666,10 +174843,38 @@ function startPsLiteRelayClient(options) {
         return;
       }
       stream.plaintext = stream.plaintext.slice(parsed.consumedBytes);
-      const response = await handleRelayHttpRequest(options.runtime, parsed.request, origin);
-      if (!isLive(stream))
+      const read = beginRead(stream, parsed.request);
+      let relayed;
+      try {
+        relayed = await handleRelayHttpRequest(options.runtime, parsed.request, origin, Boolean(read));
+      } catch (error51) {
+        finishRead(read, { outcome: "handler_error" });
+        throw error51;
+      }
+      const { response } = relayed;
+      const finish = (outcome) => ({
+        outcome,
+        status: relayed.status,
+        granteeRef: relayed.granteeRef,
+        bytesOut: response.length,
+        gzip: relayed.gzip
+      });
+      if (!isLive(stream)) {
+        finishRead(read, { ...finish("stream_closed"), bytesOut: 0 });
         return;
-      writePlaintextResponse(stream, binaryToBytes(response));
+      }
+      let written;
+      try {
+        written = writePlaintextResponse(stream, binaryToBytes(response));
+      } catch (error51) {
+        finishRead(read, { ...finish("tls_error"), bytesOut: 0 });
+        throw error51;
+      }
+      finishRead(read, written ? {
+        ...finish("classify"),
+        body: relayed.plainBody,
+        contentType: relayed.contentType
+      } : finish("stream_closed"));
       closeStream(stream, "http_response_sent");
       return;
     }
@@ -174707,7 +174912,7 @@ function startPsLiteRelayClient(options) {
       closeStream(stream, "tls_error");
     }
   };
-  const openStream = async (streamId) => {
+  const openStream = async (streamId, streamRef) => {
     const previous = streams.get(streamId);
     if (previous)
       disposeStream(previous);
@@ -174717,7 +174922,10 @@ function startPsLiteRelayClient(options) {
       socket,
       closed: false,
       ready: !tls,
-      handling: false
+      handling: false,
+      ...streamRef ? { streamRef } : {},
+      connTag,
+      requestSeq: 0
     };
     streams.set(streamId, stream);
     try {
@@ -174750,7 +174958,7 @@ function startPsLiteRelayClient(options) {
   const handleControl = (message) => {
     if (message.type === "session.ready") {
       issueToken = message.issueToken;
-      options.onStatus?.("connected");
+      emitStatus("connected");
       if (tls && tls.prepare) {
         void tls.prepare({
           sessionId: options.sessionId,
@@ -174765,7 +174973,7 @@ function startPsLiteRelayClient(options) {
       return;
     }
     if (message.type === "stream.open" && typeof message.streamId === "number") {
-      void openStream(message.streamId);
+      void openStream(message.streamId, parseStreamRef(message.streamRef));
       return;
     }
     if (message.type === "stream.close" && typeof message.streamId === "number") {
@@ -174847,18 +175055,19 @@ function startPsLiteRelayClient(options) {
       return;
     }
     issueToken = void 0;
-    socket = createSocket(options.webSocketFactory, controlUrl);
+    connTag = randomConnTag();
+    socket = createSocket(options.webSocketFactory, psLiteRelayControlUrl(options.sessionId, baseControlUrl, connTag));
     const currentSocket = socket;
     const isCurrent = () => !closed && socket === currentSocket;
     const acceptsFrames = () => isCurrent() && currentSocket.readyState === currentSocket.OPEN;
     socket.binaryType = "arraybuffer";
-    options.onStatus?.("connecting");
+    emitStatus("connecting");
     socket.onopen = () => {
       if (!acceptsFrames())
         return;
       reconnectAttempts = 0;
       startHeartbeat();
-      options.onStatus?.("connected");
+      emitStatus("connected");
     };
     socket.onmessage = (event) => {
       if (!acceptsFrames())
@@ -174878,27 +175087,31 @@ function startPsLiteRelayClient(options) {
       issueToken = void 0;
       const detail = { code: event?.code, reason: event?.reason };
       if (closed) {
-        options.onStatus?.("closed", detail);
+        stopVisibilityListener();
+        stopReadEvents();
+        emitStatus("closed", detail);
         return;
       }
       if (event?.code === RELAY_CLOSE_SESSION_REPLACED) {
         closed = true;
+        stopVisibilityListener();
+        stopReadEvents();
         if (reconnectTimer !== void 0) {
           clearTimeout(reconnectTimer);
           reconnectTimer = void 0;
         }
         log("relay session replaced by another connection \u2014 not reconnecting");
-        options.onStatus?.("replaced", detail);
+        emitStatus("replaced", detail);
         return;
       }
-      options.onStatus?.("disconnected", detail);
+      emitStatus("disconnected", detail);
       scheduleReconnect();
     };
     socket.onerror = () => {
       if (!isCurrent() || currentSocket.readyState > currentSocket.OPEN) {
         return;
       }
-      options.onStatus?.("error");
+      emitStatus("error");
     };
   }
   connect();
@@ -174925,6 +175138,8 @@ function startPsLiteRelayClient(options) {
         return;
       closed = true;
       stopHeartbeat();
+      stopVisibilityListener();
+      stopReadEvents();
       if (reconnectTimer !== void 0) {
         clearTimeout(reconnectTimer);
         reconnectTimer = void 0;
@@ -174934,7 +175149,7 @@ function startPsLiteRelayClient(options) {
     }
   };
 }
-async function handleRelayHttpRequest(runtime, request2, origin) {
+async function handleRelayHttpRequest(runtime, request2, origin, isRead) {
   const bridgeRequest = {
     requestId: crypto.randomUUID(),
     method: request2.method,
@@ -174943,20 +175158,164 @@ async function handleRelayHttpRequest(runtime, request2, origin) {
     headers: request2.headers,
     body: encodeBase642(request2.body)
   };
+  let granteeRef;
   const bridgeResponse = await handlePsLiteBridgeRequest(runtime, bridgeRequest, {
-    origin
+    origin,
+    ...isRead ? {
+      onReadGrantee: (ref) => {
+        granteeRef = ref;
+      }
+    } : {}
   });
+  const contentType = headerValue(bridgeResponse.headers, "content-type");
   const bodyBytes = decodeBase643(bridgeResponse.body);
   const acceptsGzip = (request2.headers["accept-encoding"] ?? "").includes("gzip");
   const alreadyEncoded = Boolean(bridgeResponse.headers?.["content-encoding"]);
+  const base2 = {
+    status: bridgeResponse.status,
+    plainBody: bodyBytes,
+    ...contentType !== void 0 ? { contentType } : {},
+    ...granteeRef ? { granteeRef } : {}
+  };
   if (acceptsGzip && !alreadyEncoded && bodyBytes.length >= GZIP_MIN_BYTES && typeof CompressionStream !== "undefined") {
     const gzipped = await gzipBytes(bodyBytes);
-    return buildHttpResponse(bridgeResponse, {
-      bodyOverride: gzipped,
-      contentEncoding: "gzip"
-    });
+    return {
+      ...base2,
+      gzip: true,
+      response: buildHttpResponse(bridgeResponse, {
+        bodyOverride: gzipped,
+        contentEncoding: "gzip"
+      })
+    };
+  }
+  return {
+    ...base2,
+    gzip: false,
+    response: buildHttpResponse(bridgeResponse, { bodyOverride: bodyBytes })
+  };
+}
+function headerValue(headers, name) {
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === name)
+      return value;
+  }
+  return void 0;
+}
+var DATA_PATH_PREFIX = "/v1/data/";
+function relayReadScope(request2) {
+  const method = request2.method.toUpperCase();
+  if (method !== "GET")
+    return void 0;
+  if (!request2.path.startsWith(DATA_PATH_PREFIX))
+    return void 0;
+  const rest = request2.path.slice(DATA_PATH_PREFIX.length).split("?")[0];
+  if (!rest || rest.includes("/"))
+    return void 0;
+  const segment = rest;
+  let scope;
+  try {
+    scope = decodeURIComponent(segment);
+  } catch {
+    return INVALID_SCOPE;
   }
-  return buildHttpResponse(bridgeResponse, { bodyOverride: bodyBytes });
+  if (scope.length > MAX_SCOPE_LENGTH)
+    return INVALID_SCOPE;
+  const parsed = parseDataScopeContract(scope);
+  return parsed.ok ? parsed.scope : INVALID_SCOPE;
+}
+var INVALID_SCOPE = "invalid";
+var MAX_SCOPE_LENGTH = 128;
+var GRANTEE_REF_WAIT_MS = 1e3;
+var MAX_QUEUED_READ_EVENTS = 200;
+function validGranteeRef(value) {
+  return typeof value === "string" && /^(owner|[0-9a-f]{12})$/.test(value) ? value : void 0;
+}
+async function withTimeout3(promise2, ms3) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise2.catch(() => void 0),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(void 0), ms3);
+      })
+    ]);
+  } finally {
+    if (timer !== void 0)
+      clearTimeout(timer);
+  }
+}
+var EMPTY_CHECK_MAX_BYTES = 64 * 1024;
+function classifyReadOutcome(status2, body, contentType) {
+  if (status2 === 401 || status2 === 403)
+    return "denied";
+  if (status2 === 402)
+    return "payment_required";
+  if (status2 === 404)
+    return "not_found";
+  if (status2 >= 400)
+    return "error";
+  if (status2 < 200 || status2 >= 300)
+    return "ok";
+  return body && isEmptyJsonBody(body, contentType) ? "empty" : "ok";
+}
+function isEmptyJsonBody(body, contentType) {
+  if (body.length === 0 || body.length > EMPTY_CHECK_MAX_BYTES)
+    return false;
+  if (contentType !== void 0 && !/json/i.test(contentType))
+    return false;
+  let value;
+  try {
+    value = JSON.parse(new TextDecoder().decode(body));
+  } catch {
+    return false;
+  }
+  if (isEmptyValue(value))
+    return true;
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const record3 = value;
+    if (!("data" in record3))
+      return false;
+    const data = record3.data;
+    if (isEmptyValue(data))
+      return true;
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      const values = Object.values(data);
+      return values.length > 0 && values.every(isEmptyValue);
+    }
+  }
+  return false;
+}
+function isEmptyValue(value) {
+  if (value === null || value === void 0 || value === "")
+    return true;
+  if (Array.isArray(value))
+    return value.length === 0;
+  if (typeof value === "object") {
+    return Object.keys(value).length === 0;
+  }
+  return false;
+}
+function parseStreamRef(value) {
+  return typeof value === "string" && /^[A-Za-z0-9-]{1,64}$/.test(value) ? value : void 0;
+}
+function randomConnTag() {
+  const bytes2 = new Uint8Array(8);
+  crypto.getRandomValues(bytes2);
+  let hex4 = "";
+  for (const byte of bytes2)
+    hex4 += byte.toString(16).padStart(2, "0");
+  return hex4;
+}
+function readVisibilityDocument() {
+  const candidate = globalThis.document;
+  if (!candidate || typeof candidate.addEventListener !== "function" || typeof candidate.removeEventListener !== "function") {
+    return void 0;
+  }
+  return candidate;
+}
+function documentVisibility() {
+  const state = globalThis.document?.visibilityState;
+  return state === "visible" || state === "hidden" ? state : "unknown";
 }
 var GZIP_MIN_BYTES = 1024;
 async function gzipBytes(input) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opendatalabs/personal-server-ts-server",
-  "version": "1.35.5",
+  "version": "1.36.0",
   "description": "Hono HTTP server for the Vana Personal Server — routes, middleware, composition root",
   "license": "MIT",
   "repository": {
@@ -55,8 +55,8 @@
   },
   "dependencies": {
     "@hono/node-server": "^1.19.17",
-    "@opendatalabs/personal-server-ts-core": "1.35.5",
-    "@opendatalabs/personal-server-ts-lite": "1.35.5",
+    "@opendatalabs/personal-server-ts-core": "1.36.0",
+    "@opendatalabs/personal-server-ts-lite": "1.36.0",
     "@opendatalabs/vana-sdk": "3.23.0-pr.211.36da1d8",
     "ajv": "^8.20.0",
     "better-sqlite3": "^12.11.1",