@graftland/plugin-remote 0.3.0 → 0.3.2

package/src/internal/host/runner.ts

@@ -19,169 +19,169 @@ import * as Multiplex from "../runner/Multiplex"
 import * as Packages from "../runner/Packages"
 import * as Wire from "../runner/Wire"
 import { awaitTermination, defaults, childOf } from "../runner/model"
-export const connect = (
+export const connect = Effect.fnUntraced(function* (
 	target: ConfiguredRunner,
 	contractModule: string,
 	options: Port.Options,
 	resources: Scope.Scope,
 	processScope: Scope.Scope,
-) =>
-	Effect.gen(function* () {
-		const instance = target.instance
+) {
+	const instance = target.instance
 
-		const margin = Duration.toMillis(target.margin ?? "5 seconds")
-		const channel = yield* connectCapability(target.explicitAuth).pipe(
-			Scope.provide(processScope),
-		)
-		const mux = yield* Multiplex.make(channel).pipe(Scope.provide(resources))
-		const control = yield* Port.make(Wire.channel(mux, 0), {
-			session: "session-v1",
-			serve: {},
-			call: { session: Wire.Session },
-		}).pipe(Scope.provide(resources))
-		const session = yield* RpcClient.make(Wire.Session).pipe(
-			Effect.provideService(
-				RpcClient.Protocol,
-				control.clientProtocol("session"),
-			),
-			Scope.provide(resources),
-		)
-		const expectedGeneration = yield* session.HighWater({ instance })
-		const record = yield* session.Open({
-			instance,
-			expectedGeneration,
-			requestId: options.session,
-			limits: defaults,
-			...(target.lease === undefined
-				? {}
-				: {
-						leaseMillis: Duration.toMillis(target.lease),
-					}),
-		})
-		const failures = yield* FailureGroup.make<TransportError>().pipe(
-			Scope.provide(resources),
-		)
-		const finishStarted = yield* Ref.make(false)
-		const terminate = yield* Effect.cached(
-			Effect.gen(function* () {
-				yield* Ref.set(finishStarted, true)
-				yield* failures.close
-				const result = yield* awaitTermination(
-					record.handle,
-					session.Dispose(record.handle),
-					record.leaseMillis,
-					margin,
+	const margin = Duration.toMillis(target.margin ?? "5 seconds")
+	const channel = yield* connectCapability(target.explicitAuth).pipe(
+		Scope.provide(processScope),
+	)
+	const mux = yield* Multiplex.make(channel).pipe(Scope.provide(resources))
+	const control = yield* Port.make(Wire.channel(mux, 0), {
+		session: "session-v1",
+		serve: {},
+		call: { session: Wire.Session },
+	}).pipe(Scope.provide(resources))
+	const session = yield* RpcClient.make(Wire.Session).pipe(
+		Effect.provideService(
+			RpcClient.Protocol,
+			control.clientProtocol("session"),
+		),
+		Scope.provide(resources),
+	)
+	const expectedGeneration = yield* session.HighWater({ instance })
+	const record = yield* session.Open({
+		instance,
+		expectedGeneration,
+		requestId: options.session,
+		limits: defaults,
+		...(target.lease === undefined
+			? {}
+			: {
+					leaseMillis: Duration.toMillis(target.lease),
+				}),
+	})
+	const failures = yield* FailureGroup.make<TransportError>().pipe(
+		Scope.provide(resources),
+	)
+	const finishStarted = yield* Ref.make(false)
+	const terminate = yield* Effect.cached(
+		Effect.gen(function* () {
+			yield* Ref.set(finishStarted, true)
+			// A failed close must not skip Dispose; both outcomes are reported together below.
+			const closed = yield* Effect.exit(failures.close)
+			const result = yield* awaitTermination(
+				record.handle,
+				session.Dispose(record.handle),
+				record.leaseMillis,
+				margin,
+			)
+			const { code, signal, stderr, cause } = result.exit
+			yield* Effect.logInfo("Remote execution terminated", {
+				code,
+				...(signal === null ? {} : { signal }),
+				...(stderr === undefined || stderr === "" ? {} : { stderr }),
+				...(cause === undefined || cause.reasons.length === 0 ? {} : { cause }),
+			}).pipe(
+				Effect.annotateLogs({
+					"remote.instance": record.handle.key.instance,
+					"remote.generation": record.handle.generation,
+					"remote.termination": result.kind,
+				}),
+			)
+			const failure = Exit.isFailure(closed)
+				? Cause.combine(closed.cause, result.cause)
+				: result.cause
+			if (failure.reasons.length > 0)
+				return yield* Effect.failCause(cleanupCause(failure))
+		}),
+	)
+	yield* Scope.addFinalizer(
+		processScope,
+		Effect.gen(function* () {
+			if (!(yield* Ref.get(finishStarted)))
+				yield* terminate.pipe(
+					Effect.catchCause((cause) => Effect.failCause(cleanupCause(cause))),
 				)
-				const { code, signal, stderr, cause } = result.exit
-				yield* Effect.logInfo("Remote execution terminated", {
-					code,
-					...(signal === null ? {} : { signal }),
-					...(stderr === undefined || stderr === "" ? {} : { stderr }),
-					...(cause === undefined || cause.reasons.length === 0
-						? {}
-						: { cause }),
-				}).pipe(
-					Effect.annotateLogs({
-						"remote.instance": record.handle.key.instance,
-						"remote.generation": record.handle.generation,
-						"remote.termination": result.kind,
-					}),
+		}),
+	)
+	const renewed = yield* Effect.forever(
+		Effect.sleep(record.leaseMillis / 3).pipe(
+			Effect.andThen(session.Renew(record.handle)),
+		),
+	).pipe(Effect.forkIn(resources))
+	const code = yield* session.Load({
+		handle: record.handle,
+		specifier: contractModule,
+		digest: target.expect?.digest !== undefined,
+	})
+	yield* Packages.verify(code, target.expect)
+	const loaded = yield* session.Status(record.handle)
+	const peer = yield* Port.make(Wire.channel(mux, 1), {
+		...options,
+		session: record.handle.token,
+		limits: record.limits,
+	}).pipe(Scope.provide(resources))
+	// RPC forwarding cancellation is expected; resource cleanup is collected by Connection's scopes.
+	const report = (cause: Cause.Cause<unknown>) =>
+		Cause.hasInterruptsOnly(cause)
+			? Effect.void
+			: failures.failCause(
+					Cause.map(cause, (error) =>
+						TransportError.make({ cause: Cause.fail(error) }),
+					),
 				)
-				if (result.cause.reasons.length > 0)
-					return yield* Effect.failCause(cleanupCause(result.cause))
-			}),
-		)
-		yield* Scope.addFinalizer(
-			processScope,
-			Effect.gen(function* () {
-				if (!(yield* Ref.get(finishStarted)))
-					yield* terminate.pipe(
-						Effect.catchCause((cause) => Effect.failCause(cleanupCause(cause))),
-					)
-			}),
-		)
-		const renewed = yield* Effect.forever(
-			Effect.sleep(record.leaseMillis / 3).pipe(
-				Effect.andThen(session.Renew(record.handle)),
-			),
-		).pipe(Effect.forkIn(resources))
-		const code = yield* session.Load({
-			handle: record.handle,
-			specifier: contractModule,
-			digest: target.expect?.digest !== undefined,
-		})
-		yield* Packages.verify(code, target.expect)
-		const loaded = yield* session.Status(record.handle)
-		const peer = yield* Port.make(Wire.channel(mux, 1), {
-			...options,
-			session: record.handle.token,
-			limits: record.limits,
-		}).pipe(Scope.provide(resources))
-		// RPC forwarding cancellation is expected; resource cleanup is collected by Connection's scopes.
-		const report = (cause: Cause.Cause<unknown>) =>
+	yield* failures.await.pipe(
+		Effect.catchCause((cause) =>
 			Cause.hasInterruptsOnly(cause)
 				? Effect.void
-				: failures.failCause(
-						Cause.map(cause, (error) =>
-							TransportError.make({ cause: Cause.fail(error) }),
-						),
-					)
-		yield* failures.await.pipe(
-			Effect.catchCause((cause) =>
-				Cause.hasInterruptsOnly(cause)
-					? Effect.void
-					: peer.fail(TransportError.make({ cause })),
-			),
-			Effect.forkIn(resources),
-		)
+				: peer.fail(TransportError.make({ cause })),
+		),
+		Effect.forkIn(resources),
+	)
 
-		yield* failures.run(
-			Fiber.join(renewed).pipe(
-				Effect.catchCause((cause) =>
-					Effect.gen(function* () {
-						if (Cause.hasInterruptsOnly(cause)) return
-						const status = yield* Effect.exit(
-							session.Status(record.handle).pipe(Effect.timeout("5 seconds")),
-						)
-						if (Exit.isSuccess(status) && status.value.phase === "Stopped") {
-							const exit = status.value.termination.exit
-							yield* report(
-								Cause.combine(
-									cause,
-									Cause.fail(
-										ProcessExited.make({
-											pid: Option.map(childOf(loaded), (child) => child.pid),
-											exitCode: exit.code,
-											stderr: exit.stderr ?? "",
-											statusCause: exit.cause ?? Cause.empty,
-										}),
-									),
+	yield* failures.run(
+		Fiber.join(renewed).pipe(
+			Effect.catchCause(
+				Effect.fnUntraced(function* (cause) {
+					if (Cause.hasInterruptsOnly(cause)) return
+					const status = yield* Effect.exit(
+						session.Status(record.handle).pipe(Effect.timeout("5 seconds")),
+					)
+					if (Exit.isSuccess(status) && status.value.phase === "Stopped") {
+						const exit = status.value.termination.exit
+						yield* report(
+							Cause.combine(
+								cause,
+								Cause.fail(
+									ProcessExited.make({
+										pid: Option.map(childOf(loaded), (child) => child.pid),
+										exitCode: exit.code,
+										stderr: exit.stderr ?? "",
+										statusCause: exit.cause ?? Cause.empty,
+									}),
 								),
-							)
-						} else
-							yield* report(
-								Exit.isFailure(status)
-									? Cause.combine(cause, status.cause)
-									: cause,
-							)
-					}),
-				),
-			),
-		)
-		return {
-			resources,
-			pid: Option.map(childOf(loaded), (child) => child.pid),
-			diagnostics: failures.cause,
-			terminate: () =>
-				Effect.gen(function* () {
-					// No renewal may extend a disconnected session while termination waits out its lease.
-					yield* Fiber.interrupt(renewed)
-					yield* terminate
+							),
+						)
+					} else
+						yield* report(
+							Exit.isFailure(status)
+								? Cause.combine(cause, status.cause)
+								: cause,
+						)
 				}),
-			transport: {
-				...peer,
-				failure: peer.await,
-				report,
-			},
-		} satisfies Connected
-	})
+			),
+		),
+	)
+	return {
+		resources,
+		pid: Option.map(childOf(loaded), (child) => child.pid),
+		diagnostics: failures.cause,
+		terminate: Effect.fnUntraced(function* () {
+			// No renewal may extend a disconnected session while termination waits out its lease.
+			yield* Fiber.interrupt(renewed)
+			yield* terminate
+		}),
+		transport: {
+			...peer,
+			failure: peer.await,
+			report,
+		},
+	} satisfies Connected
+})

package/src/internal/host.ts

@@ -16,15 +16,16 @@ import { RemoteWithdrawn } from "../Errors"
 import * as Control from "./control"
 import { cleanupCause } from "./cleanup"
 import { Connection } from "./runner/Connection"
-import type { Service } from "./services"
+import type { Service } from "../Contract"
+import type { ChildFailure } from "./childErrors"
+import type { prepare } from "./contract"
 
 type ErrorSchema = Schema.Top & {
 	readonly DecodingServices: never
 	readonly EncodingServices: never
 }
-type ControlGroup<E extends ErrorSchema> = ContractModule.Contract<
-	Schema.Codec<unknown, Schema.Json>,
-	E
+type ControlGroup<E extends ErrorSchema> = ReturnType<
+	typeof prepare<Schema.Codec<unknown, Schema.Json>, E>
 >["control"]
 interface Contract<E extends ErrorSchema> {
 	readonly control: ControlGroup<E>
@@ -32,9 +33,7 @@ interface Contract<E extends ErrorSchema> {
 	readonly decodeCause: (
 		input: unknown,
 	) => Effect.Effect<
-		Cause.Cause<
-			E["Type"] | ContractModule.UndeclaredFailure | ContractModule.ChildFailure
-		>,
+		Cause.Cause<E["Type"] | ContractModule.UndeclaredFailure | ChildFailure>,
 		Schema.SchemaError
 	>
 }
@@ -47,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
-			| ContractModule.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>>
 >
@@ -179,9 +175,7 @@ export const load = <E extends ErrorSchema>(
 						(
 							cause,
 						): cause is Cause.Cause<
-							| E["Type"]
-							| ContractModule.UndeclaredFailure
-							| ContractModule.ChildFailure
+							E["Type"] | ContractModule.UndeclaredFailure | ChildFailure
 						> => Cause.isCause(cause),
 						Effect.failCause,
 					),
@@ -189,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
+})