@graftland/plugin-remote 0.3.1 → 0.3.3

package/src/internal/host.ts

@@ -46,121 +46,118 @@ const race = <A, E, R>(
 	effect: Effect.Effect<A, E, R>,
 ) => Effect.raceFirst(effect, connection.transport.failure)
 
-const forwardEvents = <E extends ErrorSchema>(
+const forwardEvents = Effect.fnUntraced(function* <E extends ErrorSchema>(
 	contract: Contract<E>,
 	client: Client<E>,
 	connection: Connection["Service"],
-) =>
-	Effect.gen(function* () {
-		const stopped = yield* Deferred.make<void>()
-		const remoteFailure = yield* FailureGroup.make<
-			| E["Type"]
-			| ContractModule.UndeclaredFailure
-			| ChildFailure
-			| RemoteWithdrawn
-		>()
-		const events = yield* race(
-			connection,
-			client.Events().pipe(
-				Stream.runForEach((event) => {
-					switch (event._tag) {
-						case "Stopped":
-							return Deferred.succeed(stopped, undefined)
-						case "Withdrawing":
-							return remoteFailure.fail(RemoteWithdrawn.make({}))
-						case "Failed":
-							return contract
-								.decodeCause(event.cause)
-								.pipe(Effect.flatMap((cause) => remoteFailure.failCause(cause)))
-					}
-				}),
-			),
-		).pipe(
-			Effect.tapCause(connection.transport.report),
-			Effect.forkIn(connection.resources),
-		)
-		return { stopped, remoteFailure, events }
-	})
-const forwardLogs = <E extends ErrorSchema>(
+) {
+	const stopped = yield* Deferred.make<void>()
+	const remoteFailure = yield* FailureGroup.make<
+		| E["Type"]
+		| ContractModule.UndeclaredFailure
+		| ChildFailure
+		| RemoteWithdrawn
+	>()
+	const events = yield* race(
+		connection,
+		client.Events().pipe(
+			Stream.runForEach((event) => {
+				switch (event._tag) {
+					case "Stopped":
+						return Deferred.succeed(stopped, undefined)
+					case "Withdrawing":
+						return remoteFailure.fail(RemoteWithdrawn.make({}))
+					case "Failed":
+						return contract
+							.decodeCause(event.cause)
+							.pipe(Effect.flatMap((cause) => remoteFailure.failCause(cause)))
+				}
+			}),
+		),
+	).pipe(
+		Effect.tapCause(connection.transport.report),
+		Effect.forkIn(connection.resources),
+	)
+	return { stopped, remoteFailure, events }
+})
+const forwardLogs = Effect.fnUntraced(function* <E extends ErrorSchema>(
 	contract: Contract<E>,
 	client: Client<E>,
 	connection: Connection["Service"],
-) =>
-	Effect.gen(function* () {
-		const logsEnded = yield* Deferred.make<void>()
-		const reportedDrops = yield* Ref.make(0)
-		yield* race(
-			connection,
-			client.Logs().pipe(
-				Stream.runForEach((event) =>
-					Effect.gen(function* () {
-						const previous = yield* Ref.getAndSet(reportedDrops, event.dropped)
-						if (event.dropped > previous)
-							yield* Effect.logWarning("Remote logs were dropped").pipe(
-								Effect.annotateLogs({
-									...(Option.isSome(connection.pid)
-										? { "remote.pid": connection.pid.value }
-										: {}),
-									"remote.logs.dropped": event.dropped - previous,
-									"remote.logs.droppedTotal": event.dropped,
-								}),
-							)
-						if (event._tag === "LogsEnded") {
-							yield* Deferred.succeed(logsEnded, undefined)
-							return
-						}
-						const entry = event.entry
-						const cause = yield* contract.decodeCause(entry.cause)
-						yield* Effect.logWithLevel(
-							entry.level === "All" || entry.level === "None"
-								? "Info"
-								: entry.level,
-						)(
-							...(Array.isArray(entry.message)
-								? entry.message
-								: [entry.message]),
-							cause,
-						).pipe(
+) {
+	const logsEnded = yield* Deferred.make<void>()
+	const reportedDrops = yield* Ref.make(0)
+	yield* race(
+		connection,
+		client.Logs().pipe(
+			Stream.runForEach(
+				Effect.fnUntraced(function* (event) {
+					const previous = yield* Ref.getAndSet(reportedDrops, event.dropped)
+					if (event.dropped > previous)
+						yield* Effect.logWarning("Remote logs were dropped").pipe(
 							Effect.annotateLogs({
 								...(Option.isSome(connection.pid)
 									? { "remote.pid": connection.pid.value }
 									: {}),
-								...(connection.threadId === undefined
-									? {}
-									: { "remote.threadId": connection.threadId }),
-								"remote.annotations": entry.annotations,
+								"remote.logs.dropped": event.dropped - previous,
+								"remote.logs.droppedTotal": event.dropped,
 							}),
 						)
-					}),
-				),
-			),
-		).pipe(
-			Effect.tapCause(connection.transport.report),
-			Effect.forkIn(connection.resources),
-		)
-		return logsEnded
-	})
-export const initialize = <E extends ErrorSchema>(contract: Contract<E>) =>
-	Effect.gen(function* () {
-		const connection = yield* Connection
-		const client = yield* RpcClient.make(contract.control).pipe(
-			Effect.provideService(
-				RpcClient.Protocol,
-				connection.transport.clientProtocol(Control.endpoint),
+					if (event._tag === "LogsEnded") {
+						yield* Deferred.succeed(logsEnded, undefined)
+						return
+					}
+					const entry = event.entry
+					const cause = yield* contract.decodeCause(entry.cause)
+					yield* Effect.logWithLevel(
+						entry.level === "All" || entry.level === "None"
+							? "Info"
+							: entry.level,
+					)(
+						...(Array.isArray(entry.message) ? entry.message : [entry.message]),
+						cause,
+					).pipe(
+						Effect.annotateLogs({
+							...(Option.isSome(connection.pid)
+								? { "remote.pid": connection.pid.value }
+								: {}),
+							...(connection.threadId === undefined
+								? {}
+								: { "remote.threadId": connection.threadId }),
+							"remote.annotations": entry.annotations,
+						}),
+					)
+				}),
 			),
-			Scope.provide(connection.resources),
-		)
-		for (const service of contract.inject)
-			yield* service
-				.serve(connection.transport)
-				.pipe(
-					Effect.tapCause(connection.transport.report),
-					Effect.forkIn(connection.resources),
-				)
-		const events = yield* forwardEvents(contract, client, connection)
-		const logsEnded = yield* forwardLogs(contract, client, connection)
-		return { connection, client, ...events, logsEnded }
-	})
+		),
+	).pipe(
+		Effect.tapCause(connection.transport.report),
+		Effect.forkIn(connection.resources),
+	)
+	return logsEnded
+})
+export const initialize = Effect.fnUntraced(function* <E extends ErrorSchema>(
+	contract: Contract<E>,
+) {
+	const connection = yield* Connection
+	const client = yield* RpcClient.make(contract.control).pipe(
+		Effect.provideService(
+			RpcClient.Protocol,
+			connection.transport.clientProtocol(Control.endpoint),
+		),
+		Scope.provide(connection.resources),
+	)
+	for (const service of contract.inject)
+		yield* service
+			.serve(connection.transport)
+			.pipe(
+				Effect.tapCause(connection.transport.report),
+				Effect.forkIn(connection.resources),
+			)
+	const events = yield* forwardEvents(contract, client, connection)
+	const logsEnded = yield* forwardLogs(contract, client, connection)
+	return { connection, client, ...events, logsEnded }
+})
 type Active<E extends ErrorSchema> = Effect.Success<
 	ReturnType<typeof initialize<E>>
 >
@@ -186,21 +183,20 @@ export const load = <E extends ErrorSchema>(
 			active.remoteFailure.await,
 		),
 	)
-export const dispose = <E extends ErrorSchema>(active: Active<E>) =>
-	Effect.gen(function* () {
-		const result = yield* race(
-			active.connection,
-			active.client
-				.Dispose()
-				.pipe(Effect.catchIf(Cause.isCause, Effect.succeed)),
-		)
-		const cause = Cause.isCause(result) ? result : Cause.empty
-		// A remote cleanup failure still permits the bounded event and log tail to drain.
-		yield* race(
-			active.connection,
-			Deferred.await(active.stopped).pipe(
-				Effect.andThen(Deferred.await(active.logsEnded)),
-			),
-		).pipe(Effect.onError(() => Effect.failCause(cleanupCause(cause))))
-		return cause
-	})
+export const dispose = Effect.fnUntraced(function* <E extends ErrorSchema>(
+	active: Active<E>,
+) {
+	const result = yield* race(
+		active.connection,
+		active.client.Dispose().pipe(Effect.catchIf(Cause.isCause, Effect.succeed)),
+	)
+	const cause = Cause.isCause(result) ? result : Cause.empty
+	// A remote cleanup failure still permits the bounded event and log tail to drain.
+	yield* race(
+		active.connection,
+		Deferred.await(active.stopped).pipe(
+			Effect.andThen(Deferred.await(active.logsEnded)),
+		),
+	).pipe(Effect.onError(() => Effect.failCause(cleanupCause(cause))))
+	return cause
+})

package/src/internal/port.ts

@@ -167,64 +167,66 @@ interface State {
 	readonly servers: HashMap.HashMap<string, ServerEndpoint>
 	readonly clients: HashMap.HashMap<string, ClientEndpoint>
 }
-const initialize = (bytes: Channel, options: Options) =>
-	Effect.gen(function* (): Effect.gen.Return<State, never, Scope.Scope> {
-		const limits = { ...defaults, ...options.limits }
-		const workers = yield* FailureGroup.make<TransportError>()
-		const incoming = yield* TxRef.make(
-			HashMap.empty<RequestKey, RequestState<RpcMessage.FromClientEncoded>>(),
-		)
-		const outgoing = yield* TxRef.make(
-			HashMap.empty<RequestKey, RequestState<RpcMessage.FromServerEncoded>>(),
-		)
-		const queues = {
-			control: yield* TxQueue.unbounded<Pending, Cause.Done>(),
-			data: yield* TxQueue.unbounded<Pending, Cause.Done>(),
-			log: yield* TxQueue.unbounded<Pending, Cause.Done>(),
-		}
-		const servers = yield* Effect.forEach(
-			Record.toEntries(options.serve),
-			Effect.fnUntraced(function* ([name, group]) {
-				return [
-					name,
-					{
-						group,
-						ready:
-							yield* Deferred.make<
-								Parameters<RpcServer.Protocol["Service"]["run"]>[0]
-							>(),
-						disconnects: yield* Queue.dropping<number>(1),
-					},
-				] satisfies readonly [string, unknown]
-			}),
-		).pipe(Effect.map(HashMap.fromIterable))
-		const clients = yield* Effect.forEach(
-			Record.toEntries(options.call),
-			Effect.fnUntraced(function* ([name, group]) {
-				return [
-					name,
-					{
-						group,
-						ready:
-							yield* Deferred.make<
-								Parameters<RpcClient.Protocol["Service"]["run"]>[1]
-							>(),
-					},
-				] satisfies readonly [string, unknown]
-			}),
-		).pipe(Effect.map(HashMap.fromIterable))
-		return {
-			bytes,
-			options,
-			limits,
-			workers,
-			incoming,
-			outgoing,
-			queues,
-			servers,
-			clients,
-		}
-	})
+const initialize = Effect.fnUntraced(function* (
+	bytes: Channel,
+	options: Options,
+): Effect.fn.Return<State, never, Scope.Scope> {
+	const limits = { ...defaults, ...options.limits }
+	const workers = yield* FailureGroup.make<TransportError>()
+	const incoming = yield* TxRef.make(
+		HashMap.empty<RequestKey, RequestState<RpcMessage.FromClientEncoded>>(),
+	)
+	const outgoing = yield* TxRef.make(
+		HashMap.empty<RequestKey, RequestState<RpcMessage.FromServerEncoded>>(),
+	)
+	const queues = {
+		control: yield* TxQueue.unbounded<Pending, Cause.Done>(),
+		data: yield* TxQueue.unbounded<Pending, Cause.Done>(),
+		log: yield* TxQueue.unbounded<Pending, Cause.Done>(),
+	}
+	const servers = yield* Effect.forEach(
+		Record.toEntries(options.serve),
+		Effect.fnUntraced(function* ([name, group]) {
+			return [
+				name,
+				{
+					group,
+					ready:
+						yield* Deferred.make<
+							Parameters<RpcServer.Protocol["Service"]["run"]>[0]
+						>(),
+					disconnects: yield* Queue.dropping<number>(1),
+				},
+			] satisfies readonly [string, unknown]
+		}),
+	).pipe(Effect.map(HashMap.fromIterable))
+	const clients = yield* Effect.forEach(
+		Record.toEntries(options.call),
+		Effect.fnUntraced(function* ([name, group]) {
+			return [
+				name,
+				{
+					group,
+					ready:
+						yield* Deferred.make<
+							Parameters<RpcClient.Protocol["Service"]["run"]>[1]
+						>(),
+				},
+			] satisfies readonly [string, unknown]
+		}),
+	).pipe(Effect.map(HashMap.fromIterable))
+	return {
+		bytes,
+		options,
+		limits,
+		workers,
+		incoming,
+		outgoing,
+		queues,
+		servers,
+		clients,
+	}
+})
 
 const admit = Effect.fnUntraced(function* <A>(
 	state: State,
@@ -447,41 +449,38 @@ const serverProtocol = (
 			),
 	})
 }
-const next = (state: State) =>
-	Effect.tx(
-		Effect.gen(function* () {
-			yield* state.workers.check
-			for (const p of [
-				"control",
-				"data",
-				"log",
-			] satisfies ReadonlyArray<Priority>) {
-				const pending = yield* TxQueue.poll(state.queues[p])
-				if (Option.isNone(pending)) continue
-				const { frame, request } = pending.value
-				if (Option.isSome(request)) {
-					const table = yield* TxRef.get(state.outgoing)
-					const requestState = HashMap.get(table, request.value)
-					if (Option.isNone(requestState)) return Option.none<Frame>()
-					yield* TxRef.set(
-						state.outgoing,
-						HashMap.set(table, request.value, {
-							...requestState.value,
-							sent: true,
-						}),
-					)
-				}
-				return Option.some(frame)
-			}
-			if (
-				(yield* TxQueue.isDone(state.queues.control)) &&
-				(yield* TxQueue.isDone(state.queues.data)) &&
-				(yield* TxQueue.isDone(state.queues.log))
+const next = Effect.fnUntraced(function* (state: State) {
+	yield* state.workers.check
+	for (const p of [
+		"control",
+		"data",
+		"log",
+	] satisfies ReadonlyArray<Priority>) {
+		const pending = yield* TxQueue.poll(state.queues[p])
+		if (Option.isNone(pending)) continue
+		const { frame, request } = pending.value
+		if (Option.isSome(request)) {
+			const table = yield* TxRef.get(state.outgoing)
+			const requestState = HashMap.get(table, request.value)
+			if (Option.isNone(requestState)) return Option.none<Frame>()
+			yield* TxRef.set(
+				state.outgoing,
+				HashMap.set(table, request.value, {
+					...requestState.value,
+					sent: true,
+				}),
 			)
-				return yield* Cause.done()
-			return yield* Effect.txRetry
-		}),
+		}
+		return Option.some(frame)
+	}
+	if (
+		(yield* TxQueue.isDone(state.queues.control)) &&
+		(yield* TxQueue.isDone(state.queues.data)) &&
+		(yield* TxQueue.isDone(state.queues.log))
 	)
+		return yield* Cause.done()
+	return yield* Effect.txRetry
+}, Effect.tx)
 const writer = (state: State) =>
 	Stream.fromEffectRepeat(next(state)).pipe(
 		Stream.filterMap(Result.fromOption(() => undefined)),
@@ -592,18 +591,16 @@ export const make = Effect.fnUntraced(function* (
 	// The same failure remains observable through Port.await and client requests.
 	// This observer only publishes disconnects, even while the owner closes its scope.
 	yield* state.workers.await.pipe(
-		Effect.catchCause(() =>
-			Effect.uninterruptible(
-				Effect.gen(function* () {
-					for (const server of HashMap.values(state.servers))
-						yield* Queue.offer(server.disconnects, 0)
-					yield* Effect.tx(
-						TxRef.set(state.incoming, HashMap.empty()).pipe(
-							Effect.andThen(TxRef.set(state.outgoing, HashMap.empty())),
-						),
-					)
-				}),
-			),
+		Effect.catchCause(
+			Effect.fnUntraced(function* () {
+				for (const server of HashMap.values(state.servers))
+					yield* Queue.offer(server.disconnects, 0)
+				yield* Effect.tx(
+					TxRef.set(state.incoming, HashMap.empty()).pipe(
+						Effect.andThen(TxRef.set(state.outgoing, HashMap.empty())),
+					),
+				)
+			}, Effect.uninterruptible),
 		),
 		Effect.forkScoped,
 	)

package/src/internal/release.ts

@@ -19,8 +19,9 @@ export const close = (
 ) =>
 	Effect.uninterruptible(
 		Scope.close(scope, exit).pipe(
-			Effect.catchCauseIf(Cause.hasInterruptsOnly, (cause) =>
-				Effect.gen(function* () {
+			Effect.catchCauseIf(
+				Cause.hasInterruptsOnly,
+				Effect.fnUntraced(function* (cause) {
 					// Re-entering interruptibility observes pending external cancellation without producing a self-interrupt.
 					// Read it after release so cancellation arriving during a finalizer is included too.
 					const pending = yield* Effect.exit(Effect.interruptible(Effect.void))

package/src/internal/runner/Connection.ts

@@ -112,73 +112,65 @@ const finish = (causes: ReadonlyArray<Cause.Cause<unknown>>) => {
 /** Close partially acquired resources too; the normal release observes exit before stopping readers. */
 const scopes = Effect.acquireRelease(
 	Effect.all({ resources: Scope.make(), process: Scope.make() }),
-	(scopes, exit) =>
-		Effect.gen(function* () {
-			const process = yield* Effect.exit(Release.close(scopes.process, exit))
-			const resources = yield* Effect.exit(
-				Release.close(scopes.resources, exit),
-			)
-			yield* finish([reason(process), reason(resources)])
-		}),
+	Effect.fnUntraced(function* (scopes, exit) {
+		const process = yield* Effect.exit(Release.close(scopes.process, exit))
+		const resources = yield* Effect.exit(Release.close(scopes.resources, exit))
+		yield* finish([reason(process), reason(resources)])
+	}),
 )
 
 /** Setup supplies a concrete control lifecycle; release never reads a later-installed effect. */
-export const acquire = <A, E, R, D, DR>(
+export const acquire = Effect.fnUntraced(function* <A, E, R, D, DR>(
 	target: Target,
 	contractModule: string,
 	options: Port.Options,
 	setup: Effect.Effect<A, E, R | Connection>,
 	dispose: (value: A) => Effect.Effect<Cause.Cause<unknown>, D, DR>,
 	timeout: Duration.Input,
-) =>
-	Effect.gen(function* () {
-		const owned = yield* scopes
-		const connection = yield* Effect.acquireRelease(
-			Effect.gen(function* () {
-				return target._tag === "Local" || target._tag === "Worker"
-					? yield* Local(
-							target,
-							contractModule,
-							options,
-							owned.resources,
-							owned.process,
-						).pipe(Effect.map(connected))
-					: yield* RunnerConnection.connect(
-							target,
-							contractModule,
-							options,
-							owned.resources,
-							owned.process,
-						)
-			}).pipe(Effect.interruptible),
-			(connection, exit) =>
-				Effect.gen(function* () {
-					const process = yield* Effect.exit(Release.close(owned.process, exit))
-					// Wait for exit while readers are alive; collect their final cause after resources close.
-					yield* connection.diagnostics
-					const resources = yield* Effect.exit(
-						Release.close(owned.resources, exit),
-					)
-					const diagnostics = yield* connection.diagnostics
-					yield* finish([reason(process), reason(resources), diagnostics])
-				}),
-		)
-		return yield* Effect.acquireRelease(
-			setup.pipe(Effect.provideService(Connection, connection)),
-			(value) =>
-				Effect.gen(function* () {
-					const graceful = yield* dispose(value).pipe(
-						Effect.interruptible,
-						Effect.timeout(timeout),
-						Effect.exit,
-					)
-					const terminated = yield* Effect.exit(
-						connection.terminate(Exit.isSuccess(graceful)),
+) {
+	const owned = yield* scopes
+	const connection = yield* Effect.acquireRelease(
+		Effect.gen(function* () {
+			return target._tag === "Local" || target._tag === "Worker"
+				? yield* Local(
+						target,
+						contractModule,
+						options,
+						owned.resources,
+						owned.process,
+					).pipe(Effect.map(connected))
+				: yield* RunnerConnection.connect(
+						target,
+						contractModule,
+						options,
+						owned.resources,
+						owned.process,
 					)
-					yield* finish([
-						Exit.isSuccess(graceful) ? graceful.value : graceful.cause,
-						reason(terminated),
-					])
-				}),
-		)
-	})
+		}).pipe(Effect.interruptible),
+		Effect.fnUntraced(function* (connection, exit) {
+			const process = yield* Effect.exit(Release.close(owned.process, exit))
+			// Wait for exit while readers are alive; collect their final cause after resources close.
+			yield* connection.diagnostics
+			const resources = yield* Effect.exit(Release.close(owned.resources, exit))
+			const diagnostics = yield* connection.diagnostics
+			yield* finish([reason(process), reason(resources), diagnostics])
+		}),
+	)
+	return yield* Effect.acquireRelease(
+		setup.pipe(Effect.provideService(Connection, connection)),
+		Effect.fnUntraced(function* (value) {
+			const graceful = yield* dispose(value).pipe(
+				Effect.interruptible,
+				Effect.timeout(timeout),
+				Effect.exit,
+			)
+			const terminated = yield* Effect.exit(
+				connection.terminate(Exit.isSuccess(graceful)),
+			)
+			yield* finish([
+				Exit.isSuccess(graceful) ? graceful.value : graceful.cause,
+				reason(terminated),
+			])
+		}),
+	)
+})