ignotum 0.0.7 → 0.0.9

package/dist/runtime/client.js

@@ -1,12 +1,109 @@
-import { a as InvocationId, c as SubscriptionId, i as IdAlphabet, l as TableId, n as DeploymentId, r as GeneratedId, s as RuntimeRequestNonce, t as AppId } from "./id-D570vudg.js";
-import { d as failureFromWire, f as inspectResult, l as Result$1, o as PaginationPageSize, p as pending, t as ValueDescriptor, v as decodeTransportValue, y as encodeTransportObject } from "./descriptor-t6BOEGw9-C1rwYIlx.js";
-import { a as FunctionAddress, c as ServerMessageJson, d as WireSuccess, f as AppStateRevision, i as DeploymentChangedCloseCode, l as WireFailure, m as InvocationKey, n as functionPathOf, o as Operation, p as DeploymentGeneration, r as ClientMessageJson, s as ProtocolErrorCode, u as WireResult } from "./api-DtX8qPrq.js";
+import { C as RuntimeRequestNonce, T as TableId, _ as AppId, a as RuntimeFileMetadata, b as IdAlphabet, c as fileFormats, d as fileLimits, f as fileMimeTypes, h as makeFileValue, l as fileGrantUrlOf, m as isFileValue, o as RuntimeFileOccurrence, p as grantFileValue, r as FileId, u as fileIdOf, v as DeploymentId, w as SubscriptionId, x as InvocationId, y as GeneratedId } from "./file-C1abuMgd.js";
+import { b as decodeTransportValue, c as upgrade, d as Result$1, h as pending, m as inspectResult, o as PaginationPageSize, p as failureFromWire, s as initial, t as ValueDescriptor, x as encodeTransportObject } from "./descriptor-C5VA9qRl-BKbdenuU.js";
+import { a as ErrorCode, c as ServerMessageJson, d as WireSuccess, f as AppStateRevision, i as DeploymentCloseCode, l as WireFailure, m as InvocationKey, n as functionPathOf, o as FunctionAddress, p as DeploymentGeneration, r as ClientMessageJson, s as Operation, u as WireResult } from "./api-DzcR7spt.js";
 import { Array as Array$1, Cause, Context, Deferred, Duration, Effect, ErrorReporter, Fiber, HashMap, Layer, ManagedRuntime, Predicate, Schedule, Schema, String } from "effect";
+import { customAlphabet } from "nanoid";
 import { useCallback, useCallback as useCallback$1, useContext, useDebugValue, useDebugValue as useDebugValue$1, useEffect, useEffect as useEffect$1, useErrorBoundary, useId, useImperativeHandle, useLayoutEffect, useMemo, useMemo as useMemo$1, useReducer, useRef, useState, useState as useState$1 } from "preact/hooks";
 import * as Socket from "effect/unstable/socket/Socket";
 import * as BrowserCrypto from "@effect/platform-browser/BrowserCrypto";
-import { customAlphabet } from "nanoid";
 import { Component, Fragment, cloneElement, createContext, createElement, createRef, h, isValidElement, toChildArray } from "preact";
+//#region ../shared/dist/id.js
+const decodeGenerated = (definition, payload) => Schema.decodeSync(definition)(definition.idPrefix === void 0 ? payload : `${definition.idPrefix}_${payload}`);
+var IdGenerator = class IdGenerator extends Context.Service()("@ignotum/shared/id/IdGenerator") {
+	static layer = Layer.sync(IdGenerator, () => {
+		const generatePayload = customAlphabet(IdAlphabet, 24);
+		return IdGenerator.of({ generate: (definition) => Effect.sync(() => decodeGenerated(definition, generatePayload())) });
+	});
+	static deterministic = (startAt = 1) => Layer.sync(IdGenerator, () => {
+		const counters = /* @__PURE__ */ new Map();
+		return IdGenerator.of({ generate: (definition) => Effect.sync(() => {
+			const counter = (counters.get(definition.idPrefix) ?? startAt - 1) + 1;
+			counters.set(definition.idPrefix, counter);
+			return decodeGenerated(definition, counter.toString(36).padStart(24, "0"));
+		}) });
+	});
+};
+//#endregion
+//#region src/client/files.ts
+const Files = { url: (file) => {
+	const url = fileGrantUrlOf(file);
+	if (url === void 0) throw new Error("This FileValue has no active query grant.");
+	return url;
+} };
+const formatByMime = {};
+for (const format of fileFormats) formatByMime[fileMimeTypes[format]] = format;
+const collectNativeFiles = (value, files) => {
+	if (value instanceof File) {
+		files.push(value);
+		return;
+	}
+	if (isFileValue(value) || Predicate.isDate(value)) return;
+	if (globalThis.Array.isArray(value)) {
+		for (const child of value) collectNativeFiles(child, files);
+		return;
+	}
+	if (!Predicate.isObject(value)) return;
+	for (const child of Object.values(value)) collectNativeFiles(child, files);
+};
+const replaceNativeFiles = (value, replacements) => {
+	if (value instanceof File) return replacements.get(value);
+	if (isFileValue(value) || Predicate.isDate(value)) return value;
+	if (globalThis.Array.isArray(value)) return value.map((child) => replaceNativeFiles(child, replacements));
+	if (!Predicate.isObject(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, replaceNativeFiles(child, replacements)]));
+};
+const prepareMutationArguments = Effect.fn("SyncClient.prepareMutationArguments")(function* (input) {
+	const ids = yield* IdGenerator;
+	const native = [];
+	collectNativeFiles(input, native);
+	const unique = new Set(native);
+	if (unique.size > fileLimits.filesPerMutation) throw new Error(`A mutation may upload at most ${fileLimits.filesPerMutation} files.`);
+	if ([...unique].reduce((total, file) => total + file.size, 0) > fileLimits.mutationBytes) throw new Error(`Mutation uploads may total at most ${fileLimits.mutationBytes} bytes.`);
+	const replacements = /* @__PURE__ */ new Map();
+	const nativeFiles = /* @__PURE__ */ new Map();
+	for (const file of unique) {
+		const format = formatByMime[file.type.toLowerCase()];
+		if (format === void 0) throw new Error(`File '${file.name}' has unsupported media type '${file.type || "unknown"}'.`);
+		if (file.size === 0 || file.size > fileLimits.fileBytes) throw new Error(`File '${file.name}' must be between 1 and ${fileLimits.fileBytes} bytes.`);
+		if (new TextEncoder().encode(file.name).byteLength > fileLimits.filenameBytes) throw new Error(`File '${file.name}' has a filename that is too long.`);
+		const id = yield* ids.generate(FileId);
+		replacements.set(file, makeFileValue(id, {
+			format,
+			name: file.name,
+			size: file.size
+		}));
+		nativeFiles.set(id, file);
+	}
+	return {
+		value: replaceNativeFiles(input, replacements),
+		nativeFiles,
+		fileIds: Array.from(nativeFiles.keys())
+	};
+});
+const applyFileGrants = (value, grants) => {
+	const byId = /* @__PURE__ */ new Map();
+	for (const grant of grants) {
+		if (byId.has(grant.id)) throw new Error("A query file grant ID is duplicated.");
+		byId.set(grant.id, grant.url);
+	}
+	const matched = /* @__PURE__ */ new Set();
+	const visit = (current) => {
+		if (isFileValue(current)) {
+			const id = fileIdOf(current);
+			const url = byId.get(id);
+			if (url === void 0) return current;
+			matched.add(id);
+			return grantFileValue(current, url);
+		}
+		if (globalThis.Array.isArray(current)) return current.map(visit);
+		if (!Predicate.isObject(current) || Predicate.isDate(current)) return current;
+		return Object.fromEntries(Object.entries(current).map(([key, child]) => [key, visit(child)]));
+	};
+	const granted = visit(value);
+	if (matched.size !== byId.size) throw new Error("A query file grant has no result value.");
+	return granted;
+};
+//#endregion
 //#region ../contracts/dist/json.js
 const encodeScalar = (value) => Schema.decodeSync(Schema.String)(JSON.stringify(value));
 const encodeCanonicalJson = (value) => {
@@ -37,8 +134,8 @@ var InvalidServerMessage = class extends Schema.TaggedError()("InvalidServerMess
 	cause: Schema.Defect(),
 	message: Schema.String
 }) {};
-var ServerProtocolError = class extends Schema.TaggedError()("ServerProtocolError", {
-	code: ProtocolErrorCode,
+var ServerError = class extends Schema.TaggedError()("ServerError", {
+	code: ErrorCode,
 	message: Schema.String,
 	operation: Schema.optional(Operation)
 }) {};
@@ -47,7 +144,7 @@ const ClientInfrastructureError = Schema.Union([
 	InvalidClientMessage,
 	InvalidMutationArguments,
 	InvalidServerMessage,
-	ServerProtocolError
+	ServerError
 ]);
 const browserErrorReporter = ErrorReporter.make(({ attributes, error }) => {
 	globalThis.console.error("Ignotum infrastructure error", error, attributes);
@@ -114,13 +211,41 @@ const RuntimeQueryResult = Schema.Struct({
 	type: Schema.Literal("Query"),
 	result: WireResult,
 	dependencies: DependencySet,
-	observedRevision: AppStateRevision
+	observedRevision: AppStateRevision,
+	files: Schema.optional(Schema.Array(RuntimeFileOccurrence))
+});
+const FileReferenceAdded = Schema.Struct({
+	type: Schema.Literal("AddReference"),
+	file: RuntimeFileMetadata,
+	tableId: TableId,
+	documentId: GeneratedId
+});
+const FileReferenceRemoved = Schema.Struct({
+	type: Schema.Literal("RemoveReference"),
+	fileId: FileId,
+	tableId: TableId,
+	documentId: GeneratedId
+});
+const FileReferenceEffect = Schema.Union([FileReferenceAdded, FileReferenceRemoved]);
+const FileEffectBatch = Schema.Struct({
+	id: InvocationId,
+	committedRevision: AppStateRevision,
+	effects: Schema.Array(FileReferenceEffect)
+});
+Schema.Struct({ appId: AppId });
+Schema.Struct({ batches: Schema.Array(FileEffectBatch) });
+Schema.Struct({
+	appId: AppId,
+	invocationId: InvocationId,
+	acknowledgedAt: Schema.Int
 });
+Schema.Struct({ completed: Schema.Literal(true) });
 const RuntimeMutationSuccess = Schema.Struct({
 	type: Schema.Literal("Mutation"),
 	result: WireSuccess,
 	invalidations: InvalidationSet,
-	committedRevision: AppStateRevision
+	committedRevision: AppStateRevision,
+	fileEffects: Schema.optional(FileEffectBatch)
 });
 const RuntimeMutationFailure = Schema.Struct({
 	type: Schema.Literal("Mutation"),
@@ -143,7 +268,8 @@ const QueryInvocation = Schema.Struct({
 const MutationInvocation = Schema.Struct({
 	...InvocationBase,
 	type: Schema.Literal("Mutation"),
-	invocationId: InvocationId
+	invocationId: InvocationId,
+	files: Schema.optional(Schema.Array(RuntimeFileOccurrence))
 });
 Schema.Union([QueryInvocation, MutationInvocation]);
 Schema.Struct({
@@ -182,23 +308,6 @@ Schema.Union([
 	RuntimeInvocationUnavailable
 ]);
 //#endregion
-//#region ../shared/dist/id.js
-const decodeGenerated = (definition, payload) => Schema.decodeSync(definition)(definition.idPrefix === void 0 ? payload : `${definition.idPrefix}_${payload}`);
-var IdGenerator = class IdGenerator extends Context.Service()("@ignotum/shared/id/IdGenerator") {
-	static layer = Layer.sync(IdGenerator, () => {
-		const generatePayload = customAlphabet(IdAlphabet, 24);
-		return IdGenerator.of({ generate: (definition) => Effect.sync(() => decodeGenerated(definition, generatePayload())) });
-	});
-	static deterministic = (startAt = 1) => Layer.sync(IdGenerator, () => {
-		const counters = /* @__PURE__ */ new Map();
-		return IdGenerator.of({ generate: (definition) => Effect.sync(() => {
-			const counter = (counters.get(definition.idPrefix) ?? startAt - 1) + 1;
-			counters.set(definition.idPrefix, counter);
-			return decodeGenerated(definition, counter.toString(36).padStart(24, "0"));
-		}) });
-	});
-};
-//#endregion
 //#region ../contracts/dist/runtime/functions.js
 const FunctionKind = Schema.Literals(["Mutation", "Query"]);
 Schema.TaggedError()("UnknownFunction", {
@@ -253,24 +362,27 @@ const ClientRoute = Schema.Struct({
 	pathname: ClientPath,
 	artifact: ArtifactReference
 });
-Schema.Struct({
+const DeploymentInventoryV1 = Schema.Struct({
 	formatVersion: Schema.Literal(1),
 	files: Schema.Array(ArtifactFile)
 });
-Schema.Struct({
+initial(DeploymentInventoryV1);
+const ClientManifestV1 = Schema.Struct({
 	formatVersion: Schema.Literal(1),
 	shell: ArtifactReference,
 	routes: Schema.Array(ClientRoute)
 });
+initial(ClientManifestV1);
 const ClientRoutingRoute = Schema.Struct({
 	pathname: ClientPath,
 	artifact: ArtifactPath
 });
-Schema.Struct({
+const ClientRoutingV1 = Schema.Struct({
 	formatVersion: Schema.Literal(1),
 	shell: ArtifactPath,
 	routes: Schema.Array(ClientRoutingRoute)
 });
+initial(ClientRoutingV1);
 const SchemaSnapshotField = Schema.Struct({
 	name: Schema.String,
 	value: ValueDescriptor
@@ -279,26 +391,60 @@ const SchemaSnapshotIndex = Schema.Struct({
 	name: Schema.String,
 	fields: Schema.Array(Schema.String)
 });
+const SchemaSnapshotTableV1 = Schema.Struct({
+	name: Schema.String,
+	fields: Schema.Array(SchemaSnapshotField)
+});
+const SchemaSnapshotV1 = Schema.Struct({
+	formatVersion: Schema.Literal(1),
+	tables: Schema.Array(SchemaSnapshotTableV1)
+});
 const SchemaSnapshotTable = Schema.Struct({
 	name: Schema.String,
 	fields: Schema.Array(SchemaSnapshotField),
 	indexes: Schema.Array(SchemaSnapshotIndex)
 });
-Schema.Struct({
+const SchemaSnapshotV2 = Schema.Struct({
 	formatVersion: Schema.Literal(2),
 	tables: Schema.Array(SchemaSnapshotTable)
 });
+upgrade(initial(SchemaSnapshotV1), SchemaSnapshotV2, (snapshot) => ({
+	formatVersion: 2,
+	tables: snapshot.tables.map((table) => ({
+		...table,
+		indexes: []
+	}))
+}));
+const ServerFunctionArtifactV1 = Schema.Struct({
+	address: FunctionAddress,
+	kind: FunctionKind,
+	bundle: ArtifactReference,
+	sourceMap: ArtifactReference
+});
 const ServerFunctionArtifact = Schema.Struct({
 	address: FunctionAddress,
 	kind: FunctionKind,
+	args: Schema.optional(ValueDescriptor),
+	returns: Schema.optional(ValueDescriptor),
+	errors: Schema.optional(ValueDescriptor),
 	bundle: ArtifactReference,
 	sourceMap: ArtifactReference
 });
-Schema.Struct({
+const ServerBuildManifestV1 = Schema.Struct({
 	formatVersion: Schema.Literal(1),
 	schema: ArtifactReference,
+	functions: Schema.Array(ServerFunctionArtifactV1)
+});
+const ServerBuildManifestV2 = Schema.Struct({
+	formatVersion: Schema.Literal(2),
+	schema: ArtifactReference,
 	functions: Schema.Array(ServerFunctionArtifact)
 });
+upgrade(initial(ServerBuildManifestV1), ServerBuildManifestV2, (manifest) => ({
+	formatVersion: 2,
+	schema: manifest.schema,
+	functions: manifest.functions
+}));
 ArtifactPath.make("inventory.json");
 ArtifactPath.make("client/manifest.json");
 ArtifactPath.make("client/shell.html");
@@ -312,12 +458,16 @@ const runtimeInvocationPath = "/v1/invoke";
 const runtimeRevisionPath = "/v1/revision";
 const runtimeIndexPreparePath = "/v1/indexes/prepare";
 const runtimeIndexCommitPath = "/v1/indexes/commit";
+const runtimeFileEffectsPath = "/v1/files/effects";
+const runtimeFileEffectsAcknowledgePath = "/v1/files/effects/acknowledge";
 const appSyncPath = `/_ignotum/v1/sync`;
 const RuntimeRequestPath = Schema.Literals([
 	runtimeInvocationPath,
 	runtimeRevisionPath,
 	runtimeIndexPreparePath,
-	runtimeIndexCommitPath
+	runtimeIndexCommitPath,
+	runtimeFileEffectsPath,
+	runtimeFileEffectsAcknowledgePath
 ]);
 const RuntimeRequestTimestamp = Schema.FiniteFromString.pipe(Schema.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0)), Schema.brand("ignotum/runtime/RequestTimestamp"));
 const RuntimeRequestSignature = Sha256.pipe(Schema.brand("ignotum/runtime/RequestSignature"));
@@ -440,8 +590,8 @@ const makeQueryCache = (allocateId, sendLifecycleMessage) => {
 		}
 	};
 };
-const resultFromWire = Effect.fn("SyncClient.resultFromWire")((wire) => Effect.succeed(wire.type === "Success" ? Result$1.succeed(wire.value === void 0 ? void 0 : decodeTransportValue(wire.value, wire.dates ?? [])) : failureFromWire(wire.error, wire.dates)));
-const shouldReloadForCloseCode = (code) => code === DeploymentChangedCloseCode;
+const resultFromWire = Effect.fn("SyncClient.resultFromWire")((wire, files = []) => Effect.succeed(wire.type === "Success" ? Result$1.succeed(wire.value === void 0 ? void 0 : applyFileGrants(decodeTransportValue(wire.value, wire.dates ?? []), files)) : failureFromWire(wire.error, wire.dates)));
+const shouldReloadForCloseCode = (code) => code === DeploymentCloseCode;
 const handshakesMatch = (first, next) => first.appId === next.appId && first.deploymentId === next.deploymentId && first.generation === next.generation;
 const handshakeDecision = (remembered, acceptedOnConnection, next) => {
 	if (remembered !== void 0 && !handshakesMatch(remembered, next)) return "Reload";
@@ -484,14 +634,19 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 			const pendingInvocation = HashMap.getUnsafe(invocations, id);
 			if (pendingInvocation === void 0) return Effect.void;
 			invocations = HashMap.remove(invocations, id);
-			return reportClientError(error).pipe(Effect.andThen(Deferred.fail(pendingInvocation.deferred, error)), Effect.asVoid);
+			return reportClientError(error).pipe(Effect.andThen(Deferred.fail(pendingInvocation.prepared, error)), Effect.andThen(Deferred.fail(pendingInvocation.deferred, error)), Effect.asVoid);
 		};
 		const handleMessage = Effect.fn("SyncClient.handleMessage")(function* (message) {
 			switch (message.type) {
 				case "Snapshot":
 					if (queryCache.getById(message.id) === void 0) return;
-					yield* resultFromWire(message.result).pipe(Effect.tap((result) => Effect.sync(() => queryCache.setResult(message.id, result, message.revision))));
+					yield* resultFromWire(message.result, message.files ?? []).pipe(Effect.tap((result) => Effect.sync(() => queryCache.setResult(message.id, result, message.revision))));
 					return;
+				case "Preparation": {
+					const pendingInvocation = HashMap.getUnsafe(invocations, message.id);
+					if (pendingInvocation !== void 0) yield* Deferred.succeed(pendingInvocation.prepared, message.uploads);
+					return;
+				}
 				case "Result": {
 					const pendingInvocation = HashMap.getUnsafe(invocations, message.id);
 					if (pendingInvocation === void 0) return;
@@ -499,11 +654,11 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 					yield* resultFromWire(message.result).pipe(Effect.flatMap((result) => Deferred.succeed(pendingInvocation.deferred, result)));
 					return;
 				}
-				case "ProtocolError": {
-					const error = message.operation === void 0 ? ServerProtocolError.make({
+				case "Error": {
+					const error = message.operation === void 0 ? ServerError.make({
 						code: message.code,
 						message: message.message
-					}) : ServerProtocolError.make({
+					}) : ServerError.make({
 						code: message.code,
 						message: message.message,
 						operation: message.operation
@@ -557,7 +712,7 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 					message: "The server returned an invalid sync message."
 				})));
 				if (message.type === "Handshake") return yield* acceptHandshake(message);
-				if (message.type === "DeploymentChanged") {
+				if (message.type === "Deployment") {
 					requestReload();
 					return;
 				}
@@ -581,24 +736,103 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 		});
 		const mutate = Effect.fn("SyncClient.mutate")(function* (functionAddress, args) {
 			const invocationId = yield* ids.generate(InvocationId);
+			const preparedArguments = yield* prepareMutationArguments(args).pipe(Effect.provideService(IdGenerator, ids), Effect.mapError((cause) => InvalidMutationArguments.make({
+				cause,
+				function: functionAddress,
+				message: `Mutation arguments for ${functionAddress} contain an unsupported file or value.`
+			})), Effect.tapError(reportClientError));
+			const jsonArgs = yield* Effect.try({
+				try: () => encodeTransportObject(preparedArguments.value),
+				catch: (cause) => InvalidMutationArguments.make({
+					cause,
+					function: functionAddress,
+					message: `Mutation arguments for ${functionAddress} contain an unsupported value.`
+				})
+			}).pipe(Effect.tapError(reportClientError));
 			const deferred = yield* Deferred.make();
-			const message = {
+			const prepared = yield* Deferred.make();
+			const invokeMessage = {
 				type: "Invoke",
 				id: invocationId,
 				kind: "Mutation",
 				function: functionAddress,
-				args
+				args: jsonArgs
+			};
+			const message = preparedArguments.fileIds.length === 0 ? invokeMessage : {
+				type: "Prepare",
+				id: invocationId,
+				kind: "Mutation",
+				function: functionAddress,
+				args: jsonArgs,
+				files: preparedArguments.fileIds
 			};
 			invocations = HashMap.set(invocations, invocationId, {
 				deferred,
 				function: functionAddress,
-				message
+				message,
+				prepared
 			});
-			if (writer !== void 0) yield* sendWith(writer, message).pipe(Effect.catchTags({
-				ConnectionUnavailable: reportClientError,
-				InvalidClientMessage: (error) => rejectInvocation(invocationId, error)
-			}));
-			return yield* Deferred.await(deferred);
+			return yield* Effect.gen(function* () {
+				if (writer !== void 0) yield* sendWith(writer, message).pipe(Effect.catchTags({
+					ConnectionUnavailable: reportClientError,
+					InvalidClientMessage: (error) => rejectInvocation(invocationId, error)
+				}));
+				if (message.type === "Prepare") {
+					const uploads = yield* Deferred.await(prepared);
+					const expected = new Set(message.files);
+					const received = /* @__PURE__ */ new Set();
+					for (const upload of uploads) {
+						if (!expected.has(upload.id) || received.has(upload.id)) return yield* InvalidServerMessage.make({
+							cause: /* @__PURE__ */ new Error(`Unexpected prepared file '${upload.id}'.`),
+							message: "The server returned invalid application file preparation data."
+						});
+						received.add(upload.id);
+						const file = preparedArguments.nativeFiles.get(upload.id);
+						if (file === void 0) return yield* InvalidServerMessage.make({
+							cause: /* @__PURE__ */ new Error(`Missing native file '${upload.id}'.`),
+							message: "The server prepared an unknown application file."
+						});
+						if (upload.url === void 0) continue;
+						const uploadUrl = upload.url;
+						const response = yield* Effect.tryPromise({
+							try: () => fetch(uploadUrl, {
+								method: "PUT",
+								body: file,
+								headers: { "content-type": file.type }
+							}),
+							catch: (cause) => ConnectionUnavailable.make({
+								cause,
+								message: `File '${file.name}' could not be uploaded.`
+							})
+						});
+						if (!response.ok) {
+							const detail = yield* Effect.promise(() => response.text());
+							return yield* InvalidMutationArguments.make({
+								cause: new Error(detail),
+								function: functionAddress,
+								message: `File '${file.name}' was rejected by application storage.`
+							});
+						}
+					}
+					if (received.size !== expected.size) return yield* InvalidServerMessage.make({
+						cause: /* @__PURE__ */ new Error("The server omitted a prepared file."),
+						message: "The server returned incomplete application file preparation data."
+					});
+					const pendingInvocation = HashMap.getUnsafe(invocations, invocationId);
+					if (pendingInvocation === void 0) return yield* Deferred.await(deferred);
+					invocations = HashMap.set(invocations, invocationId, {
+						...pendingInvocation,
+						message: invokeMessage
+					});
+					if (writer !== void 0) yield* sendWith(writer, invokeMessage).pipe(Effect.catchTags({
+						ConnectionUnavailable: reportClientError,
+						InvalidClientMessage: (error) => rejectInvocation(invocationId, error)
+					}));
+				}
+				return yield* Deferred.await(deferred);
+			}).pipe(Effect.tapError(() => Effect.sync(() => {
+				invocations = HashMap.remove(invocations, invocationId);
+			})));
 		});
 		return SyncClient.of({
 			mutate,
@@ -801,16 +1035,7 @@ const useMutation = (reference) => useMemo$1(() => {
 		const functionPath = functionPathOf(reference);
 		const input = args === void 0 ? {} : args;
 		return syncRuntime.runPromise(Effect.gen(function* () {
-			const client = yield* SyncClient;
-			const jsonArgs = yield* Effect.try({
-				try: () => encodeTransportObject(input),
-				catch: (cause) => InvalidMutationArguments.make({
-					cause,
-					function: functionPath,
-					message: `Mutation arguments for ${functionPath} contain an unsupported value.`
-				})
-			}).pipe(Effect.tapError(reportClientError));
-			return yield* client.mutate(functionPath, jsonArgs);
+			return yield* (yield* SyncClient).mutate(functionPath, input);
 		}));
 	};
 	return mutate;
@@ -825,6 +1050,6 @@ const app = (definition) => {
 //#region src/client/index.ts
 const Result = { match: Result$1.match };
 //#endregion
-export { Component, Fragment, Query, Result, app, cloneElement, createContext, createElement, createRef, h, isValidElement, toChildArray, useCallback, useContext, useDebugValue, useEffect, useErrorBoundary, useId, useImperativeHandle, useLayoutEffect, useMemo, useMutation, usePaginatedQuery, useQuery, useReducer, useRef, useState };
+export { Component, Files, Fragment, Query, Result, app, cloneElement, createContext, createElement, createRef, h, isValidElement, toChildArray, useCallback, useContext, useDebugValue, useEffect, useErrorBoundary, useId, useImperativeHandle, useLayoutEffect, useMemo, useMutation, usePaginatedQuery, useQuery, useReducer, useRef, useState };
 
 //# sourceMappingURL=client.js.map