@geode/opengeodeweb-front 10.34.0-rc.9 → 10.34.0

package/{server → .build/server}/utils/app_config.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { unlink } from "node:fs";
+import { unlink } from "node:fs/promises";
 import Conf from "conf";
 import StreamZip from "node-stream-zip";
 import sanitize from "sanitize-filename";
@@ -18,9 +18,7 @@ function targetExtensionFilePath(projectName, filename) {
 	return path.join(confFolderPath(projectName), safeFilename);
 }
 function extensionsConf(projectName) {
-	const projectConfig = projectConf(projectName);
-	if (!projectConfig.has("extensions")) projectConfig.set("extensions", {});
-	return projectConfig.get("extensions");
+	return projectConf(projectName).get("extensions", {});
 }
 function addExtensionToConf(projectName, { extensionId, extensionPath }) {
 	projectConf(projectName).set(`extensions.${extensionId}.path`, extensionPath);
@@ -31,20 +29,23 @@ function extensionPathFromConf(projectName, extensionId) {
 async function removeExtensionFromConf(projectName, extensionId) {
 	const projectConfig = projectConf(projectName);
 	const extensionArchivePath = extensionPathFromConf(projectName, extensionId);
-	await unlink(extensionArchivePath, (error) => {
-		if (error) throw error;
-		console.log(`${extensionArchivePath} was deleted`);
-	});
+	await unlink(extensionArchivePath);
+	console.log(`${extensionArchivePath} was deleted`);
 	projectConfig.delete(`extensions.${extensionId}`);
 	console.log(`${extensionId} was deleted from ${projectName} config`);
 }
+function isExtensionMetadata(value) {
+	return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string";
+}
 async function registerExtensionFile(projectName, file) {
 	const StreamZipAsync = StreamZip.async;
 	const metadataJson = await new StreamZipAsync({
 		file,
 		storeEntries: true
 	}).entryData("metadata.json");
-	const { id } = JSON.parse(metadataJson.toString("utf8"));
+	const parsedMetadata = JSON.parse(metadataJson.toString("utf8"));
+	if (!isExtensionMetadata(parsedMetadata)) throw new TypeError("metadata.json does not match the expected ExtensionMetadata shape");
+	const { id } = parsedMetadata;
 	addExtensionToConf(projectName, {
 		extensionId: id,
 		extensionPath: file

package/{server → .build/server}/utils/cleanup.js

@@ -24,28 +24,35 @@ async function deleteFolderRecursive(folderPath) {
 	}
 	throw new Error(`Failed to delete folder ${folderPath} after ${MAX_DELETE_FOLDER_RETRIES} retries`);
 }
-function killHttpMicroservice(microservice) {
+function isErrorWithMessage(error) {
+	return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
+}
+async function killHttpMicroservice(microservice) {
 	console.log("killHttpMicroservice", { ...microservice });
 	const failMessage = `Failed to kill ${microservice.name}`;
 	async function do_kill() {
+		if (microservice.url === void 0) return;
 		try {
 			await fetch(microservice.url, { method: microservice.method });
 		} catch (error) {
-			console.log(`Expected error during kill of ${microservice.name}:`, error.message);
+			const message = isErrorWithMessage(error) ? error.message : String(error);
+			console.log(`Expected error during kill of ${microservice.name}:`, message);
 		}
 	}
-	return pTimeout(do_kill(), {
+	await pTimeout(do_kill(), {
 		milliseconds: 5e3,
 		message: failMessage
 	});
 }
-function killWebsocketMicroservice(microservice) {
+async function killWebsocketMicroservice(microservice) {
 	console.log("killWebsocketMicroservice", { ...microservice });
 	const failMessage = `Failed to kill ${microservice.name}`;
 	const successMessage = `Disconnected from ${microservice.name} WebSocket server`;
-	function do_kill() {
-		return new Promise((resolve) => {
-			const socket = new WebSocket(microservice.url);
+	async function do_kill() {
+		if (microservice.url === void 0) return;
+		const socketUrl = microservice.url;
+		await new Promise((resolve) => {
+			const socket = new WebSocket(socketUrl);
 			socket.on("open", () => {
 				console.log("Connected to WebSocket server");
 				socket.send(JSON.stringify({
@@ -78,7 +85,7 @@ function killWebsocketMicroservice(microservice) {
 			});
 		});
 	}
-	return pTimeout(do_kill(), {
+	await pTimeout(do_kill(), {
 		milliseconds: 5e3,
 		message: failMessage
 	});
@@ -86,25 +93,31 @@ function killWebsocketMicroservice(microservice) {
 async function killMicroservice(microservice) {
 	if (microservice.type === "back") await killHttpMicroservice(microservice);
 	else if (microservice.type === "viewer") await killWebsocketMicroservice(microservice);
-	else throw new Error(`Unknown microservice type: ${microservice.type}`);
+	else {
+		const exhaustiveCheck = microservice.type;
+		throw new Error(`Unknown microservice type: ${String(exhaustiveCheck)}`);
+	}
 }
 async function killMicroservices(microservices) {
 	console.log("killMicroservices", { microservices });
-	const results = await Promise.allSettled(microservices.map((microservice) => killMicroservice(microservice)));
-	const killed = microservices.filter((_, index) => results[index]?.status === "fulfilled");
-	for (let i = 0; i < killed.length; i += 1) {
-		const microservice = microservices[i];
-		if (microservice) microservices.splice(microservices.indexOf(microservice), 1);
-	}
+	const results = await Promise.allSettled(microservices.map(async (microservice) => {
+		await killMicroservice(microservice);
+	}));
+	return microservices.filter((_, index) => results[index]?.status !== "fulfilled");
 }
 function microservicesMetadatasPath(projectFolderPath) {
 	return path.join(projectFolderPath, "microservices.json");
 }
+function isMicroservicesMetadatas(value) {
+	return typeof value === "object" && value !== null && Array.isArray(value.microservices);
+}
 function projectMicroservices(projectFolderPath) {
 	console.log("projectMicroservices", { projectFolderPath });
 	const filePath = microservicesMetadatasPath(projectFolderPath);
 	if (!fs.existsSync(filePath)) fs.writeFileSync(filePath, JSON.stringify({ microservices: [] }, void 0, 2), "utf8");
-	return JSON.parse(fs.readFileSync(filePath, "utf8")).microservices;
+	const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+	if (!isMicroservicesMetadatas(parsed)) throw new Error(`Invalid microservices metadata file: ${filePath}`);
+	return parsed.microservices;
 }
 async function cleanupBackend(projectFolderPath) {
 	if (!fs.existsSync(projectFolderPath)) {
@@ -115,7 +128,8 @@ async function cleanupBackend(projectFolderPath) {
 	await deleteFolderRecursive(projectFolderPath);
 }
 function getMicroserviceByName(microservices, name) {
-	return microservices.find((microservice) => microservice.name === name);
+	const found = microservices.find((microservice) => microservice.name === name);
+	return found === void 0 ? void 0 : { ...found };
 }
 //#endregion
 export { cleanupBackend, deleteFolderRecursive, getMicroserviceByName, killMicroservice, microservicesMetadatasPath, projectMicroservices };

package/{server → .build/server}/utils/cloud.js

@@ -53,10 +53,7 @@ function requestConfig(parent, image, email, projectName) {
 				timeout: { seconds: 3600 },
 				containers: [{
 					image,
-					ports: [{
-						name: "h2c",
-						containerPort: 80
-					}],
+					ports: [{ containerPort: 80 }],
 					resources,
 					env: [{
 						name: "PARENT",

package/{server → .build/server}/utils/microservices.js

@@ -24,7 +24,9 @@ async function runScript(execPath, execName, args, expectedResponse, timeoutSeco
 		console.log(`[${child.name}] spawned, pid=${child.pid}`);
 	});
 	const controller = new AbortController();
-	const timer = setTimeout(() => controller.abort(), timeoutSeconds * MILLISECONDS_PER_SECOND);
+	const timer = setTimeout(() => {
+		controller.abort();
+	}, timeoutSeconds * MILLISECONDS_PER_SECOND);
 	if (typeof timer.unref === "function") timer.unref();
 	try {
 		const result = await waitForReady(child, expectedResponse, controller.signal);
@@ -42,7 +44,7 @@ function isPortInUseError(error) {
 function backArgs(args, port) {
 	const { projectFolderPath } = args;
 	if (!projectFolderPath) throw new Error("projectFolderPath is required");
-	const uploadFolderPath = args.uploadFolderPath || path.join(projectFolderPath, "uploads");
+	const uploadFolderPath = args.uploadFolderPath !== void 0 && args.uploadFolderPath !== "" ? args.uploadFolderPath : path.join(projectFolderPath, "uploads");
 	const executableArgs = [
 		"--port",
 		String(port),
@@ -55,7 +57,7 @@ function backArgs(args, port) {
 		"--timeout",
 		"0"
 	];
-	if (process.env.NODE_ENV === "development" || !process.env.NODE_ENV) executableArgs.push("--debug");
+	if (process.env.NODE_ENV === void 0 || process.env.NODE_ENV === "development") executableArgs.push("--debug");
 	return executableArgs;
 }
 async function runBack(execName, execPath, args = DEFAULT_RUN_ARGS, attempts = 0) {
@@ -76,6 +78,7 @@ async function runBack(execName, execPath, args = DEFAULT_RUN_ARGS, attempts = 0
 			return await runBack(execName, execPath, args, attempts + 1);
 		}
 	}
+	throw new Error(`runBack failed to run ${execName}`);
 }
 async function runViewer(execName, execPath, args = DEFAULT_RUN_ARGS, attempts = 0) {
 	const { projectFolderPath } = args;
@@ -96,7 +99,7 @@ async function runViewer(execName, execPath, args = DEFAULT_RUN_ARGS, attempts =
 		return port;
 	} catch (error) {
 		if (!isPortInUseError(error)) {
-			console.log("runBack error", error);
+			console.log("runViewer error", error);
 			throw error;
 		}
 		if (attempts <= MAX_PORT_RETRIES) {
@@ -104,6 +107,7 @@ async function runViewer(execName, execPath, args = DEFAULT_RUN_ARGS, attempts =
 			return await runViewer(execName, execPath, args, attempts + 1);
 		}
 	}
+	throw new Error(`runViewer failed to run ${execName}`);
 }
 async function runExtension(extensionId, execName, execPath, args = DEFAULT_RUN_ARGS, attempts = 0) {
 	let port = void 0;
@@ -117,7 +121,7 @@ async function runExtension(extensionId, execName, execPath, args = DEFAULT_RUN_
 		return port;
 	} catch (error) {
 		if (!isPortInUseError(error)) {
-			console.log("runBack error", error);
+			console.log("runExtension error", error);
 			throw error;
 		}
 		if (attempts <= MAX_PORT_RETRIES) {
@@ -125,16 +129,24 @@ async function runExtension(extensionId, execName, execPath, args = DEFAULT_RUN_
 			return await runExtension(extensionId, execName, execPath, args, attempts + 1);
 		}
 	}
+	throw new Error(`runExtension failed to run ${extensionId}`);
 }
 function addMicroserviceMetadatas(projectFolderPath, serviceObj) {
 	const microservices = projectMicroservices(projectFolderPath);
+	let enriched = { ...serviceObj };
 	if (serviceObj.type === "back") {
 		const schema = back_schemas.opengeodeweb_back.kill;
-		serviceObj.url = `http://localhost:${serviceObj.port}/${schema.$id}`;
 		const [method] = schema.methods;
-		serviceObj.method = method;
-	} else if (serviceObj.type === "viewer") serviceObj.url = `ws://localhost:${serviceObj.port}/ws`;
-	microservices.push(serviceObj);
+		enriched = {
+			...enriched,
+			url: `http://localhost:${serviceObj.port}/${schema.$id}`,
+			method
+		};
+	} else if (serviceObj.type === "viewer") enriched = {
+		...enriched,
+		url: `ws://localhost:${serviceObj.port}/ws`
+	};
+	microservices.push(enriched);
 	fs.writeFileSync(microservicesMetadatasPath(projectFolderPath), JSON.stringify({ microservices }, void 0, 2));
 }
 //#endregion

package/{server → .build/server}/utils/path.js

@@ -40,11 +40,11 @@ function executablePath(execPath, execName) {
 		return osExecutableName;
 	}
 	const foundAtExecPath = findExecutableInDir(execPath, execName, osExecutableName);
-	if (foundAtExecPath) return foundAtExecPath;
+	if (foundAtExecPath !== void 0 && foundAtExecPath !== "") return foundAtExecPath;
 	if (mode === appMode.DESKTOP && nodeEnv === "production") {
-		if (resourcesPath) {
+		if (resourcesPath !== void 0 && resourcesPath !== "") {
 			const foundInResources = findExecutableInDir(resourcesPath, execName, osExecutableName);
-			if (foundInResources) return foundInResources;
+			if (foundInResources !== void 0 && foundInResources !== "") return foundInResources;
 		}
 		throw new Error(`Executable not found in execPath (${execPath}) or resourcesPath (${resourcesPath}): ${osExecutableName}`);
 	}
@@ -94,7 +94,7 @@ async function extensionFrontendPath(unzippedExtensionPath, frontendFile, rootPa
 		extensionId
 	});
 	const localFilePath = await lookForLocalExtensionDistPath(rootPath, extensionId.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("-"), frontendFile);
-	if (localFilePath) return localFilePath;
+	if (localFilePath !== void 0 && localFilePath !== "") return localFilePath;
 	const unzippedfrontendFilePath = path.join(unzippedExtensionPath, frontendFile);
 	if (fs.existsSync(unzippedfrontendFilePath)) return unzippedfrontendFilePath;
 	throw new Error(`Failed to find ${unzippedfrontendFilePath}`);

package/{server → .build/server}/utils/scripts.js

@@ -8,14 +8,14 @@ import readline from "node:readline";
 import { getPort } from "get-port-please";
 //#region server/utils/scripts.ts
 const MAX_ERROR_BUFFER_BYTES = 65536;
-function getAvailablePort() {
-	return getPort({
+async function getAvailablePort() {
+	return await getPort({
 		host: "localhost",
 		random: true
 	});
 }
 function commandExistsSync(execName) {
-	return (process.env.PATH || "").split(path.delimiter).some((directory) => {
+	return (process.env.PATH ?? "").split(path.delimiter).some((directory) => {
 		const filePath = path.join(directory, execName);
 		return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
 	});
@@ -24,7 +24,7 @@ const encoder = new TextEncoder();
 function byteLength(str) {
 	return encoder.encode(str).byteLength;
 }
-function waitForReady(child, expectedResponse, signal) {
+async function waitForReady(child, expectedResponse, signal) {
 	return new Promise((resolve, reject) => {
 		const readlineStdout = readline.createInterface({ input: child.stdout });
 		const readlineStderr = readline.createInterface({ input: child.stderr });
@@ -104,15 +104,15 @@ async function waitNuxt(nuxtProcess) {
 		console.log(`Nuxt process closed with code ${code}`);
 	});
 	for await (const [data] of on(nuxtProcess.stdout, "data")) {
-		const output = data.toString();
+		const output = String(data);
 		console.log("Nuxt STDOUT:", output.trim());
-		const portMatch = output.match(/Listening on http:\/\/\[::\]:(?<port>\d+)/u);
-		if (portMatch?.groups) {
-			console.log("Nuxt listening on port", portMatch.groups.port);
+		const port = /Listening on http:\/\/\[::\]:(?<port>\d+)/u.exec(output)?.groups?.port;
+		if (port !== void 0) {
+			console.log("Nuxt listening on port", port);
 			nuxtProcess.stdout.on("data", (newData) => {
 				console.log("Nuxt STDOUT:", newData.toString().trim());
 			});
-			return portMatch.groups.port;
+			return port;
 		}
 	}
 	throw new Error("Nuxt process closed");

package/.build/server/utils/server_config.js

@@ -0,0 +1,51 @@
+import { createServerWsRpcClient } from "./ws_client.js";
+//#region server/utils/server_config.ts
+const stringStorage = /* @__PURE__ */ new Map();
+const booleanStorage = /* @__PURE__ */ new Map();
+const clientStorage = /* @__PURE__ */ new Map();
+function getAppBaseUrl() {
+	const value = stringStorage.get("APP_BASE_URL");
+	if (value === void 0) throw new Error("APP_BASE_URL is not set");
+	return value;
+}
+function setAppBaseUrl(baseUrl) {
+	stringStorage.set("APP_BASE_URL", baseUrl);
+}
+function getBackBaseUrl() {
+	const value = stringStorage.get("BACK_BASE_URL");
+	if (value === void 0) throw new Error("BACK_BASE_URL is not set");
+	return value;
+}
+function setBackBaseUrl(baseUrl) {
+	stringStorage.set("BACK_BASE_URL", baseUrl);
+}
+function getViewerBaseUrl() {
+	const value = stringStorage.get("VIEWER_BASE_URL");
+	if (value === void 0) throw new Error("VIEWER_BASE_URL is not set");
+	return value;
+}
+function setViewerBaseUrl(baseUrl) {
+	stringStorage.set("VIEWER_BASE_URL", baseUrl);
+}
+function getIsAppReady() {
+	return booleanStorage.get("IS_APP_READY") ?? false;
+}
+function setIsAppReady(isAppReady) {
+	booleanStorage.set("IS_APP_READY", isAppReady);
+}
+async function setViewerWebSocketClient(baseUrl) {
+	const client = createServerWsRpcClient(baseUrl);
+	client.onConnectionClose(() => {
+		if (clientStorage.get("VIEWER_CLIENT") === client) clientStorage.delete("VIEWER_CLIENT");
+	});
+	await client.ready;
+	clientStorage.set("VIEWER_CLIENT", client);
+	return client;
+}
+async function getViewerWebSocketClient() {
+	const viewerClient = clientStorage.get("VIEWER_CLIENT");
+	if (viewerClient !== void 0 && viewerClient.isOpen()) return viewerClient;
+	return await setViewerWebSocketClient(getViewerBaseUrl());
+}
+//#endregion
+export { getAppBaseUrl, getBackBaseUrl, getIsAppReady, getViewerBaseUrl, getViewerWebSocketClient, setAppBaseUrl, setBackBaseUrl, setIsAppReady, setViewerBaseUrl, setViewerWebSocketClient };

package/.build/server/utils/stream.js

@@ -0,0 +1,6 @@
+//#region server/utils/stream.ts
+function toNodeWebStream(stream) {
+	return stream;
+}
+//#endregion
+export { toNodeWebStream };

package/{server → .build/server}/utils/ws_client.js

@@ -3,6 +3,14 @@ import { v4 } from "uuid";
 //#region server/utils/ws_client.ts
 const HELLO_ID = "system:hello";
 const HELLO_SECRET = "wslink-secret";
+function isWsRpcMessage(value) {
+	return typeof value === "object" && value !== null;
+}
+function rawDataToString(raw) {
+	if (Buffer.isBuffer(raw)) return raw.toString();
+	if (Array.isArray(raw)) return Buffer.concat(raw).toString();
+	return Buffer.from(raw).toString();
+}
 function createServerWsRpcClient(baseUrl) {
 	const socket = new WebSocket(baseUrl);
 	const pending = /* @__PURE__ */ new Map();
@@ -17,10 +25,11 @@ function createServerWsRpcClient(baseUrl) {
 			}));
 		});
 		socket.on("message", (raw) => {
-			console.log("RAW WS MESSAGE:", raw.toString());
 			let message = void 0;
 			try {
-				message = JSON.parse(raw.toString());
+				const parsed = JSON.parse(rawDataToString(raw));
+				if (!isWsRpcMessage(parsed)) return;
+				message = parsed;
 			} catch {
 				return;
 			}
@@ -32,7 +41,7 @@ function createServerWsRpcClient(baseUrl) {
 			const entry = message.id === void 0 ? void 0 : pending.get(message.id);
 			if (!entry || message.id === void 0) return;
 			pending.delete(message.id);
-			if (message.error) entry.reject(new Error(message.error.message || "wslink RPC error"));
+			if (message.error) entry.reject(new Error(message.error.message ?? "wslink RPC error"));
 			else entry.resolve(message.result);
 		});
 		socket.on("error", (error) => {
@@ -65,6 +74,11 @@ function createServerWsRpcClient(baseUrl) {
 	function close() {
 		socket.close();
 	}
+	function getConnection() {
+		return { getSession: () => ({ call: async (rpc, [params]) => {
+			return await call(rpc, params);
+		} }) };
+	}
 	function isOpen() {
 		return socket.readyState === WebSocket.OPEN;
 	}
@@ -77,6 +91,7 @@ function createServerWsRpcClient(baseUrl) {
 	return {
 		call,
 		close,
+		getConnection,
 		isOpen,
 		onConnectionClose,
 		onConnectionError,

package/{shared → .build/shared}/scripts.js

@@ -1,46 +1,46 @@
 import { fetchSchema } from "./utils/fetch_schema.js";
 import { api } from "../opengeodeweb_front_schemas.js";
 //#region shared/scripts.ts
-function setAppBaseUrl(appBaseUrl) {
+async function setAppBaseUrl(appBaseUrl) {
 	console.log("[API] setAppBaseUrl", appBaseUrl);
 	const schema = api.microservice.app.set_app_base_url;
-	return fetchSchema({
+	return await fetchSchema({
 		schema,
 		params: { baseUrl: appBaseUrl },
 		baseURL: appBaseUrl
 	});
 }
-function setBackBaseUrl(appBaseUrl, backBaseUrl) {
+async function setBackBaseUrl(appBaseUrl, backBaseUrl) {
 	console.log("[API] setBackBaseUrl", appBaseUrl, backBaseUrl);
 	const schema = api.microservice.app.set_back_base_url;
-	return fetchSchema({
+	return await fetchSchema({
 		schema,
 		params: { baseUrl: backBaseUrl },
 		baseURL: appBaseUrl
 	});
 }
-function setViewerBaseUrl(appBaseUrl, viewerBaseUrl) {
+async function setViewerBaseUrl(appBaseUrl, viewerBaseUrl) {
 	console.log("[API] setViewerBaseUrl", appBaseUrl, viewerBaseUrl);
 	const schema = api.microservice.app.set_viewer_base_url;
-	return fetchSchema({
+	return await fetchSchema({
 		schema,
 		params: { baseUrl: viewerBaseUrl },
 		baseURL: appBaseUrl
 	});
 }
-function setIsAppReady(appBaseUrl, isReady) {
+async function setIsAppReady(appBaseUrl, isReady) {
 	console.log("[API] setIsAppReady", isReady);
 	const schema = api.microservice.app.set_is_app_ready;
-	return fetchSchema({
+	return await fetchSchema({
 		schema,
 		params: { isReady },
 		baseURL: appBaseUrl
 	});
 }
-function getIsAppReady(appBaseUrl) {
+async function getIsAppReady(appBaseUrl) {
 	console.log("[API] getIsAppReady");
 	const schema = api.microservice.app.get_is_app_ready;
-	return fetchSchema({
+	return await fetchSchema({
 		schema,
 		baseURL: appBaseUrl
 	});

package/.build/shared/utils/call_raw.js

@@ -0,0 +1,31 @@
+import pTimeout from "p-timeout";
+import "lodash";
+//#region shared/utils/call_raw.ts
+async function callClient({ rpc, params = {}, client }) {
+	if (globalThis.window !== void 0) return await client.getConnection().getSession().call(rpc, [params]);
+	return await client.call(rpc, params);
+}
+async function callRaw({ rpc, params = {}, client, timeout }, { request_error_function, response_function, response_error_function } = {}) {
+	async function performCall() {
+		try {
+			const response = await callClient({
+				rpc,
+				params,
+				client
+			});
+			if (response_function) await response_function(response);
+			return response;
+		} catch (error) {
+			if (request_error_function) await request_error_function(error);
+			if (response_error_function) await response_error_function(error);
+			throw error;
+		}
+	}
+	if (timeout !== void 0 && timeout > 0) return await pTimeout(performCall(), {
+		milliseconds: timeout,
+		message: `${rpc}: Timed out after ${timeout}ms`
+	});
+	return await performCall();
+}
+//#endregion
+export { callRaw };

package/{shared → .build/shared}/utils/call_schema.js

@@ -2,7 +2,7 @@ import { validateSchema } from "./validate_schema.js";
 import { callRaw } from "./call_raw.js";
 //#region shared/utils/call_schema.ts
 const ERROR_400 = 400;
-function callSchema({ schema, params = {}, client, timeout }, { request_error_function, response_function, response_error_function, validation_error_function } = {}) {
+async function callSchema({ schema, params = {}, client, timeout }, { request_error_function, response_function, response_error_function, validation_error_function } = {}) {
 	const { valid, error: schema_error } = validateSchema(schema, params);
 	if (!valid) {
 		if (process.env.NODE_ENV !== "production") console.log("Bad request", schema_error, schema, params);
@@ -13,7 +13,7 @@ function callSchema({ schema, params = {}, client, timeout }, { request_error_fu
 		});
 		throw new Error(`${schema.$id}: ${schema_error}`);
 	}
-	return callRaw({
+	return await callRaw({
 		rpc: schema.$id,
 		params,
 		client,

package/.build/shared/utils/fetch_raw.js

@@ -0,0 +1,52 @@
+import { hasBody } from "./file.js";
+import pTimeout from "p-timeout";
+import { $fetch } from "ofetch";
+import _ from "lodash";
+//#region shared/utils/fetch_raw.ts
+function resolveHeaders(headers, expectEvent) {
+	const resolvedHeaders = { ...headers };
+	if (expectEvent) {
+		const value = "text/event-stream";
+		if (_.isEmpty(resolvedHeaders)) resolvedHeaders.Accept = value;
+		else resolvedHeaders.Accept = `${resolvedHeaders.Accept}, ${value}`;
+	}
+	return resolvedHeaders;
+}
+async function performFetch({ route, method, params, baseURL, headers, max_retry, request_error_function, response_function, response_error_function }) {
+	return await $fetch(route, {
+		baseURL,
+		method,
+		headers,
+		...hasBody(params) ? { body: params } : {},
+		...max_retry === void 0 ? {} : { retry: max_retry },
+		async onRequestError({ error }) {
+			if (request_error_function) await request_error_function(error);
+		},
+		async onResponse({ response }) {
+			if (response.ok && response_function) await response_function(response._data);
+		},
+		async onResponseError({ response }) {
+			if (response_error_function) await response_error_function(response);
+		}
+	});
+}
+async function fetchRaw({ route, method, params = {}, baseURL, headers = {}, max_retry, timeout, expectEvent = false }, { request_error_function, response_function, response_error_function } = {}) {
+	const fetchOptions = {
+		route,
+		method,
+		params,
+		baseURL,
+		headers: resolveHeaders(headers, expectEvent),
+		max_retry,
+		request_error_function,
+		response_function,
+		response_error_function
+	};
+	if (timeout !== void 0 && timeout > 0) return await pTimeout(performFetch(fetchOptions), {
+		milliseconds: timeout,
+		message: `${route}: Timed out after ${timeout}ms`
+	});
+	return await performFetch(fetchOptions);
+}
+//#endregion
+export { fetchRaw };

package/{shared → .build/shared}/utils/fetch_schema.js

@@ -2,7 +2,7 @@ import { fetchRaw } from "./fetch_raw.js";
 import { validateSchema } from "./validate_schema.js";
 //#region shared/utils/fetch_schema.ts
 const ERROR_400 = 400;
-function fetchSchema({ schema, params = {}, baseURL, headers, timeout, expectEvent = false }, { request_error_function, response_function, response_error_function, validation_error_function } = {}) {
+async function fetchSchema({ schema, params = {}, baseURL, headers, timeout, expectEvent = false }, { request_error_function, response_function, response_error_function, validation_error_function } = {}) {
 	const { valid, error: schema_error } = validateSchema(schema, params);
 	if (!valid) {
 		if (process.env.NODE_ENV !== "production") console.log("Bad request", schema_error, schema, params);
@@ -13,7 +13,7 @@ function fetchSchema({ schema, params = {}, baseURL, headers, timeout, expectEve
 		});
 		throw new Error(`${schema.$id}: ${schema_error}`);
 	}
-	return fetchRaw({
+	return await fetchRaw({
 		route: schema.$id,
 		method: schema.methods.find((method) => method !== "OPTIONS"),
 		params,

package/{shared → .build/shared}/utils/file.js

@@ -1,5 +1,7 @@
 import _ from "lodash";
 //#region shared/utils/file.ts
+const BYTES_PER_KIBIBYTE = 1024;
+const CHUNK_SIZE_BYTES = 8192 * BYTES_PER_KIBIBYTE;
 function assertFile(file) {
 	console.log("[ASSERT_FILE] Asserting file", { file });
 	if (!(file instanceof File)) throw new Error("file must be an instance of File");
@@ -9,4 +11,4 @@ function hasBody(params) {
 	return !_.isEmpty(params);
 }
 //#endregion
-export { assertFile, hasBody };
+export { BYTES_PER_KIBIBYTE, CHUNK_SIZE_BYTES, assertFile, hasBody };