@org-quicko/silo-client 1.1.0 → 1.1.1

package/dist/index.js

@@ -208,12 +208,14 @@ var DefaultUsageLimit = 50;
 class MediaUsagePage extends Page {
   transport;
   assetId;
+  requestOptions;
   visible;
   visibleCapped;
-  constructor(rows, total, visible, visibleCapped, window, transport, assetId) {
+  constructor(rows, total, visible, visibleCapped, window, transport, assetId, requestOptions) {
     super(rows, total, window);
     this.transport = transport;
     this.assetId = assetId;
+    this.requestOptions = requestOptions;
     this.visible = visible;
     this.visibleCapped = visibleCapped;
   }
@@ -228,11 +230,11 @@ class MediaUsagePage extends Page {
   }
   async next(options) {
     const window = this.windowForNext();
-    return window ? MediaUsagePage.loadWindow(this.transport, this.assetId, window, options) : null;
+    return window ? MediaUsagePage.loadWindow(this.transport, this.assetId, window, { ...this.requestOptions, ...options }) : null;
   }
   async previous(options) {
     const window = this.window.previous();
-    return window ? MediaUsagePage.loadWindow(this.transport, this.assetId, window, options) : null;
+    return window ? MediaUsagePage.loadWindow(this.transport, this.assetId, window, { ...this.requestOptions, ...options }) : null;
   }
   static load(transport, assetId, query, options) {
     const window = new PageWindow(query.limit ?? DefaultUsageLimit, query.offset ?? 0);
@@ -244,10 +246,11 @@ class MediaUsagePage extends Page {
       path: ApiPath.mediaAssetUsages(assetId),
       query: { limit: window.limit, offset: window.offset },
       signal: options?.signal,
-      timeoutMilliseconds: options?.timeoutMilliseconds
+      timeoutMilliseconds: options?.timeoutMilliseconds,
+      cache: options?.cache
     });
     const mapped = MediaAssetMapper.toUsagePage(body);
-    return new MediaUsagePage(mapped.items, mapped.total, mapped.visible, mapped.visibleCapped, window, transport, assetId);
+    return new MediaUsagePage(mapped.items, mapped.total, mapped.visible, mapped.visibleCapped, window, transport, assetId, options);
   }
 }
 
@@ -343,7 +346,8 @@ class MediaAsset {
       method: "GET",
       path: ApiPath.mediaAsset(this.id),
       signal: options?.signal,
-      timeoutMilliseconds: options?.timeoutMilliseconds
+      timeoutMilliseconds: options?.timeoutMilliseconds,
+      cache: options?.cache ?? "refresh"
     });
     this.record = MediaAssetMapper.toRecord(payload);
     return this;
@@ -405,7 +409,8 @@ class MediaFolders {
       method: "GET",
       path: ApiPath.mediaFolders(),
       signal: options?.signal,
-      timeoutMilliseconds: options?.timeoutMilliseconds
+      timeoutMilliseconds: options?.timeoutMilliseconds,
+      cache: options?.cache
     });
     return body.items;
   }
@@ -447,21 +452,23 @@ class MediaFolders {
 class MediaPage extends Page {
   transport;
   wireQuery;
-  constructor(rows, total, window, transport, wireQuery) {
+  requestOptions;
+  constructor(rows, total, window, transport, wireQuery, requestOptions) {
     super(rows, total, window);
     this.transport = transport;
     this.wireQuery = wireQuery;
+    this.requestOptions = requestOptions;
   }
   get files() {
     return this.rows;
   }
   async next(options) {
     const window = this.windowForNext();
-    return window ? MediaPage.loadWindow(this.transport, this.wireQuery, window, options) : null;
+    return window ? MediaPage.loadWindow(this.transport, this.wireQuery, window, { ...this.requestOptions, ...options }) : null;
   }
   async previous(options) {
     const window = this.window.previous();
-    return window ? MediaPage.loadWindow(this.transport, this.wireQuery, window, options) : null;
+    return window ? MediaPage.loadWindow(this.transport, this.wireQuery, window, { ...this.requestOptions, ...options }) : null;
   }
   static async loadWindow(transport, wireQuery, window, options) {
     const body = await transport.json({
@@ -469,10 +476,11 @@ class MediaPage extends Page {
       path: ApiPath.media(),
       query: { ...wireQuery, limit: window.limit, offset: window.offset },
       signal: options?.signal,
-      timeoutMilliseconds: options?.timeoutMilliseconds
+      timeoutMilliseconds: options?.timeoutMilliseconds,
+      cache: options?.cache
     });
     const rows = body.items.map((payload) => new MediaAsset(transport, MediaAssetMapper.toRecord(payload)));
-    return new MediaPage(rows, body.total, new PageWindow(body.limit, body.offset), transport, wireQuery);
+    return new MediaPage(rows, body.total, new PageWindow(body.limit, body.offset), transport, wireQuery, options);
   }
 }
 
@@ -592,7 +600,8 @@ class Media {
       method: "GET",
       path: ApiPath.mediaAsset(id),
       signal: options?.signal,
-      timeoutMilliseconds: options?.timeoutMilliseconds
+      timeoutMilliseconds: options?.timeoutMilliseconds,
+      cache: options?.cache
     });
     return new MediaAsset(this.transport, MediaAssetMapper.toRecord(payload));
   }
@@ -601,7 +610,8 @@ class Media {
       method: "GET",
       path: ApiPath.mediaExtensions(),
       signal: options?.signal,
-      timeoutMilliseconds: options?.timeoutMilliseconds
+      timeoutMilliseconds: options?.timeoutMilliseconds,
+      cache: options?.cache
     });
     return body.items;
   }
@@ -1314,6 +1324,132 @@ class Projects {
   }
 }
 
+// src/transport/caching-transport.ts
+class CachingTransport {
+  #fetchTransport;
+  #cache;
+  constructor(fetchTransport, cache) {
+    this.#fetchTransport = fetchTransport;
+    this.#cache = cache;
+  }
+  async json(request) {
+    if (request.method !== "GET")
+      return this.write(() => this.#fetchTransport.json(request));
+    if (request.cache === "bypass")
+      return this.#fetchTransport.json(request);
+    if (request.signal?.aborted)
+      throw new RequestAbortedError(request.method, request.path);
+    let prepared;
+    try {
+      prepared = this.#fetchTransport.prepare(request);
+    } catch (caught) {
+      throw this.#fetchTransport.preparationFailure(request, caught);
+    }
+    const key = JSON.stringify([prepared.url, [...prepared.headers]]);
+    if (request.cache !== "refresh") {
+      const cached = this.#cache.get(key);
+      if (cached)
+        return cached.body;
+    }
+    const ticket = this.#cache.start(key);
+    try {
+      const body = await this.#fetchTransport.jsonPrepared(request, prepared);
+      this.#cache.set(key, ticket, body);
+      return body;
+    } finally {
+      this.#cache.finish(key, ticket);
+    }
+  }
+  empty(request) {
+    return request.method === "GET" ? this.#fetchTransport.empty(request) : this.write(() => this.#fetchTransport.empty(request));
+  }
+  stream(request) {
+    return request.method === "GET" ? this.#fetchTransport.stream(request) : this.write(() => this.#fetchTransport.stream(request));
+  }
+  upload(request, form) {
+    return request.method === "GET" ? this.#fetchTransport.upload(request, form) : this.write(() => this.#fetchTransport.upload(request, form));
+  }
+  async write(dispatch) {
+    this.#cache.clear();
+    try {
+      return await dispatch();
+    } finally {
+      this.#cache.clear();
+    }
+  }
+}
+
+// src/cache/response-cache.ts
+import { TTLCache } from "@isaacs/ttlcache";
+
+class ResponseCache {
+  #store;
+  #pending = new Map;
+  constructor(options) {
+    this.#store = new TTLCache({
+      ttl: options.ttlMilliseconds,
+      ...options.maxEntries === undefined || options.maxEntries === Infinity ? {} : { max: options.maxEntries },
+      checkAgeOnGet: true,
+      updateAgeOnGet: false
+    });
+  }
+  get size() {
+    return this.#store.size;
+  }
+  get(key) {
+    const cached = this.#store.get(key);
+    return cached === undefined ? undefined : { body: structuredClone(cached.body) };
+  }
+  set(key, ticket, body) {
+    if (this.#pending.get(key) !== ticket)
+      return;
+    this.#store.set(key, { body: structuredClone(body) });
+  }
+  start(key) {
+    const ticket = Symbol();
+    this.#pending.set(key, ticket);
+    return ticket;
+  }
+  finish(key, ticket) {
+    if (this.#pending.get(key) === ticket)
+      this.#pending.delete(key);
+  }
+  clear() {
+    this.#pending.clear();
+    this.#store.clear();
+  }
+}
+
+// src/cache/silo-cache.ts
+class SiloCache {
+  #responseCache;
+  constructor(options) {
+    if (options !== undefined)
+      SiloCache.validate(options);
+    this.#responseCache = options === undefined ? undefined : new ResponseCache(options);
+  }
+  get enabled() {
+    return this.#responseCache !== undefined;
+  }
+  get size() {
+    return this.#responseCache?.size ?? 0;
+  }
+  clear() {
+    this.#responseCache?.clear();
+  }
+  wrap(fetchTransport) {
+    return this.#responseCache ? new CachingTransport(fetchTransport, this.#responseCache) : fetchTransport;
+  }
+  static validate(options) {
+    if (!Number.isSafeInteger(options.ttlMilliseconds) || options.ttlMilliseconds <= 0) {
+      throw new TypeError("SiloOptions.cache.ttlMilliseconds must be a positive finite safe integer");
+    }
+    if (options.maxEntries !== undefined && options.maxEntries !== Infinity && (!Number.isSafeInteger(options.maxEntries) || options.maxEntries <= 0)) {
+      throw new TypeError("SiloOptions.cache.maxEntries must be a positive safe integer or Infinity");
+    }
+  }
+}
+
 // src/errors/silo-error.ts
 class SiloError extends Error {
   status;
@@ -1608,61 +1744,80 @@ class ResponseDecoder {
   }
 }
 
-// src/transport/transport.ts
-class Transport {
-  url;
-  key;
-  headers;
-  timeoutMilliseconds;
-  fetchFunction;
+// src/transport/fetch-transport.ts
+class FetchTransport {
+  #url;
+  #key;
+  #headers;
+  #timeoutMilliseconds;
+  #fetchFunction;
   constructor(options) {
-    this.url = Transport.normalizeUrl(options.url);
-    this.key = options.key;
-    this.headers = options.headers ?? {};
-    this.timeoutMilliseconds = options.timeoutMilliseconds;
-    this.fetchFunction = Transport.resolveFetch(options.fetch);
+    this.#url = FetchTransport.normalizeUrl(options.url);
+    this.#key = options.key;
+    this.#headers = options.headers ?? {};
+    this.#timeoutMilliseconds = options.timeoutMilliseconds;
+    this.#fetchFunction = FetchTransport.resolveFetch(options.fetch);
   }
   async json(request) {
     const response = await this.execute(request);
     return await ResponseDecoder.decode(response, request, true);
   }
+  async jsonPrepared(request, prepared) {
+    const response = await this.execute(request, prepared);
+    return await ResponseDecoder.decode(response, request, true);
+  }
   async empty(request) {
     const response = await this.execute(request);
     await ResponseDecoder.decode(response, request, false);
   }
   async stream(request) {
-    const response = await this.execute(request);
-    return response.body;
+    return (await this.execute(request)).body;
   }
   async upload(request, form) {
-    const response = await this.execute(request, form);
+    const response = await this.execute(request, undefined, form);
     return await ResponseDecoder.decode(response, request, true);
   }
   withKey(key) {
-    return new Transport({ ...this.snapshot(), key });
+    return new FetchTransport({ ...this.snapshot(), key });
   }
   withUrl(url) {
-    return new Transport({ ...this.snapshot(), url });
+    return new FetchTransport({ ...this.snapshot(), url });
+  }
+  prepare(request, form) {
+    const rawHeaders = { ...this.#headers, ...request.headers };
+    if (this.#key)
+      rawHeaders.Authorization = `Bearer ${this.#key}`;
+    if (!form && request.body !== undefined && !("Content-Type" in rawHeaders)) {
+      rawHeaders["Content-Type"] = "application/json";
+    }
+    return {
+      url: `${this.#url}${request.path}${QueryString.build(request.query)}`,
+      headers: new Headers(rawHeaders),
+      body: form ?? (request.body === undefined ? undefined : JSON.stringify(request.body))
+    };
+  }
+  preparationFailure(request, caught) {
+    return new NetworkError(request.method, request.path, caught);
   }
   snapshot() {
     return {
-      url: this.url,
-      key: this.key,
-      headers: this.headers,
-      timeoutMilliseconds: this.timeoutMilliseconds,
-      fetch: this.fetchFunction
+      url: this.#url,
+      key: this.#key,
+      headers: this.#headers,
+      timeoutMilliseconds: this.#timeoutMilliseconds,
+      fetch: this.#fetchFunction
     };
   }
-  async execute(request, form) {
-    const abortSignals = new AbortSignals(request.signal, request.timeoutMilliseconds ?? this.timeoutMilliseconds);
-    const url = `${this.url}${request.path}${QueryString.build(request.query)}`;
-    const sendRequest = this.fetchFunction;
+  async execute(request, prepared, form) {
+    const abortSignals = new AbortSignals(request.signal, request.timeoutMilliseconds ?? this.#timeoutMilliseconds);
+    const sendRequest = this.#fetchFunction;
     let response;
     try {
-      response = await sendRequest(url, {
+      const outbound = prepared ?? this.prepare(request, form);
+      response = await sendRequest(outbound.url, {
         method: request.method,
-        headers: this.buildHeaders(request, Boolean(form)),
-        body: form ?? (request.body === undefined ? undefined : JSON.stringify(request.body)),
+        headers: outbound.headers,
+        body: outbound.body,
         signal: abortSignals.signal
       });
     } catch (caught) {
@@ -1676,24 +1831,13 @@ class Transport {
     return response;
   }
   transportFailure(request, abortSignals, caught) {
-    const firedBy = abortSignals.firedBy();
-    if (firedBy === "timeout") {
-      return new TimeoutError(request.method, request.path, request.timeoutMilliseconds ?? this.timeoutMilliseconds ?? 0);
+    if (abortSignals.firedBy() === "timeout") {
+      return new TimeoutError(request.method, request.path, request.timeoutMilliseconds ?? this.#timeoutMilliseconds ?? 0);
     }
-    if (firedBy === "caller") {
+    if (abortSignals.firedBy() === "caller")
       return new RequestAbortedError(request.method, request.path);
-    }
     return new NetworkError(request.method, request.path, caught);
   }
-  buildHeaders(request, isUpload) {
-    const headers = { ...this.headers, ...request.headers };
-    if (this.key)
-      headers["Authorization"] = `Bearer ${this.key}`;
-    if (!isUpload && request.body !== undefined && !("Content-Type" in headers)) {
-      headers["Content-Type"] = "application/json";
-    }
-    return headers;
-  }
   static normalizeUrl(url) {
     return url.replace(/\/+$/, "");
   }
@@ -1711,17 +1855,20 @@ class Transport {
 class Silo {
   projects;
   media;
+  cache;
   options;
   transport;
   constructor(options) {
-    this.options = options;
-    this.transport = new Transport({
+    this.cache = options.cache instanceof SiloCache ? options.cache : new SiloCache(options.cache);
+    this.options = { ...options, cache: this.cache };
+    const fetchTransport = new FetchTransport({
       url: options.url,
       key: options.key,
       headers: options.headers,
       timeoutMilliseconds: options.timeoutMilliseconds,
       fetch: options.fetch
     });
+    this.transport = this.cache.wrap(fetchTransport);
     this.projects = new Projects(this.transport);
     this.media = new Media(this.transport);
   }
@@ -1739,7 +1886,8 @@ class Silo {
       method: "GET",
       path: ApiPath.health(),
       signal: options?.signal,
-      timeoutMilliseconds: options?.timeoutMilliseconds
+      timeoutMilliseconds: options?.timeoutMilliseconds,
+      cache: "bypass"
     });
   }
   withKey(key) {
@@ -1922,6 +2070,7 @@ export {
   SortTerm,
   Sort,
   SiloError,
+  SiloCache,
   Silo,
   SearchReach,
   SearchPage,

package/dist/media/media-page.d.cts

@@ -9,6 +9,7 @@ import { MediaAsset } from "./media-asset.cjs";
 export declare class MediaPage extends Page<MediaAsset> {
     private readonly transport;
     private readonly wireQuery;
+    private readonly requestOptions;
     private constructor();
     get files(): readonly MediaAsset[];
     next(options?: RequestOptions): Promise<MediaPage | null>;

package/dist/media/media-page.d.ts

@@ -9,6 +9,7 @@ import { MediaAsset } from "./media-asset.js";
 export declare class MediaPage extends Page<MediaAsset> {
     private readonly transport;
     private readonly wireQuery;
+    private readonly requestOptions;
     private constructor();
     get files(): readonly MediaAsset[];
     next(options?: RequestOptions): Promise<MediaPage | null>;

package/dist/media/media-usage-page.d.cts

@@ -20,6 +20,7 @@ export interface MediaUsageQuery {
 export declare class MediaUsagePage extends Page<MediaUsage> {
     private readonly transport;
     private readonly assetId;
+    private readonly requestOptions;
     readonly visible: number;
     readonly visibleCapped: boolean;
     private constructor();

package/dist/media/media-usage-page.d.ts

@@ -20,6 +20,7 @@ export interface MediaUsageQuery {
 export declare class MediaUsagePage extends Page<MediaUsage> {
     private readonly transport;
     private readonly assetId;
+    private readonly requestOptions;
     readonly visible: number;
     readonly visibleCapped: boolean;
     private constructor();

package/dist/request-options.d.cts

@@ -1,3 +1,4 @@
+import type { CacheMode } from "./cache/cache-mode.cjs";
 /**
  * The one cancellation convention on every call: the last parameter of
  * every method in the client. A per-call value wins over the client's own
@@ -6,4 +7,6 @@
 export interface RequestOptions {
     signal?: AbortSignal;
     timeoutMilliseconds?: number;
+    /** `bypass` skips lookup and storage; `refresh` fetches and stores. Ignored on writes and disabled caches. */
+    cache?: CacheMode;
 }

package/dist/request-options.d.ts

@@ -1,3 +1,4 @@
+import type { CacheMode } from "./cache/cache-mode.js";
 /**
  * The one cancellation convention on every call: the last parameter of
  * every method in the client. A per-call value wins over the client's own
@@ -6,4 +7,6 @@
 export interface RequestOptions {
     signal?: AbortSignal;
     timeoutMilliseconds?: number;
+    /** `bypass` skips lookup and storage; `refresh` fetches and stores. Ignored on writes and disabled caches. */
+    cache?: CacheMode;
 }

package/dist/silo-options.d.cts

@@ -1,4 +1,6 @@
 import type { FetchFunction } from "./transport/fetch-function.cjs";
+import type { SiloCache } from "./cache/silo-cache.cjs";
+import type { SiloCacheOptions } from "./cache/silo-cache-options.cjs";
 /**
  * Everything `new Silo(...)` accepts. Only `url` is required: a key is
  * optional because anonymous reads are legal.
@@ -9,4 +11,6 @@ export interface SiloOptions {
     timeoutMilliseconds?: number;
     headers?: Record<string, string>;
     fetch?: FetchFunction;
+    /** Enable read caching or share an existing cache. Omit to disable. */
+    cache?: SiloCacheOptions | SiloCache;
 }

package/dist/silo-options.d.ts

@@ -1,4 +1,6 @@
 import type { FetchFunction } from "./transport/fetch-function.js";
+import type { SiloCache } from "./cache/silo-cache.js";
+import type { SiloCacheOptions } from "./cache/silo-cache-options.js";
 /**
  * Everything `new Silo(...)` accepts. Only `url` is required: a key is
  * optional because anonymous reads are legal.
@@ -9,4 +11,6 @@ export interface SiloOptions {
     timeoutMilliseconds?: number;
     headers?: Record<string, string>;
     fetch?: FetchFunction;
+    /** Enable read caching or share an existing cache. Omit to disable. */
+    cache?: SiloCacheOptions | SiloCache;
 }

package/dist/silo.d.cts

@@ -7,6 +7,7 @@ import type { EnvironmentHandle } from "./scope/environment-handle.cjs";
 import type { SearchPage } from "./search/search-page.cjs";
 import type { SearchQuery } from "./search/search-query.cjs";
 import type { SiloOptions } from "./silo-options.cjs";
+import { SiloCache } from "./cache/silo-cache.cjs";
 /**
  * One silo instance. Navigate it the way the API is shaped:
  * `silo.project("acme").environment("prod").collection<Post>("posts")`.
@@ -20,6 +21,8 @@ export declare class Silo {
     readonly projects: Projects;
     /** The media catalog. Media is instance-global, so it takes no scope. */
     readonly media: Media;
+    /** This instance's optional read cache. */
+    readonly cache: SiloCache;
     private readonly options;
     private readonly transport;
     constructor(options: SiloOptions);

package/dist/silo.d.ts

@@ -7,6 +7,7 @@ import type { EnvironmentHandle } from "./scope/environment-handle.js";
 import type { SearchPage } from "./search/search-page.js";
 import type { SearchQuery } from "./search/search-query.js";
 import type { SiloOptions } from "./silo-options.js";
+import { SiloCache } from "./cache/silo-cache.js";
 /**
  * One silo instance. Navigate it the way the API is shaped:
  * `silo.project("acme").environment("prod").collection<Post>("posts")`.
@@ -20,6 +21,8 @@ export declare class Silo {
     readonly projects: Projects;
     /** The media catalog. Media is instance-global, so it takes no scope. */
     readonly media: Media;
+    /** This instance's optional read cache. */
+    readonly cache: SiloCache;
     private readonly options;
     private readonly transport;
     constructor(options: SiloOptions);

package/dist/transport/caching-transport.d.cts

@@ -0,0 +1,14 @@
+import { ResponseCache } from "../cache/response-cache.cjs";
+import type { FetchTransport } from "./fetch-transport.cjs";
+import type { TransportRequest } from "./transport-request.cjs";
+import type { Transport } from "./transport.cjs";
+/** Adds opt-in GET JSON caching to the fetch transport. */
+export declare class CachingTransport implements Transport {
+    #private;
+    constructor(fetchTransport: FetchTransport, cache: ResponseCache);
+    json<T>(request: TransportRequest): Promise<T>;
+    empty(request: TransportRequest): Promise<void>;
+    stream(request: TransportRequest): Promise<ReadableStream<Uint8Array> | null>;
+    upload<T>(request: TransportRequest, form: FormData): Promise<T>;
+    private write;
+}

package/dist/transport/caching-transport.d.ts

@@ -0,0 +1,14 @@
+import { ResponseCache } from "../cache/response-cache.js";
+import type { FetchTransport } from "./fetch-transport.js";
+import type { TransportRequest } from "./transport-request.js";
+import type { Transport } from "./transport.js";
+/** Adds opt-in GET JSON caching to the fetch transport. */
+export declare class CachingTransport implements Transport {
+    #private;
+    constructor(fetchTransport: FetchTransport, cache: ResponseCache);
+    json<T>(request: TransportRequest): Promise<T>;
+    empty(request: TransportRequest): Promise<void>;
+    stream(request: TransportRequest): Promise<ReadableStream<Uint8Array> | null>;
+    upload<T>(request: TransportRequest, form: FormData): Promise<T>;
+    private write;
+}

package/dist/transport/fetch-transport.d.cts

@@ -0,0 +1,31 @@
+import { NetworkError } from "../errors/network-error.cjs";
+import type { FetchFunction } from "./fetch-function.cjs";
+import type { PreparedTransportRequest } from "./prepared-transport-request.cjs";
+import type { TransportRequest } from "./transport-request.cjs";
+import type { Transport } from "./transport.cjs";
+export interface FetchTransportOptions {
+    url: string;
+    key?: string;
+    headers?: Record<string, string>;
+    timeoutMilliseconds?: number;
+    fetch?: FetchFunction;
+}
+/** The fetch-backed implementation behind the internal transport seam. */
+export declare class FetchTransport implements Transport {
+    #private;
+    constructor(options: FetchTransportOptions);
+    json<T>(request: TransportRequest): Promise<T>;
+    jsonPrepared<T>(request: TransportRequest, prepared: PreparedTransportRequest): Promise<T>;
+    empty(request: TransportRequest): Promise<void>;
+    stream(request: TransportRequest): Promise<ReadableStream<Uint8Array> | null>;
+    upload<T>(request: TransportRequest, form: FormData): Promise<T>;
+    withKey(key: string | undefined): FetchTransport;
+    withUrl(url: string): FetchTransport;
+    prepare(request: TransportRequest, form?: FormData): PreparedTransportRequest;
+    preparationFailure(request: TransportRequest, caught: unknown): NetworkError;
+    private snapshot;
+    private execute;
+    private transportFailure;
+    private static normalizeUrl;
+    private static resolveFetch;
+}

package/dist/transport/fetch-transport.d.ts

@@ -0,0 +1,31 @@
+import { NetworkError } from "../errors/network-error.js";
+import type { FetchFunction } from "./fetch-function.js";
+import type { PreparedTransportRequest } from "./prepared-transport-request.js";
+import type { TransportRequest } from "./transport-request.js";
+import type { Transport } from "./transport.js";
+export interface FetchTransportOptions {
+    url: string;
+    key?: string;
+    headers?: Record<string, string>;
+    timeoutMilliseconds?: number;
+    fetch?: FetchFunction;
+}
+/** The fetch-backed implementation behind the internal transport seam. */
+export declare class FetchTransport implements Transport {
+    #private;
+    constructor(options: FetchTransportOptions);
+    json<T>(request: TransportRequest): Promise<T>;
+    jsonPrepared<T>(request: TransportRequest, prepared: PreparedTransportRequest): Promise<T>;
+    empty(request: TransportRequest): Promise<void>;
+    stream(request: TransportRequest): Promise<ReadableStream<Uint8Array> | null>;
+    upload<T>(request: TransportRequest, form: FormData): Promise<T>;
+    withKey(key: string | undefined): FetchTransport;
+    withUrl(url: string): FetchTransport;
+    prepare(request: TransportRequest, form?: FormData): PreparedTransportRequest;
+    preparationFailure(request: TransportRequest, caught: unknown): NetworkError;
+    private snapshot;
+    private execute;
+    private transportFailure;
+    private static normalizeUrl;
+    private static resolveFetch;
+}

package/dist/transport/prepared-transport-request.d.cts

@@ -0,0 +1,6 @@
+/** One request after its final URL, headers and body have been prepared. */
+export interface PreparedTransportRequest {
+    url: string;
+    headers: Headers;
+    body: BodyInit | undefined;
+}

package/dist/transport/prepared-transport-request.d.ts

@@ -0,0 +1,6 @@
+/** One request after its final URL, headers and body have been prepared. */
+export interface PreparedTransportRequest {
+    url: string;
+    headers: Headers;
+    body: BodyInit | undefined;
+}