lody 0.54.1 → 0.55.0

package/dist/index.js

@@ -49,7 +49,7 @@ import require$$0$a, { execSync, exec, execFileSync, execFile as execFile$1 } fr
 import { randomFillSync, randomUUID, createHash } from "node:crypto";
 import require$$0$b from "net";
 import require$$4$3 from "tls";
-import { i as imports, _ as __wbg_set_wasm$1, r as rawWasm, L as LoroDoc, E as EphemeralStoreWasm, U as UndoManager, c as callPendingEvents$3, a as LoroTree, b as LoroText, d as LoroMovableList, e as LoroList, f as LoroMap, g as __vite__initWasm, V as VersionVector, h as decodeImportBlobMeta, __tla as __tla_0 } from "./chunks/loro_wasm_bg-DgxHrrrp.js";
+import { i as imports, _ as __wbg_set_wasm$1, r as rawWasm, L as LoroDoc, E as EphemeralStoreWasm, U as UndoManager, c as callPendingEvents$3, a as LoroTree, b as LoroText, d as LoroMovableList, e as LoroList, f as LoroMap, g as __vite__initWasm, V as VersionVector, h as decodeImportBlobMeta, __tla as __tla_0 } from "./chunks/loro_wasm_bg-ICD3atfE.js";
 import * as fs$5 from "fs/promises";
 import fs__default$1, { stat as stat$1, readFile as readFile$1, statfs } from "fs/promises";
 import fsPromises, { stat, open } from "node:fs/promises";
@@ -4068,7 +4068,7 @@ let __tla = Promise.all([
     }
     return true;
   }
-  let TimeoutError$3 = class TimeoutError2 extends Error {
+  let TimeoutError$2 = class TimeoutError2 extends Error {
     constructor(message) {
       super(message);
       Object.setPrototypeOf(this, TimeoutError2.prototype);
@@ -4078,7 +4078,7 @@ let __tla = Promise.all([
     let timeoutHandle;
     const timeoutPromise = new Promise(function timeoutFunction(_resolve, reject) {
       timeoutHandle = setTimeout(function timeoutHandler() {
-        reject(new TimeoutError$3("Operation timed out."));
+        reject(new TimeoutError$2("Operation timed out."));
       }, timeout2);
     });
     return Promise.race([
@@ -4203,7 +4203,7 @@ let __tla = Promise.all([
     SDK_INFO,
     TRACE_PARENT_HEADER,
     TRACE_STATE_HEADER,
-    TimeoutError: TimeoutError$3,
+    TimeoutError: TimeoutError$2,
     TraceState,
     W3CBaggagePropagator,
     W3CTraceContextPropagator,
@@ -36822,7 +36822,7 @@ Mongoose Error Code: ${error2.code}` : ""}`
     return client;
   }
   const name = "lody";
-  const version$4 = "0.54.1";
+  const version$4 = "0.55.0";
   const description$1 = "Lody Agent CLI tool for managing remote command execution";
   const type$2 = "module";
   const main$3 = "dist/index.js";
@@ -52071,11 +52071,11 @@ ${originalIndentation}`;
   function mod(n, x) {
     return (n % x + x) % x;
   }
-  var indexOf$2;
+  var indexOf$1;
   if (Array.prototype.indexOf) {
-    indexOf$2 = Array.prototype.indexOf;
+    indexOf$1 = Array.prototype.indexOf;
   } else {
-    indexOf$2 = function(o) {
+    indexOf$1 = function(o) {
       var i2;
       for (i2 = 0; i2 < this.length; ++i2) {
         if (this[i2] === o) {
@@ -52160,26 +52160,26 @@ ${originalIndentation}`;
     }
     if (strict) {
       if (format2 === "MMM") {
-        ii = indexOf$2.call(this._shortMonthsParse, llc);
+        ii = indexOf$1.call(this._shortMonthsParse, llc);
         return ii !== -1 ? ii : null;
       } else {
-        ii = indexOf$2.call(this._longMonthsParse, llc);
+        ii = indexOf$1.call(this._longMonthsParse, llc);
         return ii !== -1 ? ii : null;
       }
     } else {
       if (format2 === "MMM") {
-        ii = indexOf$2.call(this._shortMonthsParse, llc);
+        ii = indexOf$1.call(this._shortMonthsParse, llc);
         if (ii !== -1) {
           return ii;
         }
-        ii = indexOf$2.call(this._longMonthsParse, llc);
+        ii = indexOf$1.call(this._longMonthsParse, llc);
         return ii !== -1 ? ii : null;
       } else {
-        ii = indexOf$2.call(this._longMonthsParse, llc);
+        ii = indexOf$1.call(this._longMonthsParse, llc);
         if (ii !== -1) {
           return ii;
         }
-        ii = indexOf$2.call(this._shortMonthsParse, llc);
+        ii = indexOf$1.call(this._shortMonthsParse, llc);
         return ii !== -1 ? ii : null;
       }
     }
@@ -52509,48 +52509,48 @@ ${originalIndentation}`;
     }
     if (strict) {
       if (format2 === "dddd") {
-        ii = indexOf$2.call(this._weekdaysParse, llc);
+        ii = indexOf$1.call(this._weekdaysParse, llc);
         return ii !== -1 ? ii : null;
       } else if (format2 === "ddd") {
-        ii = indexOf$2.call(this._shortWeekdaysParse, llc);
+        ii = indexOf$1.call(this._shortWeekdaysParse, llc);
         return ii !== -1 ? ii : null;
       } else {
-        ii = indexOf$2.call(this._minWeekdaysParse, llc);
+        ii = indexOf$1.call(this._minWeekdaysParse, llc);
         return ii !== -1 ? ii : null;
       }
     } else {
       if (format2 === "dddd") {
-        ii = indexOf$2.call(this._weekdaysParse, llc);
+        ii = indexOf$1.call(this._weekdaysParse, llc);
         if (ii !== -1) {
           return ii;
         }
-        ii = indexOf$2.call(this._shortWeekdaysParse, llc);
+        ii = indexOf$1.call(this._shortWeekdaysParse, llc);
         if (ii !== -1) {
           return ii;
         }
-        ii = indexOf$2.call(this._minWeekdaysParse, llc);
+        ii = indexOf$1.call(this._minWeekdaysParse, llc);
         return ii !== -1 ? ii : null;
       } else if (format2 === "ddd") {
-        ii = indexOf$2.call(this._shortWeekdaysParse, llc);
+        ii = indexOf$1.call(this._shortWeekdaysParse, llc);
         if (ii !== -1) {
           return ii;
         }
-        ii = indexOf$2.call(this._weekdaysParse, llc);
+        ii = indexOf$1.call(this._weekdaysParse, llc);
         if (ii !== -1) {
           return ii;
         }
-        ii = indexOf$2.call(this._minWeekdaysParse, llc);
+        ii = indexOf$1.call(this._minWeekdaysParse, llc);
         return ii !== -1 ? ii : null;
       } else {
-        ii = indexOf$2.call(this._minWeekdaysParse, llc);
+        ii = indexOf$1.call(this._minWeekdaysParse, llc);
         if (ii !== -1) {
           return ii;
         }
-        ii = indexOf$2.call(this._weekdaysParse, llc);
+        ii = indexOf$1.call(this._weekdaysParse, llc);
         if (ii !== -1) {
           return ii;
         }
-        ii = indexOf$2.call(this._shortWeekdaysParse, llc);
+        ii = indexOf$1.call(this._shortWeekdaysParse, llc);
         return ii !== -1 ? ii : null;
       }
     }
@@ -53627,7 +53627,7 @@ ${originalIndentation}`;
   function isDurationValid(m) {
     var key2, unitHasDecimal = false, i2, orderLen = ordering.length;
     for (key2 in m) {
-      if (hasOwnProp(m, key2) && !(indexOf$2.call(ordering, key2) !== -1 && (m[key2] == null || !isNaN(m[key2])))) {
+      if (hasOwnProp(m, key2) && !(indexOf$1.call(ordering, key2) !== -1 && (m[key2] == null || !isNaN(m[key2])))) {
         return false;
       }
     }
@@ -74690,7 +74690,7 @@ Task description:
     }
     finalize$1(instance.exports);
   } else {
-    const wkmod = wasmModuleOrExports instanceof WebAssembly.Module ? wasmModuleOrExports : await import("./chunks/loro_wasm_bg-DgxHrrrp.js").then(async (m) => {
+    const wkmod = wasmModuleOrExports instanceof WebAssembly.Module ? wasmModuleOrExports : await import("./chunks/loro_wasm_bg-ICD3atfE.js").then(async (m) => {
       await m.__tla;
       return m;
     }).then((n) => n.r);
@@ -92691,7 +92691,7 @@ ${val.stack}`;
       console.info(prefix, ...args2);
     };
   };
-  var ProtocolError$2 = class ProtocolError extends Error {
+  var ProtocolError$1 = class ProtocolError extends Error {
     status;
     detail;
     constructor(message, status, detail) {
@@ -92700,7 +92700,7 @@ ${val.stack}`;
       this.detail = detail;
     }
   };
-  var TimeoutError$2 = class TimeoutError extends Error {
+  var TimeoutError$1 = class TimeoutError extends Error {
     phase;
     timeoutMs;
     constructor(phase, timeoutMs) {
@@ -92709,11 +92709,11 @@ ${val.stack}`;
       this.timeoutMs = timeoutMs;
     }
   };
-  function isAbortError$1(error2) {
+  function isAbortError(error2) {
     return error2 instanceof DOMException ? error2.name === "AbortError" : typeof error2 === "object" && error2 != null && "name" in error2 && error2.name === "AbortError";
   }
-  async function responseToStreamError$1(response, context2) {
-    const bodyText = await safeReadBodyText$1(response);
+  async function responseToStreamError(response, context2) {
+    const bodyText = await safeReadBodyText(response);
     const message = bodyText.length > 0 ? `${context2} failed with status ${response.status}: ${bodyText}` : `${context2} failed with status ${response.status}`;
     const presentBody = bodyText.length > 0 ? bodyText : void 0;
     switch (response.status) {
@@ -92737,7 +92737,7 @@ ${val.stack}`;
           status: 403,
           message,
           bodyText: presentBody,
-          detail: producerEpochDetail$1(response)
+          detail: producerEpochDetail(response)
         };
       case 404:
         return {
@@ -92752,7 +92752,7 @@ ${val.stack}`;
           status: 409,
           message,
           bodyText: presentBody,
-          detail: conflictDetail$1(response, bodyText)
+          detail: conflictDetail(response, bodyText)
         };
       case 410:
         return {
@@ -92774,7 +92774,7 @@ ${val.stack}`;
           message,
           status: response.status,
           statusText: response.statusText,
-          headers: headersToObject$1$1(response.headers),
+          headers: headersToObject$1(response.headers),
           bodyText: bodyText.length > 0 ? bodyText : void 0,
           cause: {
             type: "http_response",
@@ -92784,13 +92784,13 @@ ${val.stack}`;
         };
     }
   }
-  function thrownToStreamError$1(error2) {
-    if (error2 instanceof TimeoutError$2) return {
+  function thrownToStreamError(error2) {
+    if (error2 instanceof TimeoutError$1) return {
       code: "timeout",
       phase: error2.phase,
       message: error2.message
     };
-    if (error2 instanceof ProtocolError$2) return {
+    if (error2 instanceof ProtocolError$1) return {
       code: "protocol_error",
       message: error2.message,
       status: error2.status,
@@ -92812,10 +92812,10 @@ ${val.stack}`;
       cause: error2
     };
   }
-  function isRetryableLiveError$1(error2) {
-    return isRetryableStreamError$1(error2);
+  function isRetryableLiveError(error2) {
+    return isRetryableStreamError(error2);
   }
-  function producerEpochDetail$1(response) {
+  function producerEpochDetail(response) {
     const value = response.headers.get("Producer-Epoch");
     if (value == null) return;
     const parsed = Number.parseInt(value, 10);
@@ -92827,16 +92827,16 @@ ${val.stack}`;
       serverEpoch: parsed
     };
   }
-  function conflictDetail$1(response, bodyText) {
-    if (isTrueHeader$1(response.headers.get("Stream-Closed"))) return {
+  function conflictDetail(response, bodyText) {
+    if (isTrueHeader(response.headers.get("Stream-Closed"))) return {
       kind: "stream_closed",
       nextOffset: response.headers.get("Stream-Next-Offset") ?? void 0
     };
-    const expectedSeq = parseOptionalInteger$1$1(response.headers.get("Producer-Expected-Seq"));
+    const expectedSeq = parseOptionalInteger$1(response.headers.get("Producer-Expected-Seq"));
     if (expectedSeq != null) return {
       kind: "producer_seq_gap",
       expectedSeq,
-      receivedSeq: parseOptionalInteger$1$1(response.headers.get("Producer-Received-Seq")) ?? void 0
+      receivedSeq: parseOptionalInteger$1(response.headers.get("Producer-Received-Seq")) ?? void 0
     };
     const normalized = bodyText.toLowerCase();
     if (normalized.includes("content type")) return {
@@ -92849,39 +92849,39 @@ ${val.stack}`;
       kind: "other"
     };
   }
-  function parseOptionalInteger$1$1(value) {
+  function parseOptionalInteger$1(value) {
     if (value == null) return null;
     const parsed = Number.parseInt(value, 10);
     if (!Number.isFinite(parsed) || parsed < 0) return null;
     return parsed;
   }
-  function isTrueHeader$1(value) {
+  function isTrueHeader(value) {
     return value?.trim().toLowerCase() === "true";
   }
-  function headersToObject$1$1(headers) {
+  function headersToObject$1(headers) {
     const result = {};
     headers.forEach((value, name2) => {
       result[name2] = value;
     });
     return result;
   }
-  async function safeReadBodyText$1(response) {
+  async function safeReadBodyText(response) {
     try {
       return await response.text();
     } catch {
       return "";
     }
   }
-  function isRetryableStreamError$1(error2) {
+  function isRetryableStreamError(error2) {
     return error2.code === "network_error" || error2.code === "timeout";
   }
-  const DEFAULT_TIMEOUT_CONFIG$1 = {
+  const DEFAULT_TIMEOUT_CONFIG = {
     connectTimeoutMs: 1e4,
     pollTimeoutMs: 3e4
   };
-  function normalizeTimeoutConfig$1(value) {
-    const connectTimeoutMs = value?.connectTimeoutMs ?? DEFAULT_TIMEOUT_CONFIG$1.connectTimeoutMs;
-    const pollTimeoutMs = value?.pollTimeoutMs ?? DEFAULT_TIMEOUT_CONFIG$1.pollTimeoutMs;
+  function normalizeTimeoutConfig(value) {
+    const connectTimeoutMs = value?.connectTimeoutMs ?? DEFAULT_TIMEOUT_CONFIG.connectTimeoutMs;
+    const pollTimeoutMs = value?.pollTimeoutMs ?? DEFAULT_TIMEOUT_CONFIG.pollTimeoutMs;
     if (!Number.isFinite(connectTimeoutMs) || connectTimeoutMs < 0) throw new Error("timeout.connectTimeoutMs must be a non-negative finite number");
     if (!Number.isFinite(pollTimeoutMs) || pollTimeoutMs < 0) throw new Error("timeout.pollTimeoutMs must be a non-negative finite number");
     return {
@@ -92889,7 +92889,7 @@ ${val.stack}`;
       pollTimeoutMs: Math.floor(pollTimeoutMs)
     };
   }
-  function mergeAbortSignals$1$1(...signals2) {
+  function mergeAbortSignals$1(...signals2) {
     const active2 = signals2.filter((signal) => signal != null);
     if (active2.length === 0) return;
     if (active2.length === 1) return active2[0];
@@ -92908,12 +92908,12 @@ ${val.stack}`;
     }
     return controller.signal;
   }
-  async function fetchWithTimeout$1(fetchImpl, input2, init2, timeoutMs, phase) {
+  async function fetchWithTimeout(fetchImpl, input2, init2, timeoutMs, phase) {
     if (!(timeoutMs > 0)) return await fetchImpl(input2, init2);
     const controller = new AbortController();
-    const signal = mergeAbortSignals$1$1(init2.signal, controller.signal);
+    const signal = mergeAbortSignals$1(init2.signal, controller.signal);
     const timer2 = setTimeout(() => {
-      controller.abort(new TimeoutError$2(phase, timeoutMs));
+      controller.abort(new TimeoutError$1(phase, timeoutMs));
     }, timeoutMs);
     try {
       return await fetchImpl(input2, {
@@ -92921,25 +92921,25 @@ ${val.stack}`;
         signal
       });
     } catch (error2) {
-      if (controller.signal.aborted && controller.signal.reason instanceof TimeoutError$2) throw controller.signal.reason;
+      if (controller.signal.aborted && controller.signal.reason instanceof TimeoutError$1) throw controller.signal.reason;
       throw error2;
     } finally {
       clearTimeout(timer2);
     }
   }
-  var AuthorizedHttpClient$1 = class AuthorizedHttpClient {
+  var AuthorizedHttpClient = class {
     fetchImpl;
     authProvider;
     authRefreshInFlight;
     constructor(options) {
       this.fetchImpl = options.fetchImpl;
-      this.authProvider = normalizeAuthProvider$2(options.auth);
+      this.authProvider = normalizeAuthProvider$1(options.auth);
     }
     async fetchAuthorized(input2, init2, timeoutMs, phase, options) {
       const firstToken = await this.resolveToken({
         reason: "request"
       });
-      const firstResponse = await fetchWithTimeout$1(this.fetchImpl, input2, {
+      const firstResponse = await fetchWithTimeout(this.fetchImpl, input2, {
         ...init2,
         headers: this.attachAuthorization(init2.headers, firstToken)
       }, timeoutMs, phase);
@@ -92948,7 +92948,7 @@ ${val.stack}`;
       await firstResponse.body?.cancel().catch(() => {
       });
       const refreshedToken = await this.refreshTokenAfterFailure(firstResponse.status, firstToken);
-      return await fetchWithTimeout$1(this.fetchImpl, input2, {
+      return await fetchWithTimeout(this.fetchImpl, input2, {
         ...init2,
         headers: this.attachAuthorization(init2.headers, refreshedToken)
       }, timeoutMs, phase);
@@ -92978,7 +92978,7 @@ ${val.stack}`;
       return headers;
     }
   };
-  function normalizeAuthProvider$2(auth) {
+  function normalizeAuthProvider$1(auth) {
     if (auth == null) return;
     if (typeof auth === "string") {
       const token2 = auth.trim();
@@ -92989,20 +92989,20 @@ ${val.stack}`;
       return token2.length === 0 ? void 0 : token2;
     };
   }
-  function decodeMultipartMixed$1(boundary, data) {
+  function decodeMultipartMixed(boundary, data) {
     const delimiter2 = new TextEncoder().encode(`--${boundary}`);
     const closeDelimiter = new TextEncoder().encode(`--${boundary}--`);
     const crlfCrlf = new TextEncoder().encode("\r\n\r\n");
     const parts2 = [];
     let pos = 0;
-    const firstDelimPos = indexOf$1(data, delimiter2, pos);
+    const firstDelimPos = indexOf(data, delimiter2, pos);
     if (firstDelimPos < 0) return parts2;
     pos = firstDelimPos + delimiter2.byteLength;
     if (pos < data.byteLength && data[pos] === 13) pos += 1;
     if (pos < data.byteLength && data[pos] === 10) pos += 1;
     while (pos < data.byteLength) {
-      if (startsWith$1(data.subarray(pos), closeDelimiter.subarray(delimiter2.byteLength))) break;
-      const headerEnd = indexOf$1(data, crlfCrlf, pos);
+      if (startsWith(data.subarray(pos), closeDelimiter.subarray(delimiter2.byteLength))) break;
+      const headerEnd = indexOf(data, crlfCrlf, pos);
       if (headerEnd < 0) break;
       const headerBytes = data.subarray(pos, headerEnd);
       const headerText = new TextDecoder().decode(headerBytes);
@@ -93014,7 +93014,7 @@ ${val.stack}`;
         contentType = line3.slice(colon + 1).trim();
       }
       const bodyStart = headerEnd + crlfCrlf.byteLength;
-      const nextDelimiter = indexOf$1(data, delimiter2, bodyStart);
+      const nextDelimiter = indexOf(data, delimiter2, bodyStart);
       if (nextDelimiter < 0) {
         parts2.push({
           contentType,
@@ -93035,22 +93035,22 @@ ${val.stack}`;
     }
     return parts2;
   }
-  function extractBoundary$1(contentType) {
+  function extractBoundary(contentType) {
     return /boundary=("?)([^";,\s]+)\1/i.exec(contentType)?.[2] ?? null;
   }
-  function indexOf$1(haystack, needle, from2) {
+  function indexOf(haystack, needle, from2) {
     outer: for (let i2 = from2; i2 <= haystack.byteLength - needle.byteLength; i2 += 1) {
       for (let j = 0; j < needle.byteLength; j += 1) if (haystack[i2 + j] !== needle[j]) continue outer;
       return i2;
     }
     return -1;
   }
-  function startsWith$1(data, prefix) {
+  function startsWith(data, prefix) {
     if (data.byteLength < prefix.byteLength) return false;
     for (let i2 = 0; i2 < prefix.byteLength; i2 += 1) if (data[i2] !== prefix[i2]) return false;
     return true;
   }
-  const DEFAULT_RETRY_CONFIG$1 = {
+  const DEFAULT_RETRY_CONFIG = {
     delays: [
       0,
       500,
@@ -93063,16 +93063,16 @@ ${val.stack}`;
     jitterFraction: 0.2,
     maxAttempts: 5
   };
-  function normalizeRetryConfig$1(value) {
-    const delays = value?.delays ?? DEFAULT_RETRY_CONFIG$1.delays;
+  function normalizeRetryConfig(value) {
+    const delays = value?.delays ?? DEFAULT_RETRY_CONFIG.delays;
     if (delays.length === 0) throw new Error("retry.delays must contain at least one entry");
     const normalizedDelays = delays.map((delay2) => {
       if (!Number.isFinite(delay2) || delay2 < 0) throw new Error("retry.delays must contain non-negative finite numbers");
       return Math.floor(delay2);
     });
-    const jitterFraction = value?.jitterFraction ?? DEFAULT_RETRY_CONFIG$1.jitterFraction;
+    const jitterFraction = value?.jitterFraction ?? DEFAULT_RETRY_CONFIG.jitterFraction;
     if (!Number.isFinite(jitterFraction) || jitterFraction < 0) throw new Error("retry.jitterFraction must be a non-negative finite number");
-    const maxAttempts = value?.maxAttempts ?? DEFAULT_RETRY_CONFIG$1.maxAttempts;
+    const maxAttempts = value?.maxAttempts ?? DEFAULT_RETRY_CONFIG.maxAttempts;
     if (!Number.isInteger(maxAttempts) || maxAttempts < 0) throw new Error("retry.maxAttempts must be a non-negative integer");
     return {
       delays: normalizedDelays,
@@ -93080,16 +93080,16 @@ ${val.stack}`;
       maxAttempts
     };
   }
-  function applyJitter$2(baseMs, fraction) {
+  function applyJitter$1(baseMs, fraction) {
     if (baseMs === 0) return 0;
     const jitter = baseMs * fraction * (2 * Math.random() - 1);
     return Math.max(0, Math.round(baseMs + jitter));
   }
-  function computeRetryDelay$2(attempt, config2 = DEFAULT_RETRY_CONFIG$1) {
+  function computeRetryDelay$1(attempt, config2 = DEFAULT_RETRY_CONFIG) {
     const index2 = Math.min(attempt, config2.delays.length - 1);
-    return applyJitter$2(config2.delays[index2] ?? 0, config2.jitterFraction);
+    return applyJitter$1(config2.delays[index2] ?? 0, config2.jitterFraction);
   }
-  async function sleep$3(delayMs, signal) {
+  async function sleep$2(delayMs, signal) {
     if (delayMs <= 0) {
       if (signal?.aborted === true) throw signal.reason;
       return;
@@ -93118,21 +93118,21 @@ ${val.stack}`;
       }
     });
   }
-  function getRequiredHeader$1(headers, name2, context2) {
+  function getRequiredHeader(headers, name2, context2) {
     const value = headers.get(name2);
     if (value != null && value.length > 0) return value;
-    throw new ProtocolError$2(`${context2} response missing ${name2}. If this is cross-origin, expose it via Access-Control-Expose-Headers (${name2.toLowerCase()}). Visible headers: ${visibleHeaderNames$1(headers)}`);
+    throw new ProtocolError$1(`${context2} response missing ${name2}. If this is cross-origin, expose it via Access-Control-Expose-Headers (${name2.toLowerCase()}). Visible headers: ${visibleHeaderNames(headers)}`);
   }
-  function hasTrueHeader$1(headers, name2) {
+  function hasTrueHeader(headers, name2) {
     return headers.get(name2)?.trim().toLowerCase() === "true";
   }
-  function parseOptionalInteger$2(value) {
+  function parseOptionalInteger(value) {
     if (value == null) return null;
     const parsed = Number.parseInt(value, 10);
     if (!Number.isFinite(parsed) || parsed < 0) return null;
     return parsed;
   }
-  function visibleHeaderNames$1(headers) {
+  function visibleHeaderNames(headers) {
     const names2 = [];
     headers.forEach((_value, name2) => {
       names2.push(name2);
@@ -93141,60 +93141,60 @@ ${val.stack}`;
     names2.sort();
     return names2.join(", ");
   }
-  const encoder$1 = new TextEncoder();
-  const decoder$1 = new TextDecoder();
-  function createStreamPart$1(contentType, body) {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  function createStreamPart(contentType, body) {
     return {
       contentType,
       body,
       text() {
-        return decoder$1.decode(body);
+        return decoder.decode(body);
       },
       json() {
-        return JSON.parse(decoder$1.decode(body));
+        return JSON.parse(decoder.decode(body));
       }
     };
   }
-  function normalizeStreamPartLike$1(input2) {
+  function normalizeStreamPartLike(input2) {
     return {
-      contentType: normalizeContentType$1(input2.contentType),
-      body: normalizeStreamBody$1(input2.body)
+      contentType: normalizeContentType(input2.contentType),
+      body: normalizeStreamBody(input2.body)
     };
   }
-  function normalizeContentType$1(contentType) {
+  function normalizeContentType(contentType) {
     const normalized = contentType.trim();
     if (normalized.length === 0) throw new Error("contentType must be a non-empty string");
     return normalized;
   }
-  function normalizeOptionalContentType$1(contentType) {
+  function normalizeOptionalContentType(contentType) {
     if (contentType == null) return;
-    return normalizeContentType$1(contentType);
+    return normalizeContentType(contentType);
   }
-  function normalizeStreamBody$1(body) {
-    if (typeof body === "string") return encoder$1.encode(body);
+  function normalizeStreamBody(body) {
+    if (typeof body === "string") return encoder.encode(body);
     if (body instanceof Uint8Array) return body.slice();
     if (body instanceof ArrayBuffer) return new Uint8Array(body.slice(0));
     if (ArrayBuffer.isView(body)) return new Uint8Array(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength));
     throw new Error("unsupported stream body type");
   }
-  function toRequestBody$1(bytes) {
+  function toRequestBody(bytes) {
     return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
   }
-  function isSseUnsupportedErrorText$2(message) {
+  function isSseUnsupportedErrorText$1(message) {
     const normalized = message.trim().toLowerCase();
     if (normalized.length === 0) return false;
     const mentionsSse = normalized.includes("sse") || normalized.includes("text/event-stream");
     const mentionsCompatibility = normalized.includes("unsupported") || normalized.includes("not support") || normalized.includes("incompatible") || normalized.includes("content type");
     return mentionsSse && mentionsCompatibility;
   }
-  function parseSseControlData$2(data) {
+  function parseSseControlData$1(data) {
     let parsed;
     try {
       parsed = JSON.parse(data);
     } catch {
-      throw new ProtocolError$2("invalid sse control event JSON");
+      throw new ProtocolError$1("invalid sse control event JSON");
     }
-    if (typeof parsed !== "object" || parsed == null || typeof parsed.streamNextOffset !== "string") throw new ProtocolError$2("sse control event missing streamNextOffset");
+    if (typeof parsed !== "object" || parsed == null || typeof parsed.streamNextOffset !== "string") throw new ProtocolError$1("sse control event missing streamNextOffset");
     const streamClosed = parsed.streamClosed === true;
     const streamCursor = typeof parsed.streamCursor === "string" ? parsed.streamCursor : void 0;
     return {
@@ -93204,13 +93204,13 @@ ${val.stack}`;
       streamCursor
     };
   }
-  function decodeSsePayload$1(data, dataEncoding) {
+  function decodeSsePayload(data, dataEncoding) {
     const normalizedEncoding = dataEncoding?.trim().toLowerCase();
     if (normalizedEncoding == null || normalizedEncoding.length === 0) return new TextEncoder().encode(data);
-    if (normalizedEncoding !== "base64") throw new ProtocolError$2(`unsupported stream-sse-data-encoding '${dataEncoding}'`);
-    return decodeBase64Bytes$2(data.replace(/[\r\n]/g, ""));
+    if (normalizedEncoding !== "base64") throw new ProtocolError$1(`unsupported stream-sse-data-encoding '${dataEncoding}'`);
+    return decodeBase64Bytes$1(data.replace(/[\r\n]/g, ""));
   }
-  async function* readSseEvents$1(stream2, options = {}) {
+  async function* readSseEvents(stream2, options = {}) {
     const reader2 = stream2.getReader();
     const decoder2 = new TextDecoder();
     let pendingText = "";
@@ -93296,7 +93296,7 @@ ${val.stack}`;
       }
     }
   }
-  function decodeBase64Bytes$2(encoded) {
+  function decodeBase64Bytes$1(encoded) {
     if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(encoded, "base64"));
     if (typeof atob === "function") {
       const binary2 = atob(encoded);
@@ -93306,7 +93306,7 @@ ${val.stack}`;
     }
     throw new Error("base64 decoding is unavailable");
   }
-  var StreamsClient$1 = class StreamsClient {
+  var StreamsClient = class {
     streamUrl;
     http;
     defaultHeaders;
@@ -93319,19 +93319,19 @@ ${val.stack}`;
       this.streamUrl = options.url instanceof URL ? new URL(options.url) : new URL(options.url);
       const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
       if (typeof fetchImpl !== "function") throw new Error("fetch is unavailable; pass options.fetch explicitly");
-      this.http = new AuthorizedHttpClient$1({
+      this.http = new AuthorizedHttpClient({
         fetchImpl,
         auth: options.auth
       });
       this.defaultHeaders = new Headers(options.headers);
-      this.retryConfig = normalizeRetryConfig$1(options.retry);
-      this.timeoutConfig = normalizeTimeoutConfig$1(options.timeout);
+      this.retryConfig = normalizeRetryConfig(options.retry);
+      this.timeoutConfig = normalizeTimeoutConfig(options.timeout);
       this.onRetry = options.onRetry;
     }
     async create(input2 = {}) {
-      validateCreateInput$1(input2);
-      const part = input2.part == null ? void 0 : normalizeStreamPartLike$1(input2.part);
-      const requestedContentType = part?.contentType ?? normalizeOptionalContentType$1(input2.contentType) ?? void 0;
+      validateCreateInput(input2);
+      const part = input2.part == null ? void 0 : normalizeStreamPartLike(input2.part);
+      const requestedContentType = part?.contentType ?? normalizeOptionalContentType(input2.contentType) ?? void 0;
       try {
         const requestUrl = this.streamEndpoint();
         const headers = this.mergeHeaders(input2.headers);
@@ -93342,14 +93342,14 @@ ${val.stack}`;
         const response = await this.http.fetchAuthorized(requestUrl, {
           method: "PUT",
           headers,
-          body: part == null ? void 0 : toRequestBody$1(part.body)
+          body: part == null ? void 0 : toRequestBody(part.body)
         }, this.timeoutConfig.connectTimeoutMs, "connect");
         if (response.status !== 200 && response.status !== 201) return {
           ok: false,
-          result: await responseToStreamError$1(response, "create")
+          result: await responseToStreamError(response, "create")
         };
         const contentType = this.resolveContentType(response, "create", requestedContentType ?? "application/octet-stream");
-        const nextOffset = getRequiredHeader$1(response.headers, "Stream-Next-Offset", "create");
+        const nextOffset = getRequiredHeader(response.headers, "Stream-Next-Offset", "create");
         this.knownContentType = contentType;
         return {
           ok: true,
@@ -93357,13 +93357,13 @@ ${val.stack}`;
             created: response.status === 201,
             contentType,
             nextOffset,
-            closed: hasTrueHeader$1(response.headers, "Stream-Closed")
+            closed: hasTrueHeader(response.headers, "Stream-Closed")
           }, input2, "PUT", requestUrl, response)
         };
       } catch (error2) {
         return {
           ok: false,
-          result: thrownToStreamError$1(error2)
+          result: thrownToStreamError(error2)
         };
       }
     }
@@ -93372,7 +93372,8 @@ ${val.stack}`;
         const requestUrl = this.streamEndpoint();
         const response = await this.http.fetchAuthorized(requestUrl, {
           method: "DELETE",
-          headers: this.mergeHeaders(input2.headers)
+          headers: this.mergeHeaders(input2.headers),
+          signal: input2.signal
         }, this.timeoutConfig.connectTimeoutMs, "connect");
         if (response.status === 404) return {
           ok: true,
@@ -93382,7 +93383,7 @@ ${val.stack}`;
         };
         if (response.status !== 200 && response.status !== 204) return {
           ok: false,
-          result: await responseToStreamError$1(response, "delete")
+          result: await responseToStreamError(response, "delete")
         };
         return {
           ok: true,
@@ -93393,7 +93394,7 @@ ${val.stack}`;
       } catch (error2) {
         return {
           ok: false,
-          result: thrownToStreamError$1(error2)
+          result: thrownToStreamError(error2)
         };
       }
     }
@@ -93402,22 +93403,23 @@ ${val.stack}`;
         const requestUrl = this.streamEndpoint();
         const response = await this.http.fetchAuthorized(requestUrl, {
           method: "HEAD",
-          headers: this.mergeHeaders(input2.headers)
+          headers: this.mergeHeaders(input2.headers),
+          signal: input2.signal
         }, this.timeoutConfig.connectTimeoutMs, "connect");
         if (!response.ok) return {
           ok: false,
-          result: await responseToStreamError$1(response, "head")
+          result: await responseToStreamError(response, "head")
         };
         const contentType = this.resolveContentType(response, "head", this.knownContentType);
-        const nextOffset = getRequiredHeader$1(response.headers, "Stream-Next-Offset", "head");
+        const nextOffset = getRequiredHeader(response.headers, "Stream-Next-Offset", "head");
         this.knownContentType = contentType;
         return {
           ok: true,
           result: this.withMeta({
             contentType,
             nextOffset,
-            closed: hasTrueHeader$1(response.headers, "Stream-Closed"),
-            ttlSeconds: parseOptionalInteger$2(response.headers.get("Stream-TTL")) ?? void 0,
+            closed: hasTrueHeader(response.headers, "Stream-Closed"),
+            ttlSeconds: parseOptionalInteger(response.headers.get("Stream-TTL")) ?? void 0,
             expiresAt: response.headers.get("Stream-Expires-At") ?? void 0,
             snapshotOffset: response.headers.get("Stream-Snapshot-Offset") ?? void 0
           }, input2, "HEAD", requestUrl, response)
@@ -93425,26 +93427,26 @@ ${val.stack}`;
       } catch (error2) {
         return {
           ok: false,
-          result: thrownToStreamError$1(error2)
+          result: thrownToStreamError(error2)
         };
       }
     }
     async append(input2) {
-      validateAppendInput$1(input2);
-      const part = input2.part == null ? void 0 : normalizeStreamPartLike$1(input2.part);
+      validateAppendInput(input2);
+      const part = input2.part == null ? void 0 : normalizeStreamPartLike(input2.part);
       let attempt = 0;
       while (true) try {
         const requestUrl = this.streamEndpoint();
         const response = await this.http.fetchAuthorized(requestUrl, {
           method: "POST",
           headers: this.appendHeaders(input2, part?.contentType),
-          body: part == null ? void 0 : toRequestBody$1(part.body)
+          body: part == null ? void 0 : toRequestBody(part.body)
         }, this.timeoutConfig.connectTimeoutMs, "connect", {
           shouldRetryAuthFailure: (nextResponse) => nextResponse.status === 401 || nextResponse.status === 403 && nextResponse.headers.get("Producer-Epoch") == null
         });
         if (response.status !== 200 && response.status !== 204) return {
           ok: false,
-          result: await responseToStreamError$1(response, "append")
+          result: await responseToStreamError(response, "append")
         };
         if (part != null) this.knownContentType = part.contentType;
         return {
@@ -93452,12 +93454,12 @@ ${val.stack}`;
           result: this.withMeta(this.parseAppendOutput(response, input2), input2, "POST", requestUrl, response)
         };
       } catch (error2) {
-        const result = thrownToStreamError$1(error2);
-        if (input2.producer == null || !isAppendRetryable$1(result) || attempt >= this.retryConfig.maxAttempts) return {
+        const result = thrownToStreamError(error2);
+        if (input2.producer == null || !isAppendRetryable(result) || attempt >= this.retryConfig.maxAttempts) return {
           ok: false,
           result
         };
-        const delay2 = computeRetryDelay$2(attempt, this.retryConfig);
+        const delay2 = computeRetryDelay$1(attempt, this.retryConfig);
         attempt += 1;
         this.onRetry?.({
           operation: "append",
@@ -93466,7 +93468,7 @@ ${val.stack}`;
           delayMs: delay2,
           maxAttempts: this.retryConfig.maxAttempts
         });
-        await sleep$3(delay2);
+        await sleep$2(delay2);
       }
     }
     async close(input2 = {}) {
@@ -93501,7 +93503,7 @@ ${val.stack}`;
       };
     }
     async readOnce(input2 = {}) {
-      validateReadOnceInput$1(input2);
+      validateReadOnceInput(input2);
       const requestOffset = input2.offset ?? "-1";
       try {
         const requestUrl = this.readEndpoint({
@@ -93518,12 +93520,12 @@ ${val.stack}`;
         }, timeoutMs, phase);
         if (!response.ok) return {
           ok: false,
-          result: await responseToStreamError$1(response, "read once")
+          result: await responseToStreamError(response, "read once")
         };
         if (response.status === 204) {
-          const nextOffset = getRequiredHeader$1(response.headers, "Stream-Next-Offset", "read once");
-          if (!hasTrueHeader$1(response.headers, "Stream-Up-To-Date")) throw new ProtocolError$2("long-poll 204 response missing Stream-Up-To-Date: true");
-          const closed = hasTrueHeader$1(response.headers, "Stream-Closed");
+          const nextOffset = getRequiredHeader(response.headers, "Stream-Next-Offset", "read once");
+          if (!hasTrueHeader(response.headers, "Stream-Up-To-Date")) throw new ProtocolError$1("long-poll 204 response missing Stream-Up-To-Date: true");
+          const closed = hasTrueHeader(response.headers, "Stream-Closed");
           const cursor = response.headers.get("Stream-Cursor") ?? void 0;
           return {
             ok: true,
@@ -93549,7 +93551,7 @@ ${val.stack}`;
       } catch (error2) {
         return {
           ok: false,
-          result: thrownToStreamError$1(error2)
+          result: thrownToStreamError(error2)
         };
       }
     }
@@ -93558,28 +93560,29 @@ ${val.stack}`;
         const requestUrl = this.subresourceEndpoint("/bootstrap");
         const response = await this.http.fetchAuthorized(requestUrl, {
           method: "GET",
-          headers: this.mergeHeaders(input2.headers)
+          headers: this.mergeHeaders(input2.headers),
+          signal: input2.signal
         }, this.timeoutConfig.connectTimeoutMs, "connect");
         if (!response.ok) return {
           ok: false,
-          result: await responseToStreamError$1(response, "bootstrap")
-        };
-        const boundary = extractBoundary$1(response.headers.get("Content-Type") ?? "");
-        if (boundary == null) throw new ProtocolError$2("bootstrap response must be multipart/mixed");
-        const nextOffset = getRequiredHeader$1(response.headers, "Stream-Next-Offset", "bootstrap");
-        const snapshotOffset = getRequiredHeader$1(response.headers, "Stream-Snapshot-Offset", "bootstrap");
-        const parts2 = decodeMultipartMixed$1(boundary, new Uint8Array(await response.arrayBuffer()));
-        if (parts2.length === 0) throw new ProtocolError$2("bootstrap response must include at least one MIME part");
+          result: await responseToStreamError(response, "bootstrap")
+        };
+        const boundary = extractBoundary(response.headers.get("Content-Type") ?? "");
+        if (boundary == null) throw new ProtocolError$1("bootstrap response must be multipart/mixed");
+        const nextOffset = getRequiredHeader(response.headers, "Stream-Next-Offset", "bootstrap");
+        const snapshotOffset = getRequiredHeader(response.headers, "Stream-Snapshot-Offset", "bootstrap");
+        const parts2 = decodeMultipartMixed(boundary, new Uint8Array(await response.arrayBuffer()));
+        if (parts2.length === 0) throw new ProtocolError$1("bootstrap response must include at least one MIME part");
         const first2 = parts2[0];
-        const snapshot = snapshotOffset === "-1" && first2?.body.byteLength === 0 ? null : createStreamPart$1(first2.contentType, first2.body);
-        const updates = parts2.slice(1).map((part) => createStreamPart$1(part.contentType, part.body));
+        const snapshot = snapshotOffset === "-1" && first2?.body.byteLength === 0 ? null : createStreamPart(first2.contentType, first2.body);
+        const updates = parts2.slice(1).map((part) => createStreamPart(part.contentType, part.body));
         if (updates.length > 0) this.knownContentType = updates[0].contentType;
         return {
           ok: true,
           result: this.withMeta({
             snapshotOffset,
             nextOffset,
-            upToDate: hasTrueHeader$1(response.headers, "Stream-Up-To-Date"),
+            upToDate: hasTrueHeader(response.headers, "Stream-Up-To-Date"),
             cursor: response.headers.get("Stream-Cursor") ?? void 0,
             snapshot,
             updates
@@ -93588,7 +93591,7 @@ ${val.stack}`;
       } catch (error2) {
         return {
           ok: false,
-          result: thrownToStreamError$1(error2)
+          result: thrownToStreamError(error2)
         };
       }
     }
@@ -93597,7 +93600,8 @@ ${val.stack}`;
         const requestUrl = this.subresourceEndpoint("/snapshot");
         const response = await this.http.fetchAuthorized(requestUrl, {
           method: "GET",
-          headers: this.mergeHeaders(input2.headers)
+          headers: this.mergeHeaders(input2.headers),
+          signal: input2.signal
         }, this.timeoutConfig.connectTimeoutMs, "connect");
         if (response.status === 404) return {
           ok: true,
@@ -93605,7 +93609,7 @@ ${val.stack}`;
         };
         if (!response.ok) return {
           ok: false,
-          result: await responseToStreamError$1(response, "read latest snapshot")
+          result: await responseToStreamError(response, "read latest snapshot")
         };
         return {
           ok: true,
@@ -93614,21 +93618,22 @@ ${val.stack}`;
       } catch (error2) {
         return {
           ok: false,
-          result: thrownToStreamError$1(error2)
+          result: thrownToStreamError(error2)
         };
       }
     }
     async readSnapshot(offset2, input2 = {}) {
-      assertNonEmptyString$1(offset2, "offset");
+      assertNonEmptyString(offset2, "offset");
       try {
         const requestUrl = this.subresourceEndpoint(`/snapshot/${encodeURIComponent(offset2)}`);
         const response = await this.http.fetchAuthorized(requestUrl, {
           method: "GET",
-          headers: this.mergeHeaders(input2.headers)
+          headers: this.mergeHeaders(input2.headers),
+          signal: input2.signal
         }, this.timeoutConfig.connectTimeoutMs, "connect");
         if (!response.ok) return {
           ok: false,
-          result: await responseToStreamError$1(response, "read snapshot")
+          result: await responseToStreamError(response, "read snapshot")
         };
         return {
           ok: true,
@@ -93637,13 +93642,13 @@ ${val.stack}`;
       } catch (error2) {
         return {
           ok: false,
-          result: thrownToStreamError$1(error2)
+          result: thrownToStreamError(error2)
         };
       }
     }
     async putSnapshot(input2) {
-      assertNonEmptyString$1(input2.offset, "offset");
-      const part = normalizeStreamPartLike$1(input2.part);
+      assertNonEmptyString(input2.offset, "offset");
+      const part = normalizeStreamPartLike(input2.part);
       try {
         const requestUrl = this.subresourceEndpoint(`/snapshot/${encodeURIComponent(input2.offset)}`);
         const response = await this.http.fetchAuthorized(requestUrl, {
@@ -93651,11 +93656,11 @@ ${val.stack}`;
           headers: this.mergeHeaders(input2.headers, {
             "Content-Type": part.contentType
           }),
-          body: toRequestBody$1(part.body)
+          body: toRequestBody(part.body)
         }, this.timeoutConfig.connectTimeoutMs, "connect");
         if (response.status !== 200 && response.status !== 204) return {
           ok: false,
-          result: await responseToStreamError$1(response, "put snapshot")
+          result: await responseToStreamError(response, "put snapshot")
         };
         return {
           ok: true,
@@ -93667,17 +93672,18 @@ ${val.stack}`;
       } catch (error2) {
         return {
           ok: false,
-          result: thrownToStreamError$1(error2)
+          result: thrownToStreamError(error2)
         };
       }
     }
     async deleteSnapshot(offset2, input2 = {}) {
-      assertNonEmptyString$1(offset2, "offset");
+      assertNonEmptyString(offset2, "offset");
       try {
         const requestUrl = this.subresourceEndpoint(`/snapshot/${encodeURIComponent(offset2)}`);
         const response = await this.http.fetchAuthorized(requestUrl, {
           method: "DELETE",
-          headers: this.mergeHeaders(input2.headers)
+          headers: this.mergeHeaders(input2.headers),
+          signal: input2.signal
         }, this.timeoutConfig.connectTimeoutMs, "connect");
         if (response.status === 404) return {
           ok: true,
@@ -93687,7 +93693,7 @@ ${val.stack}`;
         };
         if (response.status !== 200 && response.status !== 204) return {
           ok: false,
-          result: await responseToStreamError$1(response, "delete snapshot")
+          result: await responseToStreamError(response, "delete snapshot")
         };
         return {
           ok: true,
@@ -93698,19 +93704,19 @@ ${val.stack}`;
       } catch (error2) {
         return {
           ok: false,
-          result: thrownToStreamError$1(error2)
+          result: thrownToStreamError(error2)
         };
       }
     }
     async openSseSession(input2) {
-      validateOpenSseSessionInput$1(input2);
+      validateOpenSseSessionInput(input2);
       const requestUrl = this.readEndpoint({
         offset: input2.offset,
         cursor: input2.cursor,
         live: "sse"
       });
       const controller = new AbortController();
-      const signal = mergeAbortSignals$3(input2.signal, controller.signal);
+      const signal = mergeAbortSignals$2(input2.signal, controller.signal);
       try {
         const response = await this.http.fetchAuthorized(requestUrl, {
           method: "GET",
@@ -93721,11 +93727,11 @@ ${val.stack}`;
         }, this.timeoutConfig.connectTimeoutMs, "connect");
         if (!response.ok) return {
           ok: false,
-          result: await responseToStreamError$1(response, "open sse session")
+          result: await responseToStreamError(response, "open sse session")
         };
-        if (response.body == null) throw new ProtocolError$2("sse response missing body");
-        if (!(response.headers.get("Content-Type") ?? "").toLowerCase().includes("text/event-stream")) throw new ProtocolError$2("sse response must use text/event-stream content type");
-        const events = createSessionEvents$1(response.body, signal, input2.onActivity);
+        if (response.body == null) throw new ProtocolError$1("sse response missing body");
+        if (!(response.headers.get("Content-Type") ?? "").toLowerCase().includes("text/event-stream")) throw new ProtocolError$1("sse response must use text/event-stream content type");
+        const events = createSessionEvents(response.body, signal, input2.onActivity);
         return {
           ok: true,
           result: {
@@ -93733,7 +93739,7 @@ ${val.stack}`;
             cursor: response.headers.get("Stream-Cursor") ?? void 0,
             dataEncoding: response.headers.get("Stream-SSE-Data-Encoding") ?? void 0,
             events,
-            meta: input2.includeMeta === true ? createOperationMeta$1("GET", requestUrl, response) : void 0,
+            meta: input2.includeMeta === true ? createOperationMeta("GET", requestUrl, response) : void 0,
             cancel: async () => {
               controller.abort(new DOMException("Aborted", "AbortError"));
               try {
@@ -93746,12 +93752,12 @@ ${val.stack}`;
       } catch (error2) {
         return {
           ok: false,
-          result: thrownToStreamError$1(error2)
+          result: thrownToStreamError(error2)
         };
       }
     }
     live(input2) {
-      validateLiveInput$1(input2);
+      validateLiveInput(input2);
       return this.liveInternal({
         offset: input2.offset,
         mode: input2.mode ?? "auto",
@@ -93798,7 +93804,7 @@ ${val.stack}`;
           }, this.timeoutConfig.connectTimeoutMs, "connect");
           if (response.status === 400) {
             const errorText = await response.text();
-            if (allowFallback && isSseUnsupportedErrorText$2(errorText)) return "fallback";
+            if (allowFallback && isSseUnsupportedErrorText$1(errorText)) return "fallback";
             yield {
               type: "error",
               mode: "sse",
@@ -93814,12 +93820,12 @@ ${val.stack}`;
             yield {
               type: "error",
               mode: "sse",
-              error: await responseToStreamError$1(response, "live sse")
+              error: await responseToStreamError(response, "live sse")
             };
             return "done";
           }
-          if (response.body == null) throw new ProtocolError$2("sse response missing body");
-          if (!(response.headers.get("Content-Type") ?? "").toLowerCase().includes("text/event-stream")) throw new ProtocolError$2("sse response must use text/event-stream content type");
+          if (response.body == null) throw new ProtocolError$1("sse response missing body");
+          if (!(response.headers.get("Content-Type") ?? "").toLowerCase().includes("text/event-stream")) throw new ProtocolError$1("sse response must use text/event-stream content type");
           if (reconnectAttempt > 0) yield {
             type: "reconnected",
             mode: "sse",
@@ -93830,15 +93836,15 @@ ${val.stack}`;
           const dataEncoding = response.headers.get("stream-sse-data-encoding");
           let pendingPayloads = [];
           let sawControlEvent = false;
-          for await (const event of readSseEvents$1(response.body, {
+          for await (const event of readSseEvents(response.body, {
             signal
           })) {
             if (event.event === "data") {
-              pendingPayloads.push(decodeSsePayload$1(event.data, dataEncoding));
+              pendingPayloads.push(decodeSsePayload(event.data, dataEncoding));
               continue;
             }
             if (event.event !== "control") continue;
-            const control = parseSseControlData$2(event.data);
+            const control = parseSseControlData$1(event.data);
             sawControlEvent = true;
             state2.offset = control.nextOffset;
             const effectiveCursor = control.streamCursor ?? state2.cursor;
@@ -93848,7 +93854,7 @@ ${val.stack}`;
               mode: "sse",
               nextOffset: control.nextOffset,
               cursor: effectiveCursor,
-              payload: createStreamPart$1(state2.contentType, payload)
+              payload: createStreamPart(state2.contentType, payload)
             };
             pendingPayloads = [];
             if (control.streamClosed) {
@@ -93871,10 +93877,10 @@ ${val.stack}`;
           if (sawControlEvent) continue;
           throw new TypeError("sse connection closed");
         } catch (error2) {
-          if (signal?.aborted && isAbortError$1(error2)) return "done";
-          const mapped = thrownToStreamError$1(error2);
-          if (!isRetryableLiveError$1(mapped) || attempt >= this.retryConfig.maxAttempts) {
-            const retryExhausted = isRetryableLiveError$1(mapped) && attempt >= this.retryConfig.maxAttempts;
+          if (signal?.aborted && isAbortError(error2)) return "done";
+          const mapped = thrownToStreamError(error2);
+          if (!isRetryableLiveError(mapped) || attempt >= this.retryConfig.maxAttempts) {
+            const retryExhausted = isRetryableLiveError(mapped) && attempt >= this.retryConfig.maxAttempts;
             yield {
               type: "error",
               mode: "sse",
@@ -93885,7 +93891,7 @@ ${val.stack}`;
             };
             return "done";
           }
-          const delayMs = computeRetryDelay$2(attempt, this.retryConfig);
+          const delayMs = computeRetryDelay$1(attempt, this.retryConfig);
           const nextAttempt = attempt + 1;
           this.onRetry?.({
             operation: "live-sse",
@@ -93902,7 +93908,7 @@ ${val.stack}`;
             error: mapped
           };
           try {
-            await sleep$3(delayMs, signal);
+            await sleep$2(delayMs, signal);
           } catch {
             return "done";
           }
@@ -93926,9 +93932,9 @@ ${val.stack}`;
             signal
           }, this.timeoutConfig.pollTimeoutMs, "poll");
           if (response.status === 204) {
-            const nextOffset = getRequiredHeader$1(response.headers, "Stream-Next-Offset", "live long-poll");
-            if (!hasTrueHeader$1(response.headers, "Stream-Up-To-Date")) throw new ProtocolError$2("long-poll 204 response missing Stream-Up-To-Date: true");
-            const closed = hasTrueHeader$1(response.headers, "Stream-Closed");
+            const nextOffset = getRequiredHeader(response.headers, "Stream-Next-Offset", "live long-poll");
+            if (!hasTrueHeader(response.headers, "Stream-Up-To-Date")) throw new ProtocolError$1("long-poll 204 response missing Stream-Up-To-Date: true");
+            const closed = hasTrueHeader(response.headers, "Stream-Closed");
             const effectiveCursor = response.headers.get("Stream-Cursor") ?? void 0 ?? state2.cursor;
             if (reconnectAttempt > 0) yield {
               type: "reconnected",
@@ -93959,7 +93965,7 @@ ${val.stack}`;
             yield {
               type: "error",
               mode: "long-poll",
-              error: await responseToStreamError$1(response, "live long-poll")
+              error: await responseToStreamError(response, "live long-poll")
             };
             return;
           }
@@ -93996,10 +94002,10 @@ ${val.stack}`;
             cursor: outputCursor
           };
         } catch (error2) {
-          if (signal?.aborted && isAbortError$1(error2)) return;
-          const mapped = thrownToStreamError$1(error2);
-          if (!isRetryableLiveError$1(mapped) || attempt >= this.retryConfig.maxAttempts) {
-            const retryExhausted = isRetryableLiveError$1(mapped) && attempt >= this.retryConfig.maxAttempts;
+          if (signal?.aborted && isAbortError(error2)) return;
+          const mapped = thrownToStreamError(error2);
+          if (!isRetryableLiveError(mapped) || attempt >= this.retryConfig.maxAttempts) {
+            const retryExhausted = isRetryableLiveError(mapped) && attempt >= this.retryConfig.maxAttempts;
             yield {
               type: "error",
               mode: "long-poll",
@@ -94010,7 +94016,7 @@ ${val.stack}`;
             };
             return;
           }
-          const delayMs = computeRetryDelay$2(attempt, this.retryConfig);
+          const delayMs = computeRetryDelay$1(attempt, this.retryConfig);
           const nextAttempt = attempt + 1;
           this.onRetry?.({
             operation: "live-long-poll",
@@ -94027,7 +94033,7 @@ ${val.stack}`;
             error: mapped
           };
           try {
-            await sleep$3(delayMs, signal);
+            await sleep$2(delayMs, signal);
           } catch {
             return;
           }
@@ -94062,17 +94068,17 @@ ${val.stack}`;
       if (input2?.includeMeta !== true) return result;
       return {
         ...result,
-        meta: createOperationMeta$1(method, url, response)
+        meta: createOperationMeta(method, url, response)
       };
     }
     parseAppendOutput(response, input2) {
       return {
         status: response.status,
-        nextOffset: getRequiredHeader$1(response.headers, "Stream-Next-Offset", "append"),
-        closed: hasTrueHeader$1(response.headers, "Stream-Closed"),
+        nextOffset: getRequiredHeader(response.headers, "Stream-Next-Offset", "append"),
+        closed: hasTrueHeader(response.headers, "Stream-Closed"),
         producer: input2.producer == null ? void 0 : {
-          epoch: parseOptionalInteger$2(response.headers.get("Producer-Epoch")) ?? input2.producer.epoch,
-          seq: parseOptionalInteger$2(response.headers.get("Producer-Seq")) ?? input2.producer.seq
+          epoch: parseOptionalInteger(response.headers.get("Producer-Epoch")) ?? input2.producer.epoch,
+          seq: parseOptionalInteger(response.headers.get("Producer-Seq")) ?? input2.producer.seq
         }
       };
     }
@@ -94081,20 +94087,20 @@ ${val.stack}`;
       this.knownContentType = contentType;
       return {
         requestOffset,
-        nextOffset: getRequiredHeader$1(response.headers, "Stream-Next-Offset", context2),
-        upToDate: hasTrueHeader$1(response.headers, "Stream-Up-To-Date"),
-        closed: hasTrueHeader$1(response.headers, "Stream-Closed"),
+        nextOffset: getRequiredHeader(response.headers, "Stream-Next-Offset", context2),
+        upToDate: hasTrueHeader(response.headers, "Stream-Up-To-Date"),
+        closed: hasTrueHeader(response.headers, "Stream-Closed"),
         cursor: response.headers.get("Stream-Cursor") ?? void 0,
-        payload: createStreamPart$1(contentType, new Uint8Array(await response.arrayBuffer()))
+        payload: createStreamPart(contentType, new Uint8Array(await response.arrayBuffer()))
       };
     }
     async parseSnapshotReadOutput(response, context2) {
       const contentType = this.resolveContentType(response, context2);
       return {
-        snapshotOffset: getRequiredHeader$1(response.headers, "Stream-Snapshot-Offset", context2),
-        nextOffset: getRequiredHeader$1(response.headers, "Stream-Next-Offset", context2),
-        upToDate: hasTrueHeader$1(response.headers, "Stream-Up-To-Date"),
-        payload: createStreamPart$1(contentType, new Uint8Array(await response.arrayBuffer()))
+        snapshotOffset: getRequiredHeader(response.headers, "Stream-Snapshot-Offset", context2),
+        nextOffset: getRequiredHeader(response.headers, "Stream-Next-Offset", context2),
+        upToDate: hasTrueHeader(response.headers, "Stream-Up-To-Date"),
+        payload: createStreamPart(contentType, new Uint8Array(await response.arrayBuffer()))
       };
     }
     async ensureKnownContentType() {
@@ -94114,7 +94120,7 @@ ${val.stack}`;
       const headerValue = response.headers.get("Content-Type");
       if (headerValue != null && headerValue.length > 0) return headerValue;
       if (fallback2 != null && fallback2.length > 0) return fallback2;
-      throw new ProtocolError$2(`${context2} response missing Content-Type`);
+      throw new ProtocolError$1(`${context2} response missing Content-Type`);
     }
     streamEndpoint() {
       return this.streamUrl.toString();
@@ -94133,50 +94139,50 @@ ${val.stack}`;
       return target.toString();
     }
   };
-  function validateCreateInput$1(input2) {
-    if (input2.ttlSeconds != null) assertNonNegativeSafeInteger$1(input2.ttlSeconds, "ttlSeconds");
-    if (input2.expiresAt != null) assertNonEmptyString$1(input2.expiresAt, "expiresAt");
+  function validateCreateInput(input2) {
+    if (input2.ttlSeconds != null) assertNonNegativeSafeInteger(input2.ttlSeconds, "ttlSeconds");
+    if (input2.expiresAt != null) assertNonEmptyString(input2.expiresAt, "expiresAt");
     if (input2.ttlSeconds != null && input2.expiresAt != null) throw new Error("create input must not include both ttlSeconds and expiresAt");
-    if (input2.contentType != null) normalizeContentType$1(input2.contentType);
+    if (input2.contentType != null) normalizeContentType(input2.contentType);
   }
-  function validateAppendInput$1(input2) {
-    if (input2.streamSeq != null) assertNonEmptyString$1(input2.streamSeq, "streamSeq");
+  function validateAppendInput(input2) {
+    if (input2.streamSeq != null) assertNonEmptyString(input2.streamSeq, "streamSeq");
     if (input2.producer != null) {
-      assertNonEmptyString$1(input2.producer.producerId, "producer.producerId");
-      assertNonNegativeSafeInteger$1(input2.producer.epoch, "producer.epoch");
-      assertNonNegativeSafeInteger$1(input2.producer.seq, "producer.seq");
+      assertNonEmptyString(input2.producer.producerId, "producer.producerId");
+      assertNonNegativeSafeInteger(input2.producer.epoch, "producer.epoch");
+      assertNonNegativeSafeInteger(input2.producer.seq, "producer.seq");
     }
     if (input2.part == null) {
       if (input2.close !== true) throw new Error("append requires part unless close is true");
       return;
     }
-    if (normalizeStreamPartLike$1(input2.part).body.byteLength === 0 && input2.close !== true) throw new Error("append requires a non-empty body unless close is true");
+    if (normalizeStreamPartLike(input2.part).body.byteLength === 0 && input2.close !== true) throw new Error("append requires a non-empty body unless close is true");
   }
-  function validateReadInput$1(input2) {
-    if (input2.offset != null) assertNonEmptyString$1(input2.offset, "offset");
-    if (input2.cursor != null) assertNonEmptyString$1(input2.cursor, "cursor");
+  function validateReadInput(input2) {
+    if (input2.offset != null) assertNonEmptyString(input2.offset, "offset");
+    if (input2.cursor != null) assertNonEmptyString(input2.cursor, "cursor");
   }
-  function validateReadOnceInput$1(input2) {
-    validateReadInput$1(input2);
+  function validateReadOnceInput(input2) {
+    validateReadInput(input2);
     if (input2.live != null && input2.live !== "long-poll") throw new Error("readOnce live mode must be long-poll when provided");
   }
-  function validateOpenSseSessionInput$1(input2) {
-    assertNonEmptyString$1(input2.offset, "offset");
-    if (input2.cursor != null) assertNonEmptyString$1(input2.cursor, "cursor");
+  function validateOpenSseSessionInput(input2) {
+    assertNonEmptyString(input2.offset, "offset");
+    if (input2.cursor != null) assertNonEmptyString(input2.cursor, "cursor");
   }
-  function validateLiveInput$1(input2) {
-    assertNonEmptyString$1(input2.offset, "offset");
+  function validateLiveInput(input2) {
+    assertNonEmptyString(input2.offset, "offset");
   }
-  function assertNonEmptyString$1(value, name2) {
+  function assertNonEmptyString(value, name2) {
     if (value.trim().length === 0) throw new Error(`${name2} must be a non-empty string`);
   }
-  function assertNonNegativeSafeInteger$1(value, name2) {
+  function assertNonNegativeSafeInteger(value, name2) {
     if (!Number.isSafeInteger(value) || value < 0) throw new Error(`${name2} must be a non-negative safe integer`);
   }
-  function isAppendRetryable$1(error2) {
+  function isAppendRetryable(error2) {
     return error2.code === "network_error" || error2.code === "timeout";
   }
-  function createOperationMeta$1(method, url, response) {
+  function createOperationMeta(method, url, response) {
     return {
       request: {
         method,
@@ -94185,33 +94191,33 @@ ${val.stack}`;
       response: {
         status: response.status,
         statusText: response.statusText,
-        headers: headersToObject$2(response.headers)
+        headers: headersToObject(response.headers)
       }
     };
   }
-  function headersToObject$2(headers) {
+  function headersToObject(headers) {
     const result = {};
     headers.forEach((value, name2) => {
       result[name2] = value;
     });
     return result;
   }
-  function createSessionEvents$1(stream2, signal, onActivity) {
+  function createSessionEvents(stream2, signal, onActivity) {
     return {
       async *[Symbol.asyncIterator]() {
         try {
-          yield* readSseEvents$1(stream2, {
+          yield* readSseEvents(stream2, {
             signal,
             onActivity
           });
         } catch (error2) {
-          if (signal?.aborted && isAbortError$1(error2)) return;
+          if (signal?.aborted && isAbortError(error2)) return;
           throw error2;
         }
       }
     };
   }
-  function mergeAbortSignals$3(...signals2) {
+  function mergeAbortSignals$2(...signals2) {
     const active2 = signals2.filter((signal) => signal != null);
     if (active2.length === 0) return;
     if (active2.length === 1) return active2[0];
@@ -94366,15 +94372,15 @@ ${val.stack}`;
     pollTimeoutMs: 3e4,
     liveInactivityTimeoutMs: 45e3
   };
-  function applyJitter$1(baseMs, fraction) {
+  function applyJitter(baseMs, fraction) {
     if (baseMs === 0) return 0;
     const jitter = baseMs * fraction * (2 * Math.random() - 1);
     return Math.max(0, Math.round(baseMs + jitter));
   }
-  function computeRetryDelay$1(attempt, config2 = DEFAULT_RECONNECT_CONFIG, minDelayMs) {
+  function computeRetryDelay(attempt, config2 = DEFAULT_RECONNECT_CONFIG, minDelayMs) {
     const { delays, jitterFraction } = config2;
     const scheduled2 = delays[Math.min(attempt, delays.length - 1)];
-    return applyJitter$1(typeof minDelayMs === "number" && minDelayMs > scheduled2 ? minDelayMs : scheduled2, jitterFraction);
+    return applyJitter(typeof minDelayMs === "number" && minDelayMs > scheduled2 ? minDelayMs : scheduled2, jitterFraction);
   }
   const BINARY_CONTENT_TYPE = "application/octet-stream";
   function encodeItems(items2) {
@@ -94725,7 +94731,7 @@ stream:${scope2.streamId}`;
       if (options?.body !== void 0 && options.body.length > 0) this.body = options.body;
     }
   };
-  var TimeoutError$1 = class TimeoutError extends Error {
+  var TimeoutError = class extends Error {
     timeoutType;
     timeoutMs;
     constructor(timeoutType, timeoutMs) {
@@ -94734,7 +94740,7 @@ stream:${scope2.streamId}`;
       this.timeoutMs = timeoutMs;
     }
   };
-  var ProtocolError$1 = class ProtocolError extends Error {
+  var ProtocolError = class extends Error {
     status;
     constructor(message, status) {
       super(message);
@@ -94751,7 +94757,7 @@ stream:${scope2.streamId}`;
   function isObject$1(value) {
     return typeof value === "object" && value != null;
   }
-  function decodeBase64Bytes$1(encoded) {
+  function decodeBase64Bytes(encoded) {
     const normalized = encoded.replace(/[\r\n]/g, "");
     if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(normalized, "base64"));
     if (typeof atob === "function") {
@@ -94766,10 +94772,10 @@ stream:${scope2.streamId}`;
     const normalized = dataEncoding?.trim().toLowerCase();
     if (normalized == null || normalized.length === 0) return;
     if (normalized === "base64") return "base64";
-    throw new ProtocolError$1(`unsupported stream-sse-data-encoding '${dataEncoding}'`);
+    throw new ProtocolError(`unsupported stream-sse-data-encoding '${dataEncoding}'`);
   }
   function decodeSseRawPayload(data, dataEncoding) {
-    if (dataEncoding === "base64") return decodeBase64Bytes$1(data);
+    if (dataEncoding === "base64") return decodeBase64Bytes(data);
     return new TextEncoder().encode(data);
   }
   function decodeSseItemPayloads(data, dataEncoding) {
@@ -94797,14 +94803,14 @@ stream:${scope2.streamId}`;
       ];
     }
   }
-  function parseSseControlData$1(data) {
+  function parseSseControlData(data) {
     let parsed;
     try {
       parsed = JSON.parse(data);
     } catch {
-      throw new ProtocolError$1("invalid sse control event JSON");
+      throw new ProtocolError("invalid sse control event JSON");
     }
-    if (!isObject$1(parsed) || typeof parsed.streamNextOffset !== "string") throw new ProtocolError$1("sse control event missing streamNextOffset");
+    if (!isObject$1(parsed) || typeof parsed.streamNextOffset !== "string") throw new ProtocolError("sse control event missing streamNextOffset");
     const streamCursor = typeof parsed.streamCursor === "string" ? parsed.streamCursor : void 0;
     return {
       nextOffset: parsed.streamNextOffset,
@@ -94812,14 +94818,14 @@ stream:${scope2.streamId}`;
       streamCursor
     };
   }
-  function isSseUnsupportedErrorText$1(message) {
+  function isSseUnsupportedErrorText(message) {
     const normalized = message.trim().toLowerCase();
     if (normalized.length === 0) return false;
     const mentionsSse = normalized.includes("sse") || normalized.includes("text/event-stream");
     const mentionsCompatibility = normalized.includes("unsupported") || normalized.includes("not support") || normalized.includes("incompatible") || normalized.includes("content type");
     return mentionsSse && mentionsCompatibility;
   }
-  function sleep$2(ms2, signal) {
+  function sleep$1(ms2, signal) {
     if (signal?.aborted) return Promise.resolve();
     return new Promise((resolve2) => {
       const timer2 = setTimeout(resolve2, ms2);
@@ -94831,7 +94837,7 @@ stream:${scope2.streamId}`;
       });
     });
   }
-  function mergeAbortSignals$2(...signals2) {
+  function mergeAbortSignals(...signals2) {
     const active2 = signals2.filter((signal) => signal != null);
     if (active2.length === 0) return;
     if (active2.length === 1) return active2[0];
@@ -94889,13 +94895,13 @@ stream:${scope2.streamId}`;
       retriable: true,
       atMs: Date.now()
     };
-    if (err2 instanceof ProtocolError$1) return {
+    if (err2 instanceof ProtocolError) return {
       code: "protocol",
       message,
       retriable: false,
       atMs: Date.now()
     };
-    if (err2 instanceof TimeoutError$1) return {
+    if (err2 instanceof TimeoutError) return {
       code: "timeout",
       message,
       retriable: true,
@@ -94972,13 +94978,13 @@ stream:${scope2.streamId}`;
         body: error2.body
       }
     };
-    if (error2 instanceof ProtocolError$1) return {
+    if (error2 instanceof ProtocolError) return {
       code: "protocol_error",
       retryable: false,
       status: error2.status,
       message: error2.message
     };
-    if (error2 instanceof TimeoutError$1) return {
+    if (error2 instanceof TimeoutError) return {
       code: "timeout",
       retryable: true,
       phase: error2.timeoutType,
@@ -95038,7 +95044,7 @@ stream:${scope2.streamId}`;
     return !result.upToDate && result.updates.length === 0 && result.nextOffset === requestOffset;
   }
   function isAuthOrProtocolError(error2) {
-    return error2 instanceof ProtocolError$1 || error2 instanceof HttpError && [
+    return error2 instanceof ProtocolError || error2 instanceof HttpError && [
       400,
       401,
       403,
@@ -95046,7 +95052,7 @@ stream:${scope2.streamId}`;
       409
     ].includes(error2.status);
   }
-  function normalizeAuthProvider$1(auth) {
+  function normalizeAuthProvider(auth) {
     if (auth == null) return;
     if (typeof auth === "string") {
       const token2 = auth.trim();
@@ -95125,6 +95131,57 @@ stream:${scope2.streamId}`;
     if (current2 != null && incoming != null) return incoming > current2 ? responseNextOffset : currentOffset;
     return currentOffset;
   }
+  const bodySizeEncoder = new TextEncoder();
+  function normalizeShardOrigins(urls, label2) {
+    if (urls == null) return;
+    const out2 = [];
+    for (const raw of urls) {
+      const trimmed = raw.trim();
+      if (trimmed.length === 0) continue;
+      const url = new URL(trimmed);
+      if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error(`${label2} shard URL must use http or https`);
+      if (url.pathname !== "/" || url.search !== "" || url.hash !== "") throw new Error(`${label2} shard URL must be an origin URL`);
+      out2.push(url.origin);
+    }
+    return out2.length === 0 ? void 0 : out2;
+  }
+  function normalizeShardUrlsOptions(options) {
+    if (options == null) return;
+    const largePostMinBytes = options.largePostMinBytes ?? 0;
+    if (!Number.isSafeInteger(largePostMinBytes) || largePostMinBytes < 0) throw new Error("shardUrls.largePostMinBytes must be a non-negative safe integer");
+    const normalized = {
+      bootstrap: normalizeShardOrigins(options.bootstrap, "shardUrls.bootstrap"),
+      catchup: normalizeShardOrigins(options.catchup, "shardUrls.catchup"),
+      largePost: normalizeShardOrigins(options.largePost, "shardUrls.largePost"),
+      largePostMinBytes
+    };
+    if (normalized.bootstrap == null && normalized.catchup == null && normalized.largePost == null) return;
+    return normalized;
+  }
+  function requestBodyByteLength(body) {
+    if (body == null) return 0;
+    if (typeof body === "string") return bodySizeEncoder.encode(body).byteLength;
+    if (body instanceof ArrayBuffer) return body.byteLength;
+    if (ArrayBuffer.isView(body)) return body.byteLength;
+    if (typeof Blob !== "undefined" && body instanceof Blob) return body.size;
+    if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) return bodySizeEncoder.encode(body.toString()).byteLength;
+  }
+  function createRandomShardStart(originCount) {
+    if (originCount <= 1) return 0;
+    try {
+      const crypto2 = globalThis.crypto;
+      if (crypto2 != null) {
+        const values = new Uint32Array(1);
+        crypto2.getRandomValues(values);
+        return (values[0] ?? 0) % originCount;
+      }
+    } catch {
+    }
+    return Math.floor(Math.random() * originCount);
+  }
+  function normalizedStreamPath(streamUrl) {
+    return streamUrl.pathname.endsWith("/") ? streamUrl.pathname.slice(0, -1) : streamUrl.pathname;
+  }
   var StreamsTransportClient = class {
     streamUrl;
     adapter;
@@ -95132,14 +95189,18 @@ stream:${scope2.streamId}`;
     fetchImpl;
     authProvider;
     reconnectConfig;
+    shardUrls;
+    shardCursorIndexes = {};
     authRefreshInFlight;
     constructor(options) {
       this.streamUrl = options.streamUrl;
       this.adapter = options.adapter;
-      this.client = new StreamsClient$1({
+      this.fetchImpl = options.fetchImpl;
+      this.shardUrls = normalizeShardUrlsOptions(options.shardUrls);
+      this.client = new StreamsClient({
         url: options.streamUrl,
         auth: options.authProvider,
-        fetch: options.fetchImpl,
+        fetch: this.fetchRouted.bind(this),
         retry: {
           maxAttempts: 0
         },
@@ -95148,10 +95209,44 @@ stream:${scope2.streamId}`;
           pollTimeoutMs: options.reconnectConfig.pollTimeoutMs
         }
       });
-      this.fetchImpl = options.fetchImpl;
       this.authProvider = options.authProvider;
       this.reconnectConfig = options.reconnectConfig;
     }
+    fetchRouted(input2, init2) {
+      return this.fetchImpl(this.routeRequestUrl(input2, init2), init2);
+    }
+    routeRequestUrl(input2, init2) {
+      const shardUrls = this.shardUrls;
+      if (shardUrls == null) return input2;
+      const operation = this.classifyShardOperation(input2, init2, shardUrls);
+      if (operation == null) return input2;
+      const origins = operation === "bootstrap" ? shardUrls.bootstrap : operation === "catchup" ? shardUrls.catchup : shardUrls.largePost;
+      if (origins == null || origins.length === 0) return input2;
+      const target = new URL(input2);
+      const shardOrigin = new URL(this.nextShardOrigin(operation, origins));
+      target.protocol = shardOrigin.protocol;
+      target.host = shardOrigin.host;
+      target.username = "";
+      target.password = "";
+      return target.toString();
+    }
+    nextShardOrigin(operation, origins) {
+      const currentIndex = this.shardCursorIndexes[operation] ?? createRandomShardStart(origins.length);
+      this.shardCursorIndexes[operation] = (currentIndex + 1) % origins.length;
+      return origins[currentIndex % origins.length];
+    }
+    classifyShardOperation(input2, init2, shardUrls) {
+      const method = (init2?.method ?? "GET").toUpperCase();
+      const requestUrl = new URL(input2);
+      const streamUrl = new URL(this.streamUrl);
+      const streamPath = normalizedStreamPath(streamUrl);
+      if (method === "GET" && requestUrl.pathname === `${streamPath}/bootstrap`) return "bootstrap";
+      if (method === "GET" && requestUrl.pathname === streamUrl.pathname && requestUrl.searchParams.has("offset") && requestUrl.searchParams.get("live") !== "sse") return "catchup";
+      if (method !== "POST" || requestUrl.pathname !== streamUrl.pathname) return;
+      const bodyLength = requestBodyByteLength(init2?.body);
+      if (bodyLength == null || bodyLength === 0 || bodyLength < shardUrls.largePostMinBytes) return;
+      return "large-post";
+    }
     async createStreamRequest() {
       const adapterHeaders = this.adapter.getCreateStreamHeaders ? await this.adapter.getCreateStreamHeaders() : void 0;
       const result = await this.client.create({
@@ -95195,10 +95290,11 @@ stream:${scope2.streamId}`;
     async bootstrap() {
       const result = await this.client.bootstrap();
       if (!result.ok) throw this.toTransportFailure(result.result);
+      const snapshot = result.result.snapshotOffset === "-1" ? new Uint8Array() : result.result.snapshot?.body ?? new Uint8Array();
       return {
         nextOffset: result.result.nextOffset,
         upToDate: result.result.upToDate,
-        snapshot: result.result.snapshot?.body ?? new Uint8Array(),
+        snapshot,
         updates: result.result.updates.flatMap((part) => decodeMultipartPartItems(part.body)),
         streamCursor: result.result.cursor
       };
@@ -95289,32 +95385,32 @@ stream:${scope2.streamId}`;
       if (!response.ok) {
         if (response.status === 400) {
           const message = await response.text();
-          if (isSseUnsupportedErrorText$1(message)) return {
+          if (isSseUnsupportedErrorText(message)) return {
             kind: "unsupported"
           };
           throw new HttpError(message.length > 0 ? `ephemeral live read failed: ${message}` : "ephemeral live read failed", response.status);
         }
         throw await this.responseToEphemeralFailure(response, "ephemeral live read");
       }
-      if (response.body == null) throw new ProtocolError$1("ephemeral sse response missing body");
-      if (!(response.headers.get("Content-Type") ?? "").toLowerCase().includes("text/event-stream")) throw new ProtocolError$1("ephemeral sse response must use text/event-stream content type");
+      if (response.body == null) throw new ProtocolError("ephemeral sse response missing body");
+      if (!(response.headers.get("Content-Type") ?? "").toLowerCase().includes("text/event-stream")) throw new ProtocolError("ephemeral sse response must use text/event-stream content type");
       const dataEncoding = response.headers.get("Stream-SSE-Data-Encoding") ?? void 0;
       const consume = async () => {
         let sawBootstrap = false;
-        for await (const event of readSseEvents$1(response.body)) {
+        for await (const event of readSseEvents(response.body)) {
           if (!sawBootstrap) {
-            if (event.event !== "bootstrap") throw new ProtocolError$1(`ephemeral sse must start with bootstrap, got '${event.event}'`);
-            await onBootstrap(decodeSsePayload$1(event.data, dataEncoding));
+            if (event.event !== "bootstrap") throw new ProtocolError(`ephemeral sse must start with bootstrap, got '${event.event}'`);
+            await onBootstrap(decodeSsePayload(event.data, dataEncoding));
             sawBootstrap = true;
             continue;
           }
           if (event.event === "data") {
-            await onData(decodeSsePayload$1(event.data, dataEncoding));
+            await onData(decodeSsePayload(event.data, dataEncoding));
             continue;
           }
-          throw new ProtocolError$1(`unexpected ephemeral sse event '${event.event}'`);
+          throw new ProtocolError(`unexpected ephemeral sse event '${event.event}'`);
         }
-        if (!sawBootstrap) throw new ProtocolError$1("ephemeral sse ended before bootstrap");
+        if (!sawBootstrap) throw new ProtocolError("ephemeral sse ended before bootstrap");
         return {
           kind: "ok"
         };
@@ -95363,9 +95459,9 @@ stream:${scope2.streamId}`;
     }
     async fetchWithTimeout(input2, init2, timeoutMs, phase) {
       const controller = new AbortController();
-      const signal = mergeAbortSignals$2(init2.signal, controller.signal);
+      const signal = mergeAbortSignals(init2.signal, controller.signal);
       const timer2 = setTimeout(() => {
-        controller.abort(new TimeoutError$1(phase, timeoutMs));
+        controller.abort(new TimeoutError(phase, timeoutMs));
       }, timeoutMs);
       try {
         return await this.fetchImpl(input2, {
@@ -95373,7 +95469,7 @@ stream:${scope2.streamId}`;
           signal
         });
       } catch (error2) {
-        if (controller.signal.aborted && controller.signal.reason instanceof TimeoutError$1) throw controller.signal.reason;
+        if (controller.signal.aborted && controller.signal.reason instanceof TimeoutError) throw controller.signal.reason;
         throw error2;
       } finally {
         clearTimeout(timer2);
@@ -95428,11 +95524,11 @@ stream:${scope2.streamId}`;
             body: error2.bodyText
           });
         case "timeout":
-          return new TimeoutError$1(error2.phase, error2.phase === "poll" ? this.reconnectConfig.pollTimeoutMs : this.reconnectConfig.connectTimeoutMs);
+          return new TimeoutError(error2.phase, error2.phase === "poll" ? this.reconnectConfig.pollTimeoutMs : this.reconnectConfig.connectTimeoutMs);
         case "network_error":
           return error2.cause instanceof TypeError ? error2.cause : new TypeError(error2.message);
         case "protocol_error":
-          return new ProtocolError$1(error2.message, error2.status);
+          return new ProtocolError(error2.message, error2.status);
         case "unknown":
           if (typeof error2.status === "number") return new HttpError(error2.message, error2.status, {
             requestId: extractRequestIdFromHeaders(error2.headers),
@@ -95494,7 +95590,7 @@ stream:${scope2.streamId}`;
         if (result.result.code === "not_found") return {
           kind: "not-found"
         };
-        if (result.result.code === "bad_request" && isSseUnsupportedErrorText$1(result.result.message)) return {
+        if (result.result.code === "bad_request" && isSseUnsupportedErrorText(result.result.message)) return {
           kind: "unsupported"
         };
         throw this.toTransportFailure(result.result);
@@ -95521,7 +95617,7 @@ stream:${scope2.streamId}`;
                 continue;
               }
               if (event.event !== "control") continue;
-              const control = parseSseControlData$1(event.data);
+              const control = parseSseControlData(event.data);
               const updates = [];
               for (const eventData of pendingDataEvents) updates.push(...decodeSseItemPayloads(eventData, session.dataEncoding));
               pendingDataEvents = [];
@@ -95636,7 +95732,7 @@ stream:${scope2.streamId}`;
       this.client = new StreamsTransportClient({
         streamUrl: options.streamUrl,
         adapter: createNoopAdapter(),
-        authProvider: normalizeAuthProvider$1(options.auth),
+        authProvider: normalizeAuthProvider(options.auth),
         fetchImpl: options.fetch ?? globalThis.fetch.bind(globalThis),
         reconnectConfig: this.reconnectConfig
       });
@@ -95814,7 +95910,7 @@ stream:${scope2.streamId}`;
           if (result.kind === "ok") {
             state2.retryAttempt = 0;
             this.setReadStatus(state2, "reconnecting");
-            await sleep$2(0);
+            await sleep$1(0);
             continue;
           }
           if (result.kind === "unsupported") throw new Error("ephemeral stream requires SSE support");
@@ -95846,9 +95942,9 @@ stream:${scope2.streamId}`;
             this.rejectFirstOpen(state2, toError$1(error2));
             return;
           }
-          const delay2 = computeRetryDelay$1(state2.retryAttempt, this.reconnectConfig);
+          const delay2 = computeRetryDelay(state2.retryAttempt, this.reconnectConfig);
           state2.retryAttempt += 1;
-          await sleep$2(delay2, state2.retrySleepController.signal);
+          await sleep$1(delay2, state2.retrySleepController.signal);
         }
       }
     }
@@ -95884,9 +95980,9 @@ stream:${scope2.streamId}`;
               return;
             }
             this.setWriteStatus(state2, "reconnecting");
-            const delay2 = computeRetryDelay$1(attempt, this.reconnectConfig);
+            const delay2 = computeRetryDelay(attempt, this.reconnectConfig);
             attempt += 1;
-            await sleep$2(delay2, state2.retrySleepController.signal);
+            await sleep$1(delay2, state2.retrySleepController.signal);
           }
         }
       } finally {
@@ -96273,7 +96369,7 @@ stream:${scope2.streamId}`;
   const MIN_RECONNECT_DELAY_MS = 1e3;
   const MIN_SUCCESSFUL_SSE_DURATION_MS = 5e3;
   function reconnectDelayWithFloor(attempt, config2) {
-    return Math.max(computeRetryDelay$1(attempt, config2), MIN_RECONNECT_DELAY_MS);
+    return Math.max(computeRetryDelay(attempt, config2), MIN_RECONNECT_DELAY_MS);
   }
   function fastSseCloseDelay(startedAtMs) {
     const elapsedMs = Math.max(0, Date.now() - startedAtMs);
@@ -96315,7 +96411,7 @@ stream:${scope2.streamId}`;
     constructor(options) {
       this.streamUrl = options.streamUrl;
       this.adapter = options.adapter;
-      const authProvider = normalizeAuthProvider$1(options.auth);
+      const authProvider = normalizeAuthProvider(options.auth);
       this.createStreamIfMissing = options.createStreamIfMissing ?? false;
       const fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
       this.remoteCursorStore = options.remoteCursorStore ?? new InMemoryRemoteCursorStore();
@@ -96342,7 +96438,8 @@ stream:${scope2.streamId}`;
         adapter: this.adapter,
         authProvider,
         fetchImpl,
-        reconnectConfig: this.reconnectConfig
+        reconnectConfig: this.reconnectConfig,
+        shardUrls: options.shardUrls
       });
       this.cursorManager = this.createCursorManager(this.adapter, (cursor, source) => this.saveRemoteCursor(cursor, source));
       this.volatileCursorManager = this.createCursorManager(this.adapter, async (cursor) => cursor);
@@ -96513,6 +96610,29 @@ stream:${scope2.streamId}`;
         };
       }
     }
+    async catchup(params = {}) {
+      try {
+        this.disableWriteOnlyMode("appendWriteOnly cannot be used after catchup() on the same transport");
+        const state2 = this.joinState;
+        if (state2 != null && !state2.closed) return {
+          ok: true,
+          value: {
+            cursor: await this.catchupJoinState(state2, params)
+          }
+        };
+        return {
+          ok: true,
+          value: {
+            cursor: (await this.resolvePullOnlyRemoteState()).cursor
+          }
+        };
+      } catch (error2) {
+        return {
+          ok: false,
+          error: toTransportError(error2)
+        };
+      }
+    }
     async appendWriteOnly() {
       return await this.enqueueExclusive(async () => {
         try {
@@ -96760,6 +96880,40 @@ stream:${scope2.streamId}`;
         return await this.bootstrapState(this.createInitialCursor());
       }
     }
+    async resolvePullOnlyRemoteState() {
+      const loaded = await this.remoteCursorStore.load(this.streamUrl);
+      const cursor = loaded ?? this.createInitialCursor();
+      try {
+        if (loaded == null) return await this.bootstrapState(cursor);
+        return await this.catchupFromCursor(cursor);
+      } catch (error2) {
+        if (!isStreamNotFoundError(error2) || !this.createStreamIfMissing) throw error2;
+        await this.ensureStreamExists();
+        return await this.bootstrapState(this.createInitialCursor());
+      }
+    }
+    async catchupJoinState(state2, params) {
+      if (state2.readSubStatus === "connecting") {
+        await state2.started;
+        return state2.cursor;
+      }
+      if (state2.readSubStatus === "ok" && params.force !== true) return state2.cursor;
+      const cursor = await this.enqueueExclusive(async () => {
+        if (state2.closed) throw new Error("subscription closed");
+        const caughtUp = await this.catchupFromCursor(state2.cursor, void 0, state2.streamCursor, (previousVersion, nextVersion) => {
+          this.snapshotManager.observeRemoteVersion(state2, previousVersion, nextVersion);
+        });
+        state2.cursor = caughtUp.cursor;
+        state2.streamCursor = caughtUp.streamCursor;
+        return state2.cursor;
+      });
+      if (state2.closed) return cursor;
+      state2.retryAttempt = 0;
+      state2.lastError = void 0;
+      if (state2.readSubStatus !== "ok" || state2.writeSubStatus === "error") this.rejoin();
+      else if (state2.pendingLocal.length > 0) this.flushPendingLocal(state2);
+      return cursor;
+    }
     async bootstrapState(cursor, options = {}) {
       const cursorManager = options.cursorManager ?? this.cursorManager;
       const result = await this.client.bootstrap();
@@ -96779,7 +96933,7 @@ stream:${scope2.streamId}`;
         streamCursor: bootstrapCursor
       };
     }
-    async catchup(cursor, live, streamCursor, onRemoteVersionApplied) {
+    async catchupFromCursor(cursor, live, streamCursor, onRemoteVersionApplied) {
       const result = await this.catchupOrGone(cursor, {
         live,
         streamCursor,
@@ -97126,7 +97280,7 @@ stream:${scope2.streamId}`;
             state2.retryAttempt = 0;
             this.setReadSubStatus(state2, "ok");
             if (state2.pendingLocal.length > 0) this.flushPendingLocal(state2);
-            await sleep$2(0);
+            await sleep$1(0);
             continue;
           }
           const sseRequestOffset = state2.cursor.nextOffset;
@@ -97180,12 +97334,12 @@ stream:${scope2.streamId}`;
           if (sseResult.kind === "ok") {
             state2.retryAttempt = 0;
             state2.streamCursor = sseResult.latestCursor;
-            await sleep$2(fastSseCloseDelay(sseStartedAtMs), state2.retrySleepController.signal);
+            await sleep$1(fastSseCloseDelay(sseStartedAtMs), state2.retrySleepController.signal);
             continue;
           }
           if (sseResult.kind === "unsupported") {
             state2.liveMode = "long-poll";
-            await sleep$2(0);
+            await sleep$1(0);
             continue;
           }
           if (sseResult.kind === "not-found") {
@@ -97237,7 +97391,7 @@ stream:${scope2.streamId}`;
                 return;
               }
               state2.retryAttempt += 1;
-              await sleep$2(reconnectDelayWithFloor(state2.retryAttempt - 1, this.reconnectConfig), state2.retrySleepController.signal);
+              await sleep$1(reconnectDelayWithFloor(state2.retryAttempt - 1, this.reconnectConfig), state2.retrySleepController.signal);
               continue;
             }
             const abortReason = capturedController.signal.reason;
@@ -97284,9 +97438,9 @@ stream:${scope2.streamId}`;
             this.setReadSubStatus(state2, "disconnected");
             return;
           }
-          const delay2 = computeRetryDelay$1(state2.retryAttempt, this.reconnectConfig, error2 instanceof HttpError ? error2.retryAfterMs : void 0);
+          const delay2 = computeRetryDelay(state2.retryAttempt, this.reconnectConfig, error2 instanceof HttpError ? error2.retryAfterMs : void 0);
           state2.retryAttempt += 1;
-          await sleep$2(delay2, state2.retrySleepController.signal);
+          await sleep$1(delay2, state2.retrySleepController.signal);
         }
       }
     }
@@ -97366,9 +97520,9 @@ stream:${scope2.streamId}`;
               return;
             }
             this.setWriteSubStatus(state2, "reconnecting");
-            const delay2 = computeRetryDelay$1(attempts, this.reconnectConfig, error2 instanceof HttpError ? error2.retryAfterMs : void 0);
+            const delay2 = computeRetryDelay(attempts, this.reconnectConfig, error2 instanceof HttpError ? error2.retryAfterMs : void 0);
             attempts += 1;
-            await sleep$2(delay2, state2.retrySleepController.signal);
+            await sleep$1(delay2, state2.retrySleepController.signal);
           }
         }
       } finally {
@@ -118352,1540 +118506,6 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
       });
     }
   }
-  var ProtocolError = class extends Error {
-    status;
-    detail;
-    constructor(message, status, detail) {
-      super(message);
-      this.status = status;
-      this.detail = detail;
-    }
-  };
-  var TimeoutError = class extends Error {
-    phase;
-    timeoutMs;
-    constructor(phase, timeoutMs) {
-      super(`TIMEOUT: ${phase} request exceeded ${timeoutMs}ms`);
-      this.phase = phase;
-      this.timeoutMs = timeoutMs;
-    }
-  };
-  function isAbortError(error2) {
-    return error2 instanceof DOMException ? error2.name === "AbortError" : typeof error2 === "object" && error2 != null && "name" in error2 && error2.name === "AbortError";
-  }
-  async function responseToStreamError(response, context2) {
-    const bodyText = await safeReadBodyText(response);
-    const message = bodyText.length > 0 ? `${context2} failed with status ${response.status}: ${bodyText}` : `${context2} failed with status ${response.status}`;
-    switch (response.status) {
-      case 400:
-        return {
-          code: "bad_request",
-          status: 400,
-          message
-        };
-      case 401:
-        return {
-          code: "unauthorized",
-          status: 401,
-          message
-        };
-      case 403:
-        return {
-          code: "forbidden",
-          status: 403,
-          message,
-          detail: producerEpochDetail(response)
-        };
-      case 404:
-        return {
-          code: "not_found",
-          status: 404,
-          message
-        };
-      case 409:
-        return {
-          code: "conflict",
-          status: 409,
-          message,
-          detail: conflictDetail(response, bodyText)
-        };
-      case 410:
-        return {
-          code: "gone",
-          status: 410,
-          message
-        };
-      case 429:
-        return {
-          code: "rate_limited",
-          status: 429,
-          message
-        };
-      default:
-        return {
-          code: "unknown",
-          message,
-          status: response.status,
-          statusText: response.statusText,
-          headers: headersToObject$1(response.headers),
-          bodyText: bodyText.length > 0 ? bodyText : void 0,
-          cause: {
-            type: "http_response",
-            status: response.status,
-            statusText: response.statusText
-          }
-        };
-    }
-  }
-  function thrownToStreamError(error2) {
-    if (error2 instanceof TimeoutError) return {
-      code: "timeout",
-      phase: error2.phase,
-      message: error2.message
-    };
-    if (error2 instanceof ProtocolError) return {
-      code: "protocol_error",
-      message: error2.message,
-      status: error2.status,
-      detail: error2.detail
-    };
-    if (error2 instanceof TypeError) return {
-      code: "network_error",
-      message: error2.message,
-      cause: error2
-    };
-    if (error2 instanceof Error) return {
-      code: "unknown",
-      message: error2.message,
-      cause: error2
-    };
-    return {
-      code: "unknown",
-      message: String(error2),
-      cause: error2
-    };
-  }
-  function isRetryableLiveError(error2) {
-    return isRetryableStreamError(error2);
-  }
-  function producerEpochDetail(response) {
-    const value = response.headers.get("Producer-Epoch");
-    if (value == null) return;
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isFinite(parsed) || parsed < 0) return {
-      kind: "other"
-    };
-    return {
-      kind: "stale_producer_epoch",
-      serverEpoch: parsed
-    };
-  }
-  function conflictDetail(response, bodyText) {
-    if (isTrueHeader(response.headers.get("Stream-Closed"))) return {
-      kind: "stream_closed",
-      nextOffset: response.headers.get("Stream-Next-Offset") ?? void 0
-    };
-    const expectedSeq = parseOptionalInteger$1(response.headers.get("Producer-Expected-Seq"));
-    if (expectedSeq != null) return {
-      kind: "producer_seq_gap",
-      expectedSeq,
-      receivedSeq: parseOptionalInteger$1(response.headers.get("Producer-Received-Seq")) ?? void 0
-    };
-    const normalized = bodyText.toLowerCase();
-    if (normalized.includes("content type")) return {
-      kind: "content_type_mismatch"
-    };
-    if (normalized.includes("stream-seq") || normalized.includes("sequence")) return {
-      kind: "stream_seq_conflict"
-    };
-    return {
-      kind: "other"
-    };
-  }
-  function parseOptionalInteger$1(value) {
-    if (value == null) return null;
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isFinite(parsed) || parsed < 0) return null;
-    return parsed;
-  }
-  function isTrueHeader(value) {
-    return value?.trim().toLowerCase() === "true";
-  }
-  function headersToObject$1(headers) {
-    const result = {};
-    headers.forEach((value, name2) => {
-      result[name2] = value;
-    });
-    return result;
-  }
-  async function safeReadBodyText(response) {
-    try {
-      return await response.text();
-    } catch {
-      return "";
-    }
-  }
-  function isRetryableStreamError(error2) {
-    return error2.code === "network_error" || error2.code === "timeout";
-  }
-  const DEFAULT_TIMEOUT_CONFIG = {
-    connectTimeoutMs: 1e4,
-    pollTimeoutMs: 3e4
-  };
-  function normalizeTimeoutConfig(value) {
-    const connectTimeoutMs = value?.connectTimeoutMs ?? DEFAULT_TIMEOUT_CONFIG.connectTimeoutMs;
-    const pollTimeoutMs = value?.pollTimeoutMs ?? DEFAULT_TIMEOUT_CONFIG.pollTimeoutMs;
-    if (!Number.isFinite(connectTimeoutMs) || connectTimeoutMs < 0) throw new Error("timeout.connectTimeoutMs must be a non-negative finite number");
-    if (!Number.isFinite(pollTimeoutMs) || pollTimeoutMs < 0) throw new Error("timeout.pollTimeoutMs must be a non-negative finite number");
-    return {
-      connectTimeoutMs: Math.floor(connectTimeoutMs),
-      pollTimeoutMs: Math.floor(pollTimeoutMs)
-    };
-  }
-  function mergeAbortSignals$1(...signals2) {
-    const active2 = signals2.filter((signal) => signal != null);
-    if (active2.length === 0) return;
-    if (active2.length === 1) return active2[0];
-    if (typeof AbortSignal.any === "function") return AbortSignal.any(active2);
-    const controller = new AbortController();
-    for (const signal of active2) {
-      if (signal.aborted) {
-        controller.abort(signal.reason);
-        break;
-      }
-      signal.addEventListener("abort", () => {
-        controller.abort(signal.reason);
-      }, {
-        once: true
-      });
-    }
-    return controller.signal;
-  }
-  async function fetchWithTimeout(fetchImpl, input2, init2, timeoutMs, phase) {
-    if (!(timeoutMs > 0)) return await fetchImpl(input2, init2);
-    const controller = new AbortController();
-    const signal = mergeAbortSignals$1(init2.signal, controller.signal);
-    const timer2 = setTimeout(() => {
-      controller.abort(new TimeoutError(phase, timeoutMs));
-    }, timeoutMs);
-    try {
-      return await fetchImpl(input2, {
-        ...init2,
-        signal
-      });
-    } catch (error2) {
-      if (controller.signal.aborted && controller.signal.reason instanceof TimeoutError) throw controller.signal.reason;
-      throw error2;
-    } finally {
-      clearTimeout(timer2);
-    }
-  }
-  var AuthorizedHttpClient = class {
-    fetchImpl;
-    authProvider;
-    authRefreshInFlight;
-    constructor(options) {
-      this.fetchImpl = options.fetchImpl;
-      this.authProvider = normalizeAuthProvider(options.auth);
-    }
-    async fetchAuthorized(input2, init2, timeoutMs, phase, options) {
-      const firstToken = await this.resolveToken({
-        reason: "request"
-      });
-      const firstResponse = await fetchWithTimeout(this.fetchImpl, input2, {
-        ...init2,
-        headers: this.attachAuthorization(init2.headers, firstToken)
-      }, timeoutMs, phase);
-      const shouldRetryAuthFailure = options?.shouldRetryAuthFailure ?? ((response) => response.status === 401 || response.status === 403);
-      if (this.authProvider == null || !shouldRetryAuthFailure(firstResponse)) return firstResponse;
-      await firstResponse.body?.cancel().catch(() => {
-      });
-      const refreshedToken = await this.refreshTokenAfterFailure(firstResponse.status, firstToken);
-      return await fetchWithTimeout(this.fetchImpl, input2, {
-        ...init2,
-        headers: this.attachAuthorization(init2.headers, refreshedToken)
-      }, timeoutMs, phase);
-    }
-    async resolveToken(context2) {
-      if (this.authProvider == null) return;
-      return await this.authProvider(context2);
-    }
-    async refreshTokenAfterFailure(status, previousToken) {
-      if (this.authProvider == null) return;
-      if (this.authRefreshInFlight == null) this.authRefreshInFlight = this.resolveToken({
-        reason: "unauthorized",
-        status,
-        previousToken
-      }).finally(() => {
-        this.authRefreshInFlight = void 0;
-      });
-      return await this.authRefreshInFlight;
-    }
-    attachAuthorization(base, token2) {
-      const headers = new Headers(base);
-      if (token2 == null || token2.length === 0) {
-        headers.delete("Authorization");
-        return headers;
-      }
-      headers.set("Authorization", `Bearer ${token2}`);
-      return headers;
-    }
-  };
-  function normalizeAuthProvider(auth) {
-    if (auth == null) return;
-    if (typeof auth === "string") {
-      const token2 = auth.trim();
-      return async () => token2.length === 0 ? void 0 : token2;
-    }
-    return async (context2) => {
-      const token2 = (await auth(context2))?.trim() ?? "";
-      return token2.length === 0 ? void 0 : token2;
-    };
-  }
-  function decodeMultipartMixed(boundary, data) {
-    const delimiter2 = new TextEncoder().encode(`--${boundary}`);
-    const closeDelimiter = new TextEncoder().encode(`--${boundary}--`);
-    const crlfCrlf = new TextEncoder().encode("\r\n\r\n");
-    const parts2 = [];
-    let pos = 0;
-    const firstDelimPos = indexOf(data, delimiter2, pos);
-    if (firstDelimPos < 0) return parts2;
-    pos = firstDelimPos + delimiter2.byteLength;
-    if (pos < data.byteLength && data[pos] === 13) pos += 1;
-    if (pos < data.byteLength && data[pos] === 10) pos += 1;
-    while (pos < data.byteLength) {
-      if (startsWith(data.subarray(pos), closeDelimiter.subarray(delimiter2.byteLength))) break;
-      const headerEnd = indexOf(data, crlfCrlf, pos);
-      if (headerEnd < 0) break;
-      const headerBytes = data.subarray(pos, headerEnd);
-      const headerText = new TextDecoder().decode(headerBytes);
-      let contentType = "application/octet-stream";
-      for (const line3 of headerText.split("\r\n")) {
-        const colon = line3.indexOf(":");
-        if (colon <= 0) continue;
-        if (line3.slice(0, colon).trim().toLowerCase() !== "content-type") continue;
-        contentType = line3.slice(colon + 1).trim();
-      }
-      const bodyStart = headerEnd + crlfCrlf.byteLength;
-      const nextDelimiter = indexOf(data, delimiter2, bodyStart);
-      if (nextDelimiter < 0) {
-        parts2.push({
-          contentType,
-          body: data.subarray(bodyStart)
-        });
-        break;
-      }
-      let bodyEnd = nextDelimiter;
-      if (bodyEnd >= 2 && data[bodyEnd - 2] === 13 && data[bodyEnd - 1] === 10) bodyEnd -= 2;
-      parts2.push({
-        contentType,
-        body: data.subarray(bodyStart, bodyEnd)
-      });
-      pos = nextDelimiter + delimiter2.byteLength;
-      if (pos + 1 < data.byteLength && data[pos] === 45 && data[pos + 1] === 45) break;
-      if (pos < data.byteLength && data[pos] === 13) pos += 1;
-      if (pos < data.byteLength && data[pos] === 10) pos += 1;
-    }
-    return parts2;
-  }
-  function extractBoundary(contentType) {
-    return /boundary=("?)([^";,\s]+)\1/i.exec(contentType)?.[2] ?? null;
-  }
-  function indexOf(haystack, needle, from2) {
-    outer: for (let i2 = from2; i2 <= haystack.byteLength - needle.byteLength; i2 += 1) {
-      for (let j = 0; j < needle.byteLength; j += 1) if (haystack[i2 + j] !== needle[j]) continue outer;
-      return i2;
-    }
-    return -1;
-  }
-  function startsWith(data, prefix) {
-    if (data.byteLength < prefix.byteLength) return false;
-    for (let i2 = 0; i2 < prefix.byteLength; i2 += 1) if (data[i2] !== prefix[i2]) return false;
-    return true;
-  }
-  const DEFAULT_RETRY_CONFIG = {
-    delays: [
-      0,
-      500,
-      1e3,
-      2e3,
-      4e3,
-      8e3,
-      15e3
-    ],
-    jitterFraction: 0.2,
-    maxAttempts: 5
-  };
-  function normalizeRetryConfig(value) {
-    const delays = value?.delays ?? DEFAULT_RETRY_CONFIG.delays;
-    if (delays.length === 0) throw new Error("retry.delays must contain at least one entry");
-    const normalizedDelays = delays.map((delay2) => {
-      if (!Number.isFinite(delay2) || delay2 < 0) throw new Error("retry.delays must contain non-negative finite numbers");
-      return Math.floor(delay2);
-    });
-    const jitterFraction = value?.jitterFraction ?? DEFAULT_RETRY_CONFIG.jitterFraction;
-    if (!Number.isFinite(jitterFraction) || jitterFraction < 0) throw new Error("retry.jitterFraction must be a non-negative finite number");
-    const maxAttempts = value?.maxAttempts ?? DEFAULT_RETRY_CONFIG.maxAttempts;
-    if (!Number.isInteger(maxAttempts) || maxAttempts < 0) throw new Error("retry.maxAttempts must be a non-negative integer");
-    return {
-      delays: normalizedDelays,
-      jitterFraction,
-      maxAttempts
-    };
-  }
-  function applyJitter(baseMs, fraction) {
-    if (baseMs === 0) return 0;
-    const jitter = baseMs * fraction * (2 * Math.random() - 1);
-    return Math.max(0, Math.round(baseMs + jitter));
-  }
-  function computeRetryDelay(attempt, config2 = DEFAULT_RETRY_CONFIG) {
-    const index2 = Math.min(attempt, config2.delays.length - 1);
-    return applyJitter(config2.delays[index2] ?? 0, config2.jitterFraction);
-  }
-  async function sleep$1(delayMs, signal) {
-    if (delayMs <= 0) {
-      if (signal?.aborted === true) throw signal.reason;
-      return;
-    }
-    await new Promise((resolve2, reject) => {
-      const timer2 = setTimeout(() => {
-        cleanup();
-        resolve2();
-      }, delayMs);
-      const onAbort = () => {
-        clearTimeout(timer2);
-        cleanup();
-        reject(signal?.reason);
-      };
-      const cleanup = () => {
-        signal?.removeEventListener("abort", onAbort);
-      };
-      if (signal != null) {
-        if (signal.aborted) {
-          onAbort();
-          return;
-        }
-        signal.addEventListener("abort", onAbort, {
-          once: true
-        });
-      }
-    });
-  }
-  function getRequiredHeader(headers, name2, context2) {
-    const value = headers.get(name2);
-    if (value != null && value.length > 0) return value;
-    throw new ProtocolError(`${context2} response missing ${name2}. If this is cross-origin, expose it via Access-Control-Expose-Headers (${name2.toLowerCase()}). Visible headers: ${visibleHeaderNames(headers)}`);
-  }
-  function hasTrueHeader(headers, name2) {
-    return headers.get(name2)?.trim().toLowerCase() === "true";
-  }
-  function parseOptionalInteger(value) {
-    if (value == null) return null;
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isFinite(parsed) || parsed < 0) return null;
-    return parsed;
-  }
-  function visibleHeaderNames(headers) {
-    const names2 = [];
-    headers.forEach((_value, name2) => {
-      names2.push(name2);
-    });
-    if (names2.length === 0) return "(none)";
-    names2.sort();
-    return names2.join(", ");
-  }
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
-  function createStreamPart(contentType, body) {
-    return {
-      contentType,
-      body,
-      text() {
-        return decoder.decode(body);
-      },
-      json() {
-        return JSON.parse(decoder.decode(body));
-      }
-    };
-  }
-  function normalizeStreamPartLike(input2) {
-    return {
-      contentType: normalizeContentType(input2.contentType),
-      body: normalizeStreamBody(input2.body)
-    };
-  }
-  function normalizeContentType(contentType) {
-    const normalized = contentType.trim();
-    if (normalized.length === 0) throw new Error("contentType must be a non-empty string");
-    return normalized;
-  }
-  function normalizeOptionalContentType(contentType) {
-    if (contentType == null) return;
-    return normalizeContentType(contentType);
-  }
-  function normalizeStreamBody(body) {
-    if (typeof body === "string") return encoder.encode(body);
-    if (body instanceof Uint8Array) return body.slice();
-    if (body instanceof ArrayBuffer) return new Uint8Array(body.slice(0));
-    if (ArrayBuffer.isView(body)) return new Uint8Array(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength));
-    throw new Error("unsupported stream body type");
-  }
-  function toRequestBody(bytes) {
-    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-  }
-  function isSseUnsupportedErrorText(message) {
-    const normalized = message.trim().toLowerCase();
-    if (normalized.length === 0) return false;
-    const mentionsSse = normalized.includes("sse") || normalized.includes("text/event-stream");
-    const mentionsCompatibility = normalized.includes("unsupported") || normalized.includes("not support") || normalized.includes("incompatible") || normalized.includes("content type");
-    return mentionsSse && mentionsCompatibility;
-  }
-  function parseSseControlData(data) {
-    let parsed;
-    try {
-      parsed = JSON.parse(data);
-    } catch {
-      throw new ProtocolError("invalid sse control event JSON");
-    }
-    if (typeof parsed !== "object" || parsed == null || typeof parsed.streamNextOffset !== "string") throw new ProtocolError("sse control event missing streamNextOffset");
-    const streamClosed = parsed.streamClosed === true;
-    const streamCursor = typeof parsed.streamCursor === "string" ? parsed.streamCursor : void 0;
-    return {
-      nextOffset: parsed.streamNextOffset,
-      upToDate: parsed.upToDate === true || streamClosed,
-      streamClosed,
-      streamCursor
-    };
-  }
-  function decodeSsePayload(data, dataEncoding) {
-    const normalizedEncoding = dataEncoding?.trim().toLowerCase();
-    if (normalizedEncoding == null || normalizedEncoding.length === 0) return new TextEncoder().encode(data);
-    if (normalizedEncoding !== "base64") throw new ProtocolError(`unsupported stream-sse-data-encoding '${dataEncoding}'`);
-    return decodeBase64Bytes(data.replace(/[\r\n]/g, ""));
-  }
-  async function* readSseEvents(stream2, options = {}) {
-    const reader2 = stream2.getReader();
-    const decoder2 = new TextDecoder();
-    let pendingText = "";
-    let currentEvent = "";
-    let dataLines = [];
-    let abortHandler;
-    const cancelReader = async () => {
-      await reader2.cancel(options.signal?.reason).catch(() => {
-      });
-    };
-    if (options.signal?.aborted) {
-      await cancelReader();
-      return;
-    }
-    if (options.signal != null) {
-      abortHandler = () => {
-        cancelReader();
-      };
-      options.signal.addEventListener("abort", abortHandler, {
-        once: true
-      });
-    }
-    const notifyActivity = () => {
-      try {
-        options.onActivity?.();
-      } catch {
-      }
-    };
-    const flushEvent = async function* () {
-      if (dataLines.length === 0) {
-        currentEvent = "";
-        return;
-      }
-      const eventType = currentEvent.length === 0 ? "message" : currentEvent;
-      const data = dataLines.join("\n");
-      currentEvent = "";
-      dataLines = [];
-      yield {
-        event: eventType,
-        data
-      };
-    };
-    try {
-      while (true) {
-        const { done: done2, value } = await reader2.read();
-        if (value != null) {
-          if (value.byteLength > 0) notifyActivity();
-          pendingText += decoder2.decode(value, {
-            stream: true
-          });
-          while (true) {
-            const newline = pendingText.indexOf("\n");
-            if (newline < 0) break;
-            const rawLine = pendingText.slice(0, newline);
-            pendingText = pendingText.slice(newline + 1);
-            const line3 = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
-            if (line3.length === 0) {
-              yield* flushEvent();
-              continue;
-            }
-            if (line3.startsWith(":")) continue;
-            if (line3.startsWith("event:")) {
-              currentEvent = line3.slice(6).trim();
-              continue;
-            }
-            if (line3.startsWith("data:")) dataLines.push(line3.slice(5).replace(/^ /, ""));
-          }
-        }
-        if (!done2) continue;
-        pendingText += decoder2.decode();
-        if (pendingText.length > 0) {
-          const line3 = pendingText.endsWith("\r") ? pendingText.slice(0, -1) : pendingText;
-          if (line3.startsWith("data:")) dataLines.push(line3.slice(5).replace(/^ /, ""));
-        }
-        yield* flushEvent();
-        return;
-      }
-    } finally {
-      if (abortHandler != null && options.signal != null) options.signal.removeEventListener("abort", abortHandler);
-      try {
-        await reader2.cancel();
-      } catch {
-      }
-    }
-  }
-  function decodeBase64Bytes(encoded) {
-    if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(encoded, "base64"));
-    if (typeof atob === "function") {
-      const binary2 = atob(encoded);
-      const out2 = new Uint8Array(binary2.length);
-      for (let i2 = 0; i2 < binary2.length; i2 += 1) out2[i2] = binary2.charCodeAt(i2);
-      return out2;
-    }
-    throw new Error("base64 decoding is unavailable");
-  }
-  var StreamsClient = class {
-    streamUrl;
-    http;
-    defaultHeaders;
-    retryConfig;
-    timeoutConfig;
-    onRetry;
-    knownContentType;
-    constructor(options) {
-      if (options.url == null) throw new Error("StreamsClient requires url");
-      this.streamUrl = options.url instanceof URL ? new URL(options.url) : new URL(options.url);
-      const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
-      if (typeof fetchImpl !== "function") throw new Error("fetch is unavailable; pass options.fetch explicitly");
-      this.http = new AuthorizedHttpClient({
-        fetchImpl,
-        auth: options.auth
-      });
-      this.defaultHeaders = new Headers(options.headers);
-      this.retryConfig = normalizeRetryConfig(options.retry);
-      this.timeoutConfig = normalizeTimeoutConfig(options.timeout);
-      this.onRetry = options.onRetry;
-    }
-    async create(input2 = {}) {
-      validateCreateInput(input2);
-      const part = input2.part == null ? void 0 : normalizeStreamPartLike(input2.part);
-      const requestedContentType = part?.contentType ?? normalizeOptionalContentType(input2.contentType) ?? void 0;
-      try {
-        const requestUrl = this.streamEndpoint();
-        const headers = this.mergeHeaders(input2.headers);
-        if (requestedContentType != null) headers.set("Content-Type", requestedContentType);
-        if (input2.ttlSeconds != null) headers.set("Stream-TTL", String(input2.ttlSeconds));
-        if (input2.expiresAt != null) headers.set("Stream-Expires-At", input2.expiresAt);
-        if (input2.close === true) headers.set("Stream-Closed", "true");
-        const response = await this.http.fetchAuthorized(requestUrl, {
-          method: "PUT",
-          headers,
-          body: part == null ? void 0 : toRequestBody(part.body)
-        }, this.timeoutConfig.connectTimeoutMs, "connect");
-        if (response.status !== 200 && response.status !== 201) return {
-          ok: false,
-          result: await responseToStreamError(response, "create")
-        };
-        const contentType = this.resolveContentType(response, "create", requestedContentType ?? "application/octet-stream");
-        const nextOffset = getRequiredHeader(response.headers, "Stream-Next-Offset", "create");
-        this.knownContentType = contentType;
-        return {
-          ok: true,
-          result: this.withMeta({
-            created: response.status === 201,
-            contentType,
-            nextOffset,
-            closed: hasTrueHeader(response.headers, "Stream-Closed")
-          }, input2, "PUT", requestUrl, response)
-        };
-      } catch (error2) {
-        return {
-          ok: false,
-          result: thrownToStreamError(error2)
-        };
-      }
-    }
-    async delete(input2 = {}) {
-      try {
-        const requestUrl = this.streamEndpoint();
-        const response = await this.http.fetchAuthorized(requestUrl, {
-          method: "DELETE",
-          headers: this.mergeHeaders(input2.headers)
-        }, this.timeoutConfig.connectTimeoutMs, "connect");
-        if (response.status === 404) return {
-          ok: true,
-          result: this.withMeta({
-            deleted: false
-          }, input2, "DELETE", requestUrl, response)
-        };
-        if (response.status !== 200 && response.status !== 204) return {
-          ok: false,
-          result: await responseToStreamError(response, "delete")
-        };
-        return {
-          ok: true,
-          result: this.withMeta({
-            deleted: true
-          }, input2, "DELETE", requestUrl, response)
-        };
-      } catch (error2) {
-        return {
-          ok: false,
-          result: thrownToStreamError(error2)
-        };
-      }
-    }
-    async head(input2 = {}) {
-      try {
-        const requestUrl = this.streamEndpoint();
-        const response = await this.http.fetchAuthorized(requestUrl, {
-          method: "HEAD",
-          headers: this.mergeHeaders(input2.headers)
-        }, this.timeoutConfig.connectTimeoutMs, "connect");
-        if (!response.ok) return {
-          ok: false,
-          result: await responseToStreamError(response, "head")
-        };
-        const contentType = this.resolveContentType(response, "head", this.knownContentType);
-        const nextOffset = getRequiredHeader(response.headers, "Stream-Next-Offset", "head");
-        this.knownContentType = contentType;
-        return {
-          ok: true,
-          result: this.withMeta({
-            contentType,
-            nextOffset,
-            closed: hasTrueHeader(response.headers, "Stream-Closed"),
-            ttlSeconds: parseOptionalInteger(response.headers.get("Stream-TTL")) ?? void 0,
-            expiresAt: response.headers.get("Stream-Expires-At") ?? void 0,
-            snapshotOffset: response.headers.get("Stream-Snapshot-Offset") ?? void 0
-          }, input2, "HEAD", requestUrl, response)
-        };
-      } catch (error2) {
-        return {
-          ok: false,
-          result: thrownToStreamError(error2)
-        };
-      }
-    }
-    async append(input2) {
-      validateAppendInput(input2);
-      const part = input2.part == null ? void 0 : normalizeStreamPartLike(input2.part);
-      let attempt = 0;
-      while (true) try {
-        const requestUrl = this.streamEndpoint();
-        const response = await this.http.fetchAuthorized(requestUrl, {
-          method: "POST",
-          headers: this.appendHeaders(input2, part?.contentType),
-          body: part == null ? void 0 : toRequestBody(part.body)
-        }, this.timeoutConfig.connectTimeoutMs, "connect", {
-          shouldRetryAuthFailure: (nextResponse) => nextResponse.status === 401 || nextResponse.status === 403 && nextResponse.headers.get("Producer-Epoch") == null
-        });
-        if (response.status !== 200 && response.status !== 204) return {
-          ok: false,
-          result: await responseToStreamError(response, "append")
-        };
-        if (part != null) this.knownContentType = part.contentType;
-        return {
-          ok: true,
-          result: this.withMeta(this.parseAppendOutput(response, input2), input2, "POST", requestUrl, response)
-        };
-      } catch (error2) {
-        const result = thrownToStreamError(error2);
-        if (input2.producer == null || !isAppendRetryable(result) || attempt >= this.retryConfig.maxAttempts) return {
-          ok: false,
-          result
-        };
-        const delay2 = computeRetryDelay(attempt, this.retryConfig);
-        attempt += 1;
-        this.onRetry?.({
-          operation: "append",
-          error: result,
-          attempt,
-          delayMs: delay2,
-          maxAttempts: this.retryConfig.maxAttempts
-        });
-        await sleep$1(delay2);
-      }
-    }
-    async close(input2 = {}) {
-      return await this.append({
-        close: true,
-        headers: input2.headers,
-        includeMeta: input2.includeMeta,
-        producer: input2.producer
-      });
-    }
-    async read(input2 = {}) {
-      const result = await this.readOnce(input2);
-      if (!result.ok) return result;
-      if (result.result.payload == null) return {
-        ok: false,
-        result: {
-          code: "protocol_error",
-          message: "read response must include a payload body"
-        }
-      };
-      return {
-        ok: true,
-        result: {
-          requestOffset: result.result.requestOffset,
-          nextOffset: result.result.nextOffset,
-          upToDate: result.result.upToDate,
-          closed: result.result.closed,
-          cursor: result.result.cursor,
-          payload: result.result.payload,
-          meta: result.result.meta
-        }
-      };
-    }
-    async readOnce(input2 = {}) {
-      validateReadOnceInput(input2);
-      const requestOffset = input2.offset ?? "-1";
-      try {
-        const requestUrl = this.readEndpoint({
-          offset: requestOffset,
-          cursor: input2.cursor,
-          live: input2.live
-        });
-        const timeoutMs = input2.live === "long-poll" ? this.timeoutConfig.pollTimeoutMs : this.timeoutConfig.connectTimeoutMs;
-        const phase = input2.live === "long-poll" ? "poll" : "connect";
-        const response = await this.http.fetchAuthorized(requestUrl, {
-          method: "GET",
-          headers: this.mergeHeaders(input2.headers),
-          signal: input2.signal
-        }, timeoutMs, phase);
-        if (!response.ok) return {
-          ok: false,
-          result: await responseToStreamError(response, "read once")
-        };
-        if (response.status === 204) {
-          const nextOffset = getRequiredHeader(response.headers, "Stream-Next-Offset", "read once");
-          if (!hasTrueHeader(response.headers, "Stream-Up-To-Date")) throw new ProtocolError("long-poll 204 response missing Stream-Up-To-Date: true");
-          const closed = hasTrueHeader(response.headers, "Stream-Closed");
-          const cursor = response.headers.get("Stream-Cursor") ?? void 0;
-          return {
-            ok: true,
-            result: this.withMeta({
-              status: 204,
-              requestOffset,
-              nextOffset,
-              upToDate: true,
-              closed,
-              cursor,
-              payload: null
-            }, input2, "GET", requestUrl, response)
-          };
-        }
-        const output = await this.parseReadOutput(response, requestOffset, "read once");
-        return {
-          ok: true,
-          result: this.withMeta({
-            status: 200,
-            ...output
-          }, input2, "GET", requestUrl, response)
-        };
-      } catch (error2) {
-        return {
-          ok: false,
-          result: thrownToStreamError(error2)
-        };
-      }
-    }
-    async bootstrap(input2 = {}) {
-      try {
-        const requestUrl = this.subresourceEndpoint("/bootstrap");
-        const response = await this.http.fetchAuthorized(requestUrl, {
-          method: "GET",
-          headers: this.mergeHeaders(input2.headers),
-          signal: input2.signal
-        }, this.timeoutConfig.connectTimeoutMs, "connect");
-        if (!response.ok) return {
-          ok: false,
-          result: await responseToStreamError(response, "bootstrap")
-        };
-        const boundary = extractBoundary(response.headers.get("Content-Type") ?? "");
-        if (boundary == null) throw new ProtocolError("bootstrap response must be multipart/mixed");
-        const nextOffset = getRequiredHeader(response.headers, "Stream-Next-Offset", "bootstrap");
-        const snapshotOffset = getRequiredHeader(response.headers, "Stream-Snapshot-Offset", "bootstrap");
-        const parts2 = decodeMultipartMixed(boundary, new Uint8Array(await response.arrayBuffer()));
-        if (parts2.length === 0) throw new ProtocolError("bootstrap response must include at least one MIME part");
-        const first2 = parts2[0];
-        const snapshot = snapshotOffset === "-1" && first2?.body.byteLength === 0 ? null : createStreamPart(first2.contentType, first2.body);
-        const updates = parts2.slice(1).map((part) => createStreamPart(part.contentType, part.body));
-        if (updates.length > 0) this.knownContentType = updates[0].contentType;
-        return {
-          ok: true,
-          result: this.withMeta({
-            snapshotOffset,
-            nextOffset,
-            upToDate: hasTrueHeader(response.headers, "Stream-Up-To-Date"),
-            cursor: response.headers.get("Stream-Cursor") ?? void 0,
-            snapshot,
-            updates
-          }, input2, "GET", requestUrl, response)
-        };
-      } catch (error2) {
-        return {
-          ok: false,
-          result: thrownToStreamError(error2)
-        };
-      }
-    }
-    async readLatestSnapshot(input2 = {}) {
-      try {
-        const requestUrl = this.subresourceEndpoint("/snapshot");
-        const response = await this.http.fetchAuthorized(requestUrl, {
-          method: "GET",
-          headers: this.mergeHeaders(input2.headers)
-        }, this.timeoutConfig.connectTimeoutMs, "connect");
-        if (response.status === 404) return {
-          ok: true,
-          result: null
-        };
-        if (!response.ok) return {
-          ok: false,
-          result: await responseToStreamError(response, "read latest snapshot")
-        };
-        return {
-          ok: true,
-          result: this.withMeta(await this.parseSnapshotReadOutput(response, "read latest snapshot"), input2, "GET", requestUrl, response)
-        };
-      } catch (error2) {
-        return {
-          ok: false,
-          result: thrownToStreamError(error2)
-        };
-      }
-    }
-    async readSnapshot(offset2, input2 = {}) {
-      assertNonEmptyString(offset2, "offset");
-      try {
-        const requestUrl = this.subresourceEndpoint(`/snapshot/${encodeURIComponent(offset2)}`);
-        const response = await this.http.fetchAuthorized(requestUrl, {
-          method: "GET",
-          headers: this.mergeHeaders(input2.headers)
-        }, this.timeoutConfig.connectTimeoutMs, "connect");
-        if (!response.ok) return {
-          ok: false,
-          result: await responseToStreamError(response, "read snapshot")
-        };
-        return {
-          ok: true,
-          result: this.withMeta(await this.parseSnapshotReadOutput(response, "read snapshot"), input2, "GET", requestUrl, response)
-        };
-      } catch (error2) {
-        return {
-          ok: false,
-          result: thrownToStreamError(error2)
-        };
-      }
-    }
-    async putSnapshot(input2) {
-      assertNonEmptyString(input2.offset, "offset");
-      const part = normalizeStreamPartLike(input2.part);
-      try {
-        const requestUrl = this.subresourceEndpoint(`/snapshot/${encodeURIComponent(input2.offset)}`);
-        const response = await this.http.fetchAuthorized(requestUrl, {
-          method: "PUT",
-          headers: this.mergeHeaders(input2.headers, {
-            "Content-Type": part.contentType
-          }),
-          body: toRequestBody(part.body)
-        }, this.timeoutConfig.connectTimeoutMs, "connect");
-        if (response.status !== 200 && response.status !== 204) return {
-          ok: false,
-          result: await responseToStreamError(response, "put snapshot")
-        };
-        return {
-          ok: true,
-          result: this.withMeta({
-            stored: true,
-            snapshotOffset: input2.offset
-          }, input2, "PUT", requestUrl, response)
-        };
-      } catch (error2) {
-        return {
-          ok: false,
-          result: thrownToStreamError(error2)
-        };
-      }
-    }
-    async deleteSnapshot(offset2, input2 = {}) {
-      assertNonEmptyString(offset2, "offset");
-      try {
-        const requestUrl = this.subresourceEndpoint(`/snapshot/${encodeURIComponent(offset2)}`);
-        const response = await this.http.fetchAuthorized(requestUrl, {
-          method: "DELETE",
-          headers: this.mergeHeaders(input2.headers)
-        }, this.timeoutConfig.connectTimeoutMs, "connect");
-        if (response.status === 404) return {
-          ok: true,
-          result: this.withMeta({
-            deleted: false
-          }, input2, "DELETE", requestUrl, response)
-        };
-        if (response.status !== 200 && response.status !== 204) return {
-          ok: false,
-          result: await responseToStreamError(response, "delete snapshot")
-        };
-        return {
-          ok: true,
-          result: this.withMeta({
-            deleted: true
-          }, input2, "DELETE", requestUrl, response)
-        };
-      } catch (error2) {
-        return {
-          ok: false,
-          result: thrownToStreamError(error2)
-        };
-      }
-    }
-    async openSseSession(input2) {
-      validateOpenSseSessionInput(input2);
-      const requestUrl = this.readEndpoint({
-        offset: input2.offset,
-        cursor: input2.cursor,
-        live: "sse"
-      });
-      const controller = new AbortController();
-      const signal = mergeAbortSignals(input2.signal, controller.signal);
-      try {
-        const response = await this.http.fetchAuthorized(requestUrl, {
-          method: "GET",
-          headers: this.mergeHeaders(input2.headers, {
-            Accept: "text/event-stream"
-          }),
-          signal
-        }, this.timeoutConfig.connectTimeoutMs, "connect");
-        if (!response.ok) return {
-          ok: false,
-          result: await responseToStreamError(response, "open sse session")
-        };
-        if (response.body == null) throw new ProtocolError("sse response missing body");
-        if (!(response.headers.get("Content-Type") ?? "").toLowerCase().includes("text/event-stream")) throw new ProtocolError("sse response must use text/event-stream content type");
-        const events = createSessionEvents(response.body, signal, input2.onActivity);
-        return {
-          ok: true,
-          result: {
-            nextOffset: response.headers.get("Stream-Next-Offset") ?? void 0,
-            cursor: response.headers.get("Stream-Cursor") ?? void 0,
-            dataEncoding: response.headers.get("Stream-SSE-Data-Encoding") ?? void 0,
-            events,
-            meta: input2.includeMeta === true ? createOperationMeta("GET", requestUrl, response) : void 0,
-            cancel: async () => {
-              controller.abort(new DOMException("Aborted", "AbortError"));
-              try {
-                await response.body?.cancel();
-              } catch {
-              }
-            }
-          }
-        };
-      } catch (error2) {
-        return {
-          ok: false,
-          result: thrownToStreamError(error2)
-        };
-      }
-    }
-    live(input2) {
-      validateLiveInput(input2);
-      return this.liveInternal({
-        offset: input2.offset,
-        mode: input2.mode ?? "auto",
-        signal: input2.signal
-      });
-    }
-    async *liveInternal(input2) {
-      if (input2.mode === "long-poll") {
-        const state3 = {
-          offset: input2.offset,
-          contentType: this.knownContentType ?? "application/octet-stream"
-        };
-        yield* this.runLongPollLive(state3, input2.signal);
-        return;
-      }
-      const contentTypeResult = await this.ensureKnownContentType();
-      if (!contentTypeResult.ok) {
-        yield {
-          type: "error",
-          mode: "sse",
-          error: contentTypeResult.result
-        };
-        return;
-      }
-      const state2 = {
-        offset: input2.offset,
-        contentType: contentTypeResult.result
-      };
-      if (await (yield* this.runSseLive(state2, input2.signal, input2.mode === "auto")) === "fallback") yield* this.runLongPollLive(state2, input2.signal);
-    }
-    async *runSseLive(state2, signal, allowFallback) {
-      let attempt = 0;
-      let reconnectAttempt = 0;
-      while (true) {
-        if (signal?.aborted) return "done";
-        try {
-          const response = await this.http.fetchAuthorized(this.readEndpoint({
-            offset: state2.offset,
-            cursor: state2.cursor,
-            live: "sse"
-          }), {
-            method: "GET",
-            signal
-          }, this.timeoutConfig.connectTimeoutMs, "connect");
-          if (response.status === 400) {
-            const errorText = await response.text();
-            if (allowFallback && isSseUnsupportedErrorText(errorText)) return "fallback";
-            yield {
-              type: "error",
-              mode: "sse",
-              error: {
-                code: "bad_request",
-                status: 400,
-                message: errorText.length > 0 ? `live sse failed with status 400: ${errorText}` : "live sse failed with status 400"
-              }
-            };
-            return "done";
-          }
-          if (!response.ok) {
-            yield {
-              type: "error",
-              mode: "sse",
-              error: await responseToStreamError(response, "live sse")
-            };
-            return "done";
-          }
-          if (response.body == null) throw new ProtocolError("sse response missing body");
-          if (!(response.headers.get("Content-Type") ?? "").toLowerCase().includes("text/event-stream")) throw new ProtocolError("sse response must use text/event-stream content type");
-          if (reconnectAttempt > 0) yield {
-            type: "reconnected",
-            mode: "sse",
-            attempt: reconnectAttempt
-          };
-          attempt = 0;
-          reconnectAttempt = 0;
-          const dataEncoding = response.headers.get("stream-sse-data-encoding");
-          let pendingPayloads = [];
-          let sawControlEvent = false;
-          for await (const event of readSseEvents(response.body, {
-            signal
-          })) {
-            if (event.event === "data") {
-              pendingPayloads.push(decodeSsePayload(event.data, dataEncoding));
-              continue;
-            }
-            if (event.event !== "control") continue;
-            const control = parseSseControlData(event.data);
-            sawControlEvent = true;
-            state2.offset = control.nextOffset;
-            const effectiveCursor = control.streamCursor ?? state2.cursor;
-            state2.cursor = effectiveCursor;
-            for (const payload of pendingPayloads) yield {
-              type: "data",
-              mode: "sse",
-              nextOffset: control.nextOffset,
-              cursor: effectiveCursor,
-              payload: createStreamPart(state2.contentType, payload)
-            };
-            pendingPayloads = [];
-            if (control.streamClosed) {
-              yield {
-                type: "eof",
-                mode: "sse",
-                nextOffset: control.nextOffset
-              };
-              return "done";
-            }
-            if (control.upToDate) yield {
-              type: "up_to_date",
-              mode: "sse",
-              nextOffset: control.nextOffset,
-              cursor: effectiveCursor
-            };
-          }
-          if (signal?.aborted) return "done";
-          if (pendingPayloads.length > 0) throw new TypeError("sse connection closed before control event");
-          if (sawControlEvent) continue;
-          throw new TypeError("sse connection closed");
-        } catch (error2) {
-          if (signal?.aborted && isAbortError(error2)) return "done";
-          const mapped = thrownToStreamError(error2);
-          if (!isRetryableLiveError(mapped) || attempt >= this.retryConfig.maxAttempts) {
-            const retryExhausted = isRetryableLiveError(mapped) && attempt >= this.retryConfig.maxAttempts;
-            yield {
-              type: "error",
-              mode: "sse",
-              error: mapped,
-              attempt,
-              maxAttempts: this.retryConfig.maxAttempts,
-              retryExhausted
-            };
-            return "done";
-          }
-          const delayMs = computeRetryDelay(attempt, this.retryConfig);
-          const nextAttempt = attempt + 1;
-          this.onRetry?.({
-            operation: "live-sse",
-            error: mapped,
-            attempt: nextAttempt,
-            delayMs,
-            maxAttempts: this.retryConfig.maxAttempts
-          });
-          yield {
-            type: "reconnecting",
-            mode: "sse",
-            attempt: nextAttempt,
-            delayMs,
-            error: mapped
-          };
-          try {
-            await sleep$1(delayMs, signal);
-          } catch {
-            return "done";
-          }
-          attempt = nextAttempt;
-          reconnectAttempt = nextAttempt;
-        }
-      }
-    }
-    async *runLongPollLive(state2, signal) {
-      let attempt = 0;
-      let reconnectAttempt = 0;
-      while (true) {
-        if (signal?.aborted) return;
-        try {
-          const response = await this.http.fetchAuthorized(this.readEndpoint({
-            offset: state2.offset,
-            cursor: state2.cursor,
-            live: "long-poll"
-          }), {
-            method: "GET",
-            signal
-          }, this.timeoutConfig.pollTimeoutMs, "poll");
-          if (response.status === 204) {
-            const nextOffset = getRequiredHeader(response.headers, "Stream-Next-Offset", "live long-poll");
-            if (!hasTrueHeader(response.headers, "Stream-Up-To-Date")) throw new ProtocolError("long-poll 204 response missing Stream-Up-To-Date: true");
-            const closed = hasTrueHeader(response.headers, "Stream-Closed");
-            const effectiveCursor = response.headers.get("Stream-Cursor") ?? void 0 ?? state2.cursor;
-            if (reconnectAttempt > 0) yield {
-              type: "reconnected",
-              mode: "long-poll",
-              attempt: reconnectAttempt
-            };
-            attempt = 0;
-            reconnectAttempt = 0;
-            state2.offset = nextOffset;
-            state2.cursor = effectiveCursor;
-            if (closed) {
-              yield {
-                type: "eof",
-                mode: "long-poll",
-                nextOffset
-              };
-              return;
-            }
-            yield {
-              type: "up_to_date",
-              mode: "long-poll",
-              nextOffset,
-              cursor: effectiveCursor
-            };
-            continue;
-          }
-          if (!response.ok) {
-            yield {
-              type: "error",
-              mode: "long-poll",
-              error: await responseToStreamError(response, "live long-poll")
-            };
-            return;
-          }
-          if (reconnectAttempt > 0) yield {
-            type: "reconnected",
-            mode: "long-poll",
-            attempt: reconnectAttempt
-          };
-          attempt = 0;
-          reconnectAttempt = 0;
-          const output = await this.parseReadOutput(response, state2.offset, "live long-poll");
-          const outputCursor = output.cursor ?? state2.cursor;
-          state2.offset = output.nextOffset;
-          state2.cursor = outputCursor;
-          yield {
-            type: "data",
-            mode: "long-poll",
-            nextOffset: output.nextOffset,
-            cursor: outputCursor,
-            payload: output.payload
-          };
-          if (output.closed) {
-            yield {
-              type: "eof",
-              mode: "long-poll",
-              nextOffset: output.nextOffset
-            };
-            return;
-          }
-          if (output.upToDate) yield {
-            type: "up_to_date",
-            mode: "long-poll",
-            nextOffset: output.nextOffset,
-            cursor: outputCursor
-          };
-        } catch (error2) {
-          if (signal?.aborted && isAbortError(error2)) return;
-          const mapped = thrownToStreamError(error2);
-          if (!isRetryableLiveError(mapped) || attempt >= this.retryConfig.maxAttempts) {
-            const retryExhausted = isRetryableLiveError(mapped) && attempt >= this.retryConfig.maxAttempts;
-            yield {
-              type: "error",
-              mode: "long-poll",
-              error: mapped,
-              attempt,
-              maxAttempts: this.retryConfig.maxAttempts,
-              retryExhausted
-            };
-            return;
-          }
-          const delayMs = computeRetryDelay(attempt, this.retryConfig);
-          const nextAttempt = attempt + 1;
-          this.onRetry?.({
-            operation: "live-long-poll",
-            error: mapped,
-            attempt: nextAttempt,
-            delayMs,
-            maxAttempts: this.retryConfig.maxAttempts
-          });
-          yield {
-            type: "reconnecting",
-            mode: "long-poll",
-            attempt: nextAttempt,
-            delayMs,
-            error: mapped
-          };
-          try {
-            await sleep$1(delayMs, signal);
-          } catch {
-            return;
-          }
-          attempt = nextAttempt;
-          reconnectAttempt = nextAttempt;
-        }
-      }
-    }
-    appendHeaders(input2, contentType) {
-      const headers = this.mergeHeaders(input2.headers);
-      if (contentType != null) headers.set("Content-Type", contentType);
-      if (input2.close === true) headers.set("Stream-Closed", "true");
-      if (input2.streamSeq != null) headers.set("Stream-Seq", input2.streamSeq);
-      if (input2.producer != null) {
-        headers.set("Producer-Id", input2.producer.producerId);
-        headers.set("Producer-Epoch", String(input2.producer.epoch));
-        headers.set("Producer-Seq", String(input2.producer.seq));
-      }
-      return headers;
-    }
-    mergeHeaders(...layers) {
-      const headers = new Headers(this.defaultHeaders);
-      for (const layer2 of layers) {
-        if (layer2 == null) continue;
-        new Headers(layer2).forEach((value, name2) => {
-          headers.set(name2, value);
-        });
-      }
-      return headers;
-    }
-    withMeta(result, input2, method, url, response) {
-      if (input2?.includeMeta !== true) return result;
-      return {
-        ...result,
-        meta: createOperationMeta(method, url, response)
-      };
-    }
-    parseAppendOutput(response, input2) {
-      return {
-        status: response.status,
-        nextOffset: getRequiredHeader(response.headers, "Stream-Next-Offset", "append"),
-        closed: hasTrueHeader(response.headers, "Stream-Closed"),
-        producer: input2.producer == null ? void 0 : {
-          epoch: parseOptionalInteger(response.headers.get("Producer-Epoch")) ?? input2.producer.epoch,
-          seq: parseOptionalInteger(response.headers.get("Producer-Seq")) ?? input2.producer.seq
-        }
-      };
-    }
-    async parseReadOutput(response, requestOffset, context2) {
-      const contentType = this.resolveContentType(response, context2, this.knownContentType);
-      this.knownContentType = contentType;
-      return {
-        requestOffset,
-        nextOffset: getRequiredHeader(response.headers, "Stream-Next-Offset", context2),
-        upToDate: hasTrueHeader(response.headers, "Stream-Up-To-Date"),
-        closed: hasTrueHeader(response.headers, "Stream-Closed"),
-        cursor: response.headers.get("Stream-Cursor") ?? void 0,
-        payload: createStreamPart(contentType, new Uint8Array(await response.arrayBuffer()))
-      };
-    }
-    async parseSnapshotReadOutput(response, context2) {
-      const contentType = this.resolveContentType(response, context2);
-      return {
-        snapshotOffset: getRequiredHeader(response.headers, "Stream-Snapshot-Offset", context2),
-        nextOffset: getRequiredHeader(response.headers, "Stream-Next-Offset", context2),
-        upToDate: hasTrueHeader(response.headers, "Stream-Up-To-Date"),
-        payload: createStreamPart(contentType, new Uint8Array(await response.arrayBuffer()))
-      };
-    }
-    async ensureKnownContentType() {
-      if (this.knownContentType != null) return {
-        ok: true,
-        result: this.knownContentType
-      };
-      const headResult = await this.head();
-      if (!headResult.ok) return headResult;
-      this.knownContentType = headResult.result.contentType;
-      return {
-        ok: true,
-        result: headResult.result.contentType
-      };
-    }
-    resolveContentType(response, context2, fallback2) {
-      const headerValue = response.headers.get("Content-Type");
-      if (headerValue != null && headerValue.length > 0) return headerValue;
-      if (fallback2 != null && fallback2.length > 0) return fallback2;
-      throw new ProtocolError(`${context2} response missing Content-Type`);
-    }
-    streamEndpoint() {
-      const target = new URL(this.streamUrl);
-      target.search = "";
-      return target.toString();
-    }
-    subresourceEndpoint(suffix) {
-      const target = new URL(this.streamUrl);
-      target.search = "";
-      target.pathname = `${target.pathname.endsWith("/") ? target.pathname.slice(0, -1) : target.pathname}${suffix}`;
-      return target.toString();
-    }
-    readEndpoint(input2) {
-      const target = new URL(this.streamEndpoint());
-      target.searchParams.set("offset", input2.offset);
-      if (input2.cursor != null && input2.cursor.length > 0) target.searchParams.set("cursor", input2.cursor);
-      if (input2.live != null) target.searchParams.set("live", input2.live);
-      return target.toString();
-    }
-  };
-  function validateCreateInput(input2) {
-    if (input2.ttlSeconds != null) assertNonNegativeSafeInteger(input2.ttlSeconds, "ttlSeconds");
-    if (input2.expiresAt != null) assertNonEmptyString(input2.expiresAt, "expiresAt");
-    if (input2.ttlSeconds != null && input2.expiresAt != null) throw new Error("create input must not include both ttlSeconds and expiresAt");
-    if (input2.contentType != null) normalizeContentType(input2.contentType);
-  }
-  function validateAppendInput(input2) {
-    if (input2.streamSeq != null) assertNonEmptyString(input2.streamSeq, "streamSeq");
-    if (input2.producer != null) {
-      assertNonEmptyString(input2.producer.producerId, "producer.producerId");
-      assertNonNegativeSafeInteger(input2.producer.epoch, "producer.epoch");
-      assertNonNegativeSafeInteger(input2.producer.seq, "producer.seq");
-    }
-    if (input2.part == null) {
-      if (input2.close !== true) throw new Error("append requires part unless close is true");
-      return;
-    }
-    if (normalizeStreamPartLike(input2.part).body.byteLength === 0 && input2.close !== true) throw new Error("append requires a non-empty body unless close is true");
-  }
-  function validateReadInput(input2) {
-    if (input2.offset != null) assertNonEmptyString(input2.offset, "offset");
-    if (input2.cursor != null) assertNonEmptyString(input2.cursor, "cursor");
-  }
-  function validateReadOnceInput(input2) {
-    validateReadInput(input2);
-    if (input2.live != null && input2.live !== "long-poll") throw new Error("readOnce live mode must be long-poll when provided");
-  }
-  function validateOpenSseSessionInput(input2) {
-    assertNonEmptyString(input2.offset, "offset");
-    if (input2.cursor != null) assertNonEmptyString(input2.cursor, "cursor");
-  }
-  function validateLiveInput(input2) {
-    assertNonEmptyString(input2.offset, "offset");
-  }
-  function assertNonEmptyString(value, name2) {
-    if (value.trim().length === 0) throw new Error(`${name2} must be a non-empty string`);
-  }
-  function assertNonNegativeSafeInteger(value, name2) {
-    if (!Number.isSafeInteger(value) || value < 0) throw new Error(`${name2} must be a non-negative safe integer`);
-  }
-  function isAppendRetryable(error2) {
-    return error2.code === "network_error" || error2.code === "timeout";
-  }
-  function createOperationMeta(method, url, response) {
-    return {
-      request: {
-        method,
-        url
-      },
-      response: {
-        status: response.status,
-        statusText: response.statusText,
-        headers: headersToObject(response.headers)
-      }
-    };
-  }
-  function headersToObject(headers) {
-    const result = {};
-    headers.forEach((value, name2) => {
-      result[name2] = value;
-    });
-    return result;
-  }
-  function createSessionEvents(stream2, signal, onActivity) {
-    return {
-      async *[Symbol.asyncIterator]() {
-        try {
-          yield* readSseEvents(stream2, {
-            signal,
-            onActivity
-          });
-        } catch (error2) {
-          if (signal?.aborted && isAbortError(error2)) return;
-          throw error2;
-        }
-      }
-    };
-  }
-  function mergeAbortSignals(...signals2) {
-    const active2 = signals2.filter((signal) => signal != null);
-    if (active2.length === 0) return;
-    if (active2.length === 1) return active2[0];
-    if (typeof AbortSignal.any === "function") return AbortSignal.any(active2);
-    const controller = new AbortController();
-    for (const signal of active2) {
-      if (signal.aborted) {
-        controller.abort(signal.reason);
-        break;
-      }
-      signal.addEventListener("abort", () => {
-        controller.abort(signal.reason);
-      }, {
-        once: true
-      });
-    }
-    return controller.signal;
-  }
   const DEFAULT_GATEWAY_BASE_URL = "https://streams-api-proxy.loro.dev";
   const JSON_RPC_VERSION$1 = "2.0";
   const LORO_STREAMS_RPC_VERSION = "1";