@ayepi/core 0.1.0

package/dist/ws-transport.cjs

@@ -0,0 +1,1472 @@
+//#region src/path.ts
+/**
+* Split a spec-author `:key` pattern string into {@link PathPart}s.
+*
+* The input is author-controlled (not user input), so a plain `split('/')` is
+* appropriate here. The leading empty segment from a leading `/` is dropped.
+*/
+function splitPattern(pattern) {
+	return pattern.split("/").filter((seg, i) => !(i === 0 && seg === "")).map((seg) => seg.startsWith(":") ? {
+		t: "param",
+		k: seg.slice(1)
+	} : {
+		t: "lit",
+		v: seg
+	});
+}
+/** Render {@link PathPart}s back into a `:key` pattern string (the inverse of {@link splitPattern}). */
+function joinPattern(parts) {
+	return "/" + parts.map((p) => p.t === "param" ? `:${p.k}` : p.v).join("/");
+}
+/**
+* Match a concrete pathname against {@link PathPart}s.
+*
+* Walks segment by segment: literals must equal, params must be non-empty and
+* are individually `decodeURIComponent`-decoded. Returns the raw (decoded but
+* un-coerced) param map, or `null` on any mismatch (literal differs, length
+* differs, or an empty param segment).
+*/
+function matchParts(parts, pathname) {
+	const segs = pathname.split("/").filter((seg, i) => !(i === 0 && seg === ""));
+	if (segs.length !== parts.length) return null;
+	const out = {};
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		const seg = segs[i];
+		if (part.t === "lit") {
+			if (part.v !== seg) return null;
+		} else {
+			if (seg === "") return null;
+			out[part.k] = decodeURIComponent(seg);
+		}
+	}
+	return out;
+}
+/**
+* Build a concrete pathname from {@link PathPart}s and a value map. Each param
+* value is stringified and `encodeURIComponent`-encoded per-segment.
+*
+* @throws if a declared param has no value.
+*/
+function buildParts(parts, values) {
+	return "/" + parts.map((p) => {
+		if (p.t === "lit") return p.v;
+		const v = values[p.k];
+		if (v === void 0) throw new Error(`path is missing a value for ":${p.k}"`);
+		return encodeURIComponent(String(v));
+	}).join("/");
+}
+/** Extract the param keys (in order) from {@link PathPart}s. */
+function paramKeys(parts) {
+	return parts.filter((p) => p.t === "param").map((p) => p.k);
+}
+/**
+* Tagged template for typed paths. Each interpolation is a single
+* `{ name: schema }` object; the schema both **declares** and **types** that
+* param and must accept string input.
+*
+* @example
+* ```ts
+* const userPost = path`/users/${{ id: z.uuid() }}/posts/${{ slug: z.string() }}`
+* userPost.pattern                     // '/users/:id/posts/:slug'
+* userPost.build({ id, slug })         // '/users/3f…/posts/intro'
+* userPost.parse('/users/3f…/posts/intro') // { id, slug } | null
+*
+* path`/x/${{ n: z.number() }}`        // ❌ compile error: schema must accept string input
+* path`/x/${{ n: z.coerce.number() }}` // ✅ ok: coerces from string
+* ```
+*
+* @throws at definition time if a param does not occupy a whole segment, an
+* interpolation is not a single-key object, or a key is declared twice.
+*/
+function path(strings, ...interpolations) {
+	const keys = [];
+	const schemas = {};
+	const parts = [];
+	let i = 0;
+	for (let s = 0; s < strings.length; s++) {
+		const lits = strings[s].split("/").filter((seg, j) => !(s === 0 && j === 0 && seg === ""));
+		for (let j = 0; j < lits.length; j++) {
+			const lit = lits[j];
+			if (lit !== "") parts.push({
+				t: "lit",
+				v: lit
+			});
+			else if (j > 0 && j < lits.length - 1) parts.push({
+				t: "lit",
+				v: ""
+			});
+		}
+		const part = interpolations[s];
+		if (!part) continue;
+		if (strings[s].length > 0 && !strings[s].endsWith("/")) throw new Error(`path template param #${i + 1} must occupy a whole segment (missing "/" before it)`);
+		const after = strings[s + 1];
+		if (after !== void 0 && after.length > 0 && !after.startsWith("/")) throw new Error(`path template param #${i + 1} must occupy a whole segment (missing "/" after it)`);
+		const entries = Object.entries(part);
+		if (entries.length !== 1) throw new Error(`path template interpolation #${i + 1} must be a single { name: schema } object`);
+		const [key, schema] = entries[0];
+		if (keys.includes(key)) throw new Error(`path template declares param ":${key}" twice`);
+		keys.push(key);
+		schemas[key] = schema;
+		parts.push({
+			t: "param",
+			k: key
+		});
+		i++;
+	}
+	return {
+		kind: "path",
+		parts,
+		pattern: joinPattern(parts),
+		keys,
+		schemas,
+		build(params) {
+			for (const key of keys) schemas[key].parse(String(params[key]));
+			return buildParts(parts, params);
+		},
+		parse(input) {
+			const raw = matchParts(parts, input);
+			if (!raw) return null;
+			const out = {};
+			for (const key of keys) out[key] = schemas[key].parse(raw[key]);
+			return out;
+		}
+	};
+}
+//#endregion
+//#region src/errors.ts
+/**
+* # Errors
+*
+* The error envelope used on both sides of the wire. This module is deliberately
+* **zod-free** so it can be imported by the browser client without pulling zod
+* into the bundle.
+*
+* @module
+*/
+/**
+* A transport-level API error.
+*
+* Thrown server-side to short-circuit a request with a status + machine code,
+* and re-constructed client-side from an HTTP error envelope (`{ error: { code,
+* message } }`) or a ws response frame whose `$status` is not 2xx (`$error`/`$code`
+* + an optional typed `data` body), so the same `instanceof ApiError` check works
+* everywhere.
+*
+* @example
+* ```ts
+* try {
+*   await sdk.call('getUser', { id: 'nope' })
+* } catch (err) {
+*   if (err instanceof ApiError && err.status === 404) showNotFound()
+* }
+* ```
+*/
+var ApiError = class extends Error {
+	status;
+	code;
+	data;
+	/**
+	* @param status  HTTP (or ws-mapped) status code.
+	* @param code    Stable machine-readable error code (e.g. `'UNAUTHORIZED'`).
+	* @param message Optional human-readable message; defaults to `code`.
+	* @param data    Optional structured payload — the parsed error body for
+	*                declared typed errors, or the raw envelope otherwise.
+	*/
+	constructor(status, code, message, data) {
+		super(message ?? code);
+		this.status = status;
+		this.code = code;
+		this.data = data;
+		this.name = "ApiError";
+	}
+};
+/**
+* Internal control-flow signal thrown by a handler's `fail()`.
+*
+* Carries an **already-validated** declared-error body so the server can emit it
+* verbatim with the declared status. Not part of the public surface.
+*
+* @internal
+*/
+var ApiFailure = class extends Error {
+	status;
+	data;
+	constructor(status, data) {
+		super(`declared error ${status}`);
+		this.status = status;
+		this.data = data;
+		this.name = "ApiFailure";
+	}
+};
+/**
+* Construct an {@link ApiError} to `throw` from a handler or middleware.
+*
+* @example
+* ```ts
+* const auth = middleware('auth', async (io) => {
+*   if (!io.req.headers.get('authorization')) throw reject(401, 'UNAUTHORIZED')
+*   return io.next()
+* })
+* ```
+*/
+function reject(status, code, message) {
+	return new ApiError(status, code, message);
+}
+//#endregion
+//#region src/caller.ts
+const sortDeep = (v) => {
+	if (Array.isArray(v)) return v.map(sortDeep);
+	if (v && typeof v === "object") {
+		const out = {};
+		for (const key of Object.keys(v).sort()) out[key] = sortDeep(v[key]);
+		return out;
+	}
+	return v;
+};
+/** Deterministic JSON (sorted keys) — the default cache key for a call's `data`. */
+const stableStringify = (value) => JSON.stringify(sortDeep(value)) ?? "null";
+/** Whether a value round-trips through JSON (only such results are cacheable — excludes `undefined`/functions). */
+const isJsonSafe = (v) => {
+	try {
+		return JSON.stringify(v) !== void 0;
+	} catch {
+		return false;
+	}
+};
+/** A `Storage`-backed {@link KVStore} (localStorage/sessionStorage), namespaced by `prefix`. */
+const storageKV = (storage, prefix) => ({
+	get: (key) => storage.getItem(prefix + key) ?? void 0,
+	set: (key, value) => storage.setItem(prefix + key, value),
+	delete: (key) => {
+		const full = prefix + key;
+		const had = storage.getItem(full) !== null;
+		storage.removeItem(full);
+		return had;
+	},
+	keys: function* () {
+		for (let i = 0; i < storage.length; i++) {
+			const k = storage.key(i);
+			if (k !== null && k.startsWith(prefix)) yield k.slice(prefix.length);
+		}
+	}
+});
+/** Resolve a {@link CacheStoreSpec} to a concrete {@link KVStore}, falling back to memory (SSR-safe). */
+const resolveStore = (spec, prefix) => {
+	if (typeof spec === "object") return spec;
+	if (spec !== "memory") try {
+		const storage = spec === "local" ? globalThis.localStorage : globalThis.sessionStorage;
+		if (storage) return storageKV(storage, prefix);
+	} catch {}
+	const map = /* @__PURE__ */ new Map();
+	return {
+		get: (k) => map.get(k),
+		set: (k, v) => void map.set(k, v),
+		delete: (k) => map.delete(k),
+		keys: () => map.keys()
+	};
+};
+/** Create a tag-aware LRU cache over the chosen backend. */
+function createClientCache(opts = {}) {
+	const max = opts.max ?? 500;
+	const defaultTtl = opts.ttl ?? 0;
+	const now = opts.now ?? Date.now;
+	const kv = resolveStore(opts.store ?? "memory", opts.prefix ?? "ayepi:cache:");
+	const order = /* @__PURE__ */ new Map();
+	for (const k of kv.keys()) order.set(k, true);
+	const touch = (key) => {
+		order.delete(key);
+		order.set(key, true);
+	};
+	const parse = (key) => {
+		const raw = kv.get(key);
+		if (raw === void 0) return;
+		try {
+			return JSON.parse(raw);
+		} catch {
+			kv.delete(key);
+			return;
+		}
+	};
+	const drop = (key) => {
+		order.delete(key);
+		return kv.delete(key);
+	};
+	const evict = () => {
+		while (order.size > max) drop(order.keys().next().value);
+	};
+	return {
+		read: (key) => {
+			const e = parse(key);
+			if (!e) return;
+			const t = now();
+			if (e.exp && t >= e.exp) {
+				if (!e.stale || t >= e.stale) {
+					drop(key);
+					return;
+				}
+				touch(key);
+				return {
+					value: e.v,
+					stale: true
+				};
+			}
+			touch(key);
+			return {
+				value: e.v,
+				stale: false
+			};
+		},
+		write: (key, value, o) => {
+			if (!isJsonSafe(value)) return;
+			const ttl = o?.ttl ?? defaultTtl;
+			const exp = ttl > 0 ? now() + ttl : 0;
+			const entry = {
+				v: value,
+				exp,
+				stale: exp && o?.staleWhileRevalidate ? exp + o.staleWhileRevalidate : 0,
+				tags: o?.tags ?? []
+			};
+			kv.set(key, JSON.stringify(entry));
+			touch(key);
+			evict();
+		},
+		remove: (key) => void drop(key),
+		removeWhere: (pred) => {
+			let n = 0;
+			for (const key of [...kv.keys()]) if (pred(key) && drop(key)) n += 1;
+			return n;
+		},
+		invalidateTags: (tags) => {
+			if (tags.length === 0) return 0;
+			const want = new Set(tags);
+			let n = 0;
+			for (const key of [...kv.keys()]) {
+				const e = parse(key);
+				if (e && e.tags.some((tag) => want.has(tag)) && drop(key)) n += 1;
+			}
+			return n;
+		},
+		clear: () => {
+			for (const key of [...kv.keys()]) kv.delete(key);
+			order.clear();
+		}
+	};
+}
+/** Create the shared caller context. `defaults` seed each store's cache (`max`/`ttl`/`store`). */
+function createCallerContext(defaults = {}) {
+	const caches = /* @__PURE__ */ new Map();
+	const cacheFor = (store) => {
+		const spec = store ?? defaults.store ?? "memory";
+		let c = caches.get(spec);
+		if (!c) {
+			c = createClientCache({
+				...defaults,
+				store: spec
+			});
+			caches.set(spec, c);
+		}
+		return c;
+	};
+	return {
+		cacheFor,
+		invalidateTags: (tags) => {
+			cacheFor(void 0);
+			for (const c of caches.values()) c.invalidateTags(tags);
+		}
+	};
+}
+/** Rejected when a rate-limited caller is over budget with `onLimit: 'drop'`/`'throw'`. */
+var CallerRateLimited = class extends Error {
+	constructor(message = "caller rate limit exceeded") {
+		super(message);
+		this.name = "CallerRateLimited";
+	}
+};
+const KEY_SEP = "\0";
+const abortError = (reason) => new DOMException(reason, "AbortError");
+/** A signal that aborts when any input signal aborts (a portable `AbortSignal.any`). */
+const anySignal = (signals) => {
+	const real = signals.filter((s) => s !== void 0);
+	if (real.length === 1) return real[0];
+	const ctrl = new AbortController();
+	const onAbort = () => {
+		ctrl.abort();
+		for (const s of real) s.removeEventListener("abort", onAbort);
+	};
+	for (const s of real) {
+		if (s.aborted) {
+			ctrl.abort();
+			return ctrl.signal;
+		}
+		s.addEventListener("abort", onAbort, { once: true });
+	}
+	return ctrl.signal;
+};
+/** Sleep `ms`, rejecting early if `signal` aborts. */
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+	if (signal.aborted) {
+		reject(abortError("aborted"));
+		return;
+	}
+	const onAbort = () => {
+		clearTimeout(timer);
+		reject(abortError("aborted"));
+	};
+	const timer = setTimeout(() => {
+		signal.removeEventListener("abort", onAbort);
+		resolve();
+	}, ms);
+	signal.addEventListener("abort", onAbort, { once: true });
+});
+const compose = (base, layers) => layers.reduceRight((next, layer) => layer(next), base);
+const resolveTags = (tagger, data, result) => tagger === void 0 ? [] : typeof tagger === "function" ? tagger(data, result) : tagger;
+const withHooks = (o, pending) => (next) => async (call, signal) => {
+	pending.n += 1;
+	o.onStart?.(call.data);
+	try {
+		const r = await next(call, signal);
+		o.onSuccess?.(r, call.data);
+		return r;
+	} catch (err) {
+		o.onError?.(err, call.data);
+		throw err;
+	} finally {
+		pending.n -= 1;
+		o.onSettled?.(call.data);
+	}
+};
+const withInvalidate = (tagger, when, ctx) => (next) => async (call, signal) => {
+	if (when !== "success") ctx.invalidateTags(resolveTags(tagger, call.data, void 0));
+	const r = await next(call, signal);
+	if (when !== "start") ctx.invalidateTags(resolveTags(tagger, call.data, r));
+	return r;
+};
+const withCache = (cfg, cache, keyOf) => (next) => async (call, signal) => {
+	const key = keyOf(call.data);
+	const store = (result) => cache.write(key, result, {
+		ttl: cfg.ttl,
+		staleWhileRevalidate: cfg.staleWhileRevalidate,
+		tags: resolveTags(cfg.tags, call.data, result)
+	});
+	const hit = cache.read(key);
+	if (hit && !hit.stale) return hit.value;
+	if (hit && hit.stale) {
+		next(call, signal).then(store).catch(() => {});
+		return hit.value;
+	}
+	const r = await next(call, signal);
+	store(r);
+	return r;
+};
+const withDedupe = (keyOf) => {
+	const inflight = /* @__PURE__ */ new Map();
+	return (next) => (call, signal) => {
+		const key = keyOf(call.data);
+		const existing = inflight.get(key);
+		if (existing) return existing;
+		const p = next(call, signal).finally(() => inflight.delete(key));
+		inflight.set(key, p);
+		return p;
+	};
+};
+const withLastOnly = () => {
+	let current = null;
+	return (next) => (call, signal) => {
+		current?.abort(abortError("superseded"));
+		const ctrl = new AbortController();
+		current = ctrl;
+		const linked = anySignal([signal, ctrl.signal]);
+		return new Promise((resolve, reject) => {
+			linked.addEventListener("abort", () => reject(abortError("superseded")), { once: true });
+			next(call, linked).then(resolve, reject);
+		}).finally(() => {
+			if (current === ctrl) current = null;
+		});
+	};
+};
+const withRateLimit = (cfg) => {
+	const onLimit = cfg.onLimit ?? "wait";
+	const perToken = cfg.window / cfg.limit;
+	let tokens = cfg.limit;
+	let last = Date.now();
+	const refill = () => {
+		const t = Date.now();
+		const add = (t - last) / cfg.window * cfg.limit;
+		if (add > 0) {
+			tokens = Math.min(cfg.limit, tokens + add);
+			last = t;
+		}
+	};
+	return (next) => async (call, signal) => {
+		refill();
+		if (tokens < 1) {
+			if (onLimit === "throw" || onLimit === "drop") throw new CallerRateLimited();
+			await sleep((1 - tokens) * perToken, signal);
+			refill();
+		}
+		tokens -= 1;
+		return next(call, signal);
+	};
+};
+const withRetry = (cfg) => {
+	const attempts = cfg.attempts ?? 3;
+	const base = cfg.base ?? 200;
+	const factor = cfg.factor ?? 2;
+	const max = cfg.max ?? 3e4;
+	const jitter = cfg.jitter ?? .5;
+	return (next) => async (call, signal) => {
+		let lastErr;
+		for (let attempt = 1; attempt <= attempts; attempt += 1) try {
+			return await next(call, signal);
+		} catch (err) {
+			lastErr = err;
+			if (attempt >= attempts) break;
+			await sleep(Math.min(max, base * factor ** (attempt - 1)) * (1 - jitter * Math.random()), signal);
+		}
+		throw lastErr;
+	};
+};
+const withDebounce = (cfg, cancellers) => {
+	let timer = null;
+	let queue = [];
+	let firstAt = 0;
+	return (next) => {
+		const fire = (signal) => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			const batch = queue;
+			queue = [];
+			firstAt = 0;
+			const dataList = batch.map((q) => q.call.data);
+			next(cfg.accumulate ? {
+				data: cfg.accumulate(dataList),
+				opts: batch[batch.length - 1].call.opts
+			} : batch[batch.length - 1].call, signal).then((r) => {
+				const results = cfg.spread ? cfg.spread(r, dataList) : null;
+				batch.forEach((q, i) => q.resolve(results ? results[i] : r));
+			}, (e) => batch.forEach((q) => q.reject(e)));
+		};
+		cancellers.push(() => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			const batch = queue;
+			queue = [];
+			firstAt = 0;
+			for (const q of batch) q.reject(abortError("cancelled"));
+		});
+		return (call, signal) => new Promise((resolve, reject) => {
+			const now = Date.now();
+			if (queue.length === 0) firstAt = now;
+			queue.push({
+				call,
+				resolve,
+				reject
+			});
+			const lead = cfg.leading && timer === null && queue.length === 1;
+			if (timer) clearTimeout(timer);
+			const overdue = cfg.maxWait !== void 0 && now - firstAt >= cfg.maxWait;
+			if (lead || overdue) {
+				fire(signal);
+				return;
+			}
+			const delay = cfg.maxWait !== void 0 ? Math.min(cfg.wait, firstAt + cfg.maxWait - now) : cfg.wait;
+			timer = setTimeout(() => fire(signal), delay);
+		});
+	};
+};
+/**
+* Build a {@link Caller} for one endpoint: normalize args → `{ data, opts }`, fold the enabled
+* policy layers around a base that calls `rawCall(data?, opts)`, and expose `cancel`/`invalidate`/
+* `pending`. Streaming endpoints bypass every layer (policies are for unary request/response calls).
+*/
+function makeCaller(name, m, rawCall, ctx, options) {
+	if (m.items || m.itemsIn || m.streamIn !== null || m.streamOut !== null) return {
+		call: (...args) => rawCall(...args),
+		cancel: () => {},
+		invalidate: () => {},
+		pending: 0
+	};
+	const hasData = m.p.length > 0 || m.q.length > 0 || m.hasBody || m.f.length > 0;
+	const cacheCfg = options.cache === true ? {} : options.cache === void 0 || options.cache === false ? {} : options.cache;
+	const dataKey = (data) => cacheCfg.key ? cacheCfg.key(data) : stableStringify(data);
+	const namespaced = (data) => `${name}${KEY_SEP}${dataKey(data)}`;
+	const cache = options.cache ? ctx.cacheFor(cacheCfg.store) : null;
+	const pending = { n: 0 };
+	const cancellers = [];
+	let callerCtrl = new AbortController();
+	const base = (call, signal) => {
+		const opts = {
+			...call.opts ?? {},
+			signal
+		};
+		return Promise.resolve(hasData ? rawCall(call.data, opts) : rawCall(opts));
+	};
+	const layers = [];
+	if (options.onStart || options.onSuccess || options.onError || options.onSettled) layers.push(withHooks(options, pending));
+	if (options.invalidates) layers.push(withInvalidate(options.invalidates, options.invalidateOn ?? "success", ctx));
+	if (cache) layers.push(withCache(cacheCfg, cache, namespaced));
+	if (options.dedupe) layers.push(withDedupe(namespaced));
+	if (options.lastOnly) layers.push(withLastOnly());
+	if (options.debounce !== void 0) {
+		const dc = typeof options.debounce === "number" ? { wait: options.debounce } : options.debounce;
+		layers.push(withDebounce(dc, cancellers));
+	}
+	if (options.rateLimit) layers.push(withRateLimit(options.rateLimit));
+	if (options.retry) layers.push(withRetry(options.retry));
+	const invoke = compose(base, layers);
+	const call = (...args) => {
+		const data = hasData ? args[0] : void 0;
+		const opts = hasData ? args[1] : args[0];
+		const signal = anySignal([opts?.signal, callerCtrl.signal]);
+		return invoke({
+			data,
+			opts
+		}, signal);
+	};
+	return {
+		call,
+		cancel: () => {
+			callerCtrl.abort(abortError("cancelled"));
+			callerCtrl = new AbortController();
+			for (const c of cancellers) c();
+		},
+		invalidate: () => void cache?.removeWhere((key) => key.startsWith(`${name}${KEY_SEP}`)),
+		get pending() {
+			return pending.n;
+		}
+	};
+}
+//#endregion
+//#region src/client.ts
+/** Response statuses that must carry a null body (the `Response` constructor rejects a body for these). */
+const NULL_BODY_STATUS = new Set([
+	101,
+	204,
+	205,
+	304
+]);
+/**
+* Send a **non-streaming** request via `XMLHttpRequest` so the caller can observe upload progress —
+* `fetch` has no upload-progress events. Resolves a normal {@link Response} (built from the buffered
+* reply) so the rest of the client treats it identically, and rejects with fetch-compatible errors
+* (`TypeError` for network failures, an `AbortError` `DOMException` for aborts).
+*/
+function xhrSend(method, url, headers, body, signal, onProgress) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new DOMException("The operation was aborted.", "AbortError"));
+			return;
+		}
+		const xhr = new XMLHttpRequest();
+		xhr.open(method, url, true);
+		xhr.responseType = "arraybuffer";
+		for (const [k, v] of Object.entries(headers)) xhr.setRequestHeader(k, v);
+		xhr.upload.onprogress = (e) => {
+			if (e.lengthComputable) onProgress({
+				loaded: e.loaded,
+				total: e.total
+			});
+		};
+		const onAbort = () => xhr.abort();
+		const cleanup = () => signal?.removeEventListener("abort", onAbort);
+		xhr.onload = () => {
+			cleanup();
+			const resBody = NULL_BODY_STATUS.has(xhr.status) ? null : xhr.response;
+			resolve(new Response(resBody, {
+				status: xhr.status,
+				statusText: xhr.statusText
+			}));
+		};
+		xhr.onerror = () => {
+			cleanup();
+			reject(/* @__PURE__ */ new TypeError("Network request failed"));
+		};
+		xhr.onabort = () => {
+			cleanup();
+			reject(new DOMException("The operation was aborted.", "AbortError"));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+		xhr.send(body);
+	});
+}
+/** Duck-type a zod schema without referencing `z` as a value (keeps the bundle zod-free). */
+function isSchema(v) {
+	return !!v && typeof v.parse === "function";
+}
+/**
+* Accept either a {@link Manifest} or a spec and return the manifest. A spec carries its
+* zod-free manifest builder under `Symbol.for('ayepi.manifest')` (stamped by `spec()`); we
+* read it off the value rather than importing the deriver, so a manifest-only bundle never
+* pulls in that (zod-bearing) code. A plain manifest has no such method and is used as-is.
+*/
+function resolveManifest(src) {
+	const build = src[Symbol.for("ayepi.manifest")];
+	return typeof build === "function" ? build() : src;
+}
+/** A ws call response is successful when its reserved `$status` is in the 2xx range. */
+function is2xx(status) {
+	return typeof status === "number" && status >= 200 && status < 300;
+}
+/** Default human messages for common statuses — used when an error frame omits `$error`. */
+const STATUS_TEXT = {
+	400: "Bad Request",
+	401: "Unauthorized",
+	403: "Forbidden",
+	404: "Not Found",
+	405: "Method Not Allowed",
+	409: "Conflict",
+	410: "Gone",
+	422: "Unprocessable Entity",
+	429: "Too Many Requests",
+	500: "Internal Server Error",
+	502: "Bad Gateway",
+	503: "Service Unavailable"
+};
+/**
+* Build an {@link ApiError} from a ws error frame. Frames carry the reserved
+* `$status` (always), `$error` (message), and `$code` (machine code) fields, plus
+* an optional typed `data` body for declared errors. Missing `$error`/`$code` fall
+* back to a status-derived message / `'ERROR'`.
+*/
+function frameError(frame) {
+	const status = Number(frame.$status);
+	return new ApiError(status, typeof frame.$code === "string" ? frame.$code : "ERROR", typeof frame.$error === "string" ? frame.$error : STATUS_TEXT[status] ?? `Request failed with status ${status}`, frame.data);
+}
+/**
+* Create a typed client from a {@link Manifest}.
+*
+* @typeParam S - the spec type, used purely for inference (no runtime schemas).
+*
+* @example
+* ```ts
+* const sdk = client<typeof api>({ baseUrl, manifest, ws })
+* const user = await sdk.call('getUser', { id: 'u1' })       // fully typed
+* for await (const row of sdk.call('streamRows', { n: 4 })) … // typed item stream
+* const off = sdk.on('jobProgress', { jobId }, (d) => …)     // typed event
+* ```
+*/
+function client(opts) {
+	const manifest = resolveManifest(opts.manifest);
+	const doFetch = opts.fetchImpl ?? ((req) => fetch(req));
+	const callerCtx = createCallerContext(opts.cache);
+	const baseHeaders = () => typeof opts.headers === "function" ? opts.headers() : opts.headers ?? {};
+	const vcfg = (name) => opts.validate?.endpoints[name]?.cfg;
+	const vParse = (name, data) => {
+		const c = vcfg(name);
+		return c?.response ? c.response.parse(data) : data;
+	};
+	const vParseItem = (name, item) => {
+		const c = vcfg(name);
+		return c && isSchema(c.streamOut) ? c.streamOut.parse(item) : item;
+	};
+	const vParseMulti = (name, status, data) => {
+		const schema = vcfg(name)?.responses?.[status];
+		return schema ? schema.parse(data) : data;
+	};
+	let frameSeq = 0;
+	const pending = /* @__PURE__ */ new Map();
+	const streamQueues = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Map();
+	/** per-call abort-listener removers, run when a call settles so signals don't leak listeners */
+	const abortCleanups = /* @__PURE__ */ new Map();
+	const runCleanup = (id) => {
+		const c = abortCleanups.get(id);
+		if (c) {
+			abortCleanups.delete(id);
+			c();
+		}
+	};
+	/**
+	* Wire `opts.signal` to a ws call: on abort, send an `{ id, abort: true }` frame
+	* and fail the local pending/queue. `fail` returns whether the call was still live.
+	*/
+	const wireAbort = (id, signal, fail) => {
+		if (!signal) return;
+		const onAbort = () => {
+			abortCleanups.delete(id);
+			if (fail(signal.reason)) opts.ws?.send(JSON.stringify({
+				id,
+				abort: true
+			}));
+		};
+		if (signal.aborted) {
+			onAbort();
+			return;
+		}
+		signal.addEventListener("abort", onAbort, { once: true });
+		abortCleanups.set(id, () => signal.removeEventListener("abort", onAbort));
+	};
+	const canon = (v) => JSON.stringify(v ?? {}, Object.keys(v ?? {}).sort());
+	if (opts.ws) opts.ws.onMessage((raw) => {
+		const frame = JSON.parse(raw);
+		if (typeof frame.id !== "string") {
+			if (typeof frame.type === "string") {
+				const key = `${frame.type}|${canon(frame.params)}`;
+				for (const cb of listeners.get(key) ?? []) cb(frame.data);
+			}
+			return;
+		}
+		const errored = "$status" in frame && !is2xx(frame.$status);
+		if (streamQueues.has(frame.id)) {
+			const q = streamQueues.get(frame.id);
+			if ("chunk" in frame) q.push(frame.chunk);
+			else if (frame.end === true) {
+				streamQueues.delete(frame.id);
+				runCleanup(frame.id);
+				q.end();
+			} else if (errored) {
+				streamQueues.delete(frame.id);
+				runCleanup(frame.id);
+				q.fail(frameError(frame));
+			}
+		} else if (pending.has(frame.id)) {
+			const p = pending.get(frame.id);
+			pending.delete(frame.id);
+			runCleanup(frame.id);
+			if (errored) p.reject(frameError(frame));
+			else p.resolve(frame.data);
+		}
+	});
+	function clientQueue() {
+		const buf = [];
+		let done = false;
+		let err;
+		let wake = null;
+		return {
+			push(v) {
+				buf.push(v);
+				wake?.();
+			},
+			end() {
+				done = true;
+				wake?.();
+			},
+			fail(e) {
+				err = e;
+				done = true;
+				wake?.();
+			},
+			async *iterate() {
+				for (;;) {
+					if (buf.length > 0) {
+						yield buf.shift();
+						continue;
+					}
+					if (err !== void 0) throw err;
+					if (done) return;
+					await new Promise((r) => wake = r);
+					wake = null;
+				}
+			}
+		};
+	}
+	/** Pump a client item iterable to the server as chunk frames. */
+	function pumpItems(id, src) {
+		const iterable = typeof src === "function" ? src() : src;
+		(async () => {
+			try {
+				for await (const item of iterable) opts.ws.send(JSON.stringify({
+					id,
+					chunk: item
+				}));
+				opts.ws.send(JSON.stringify({
+					id,
+					end: true
+				}));
+			} catch {
+				opts.ws.send(JSON.stringify({
+					id,
+					end: true
+				}));
+			}
+		})();
+	}
+	/** the call frame: explicit ws id, or the un-injected url pattern + http method */
+	function callFrame(id, m, data) {
+		return JSON.stringify(m.ws !== null ? {
+			id,
+			type: m.ws,
+			data
+		} : {
+			id,
+			type: m.path,
+			method: m.method,
+			data
+		});
+	}
+	/** ws transport for typed item streams: chunk frames both directions. */
+	function wsStreamCall(name, m, data, stream, signal) {
+		if (!opts.ws) {
+			const err = /* @__PURE__ */ new Error("no websocket transport configured");
+			if (!m.items) return Promise.reject(err);
+			throw err;
+		}
+		const id = `c${++frameSeq}`;
+		if (m.items) {
+			const queue = clientQueue();
+			streamQueues.set(id, queue);
+			wireAbort(id, signal, (reason) => {
+				if (!streamQueues.delete(id)) return false;
+				queue.fail(reason);
+				return true;
+			});
+			opts.ws.send(callFrame(id, m, data));
+			if (m.itemsIn) pumpItems(id, stream);
+			return (async function* () {
+				for await (const item of queue.iterate()) yield vParseItem(name, item);
+			})();
+		}
+		const result = new Promise((resolve, reject) => {
+			pending.set(id, {
+				resolve,
+				reject
+			});
+			wireAbort(id, signal, (reason) => {
+				const p = pending.get(id);
+				if (!p) return false;
+				pending.delete(id);
+				p.reject(reason);
+				return true;
+			});
+			opts.ws.send(callFrame(id, m, data));
+		});
+		if (m.itemsIn) pumpItems(id, stream);
+		return result.then((d) => m.multi ? d : vParse(name, d));
+	}
+	function wsRequest(payload, signal) {
+		if (!opts.ws) return Promise.reject(/* @__PURE__ */ new Error("no websocket transport configured"));
+		const id = `c${++frameSeq}`;
+		return new Promise((resolve, reject) => {
+			pending.set(id, {
+				resolve,
+				reject
+			});
+			wireAbort(id, signal, (reason) => {
+				const p = pending.get(id);
+				if (!p) return false;
+				pending.delete(id);
+				p.reject(reason);
+				return true;
+			});
+			opts.ws.send(JSON.stringify({
+				id,
+				...payload
+			}));
+		});
+	}
+	function splitData(m, data) {
+		if (m.b === "raw") return {
+			p: {},
+			q: {},
+			b: data,
+			f: {}
+		};
+		const p = {};
+		const q = {};
+		const bObj = {};
+		const f = {};
+		const pSet = new Set(m.p);
+		const qSet = new Set(m.q);
+		const bSet = new Set(m.b ?? []);
+		const fSet = new Set(m.f);
+		for (const [k, v] of Object.entries(data ?? {})) if (pSet.has(k)) p[k] = v;
+		else if (qSet.has(k)) q[k] = v;
+		else if (bSet.has(k)) bObj[k] = v;
+		else if (fSet.has(k)) f[k] = v;
+		else throw new Error(`key "${k}" does not belong to endpoint data`);
+		return {
+			p,
+			q,
+			b: m.hasBody ? bObj : void 0,
+			f
+		};
+	}
+	function buildUrl(m, p, q) {
+		const path = buildParts(splitPattern(m.path), p);
+		const url = new URL(path.slice(1), opts.baseUrl.endsWith("/") ? opts.baseUrl : opts.baseUrl + "/");
+		for (const [k, v] of Object.entries(q)) {
+			if (v === void 0) continue;
+			if (Array.isArray(v)) for (const item of v) url.searchParams.append(k, String(item));
+			else url.searchParams.set(k, String(v));
+		}
+		return url;
+	}
+	/** AsyncIterable (or generator function) of items → lazy NDJSON request body. */
+	function encodeItems(src) {
+		const it = (typeof src === "function" ? src() : src)[Symbol.asyncIterator]();
+		const enc = new TextEncoder();
+		return new ReadableStream({
+			async pull(controller) {
+				const { done, value } = await it.next();
+				if (done) return controller.close();
+				controller.enqueue(enc.encode(JSON.stringify(value) + "\n"));
+			},
+			async cancel() {
+				await it.return?.(void 0);
+			}
+		});
+	}
+	async function httpRequest(m, data, callOpts) {
+		const { p, q, b, f } = splitData(m, data);
+		const stream = callOpts?.stream;
+		const url = buildUrl(m, p, q);
+		const headers = {
+			...baseHeaders(),
+			...callOpts?.headers ?? {}
+		};
+		let body = null;
+		let duplex = false;
+		if (m.streamIn) {
+			headers["content-type"] = m.streamIn;
+			if (m.itemsIn) {
+				body = encodeItems(stream);
+				duplex = true;
+			} else {
+				body = stream;
+				duplex = stream instanceof ReadableStream;
+			}
+		} else if (m.f.length > 0) {
+			const form = new FormData();
+			if (b !== void 0) form.set("body", JSON.stringify(b));
+			for (const [k, v] of Object.entries(f)) {
+				if (v === void 0) continue;
+				if (Array.isArray(v)) for (const file of v) form.append(k, file);
+				else form.set(k, v);
+			}
+			body = form;
+		} else if (m.hasBody) if (m.bodyEnc === "urlencoded") {
+			headers["content-type"] = "application/x-www-form-urlencoded";
+			const sp = new URLSearchParams();
+			for (const [k, v] of Object.entries(b ?? {})) {
+				if (v === void 0) continue;
+				if (Array.isArray(v)) for (const item of v) sp.append(k, String(item));
+				else sp.set(k, String(v));
+			}
+			body = sp.toString();
+		} else {
+			headers["content-type"] = "application/json";
+			body = JSON.stringify(b);
+		}
+		const init = {
+			method: m.method,
+			headers,
+			body,
+			signal: callOpts?.signal
+		};
+		if (duplex) init.duplex = "half";
+		const onProgress = callOpts?.onUploadProgress;
+		const res = onProgress && !m.streamIn && !m.streamOut && typeof XMLHttpRequest !== "undefined" ? await xhrSend(m.method, url.toString(), headers, body, callOpts?.signal, onProgress) : await doFetch(new Request(url, init));
+		if (!res.ok) {
+			const errBody = await res.json().catch(() => ({}));
+			const env = errBody?.error;
+			throw new ApiError(res.status, env?.code ?? "ERROR", env?.message, errBody);
+		}
+		return res;
+	}
+	async function httpCall(name, m, data, callOpts) {
+		const res = await httpRequest(m, data, callOpts);
+		if (m.streamOut) return res.body ?? new ReadableStream({ start: (c) => c.close() });
+		if (m.multi) return {
+			status: res.status,
+			data: vParseMulti(name, res.status, await res.json())
+		};
+		if (res.status === 204) return;
+		return vParse(name, await res.json());
+	}
+	/** Lazy NDJSON/SSE consumer — the request fires on first pull, items decode as they arrive. */
+	async function* iterateItems(name, m, data, callOpts) {
+		const res = await httpRequest(m, data, callOpts);
+		if (!res.body) return;
+		const sse = m.streamOut === "text/event-stream";
+		const sep = sse ? "\n\n" : "\n";
+		const decodeLine = (chunk) => {
+			const text = sse ? chunk.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trimStart()).join("\n") : chunk;
+			if (!text.trim()) return;
+			return vParseItem(name, JSON.parse(text));
+		};
+		const reader = res.body.getReader();
+		const dec = new TextDecoder();
+		let buf = "";
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				buf += dec.decode(value, { stream: true });
+				let nl;
+				while ((nl = buf.indexOf(sep)) >= 0) {
+					const chunk = buf.slice(0, nl);
+					buf = buf.slice(nl + sep.length);
+					const item = decodeLine(chunk);
+					if (item !== void 0) yield item;
+				}
+			}
+			buf += dec.decode();
+			const item = decodeLine(buf);
+			if (item !== void 0) yield item;
+		} finally {
+			await reader.cancel().catch(() => {});
+		}
+	}
+	function call(name, ...rest) {
+		const m = manifest.endpoints[name];
+		if (!m) return Promise.reject(/* @__PURE__ */ new Error(`unknown endpoint "${name}"`));
+		const hasData = m.p.length > 0 || m.q.length > 0 || m.hasBody || m.f.length > 0 || m.streamIn !== null;
+		const data = hasData ? rest[0] : void 0;
+		const callOpts = hasData ? rest[1] : rest[0];
+		const transport = callOpts?.transport ?? (opts.prefer === "ws" && !m.httpOnly && opts.ws ? "ws" : "http");
+		if (transport === "ws" && m.httpOnly) {
+			const err = /* @__PURE__ */ new Error(`endpoint "${name}" is http-only`);
+			if (m.items) throw err;
+			return Promise.reject(err);
+		}
+		if (m.items || m.itemsIn) {
+			if (transport === "ws") return wsStreamCall(name, m, data, callOpts?.stream, callOpts?.signal);
+			if (m.items) return iterateItems(name, m, data, callOpts);
+			return httpCall(name, m, data, callOpts);
+		}
+		if (transport === "ws") return wsRequest(m.ws !== null ? {
+			type: m.ws,
+			data
+		} : {
+			type: m.path,
+			method: m.method,
+			data
+		}, callOpts?.signal).then((d) => m.multi ? d : vParse(name, d));
+		return httpCall(name, m, data, callOpts);
+	}
+	function url(name, ...rest) {
+		const m = manifest.endpoints[name];
+		if (!m) throw new Error(`unknown endpoint "${name}"`);
+		if (m.method !== "GET") throw new Error(`url() requires a GET endpoint; "${name}" is ${m.method}`);
+		const { p, q } = splitData(m, rest[0]);
+		return buildUrl(m, p, q).toString();
+	}
+	function on(name, ...rest) {
+		const ev = manifest.events[name];
+		if (!ev) throw new Error(`unknown event "${name}"`);
+		if (!opts.ws) throw new Error("no websocket transport configured");
+		const params = ev.hasParams ? rest[0] : void 0;
+		const cb = ev.hasParams ? rest[1] : rest[0];
+		const key = `${ev.ws}|${canon(params)}`;
+		let set = listeners.get(key);
+		if (!set) listeners.set(key, set = /* @__PURE__ */ new Set());
+		set.add(cb);
+		wsRequest({
+			sub: ev.ws,
+			params
+		});
+		return () => {
+			set.delete(cb);
+			if (set.size === 0) wsRequest({
+				unsub: ev.ws,
+				params
+			});
+		};
+	}
+	function caller(name, options) {
+		const m = manifest.endpoints[name];
+		if (!m) throw new Error(`unknown endpoint "${name}"`);
+		return makeCaller(name, m, (...args) => call(name, ...args), callerCtx, options ?? {});
+	}
+	return {
+		call,
+		on,
+		url,
+		caller
+	};
+}
+//#endregion
+//#region src/ws-transport.ts
+/** Reconnect backoff defaults: 500ms → … → 30s, doubling, with jitter. */
+const DEFAULT_BACKOFF = {
+	initial: 500,
+	max: 3e4,
+	factor: 2,
+	jitter: true
+};
+/** Heartbeat defaults: ping every 30s, expect a pong within 10s. */
+const DEFAULT_HEARTBEAT = {
+	interval: 3e4,
+	timeout: 1e4
+};
+/** Synthetic status for locally-failed calls (disconnected / never sent) — there is no HTTP response. */
+const DISCONNECTED_STATUS = 0;
+/**
+* Create a resilient {@link WsTransport} for {@link client}'s `ws` option.
+*
+* @param url  - the WebSocket URL (e.g. `wss://host/ws`), or a function returning
+*   it. The function form is **resolved at each (re)connect**, so it's the place
+*   to inject auth that isn't known up front — e.g. a token as a query param:
+*   `wsTransport(() => \`wss://host/ws?access_token=${getToken()}\`)`. (Browsers
+*   can't set headers on a ws handshake, so the token rides the URL or a subprotocol.)
+* @param opts - reconnect / heartbeat / policy tuning.
+*/
+function wsTransport(url, opts = {}) {
+	const maybeWS = opts.WebSocket ?? globalThis.WebSocket;
+	if (!maybeWS) throw new Error("wsTransport: no WebSocket implementation available; pass opts.WebSocket");
+	const WS = maybeWS;
+	const policy = opts.whileDisconnected ?? "fail";
+	const bo = {
+		...DEFAULT_BACKOFF,
+		...opts.backoff
+	};
+	const hb = opts.heartbeat === false ? null : {
+		...DEFAULT_HEARTBEAT,
+		...opts.heartbeat ?? {}
+	};
+	const maxRetries = opts.maxRetries ?? Infinity;
+	let sock = null;
+	let state = "closed";
+	let messageCb = null;
+	let retries = 0;
+	let everConnected = false;
+	let manualClose = false;
+	let reconnectTimer = null;
+	let hbInterval = null;
+	let hbDeadline = null;
+	const outbox = [];
+	const subs = /* @__PURE__ */ new Map();
+	const openCalls = /* @__PURE__ */ new Set();
+	const setState = (s) => {
+		if (s === state) return;
+		state = s;
+		opts.onStateChange?.(s);
+	};
+	const deliver = (raw) => messageCb?.(raw);
+	const canon = (v) => JSON.stringify(v ?? {}, Object.keys(v ?? {}).sort());
+	/** Synthesize disconnect errors so the client rejects in-flight pendings / fails item streams. */
+	function failOpenCalls() {
+		for (const id of openCalls) deliver(JSON.stringify({
+			id,
+			$status: DISCONNECTED_STATUS,
+			$code: "DISCONNECTED",
+			$error: "connection closed"
+		}));
+		openCalls.clear();
+	}
+	function clearHeartbeat() {
+		if (hbInterval) clearInterval(hbInterval);
+		if (hbDeadline) clearTimeout(hbDeadline);
+		hbInterval = hbDeadline = null;
+	}
+	function startHeartbeat() {
+		if (!hb) return;
+		clearHeartbeat();
+		hbInterval = setInterval(() => {
+			if (state !== "open" || !sock) return;
+			sock.send(JSON.stringify({ ping: true }));
+			if (hbDeadline) clearTimeout(hbDeadline);
+			hbDeadline = setTimeout(() => sock?.close(), hb.timeout);
+		}, hb.interval);
+	}
+	function onMessage(raw) {
+		let f = null;
+		try {
+			f = JSON.parse(raw);
+		} catch {
+			deliver(raw);
+			return;
+		}
+		if (f && f.pong === true) {
+			if (hbDeadline) {
+				clearTimeout(hbDeadline);
+				hbDeadline = null;
+			}
+			return;
+		}
+		if (f && typeof f.id === "string" && ("$status" in f || f.end === true)) openCalls.delete(f.id);
+		deliver(raw);
+	}
+	function onOpen() {
+		if (manualClose) return;
+		everConnected = true;
+		retries = 0;
+		setState("open");
+		for (const raw of subs.values()) sock?.send(raw);
+		const queued = outbox.splice(0);
+		for (const raw of queued) sock?.send(raw);
+		startHeartbeat();
+	}
+	function onClose() {
+		clearHeartbeat();
+		sock = null;
+		failOpenCalls();
+		if (manualClose) {
+			setState("closed");
+			return;
+		}
+		scheduleReconnect();
+	}
+	function scheduleReconnect() {
+		if (manualClose) return;
+		if (retries >= maxRetries) {
+			setState("closed");
+			return;
+		}
+		const base = Math.min(bo.max, bo.initial * Math.pow(bo.factor, retries));
+		const delay = bo.jitter ? base / 2 + Math.random() * (base / 2) : base;
+		retries++;
+		setState("connecting");
+		reconnectTimer = setTimeout(connect, delay);
+	}
+	function connect() {
+		if (manualClose || sock) return;
+		if (reconnectTimer) {
+			clearTimeout(reconnectTimer);
+			reconnectTimer = null;
+		}
+		setState("connecting");
+		let s;
+		try {
+			s = new WS(typeof url === "function" ? url() : url, typeof opts.protocols === "function" ? opts.protocols() : opts.protocols);
+		} catch (err) {
+			opts.onError?.(err);
+			scheduleReconnect();
+			return;
+		}
+		sock = s;
+		s.addEventListener("open", () => onOpen());
+		s.addEventListener("message", (ev) => onMessage(String(ev.data)));
+		s.addEventListener("close", () => onClose());
+		s.addEventListener("error", (ev) => opts.onError?.(ev));
+	}
+	function send(frame) {
+		let f = {};
+		try {
+			f = JSON.parse(frame);
+		} catch {}
+		if (typeof f.sub === "string") subs.set(`${f.sub}|${canon(f.params)}`, frame);
+		else if (typeof f.unsub === "string") subs.delete(`${f.unsub}|${canon(f.params)}`);
+		if (typeof f.id === "string" && typeof f.type === "string") openCalls.add(f.id);
+		const isSubCtl = typeof f.sub === "string" || typeof f.unsub === "string";
+		if (state === "open" && sock) {
+			sock.send(frame);
+			return;
+		}
+		connect();
+		if (isSubCtl) return;
+		if (!everConnected || policy === "queue") outbox.push(frame);
+		else if (typeof f.id === "string") deliver(JSON.stringify({
+			id: f.id,
+			$status: DISCONNECTED_STATUS,
+			$code: "DISCONNECTED",
+			$error: "not connected"
+		}));
+	}
+	return {
+		send,
+		onMessage(cb) {
+			messageCb = cb;
+		},
+		connect,
+		close() {
+			manualClose = true;
+			if (reconnectTimer) clearTimeout(reconnectTimer);
+			reconnectTimer = null;
+			clearHeartbeat();
+			failOpenCalls();
+			sock?.close();
+			sock = null;
+			setState("closed");
+		},
+		get state() {
+			return state;
+		}
+	};
+}
+//#endregion
+Object.defineProperty(exports, "ApiError", {
+	enumerable: true,
+	get: function() {
+		return ApiError;
+	}
+});
+Object.defineProperty(exports, "ApiFailure", {
+	enumerable: true,
+	get: function() {
+		return ApiFailure;
+	}
+});
+Object.defineProperty(exports, "CallerRateLimited", {
+	enumerable: true,
+	get: function() {
+		return CallerRateLimited;
+	}
+});
+Object.defineProperty(exports, "buildParts", {
+	enumerable: true,
+	get: function() {
+		return buildParts;
+	}
+});
+Object.defineProperty(exports, "client", {
+	enumerable: true,
+	get: function() {
+		return client;
+	}
+});
+Object.defineProperty(exports, "createCallerContext", {
+	enumerable: true,
+	get: function() {
+		return createCallerContext;
+	}
+});
+Object.defineProperty(exports, "createClientCache", {
+	enumerable: true,
+	get: function() {
+		return createClientCache;
+	}
+});
+Object.defineProperty(exports, "joinPattern", {
+	enumerable: true,
+	get: function() {
+		return joinPattern;
+	}
+});
+Object.defineProperty(exports, "matchParts", {
+	enumerable: true,
+	get: function() {
+		return matchParts;
+	}
+});
+Object.defineProperty(exports, "paramKeys", {
+	enumerable: true,
+	get: function() {
+		return paramKeys;
+	}
+});
+Object.defineProperty(exports, "path", {
+	enumerable: true,
+	get: function() {
+		return path;
+	}
+});
+Object.defineProperty(exports, "reject", {
+	enumerable: true,
+	get: function() {
+		return reject;
+	}
+});
+Object.defineProperty(exports, "splitPattern", {
+	enumerable: true,
+	get: function() {
+		return splitPattern;
+	}
+});
+Object.defineProperty(exports, "stableStringify", {
+	enumerable: true,
+	get: function() {
+		return stableStringify;
+	}
+});
+Object.defineProperty(exports, "wsTransport", {
+	enumerable: true,
+	get: function() {
+		return wsTransport;
+	}
+});