@camera.ui/transport 0.0.29 → 0.1.0

package/dist/signal.d.ts

@@ -8,6 +8,7 @@ export type ConnectionSignal = {
 } | {
     readonly kind: 'degraded';
     readonly channels: readonly TransportId[];
+    readonly reason?: 'first-connect';
 } | {
     readonly kind: 'offline';
     readonly retryAt?: number;
@@ -18,6 +19,7 @@ export interface ConnectionSignalOptions {
     readonly kernel: Kernel;
     readonly transports: readonly Transport[];
     readonly debounceMs?: number;
+    readonly firstConnectTimeoutMs?: number;
 }
 export interface ConnectionSignalHandle {
     readonly current: ConnectionSignal;

package/dist/testing/fakeTransport.d.ts

@@ -8,6 +8,7 @@ export declare class FakeTransport implements Transport {
     readonly spec: TransportSpec;
     readonly applyCalls: (ConnectionTarget | null)[];
     failNextApplies: number;
+    failWith: unknown;
     ensureAliveCalls: number;
     private readonly emitter;
     private readonly applyDelayMs;
@@ -22,6 +23,6 @@ export declare class FakeTransport implements Transport {
     dispose(): Promise<void>;
     emitDown(reason: string): void;
     emitUp(): void;
-    emitAuthError(status?: number): void;
+    emitAuthError(status?: number, access?: string): void;
     get target(): ConnectionTarget | null;
 }

package/dist/testing.js

@@ -4,6 +4,7 @@ var FakeTransport = class {
 	spec;
 	applyCalls = [];
 	failNextApplies = 0;
+	failWith;
 	ensureAliveCalls = 0;
 	emitter = new TransportEmitter();
 	applyDelayMs;
@@ -24,7 +25,7 @@ var FakeTransport = class {
 				up: false,
 				lastError: "apply failed"
 			};
-			throw new Error("apply failed");
+			throw this.failWith ?? /* @__PURE__ */ new Error("apply failed");
 		}
 		this.currentTarget = target;
 		this.currentStatus = target ? { up: true } : { up: false };
@@ -56,8 +57,11 @@ var FakeTransport = class {
 		this.currentStatus = { up: true };
 		this.emitter.emit("up", void 0);
 	}
-	emitAuthError(status) {
-		this.emitter.emit("auth-error", { status });
+	emitAuthError(status, access) {
+		this.emitter.emit("auth-error", access === void 0 ? { status } : {
+			status,
+			access
+		});
 	}
 	get target() {
 		return this.currentTarget;

package/dist/transports/closeCodes.d.ts

@@ -4,5 +4,7 @@ export interface CloseLike {
     readonly wsCloseCode?: number;
     readonly message?: string;
     readonly reason?: string;
+    readonly data?: unknown;
 }
 export declare function classifyClose(input: CloseLike | string): CloseClass;
+export declare function refusedByServer(input: unknown): boolean;

package/dist/transports/contract.d.ts

@@ -5,6 +5,8 @@ export type TransportEventPayload<E extends TransportEvent> = E extends 'down' ?
 } : E extends 'auth-error' ? {
     readonly status?: number;
     readonly message?: string;
+    readonly access?: string;
+    readonly holdFor?: (refresh: Promise<boolean>) => void;
 } : void;
 export type TransportEventHandler<E extends TransportEvent> = (payload: TransportEventPayload<E>) => void;
 export type Unsubscribe = () => void;

package/dist/transports/http.d.ts

@@ -7,6 +7,7 @@ export interface HttpTransportOptions {
     readonly apiPrefix?: string;
     readonly timeoutMs?: number;
     readonly targetWaitMs?: number;
+    readonly authRetryWaitMs?: number;
     readonly spec?: Partial<TransportSpec>;
     readonly authorize?: HttpAuthorizer;
     readonly logger?: Logger;

package/dist/transports/http.js

@@ -6,6 +6,11 @@ var HTTP_SPEC = {
 	kind: "request",
 	phaseGating: false
 };
+var TOKEN_REJECTED_MESSAGES = /* @__PURE__ */ new Set([
+	"Unauthorized",
+	"Token expired",
+	"Token revoked"
+]);
 function createHttpTransport(options = {}) {
 	const spec = {
 		...HTTP_SPEC,
@@ -13,12 +18,14 @@ function createHttpTransport(options = {}) {
 	};
 	const apiPrefix = options.apiPrefix ?? "/api";
 	const targetWaitMs = options.targetWaitMs ?? 15e3;
+	const authRetryWaitMs = options.authRetryWaitMs ?? 1e4;
 	const logger = options.logger;
 	const emitter = new TransportEmitter();
 	let currentTarget = null;
 	let status = { up: false };
 	let disposed = false;
 	const targetWaiters = /* @__PURE__ */ new Set();
+	const accessWaiters = /* @__PURE__ */ new Set();
 	const client = axios.create({ timeout: options.timeoutMs ?? 3e4 });
 	function waitForTarget(signal) {
 		if (currentTarget) return Promise.resolve();
@@ -52,14 +59,50 @@ function createHttpTransport(options = {}) {
 		if (!currentTarget) return;
 		for (const waiter of [...targetWaiters]) waiter.resolve();
 	}
+	function waitForNewAccess(staleAccess, signal, refresh) {
+		if (currentTarget && currentTarget.tokens.access !== staleAccess) return Promise.resolve(true);
+		return new Promise((resolve, reject) => {
+			const waiter = {
+				staleAccess,
+				resolve: (fresh) => {
+					cleanup();
+					resolve(fresh);
+				},
+				reject: (reason) => {
+					cleanup();
+					reject(reason);
+				}
+			};
+			const timer = setTimeout(() => waiter.reject(/* @__PURE__ */ new Error("http-transport: token refresh timed out")), authRetryWaitMs);
+			const onAbort = () => waiter.reject(new axios.Cancel("http-transport: aborted"));
+			function cleanup() {
+				clearTimeout(timer);
+				accessWaiters.delete(waiter);
+				signal?.removeEventListener?.("abort", onAbort);
+			}
+			if (signal?.aborted) {
+				waiter.reject(new axios.Cancel("http-transport: aborted"));
+				return;
+			}
+			signal?.addEventListener?.("abort", onAbort);
+			accessWaiters.add(waiter);
+			refresh?.then((coming) => {
+				if (!coming) waiter.resolve(false);
+			});
+		});
+	}
+	function flushAccessWaiters() {
+		for (const waiter of [...accessWaiters]) if (!currentTarget) waiter.reject(new axios.Cancel("http-transport: no target"));
+		else if (currentTarget.tokens.access !== waiter.staleAccess) waiter.resolve(true);
+	}
 	client.interceptors.request.use(async (config) => {
 		if (!currentTarget) await waitForTarget(config.signal);
 		const target = currentTarget;
 		if (!target) throw new axios.Cancel("http-transport: no target");
+		config._sentAccess = target.tokens.access;
 		if (!config.baseURL) config.baseURL = `${target.endpoint.url}${apiPrefix}`;
 		if (options.authorize) await options.authorize(config, target);
 		else config.headers.set("Authorization", `Bearer ${target.tokens.access}`);
-		if (target.tokens.proxySession) config.headers.set("X-Proxy-Session", target.tokens.proxySession);
 		return config;
 	});
 	client.interceptors.response.use((response) => {
@@ -69,7 +112,7 @@ function createHttpTransport(options = {}) {
 			emitter.emit("up", void 0);
 		}
 		return response;
-	}, (error) => {
+	}, async (error) => {
 		if (axios.isCancel(error)) return Promise.reject(error);
 		if (!error.response) {
 			markDown(error.message ?? "network");
@@ -77,13 +120,34 @@ function createHttpTransport(options = {}) {
 		}
 		if (error.response.status === 401) {
 			logger?.debug(`auth-error 401 (${error.config?.url ?? "unknown-url"})`);
+			const refreshes = [];
+			const config = error.config;
+			const message = extractMessage(error);
+			const tokenRejected = !options.authorize && message !== void 0 && TOKEN_REJECTED_MESSAGES.has(message);
 			emitter.emit("auth-error", {
 				status: 401,
-				message: extractMessage(error)
+				message,
+				access: tokenRejected ? config?._sentAccess : void 0,
+				holdFor: (refresh) => refreshes.push(refresh)
 			});
+			if (config?._sentAccess && !config._authRetried && !disposed) {
+				config._authRetried = true;
+				if (!await shouldRetryAuth(config._sentAccess, refreshes, config.signal)) return Promise.reject(error);
+				logger?.debug(`retry after 401 (${config.url ?? "unknown-url"})`);
+				return client(config);
+			}
 		}
 		return Promise.reject(error);
 	});
+	async function shouldRetryAuth(sentAccess, refreshes, signal) {
+		if (refreshes.length === 0 && options.authorize) return true;
+		const refresh = refreshes.length > 0 ? Promise.all(refreshes).then((results) => results.some(Boolean), () => false) : void 0;
+		try {
+			return await waitForNewAccess(sentAccess, signal, refresh) || Boolean(options.authorize);
+		} catch {
+			return false;
+		}
+	}
 	function markDown(reason) {
 		if (status.up || status.lastError !== reason) {
 			status = {
@@ -102,10 +166,12 @@ function createHttpTransport(options = {}) {
 		if (!target) {
 			status = { up: false };
 			emitter.emit("down", { reason: "detached" });
+			flushAccessWaiters();
 			return;
 		}
 		if (endpointChanged) status = { up: false };
 		flushTargetWaiters();
+		flushAccessWaiters();
 	}
 	function health() {
 		return status;
@@ -118,6 +184,7 @@ function createHttpTransport(options = {}) {
 		currentTarget = null;
 		status = { up: false };
 		for (const waiter of [...targetWaiters]) waiter.reject(new axios.Cancel("http-transport: disposed"));
+		for (const waiter of [...accessWaiters]) waiter.reject(new axios.Cancel("http-transport: disposed"));
 		emitter.clear();
 	}
 	return {

package/dist/transports/nativeHttp.d.ts

@@ -6,6 +6,7 @@ export interface NativeHttpRequestInit {
     headers: Record<string, string>;
     params?: Record<string, string>;
     data?: unknown;
+    dataType?: 'file' | 'formData';
     responseType: NativeResponseType;
     connectTimeout?: number;
     readTimeout?: number;
@@ -24,10 +25,11 @@ export interface NativeHttpBinding {
 export declare function isAbsoluteURL(url: string): boolean;
 export declare function buildFullUrl(config: InternalAxiosRequestConfig): string;
 export declare function isPublicFqdnUrl(url: string): boolean;
-export declare function shouldUseNativeHttp(config: InternalAxiosRequestConfig): boolean;
+export declare function shouldUseNativeHttp(config: InternalAxiosRequestConfig, exclude?: (url: string) => boolean): boolean;
 export declare function createNativeHttpAdapter(binding: NativeHttpBinding): AxiosAdapter;
 export declare function applyNativeHttp(client: AxiosInstance, opts: {
     enabled: boolean;
+    exclude?: (url: string) => boolean;
 } & NativeHttpBinding): void;
 export declare function normalizeBody(config: InternalAxiosRequestConfig): unknown;
 export declare function mapResponseType(type?: ResponseType): NativeResponseType;

package/dist/transports/nativeHttp.js

@@ -1,5 +1,6 @@
 import axios, { AxiosError, AxiosHeaders, CanceledError } from "axios";
 //#region src/transports/nativeHttp.ts
+var BASE64_CHUNK = 24576;
 function isAbsoluteURL(url) {
 	return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
 }
@@ -21,37 +22,44 @@ function isPublicFqdnUrl(url) {
 	if (/^\d{1,3}(?:\.\d{1,3}){3}$/.test(host)) return false;
 	return host.includes(".");
 }
-function shouldUseNativeHttp(config) {
-	return !config.withCredentials && isPublicFqdnUrl(buildFullUrl(config));
+function shouldUseNativeHttp(config, exclude) {
+	if (config.withCredentials) return false;
+	const url = buildFullUrl(config);
+	return isPublicFqdnUrl(url) && !exclude?.(url);
 }
 function createNativeHttpAdapter(binding) {
 	return async (config) => {
 		throwIfAborted(config.signal);
 		const headers = flattenHeaders(config.headers);
 		if (binding.extraHeaders) Object.assign(headers, binding.extraHeaders);
+		const body = await encodeBody(config, headers);
+		throwIfAborted(config.signal);
+		if (body.contentType) setContentType(headers, body.contentType);
 		const timeout = typeof config.timeout === "number" && config.timeout > 0 ? config.timeout : void 0;
 		const pending = binding.request({
 			url: buildFullUrl(config),
 			method: (config.method ?? "get").toUpperCase(),
 			headers,
 			params: normalizeParams(config.params),
-			data: normalizeBody(config),
+			data: body.data,
+			dataType: body.dataType,
 			responseType: mapResponseType(config.responseType),
 			connectTimeout: timeout,
 			readTimeout: timeout
 		});
 		let res;
 		try {
-			res = await raceAbort(pending, config.signal);
+			res = await raceNative(pending, config, timeout);
 		} catch (err) {
-			if (err instanceof CanceledError) throw err;
+			if (err instanceof AxiosError) throw err;
 			throw new AxiosError(err instanceof Error ? err.message : "Network Error", AxiosError.ERR_NETWORK, config, pending);
 		}
+		const responseHeaders = AxiosHeaders.from(res.headers ?? {});
 		const response = {
-			data: res.data,
+			data: decodeBinaryResponse(res.data, config.responseType, String(responseHeaders.get("Content-Type") ?? "")),
 			status: res.status,
 			statusText: "",
-			headers: AxiosHeaders.from(res.headers ?? {}),
+			headers: responseHeaders,
 			config,
 			request: pending
 		};
@@ -63,18 +71,30 @@ function applyNativeHttp(client, opts) {
 	if (!opts.enabled) return;
 	const fallback = axios.getAdapter(client.defaults.adapter ?? axios.defaults.adapter);
 	const native = createNativeHttpAdapter(opts);
-	client.defaults.adapter = (config) => shouldUseNativeHttp(config) ? native(config) : fallback(config);
+	client.defaults.adapter = (config) => shouldUseNativeHttp(config, opts.exclude) ? native(config) : fallback(config);
 }
 function throwIfAborted(signal) {
 	if (signal?.aborted) throw new CanceledError("canceled");
 }
-function raceAbort(pending, signal) {
-	if (!signal || typeof signal.addEventListener !== "function") return pending;
-	if (signal.aborted) return Promise.reject(new CanceledError("canceled"));
+function raceNative(pending, config, timeout) {
+	const signal = config.signal;
+	const abortable = !!signal && typeof signal.addEventListener === "function";
+	if (!abortable && !timeout) return pending;
+	if (signal?.aborted) return Promise.reject(new CanceledError("canceled"));
 	return new Promise((resolve, reject) => {
-		const onAbort = () => reject(new CanceledError("canceled"));
-		signal.addEventListener("abort", onAbort, { once: true });
-		const cleanup = () => signal.removeEventListener?.("abort", onAbort);
+		const onAbort = () => {
+			cleanup();
+			reject(new CanceledError("canceled"));
+		};
+		const timer = timeout ? setTimeout(() => {
+			cleanup();
+			reject(timeoutError(config, timeout, pending));
+		}, timeout) : void 0;
+		if (abortable) signal.addEventListener("abort", onAbort, { once: true });
+		function cleanup() {
+			clearTimeout(timer);
+			signal?.removeEventListener?.("abort", onAbort);
+		}
 		pending.then((value) => {
 			cleanup();
 			resolve(value);
@@ -84,6 +104,10 @@ function raceAbort(pending, signal) {
 		});
 	});
 }
+function timeoutError(config, timeout, request) {
+	const code = config.transitional?.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED;
+	return new AxiosError(config.timeoutErrorMessage || `timeout of ${timeout}ms exceeded`, code, config, request);
+}
 function flattenHeaders(headers) {
 	const out = {};
 	if (!headers) return out;
@@ -109,6 +133,86 @@ function normalizeBody(config) {
 	} catch {}
 	return data;
 }
+async function encodeBody(config, headers) {
+	const data = config.data;
+	if (data instanceof FormData) return {
+		data: await encodeFormData(data),
+		dataType: "formData",
+		contentType: "multipart/form-data"
+	};
+	const bytes = await binaryOf(data);
+	if (!bytes) return { data: normalizeBody(config) };
+	const explicit = headerValue(headers, "Content-Type");
+	const contentType = explicit && !explicit.includes("application/x-www-form-urlencoded") ? explicit : data instanceof Blob && data.type || "application/octet-stream";
+	return {
+		data: bytesToBase64(bytes),
+		dataType: "file",
+		contentType
+	};
+}
+async function encodeFormData(form) {
+	const pairs = [];
+	form.forEach((value, key) => pairs.push([key, value]));
+	const entries = [];
+	for (const [key, value] of pairs) {
+		if (typeof value === "string") {
+			entries.push({
+				key,
+				value,
+				type: "string"
+			});
+			continue;
+		}
+		entries.push({
+			key,
+			value: bytesToBase64(new Uint8Array(await value.arrayBuffer())),
+			type: "base64File",
+			fileName: value.name || "blob",
+			contentType: value.type || "application/octet-stream"
+		});
+	}
+	return entries;
+}
+async function binaryOf(data) {
+	if (data instanceof Blob) return new Uint8Array(await data.arrayBuffer());
+	if (data instanceof ArrayBuffer) return new Uint8Array(data);
+	if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+	return null;
+}
+function headerValue(headers, name) {
+	const wanted = name.toLowerCase();
+	for (const key of Object.keys(headers)) if (key.toLowerCase() === wanted) return headers[key];
+}
+function setContentType(headers, value) {
+	for (const key of Object.keys(headers)) if (key.toLowerCase() === "content-type") delete headers[key];
+	headers["Content-Type"] = value;
+}
+function decodeBinaryResponse(data, type, contentType) {
+	if (type !== "arraybuffer" && type !== "blob" || typeof data !== "string" || contentType.includes("application/json")) return data;
+	if (/[ \t\f]/.test(data)) return data;
+	let bytes;
+	try {
+		bytes = base64ToBytes(data);
+	} catch {
+		return data;
+	}
+	return type === "blob" ? new Blob([bytes], { type: contentType }) : bytes.buffer;
+}
+function bytesToBase64(bytes) {
+	const native = bytes.toBase64;
+	if (typeof native === "function") return native.call(bytes);
+	let out = "";
+	for (let i = 0; i < bytes.length; i += BASE64_CHUNK) out += btoa(String.fromCharCode.apply(null, bytes.subarray(i, i + BASE64_CHUNK)));
+	return out;
+}
+function base64ToBytes(text) {
+	const native = Uint8Array.fromBase64;
+	if (typeof native === "function") return native(text);
+	const binary = atob(text);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
 function mapResponseType(type) {
 	switch (type) {
 		case "blob": return "blob";