@graftland/plugin-remote 0.3.0 → 0.3.2

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),
+			])
+		}),
+	)
+})