@graftland/plugin-remote 0.3.1 → 0.3.3

package/src/internal/FailureGroup.ts

@@ -13,6 +13,7 @@ import {
 	TxRef,
 } from "effect"
 import * as Release from "./release"
+import { cleanupCause } from "./cleanup"
 
 type State<E> = Data.TaggedEnum<{
 	Open: {}
@@ -44,133 +45,139 @@ export interface FailureGroup<E> {
 }
 
 /** One owner for first failure, transaction wakeups, and interruption of sibling work. */
-export const make = <E>(): Effect.Effect<FailureGroup<E>, never, Scope.Scope> =>
-	Effect.gen(function* () {
-		const fibers = yield* FiberSet.make<unknown, E>()
-		const state = yield* TxRef.make<State<E>>(State.Open())
-		const failures = yield* Ref.make<Cause.Cause<E>>(Cause.empty)
-		const cleanup = yield* Ref.make<Cause.Cause<E>>(Cause.empty)
-		const check = TxRef.get(state).pipe(
-			Effect.flatMap((s) =>
-				s._tag === "Failed"
-					? Effect.failCause(s.cause)
-					: s._tag === "Closed"
-						? Effect.interrupt
-						: Effect.void,
-			),
+export const make = Effect.fnUntraced(function* <E>(): Effect.fn.Return<
+	FailureGroup<E>,
+	never,
+	Scope.Scope
+> {
+	const fibers = yield* FiberSet.make<unknown, E>()
+	const state = yield* TxRef.make<State<E>>(State.Open())
+	const failures = yield* Ref.make<Cause.Cause<E>>(Cause.empty)
+	const cleanup = yield* Ref.make<Cause.Cause<E>>(Cause.empty)
+	const check = TxRef.get(state).pipe(
+		Effect.flatMap((s) =>
+			s._tag === "Failed"
+				? Effect.failCause(s.cause)
+				: s._tag === "Closed"
+					? Effect.interrupt
+					: Effect.void,
+		),
+	)
+	const publish = (cause: Cause.Cause<E>) =>
+		TxRef.update(state, (s): State<E> =>
+			s._tag === "Open" ? State.Failed({ cause }) : s,
 		)
-		const publish = (cause: Cause.Cause<E>) =>
-			TxRef.update(state, (s): State<E> =>
-				s._tag === "Open" ? State.Failed({ cause }) : s,
-			)
 
-		const observe = <A, R>(effect: Effect.Effect<A, E, R>) =>
-			Effect.uninterruptibleMask((restore) =>
-				Effect.gen(function* () {
-					const scope = yield* Scope.make()
-					// The owned child makes cancellation explicit, even when a stream closes an internal scope.
-					const ownerId = yield* Effect.withFiber((self) =>
-						Effect.succeed(self.id),
-					)
-					const worker = yield* Effect.forkIn(
-						restore(Scope.provide(scope)(effect)),
-						scope,
+	const observe = <A, R>(effect: Effect.Effect<A, E, R>) =>
+		Effect.uninterruptibleMask((restore) =>
+			Effect.gen(function* () {
+				const scope = yield* Scope.make()
+				// The owned child makes cancellation explicit, even when a stream closes an internal scope.
+				const ownerId = yield* Effect.withFiber((self) =>
+					Effect.succeed(self.id),
+				)
+				const worker = yield* Effect.forkIn(
+					restore(Scope.provide(scope)(effect)),
+					scope,
+				)
+				const waiting = yield* Effect.exit(restore(Fiber.await(worker)))
+				if (Exit.isFailure(waiting)) yield* Fiber.interrupt(worker)
+				const body = yield* Fiber.await(worker)
+				const closed = yield* Effect.exit(Release.close(scope, body))
+				// Forwarding this exact cancellation from a finalizer is indistinguishable from acknowledging it.
+				const expected =
+					Exit.isFailure(waiting) &&
+					Exit.isFailure(body) &&
+					Array.every(
+						body.cause.reasons,
+						(reason) =>
+							reason._tag === "Interrupt" && reason.fiberId === ownerId,
 					)
-					const waiting = yield* Effect.exit(restore(Fiber.await(worker)))
-					if (Exit.isFailure(waiting)) yield* Fiber.interrupt(worker)
-					const body = yield* Fiber.await(worker)
-					const closed = yield* Effect.exit(Release.close(scope, body))
-					// Forwarding this exact cancellation from a finalizer is indistinguishable from acknowledging it.
-					const expected =
-						Exit.isFailure(waiting) &&
-						Exit.isFailure(body) &&
-						Array.every(
-							body.cause.reasons,
+				const bodyCause =
+					Exit.isFailure(body) && !expected ? body.cause : Cause.empty
+				// Release.close marks independent interruptions; an unmarked one is pending cancellation.
+				const releaseCause =
+					Exit.isFailure(closed) && !Cause.hasInterruptsOnly(closed.cause)
+						? closed.cause
+						: Cause.empty
+				const failure = Cause.combine(bodyCause, releaseCause)
+				// Body cleanup may carry either an interruption or a release defect from an inner group.
+				const closing = Cause.combine(
+					Cause.hasInterrupts(bodyCause) ||
+						Array.some(
+							bodyCause.reasons,
 							(reason) =>
-								reason._tag === "Interrupt" && reason.fiberId === ownerId,
+								reason._tag === "Die" &&
+								Schema.is(Release.ReleaseInterrupted)(reason.defect),
 						)
-					const bodyCause =
-						Exit.isFailure(body) && !expected ? body.cause : Cause.empty
-					// Release.close marks independent interruptions; an unmarked one is pending cancellation.
-					const releaseCause =
-						Exit.isFailure(closed) && !Cause.hasInterruptsOnly(closed.cause)
-							? closed.cause
-							: Cause.empty
-					const failure = Cause.combine(bodyCause, releaseCause)
-					// Body cleanup may carry either an interruption or a release defect from an inner group.
-					const closing = Cause.combine(
-						Cause.hasInterrupts(bodyCause) ||
-							Array.some(
-								bodyCause.reasons,
-								(reason) =>
-									reason._tag === "Die" &&
-									Schema.is(Release.ReleaseInterrupted)(reason.defect),
-							)
-							? bodyCause
-							: Cause.empty,
-						releaseCause,
+						? bodyCause
+						: Cause.empty,
+					releaseCause,
+				)
+				yield* Ref.update(cleanup, (cause) => Cause.combine(cause, closing))
+				if (failure.reasons.length > 0) {
+					yield* Ref.update(failures, (cause) => Cause.combine(cause, failure))
+					yield* publish(failure)
+					yield* Deferred.failCause(fibers.deferred, failure)
+				}
+				if (Exit.isFailure(closed))
+					return yield* Effect.failCause(
+						Exit.isFailure(body)
+							? Cause.combine(body.cause, closed.cause)
+							: closed.cause,
 					)
-					yield* Ref.update(cleanup, (cause) => Cause.combine(cause, closing))
-					if (failure.reasons.length > 0) {
-						yield* Ref.update(failures, (cause) =>
-							Cause.combine(cause, failure),
-						)
-						yield* publish(failure)
-						yield* Deferred.failCause(fibers.deferred, failure)
-					}
-					if (Exit.isFailure(closed))
-						return yield* Effect.failCause(
-							Exit.isFailure(body)
-								? Cause.combine(body.cause, closed.cause)
-								: closed.cause,
-						)
-					if (Exit.isFailure(waiting) && Exit.isSuccess(body))
-						return yield* Effect.failCause(waiting.cause)
-					return yield* body
-				}),
-			)
-		yield* FiberSet.join(fibers).pipe(
-			Effect.catchCause((cause) =>
-				publish(cause).pipe(
-					Effect.andThen(FiberSet.clear(fibers)),
-					Effect.uninterruptible,
-				),
-			),
-			Effect.forkScoped,
+				if (Exit.isFailure(waiting) && Exit.isSuccess(body))
+					return yield* Effect.failCause(waiting.cause)
+				return yield* body
+			}),
 		)
-		const failure = Effect.tx(check.pipe(Effect.andThen(Effect.txRetry)))
-		const failCause = (cause: Cause.Cause<E>) =>
-			// This is an explicit failure report, not cancellation of an owned worker.
-			FiberSet.run(fibers, observe(Effect.failCause(cause))).pipe(Effect.asVoid)
-		const close = TxRef.update(state, (s) =>
-			s._tag === "Open" ? State.Closed() : s,
-		).pipe(
-			Effect.andThen(FiberSet.clear(fibers)),
-			Effect.andThen(Ref.get(cleanup)),
-			Effect.flatMap((cause) =>
-				cause.reasons.length > 0 ? Effect.failCause(cause) : Effect.void,
+	yield* FiberSet.join(fibers).pipe(
+		Effect.catchCause((cause) =>
+			publish(cause).pipe(
+				Effect.andThen(FiberSet.clear(fibers)),
+				Effect.uninterruptible,
 			),
-			Effect.uninterruptible,
-		)
-		// Operational failure is delivered by await; release must also deliver sibling cleanup failures.
-		yield* Effect.addFinalizer(() => close.pipe(Effect.orDie))
-		return {
-			await: failure,
-			check,
-			cause: Ref.get(failures),
-			runtime: <R>() =>
-				FiberSet.runtime(fibers)<R>().pipe(
-					Effect.map(
-						(run) => (effect: Effect.Effect<unknown, E, R>) =>
-							run(check.pipe(Effect.andThen(observe(effect)))),
-					),
+		),
+		Effect.forkScoped,
+	)
+	const failure = Effect.tx(check.pipe(Effect.andThen(Effect.txRetry)))
+	const failCause = (cause: Cause.Cause<E>) =>
+		// This is an explicit failure report, not cancellation of an owned worker.
+		FiberSet.run(fibers, observe(Effect.failCause(cause))).pipe(Effect.asVoid)
+	const close = TxRef.update(state, (s) =>
+		s._tag === "Open" ? State.Closed() : s,
+	).pipe(
+		Effect.andThen(FiberSet.clear(fibers)),
+		Effect.andThen(Ref.get(cleanup)),
+		Effect.flatMap((cause) =>
+			cause.reasons.length > 0 ? Effect.failCause(cause) : Effect.void,
+		),
+		Effect.uninterruptible,
+	)
+	// Operational failure is delivered by await; release must also deliver sibling cleanup failures.
+	// Every sibling failure and interruption survives as a defect; orDie would keep only the first failure.
+	yield* Effect.addFinalizer(() =>
+		close.pipe(
+			Effect.catchCause((cause) => Effect.failCause(cleanupCause(cause))),
+		),
+	)
+	return {
+		await: failure,
+		check,
+		cause: Ref.get(failures),
+		runtime: <R>() =>
+			FiberSet.runtime(fibers)<R>().pipe(
+				Effect.map(
+					(run) => (effect: Effect.Effect<unknown, E, R>) =>
+						run(check.pipe(Effect.andThen(observe(effect)))),
 				),
-			run: (effect) =>
-				FiberSet.run(fibers, check.pipe(Effect.andThen(observe(effect)))),
-			fail: (error) => failCause(Cause.fail(error)),
-			failCause,
-			race: (effect) =>
-				check.pipe(Effect.andThen(Effect.raceFirst(effect, failure))),
-			close,
-		}
-	})
+			),
+		run: (effect) =>
+			FiberSet.run(fibers, check.pipe(Effect.andThen(observe(effect)))),
+		fail: (error) => failCause(Cause.fail(error)),
+		failCause,
+		race: (effect) =>
+			check.pipe(Effect.andThen(Effect.raceFirst(effect, failure))),
+		close,
+	}
+})

package/src/internal/assembly.ts

@@ -63,6 +63,14 @@ export class CapabilityFailed extends Schema.TaggedError<
 	cause: Schema.Cause(Schema.Unknown, Schema.Unknown),
 }) {}
 
+/** Every failure class assembly raises; host error classification reads this list. */
+export const errors = [
+	ListenerConfigError,
+	CapabilityContractError,
+	CapabilityCombinationError,
+	CapabilityFailed,
+] as const
+
 const definition = Schema.declare(Plugin.isPlugin)
 /** Entries resolve capability modules before assembling their private providers. */
 export const Invocation = Schema.Struct({
@@ -235,16 +243,17 @@ export const directAuth = (properties: Properties, explicit: boolean) =>
 			)
 		: Effect.void
 
-export const connectWith = (explicitAuth = false) =>
-	Effect.gen(function* () {
-		const connector = yield* Connector
-		const credentials = yield* Credentials
-		yield* directAuth(connector.properties, explicitAuth)
-		yield* compatible(connector.properties, credentials.kind)
-		yield* warn(connector.properties, credentials.kind, "host")
-		const prepared = yield* credentials.read
-		return yield* connector.connect(prepared)
-	})
+export const connectWith = Effect.fnUntraced(function* (
+	explicitAuth: boolean = false,
+) {
+	const connector = yield* Connector
+	const credentials = yield* Credentials
+	yield* directAuth(connector.properties, explicitAuth)
+	yield* compatible(connector.properties, credentials.kind)
+	yield* warn(connector.properties, credentials.kind, "host")
+	const prepared = yield* credentials.read
+	return yield* connector.connect(prepared)
+})
 
 export const accept =
 	(

package/src/internal/auth/mtls.ts

@@ -17,24 +17,23 @@ const uriValue = (field: string) => {
 }
 
 /** Read exactly one graft URI from Node's plain or JSON-quoted SAN representation. */
-export const identityFromSubjectAltName = (
+export const identityFromSubjectAltName = Effect.fnUntraced(function* (
 	san: string | undefined,
-): Effect.Effect<string, AuthenticationFailed> =>
-	Effect.gen(function* () {
-		const values = yield* Effect.forEach(
-			Array.filter(String.split(san ?? "", ", "), String.startsWith("URI:")),
-			uriValue,
-		)
-		const uris = Array.filter(values, String.startsWith("graft://"))
-		const [uri] = uris
-		return yield* uris.length === 1 && uri !== undefined
-			? Effect.succeed(uri)
-			: Effect.fail(
-					AuthenticationFailed.make({
-						reason: "invalid",
-						cause: Cause.fail(
-							"The peer certificate must contain exactly one graft SAN URI",
-						),
-					}),
-				)
-	})
+): Effect.fn.Return<string, AuthenticationFailed> {
+	const values = yield* Effect.forEach(
+		Array.filter(String.split(san ?? "", ", "), String.startsWith("URI:")),
+		uriValue,
+	)
+	const uris = Array.filter(values, String.startsWith("graft://"))
+	const [uri] = uris
+	return yield* uris.length === 1 && uri !== undefined
+		? Effect.succeed(uri)
+		: Effect.fail(
+				AuthenticationFailed.make({
+					reason: "invalid",
+					cause: Cause.fail(
+						"The peer certificate must contain exactly one graft SAN URI",
+					),
+				}),
+			)
+})