@graftland/plugin-remote 0.3.0 → 0.3.2

package/src/internal/runner/accept.ts

@@ -10,94 +10,86 @@ import * as Multiplex from "./Multiplex"
 import * as Wire from "./Wire"
 import { SessionAccessDenied, SessionConflict, type Handle } from "./model"
 
-export const accept = (
+export const accept = Effect.fnUntraced(function* (
 	supervisor: typeof Supervisor.Service,
 	execution: typeof Channels.Service,
 	channel: Channel,
-) =>
-	Effect.gen(function* () {
-		const identity = yield* Peer
-		const scope = yield* Effect.scope
-		const mux = yield* Multiplex.make(channel)
-		const peer = yield* Port.make(Wire.channel(mux, 0), {
-			session: "session-v1",
-			serve: { session: Wire.Session },
-			call: {},
-		})
-		const attached = yield* Ref.make(Option.none<string>())
-		const loading = yield* Semaphore.make(1)
-		const authorize = (handle: Handle) =>
-			handle.key.identity === identity
-				? Effect.void
-				: Effect.fail(
-						SessionAccessDenied.make({
-							detail: "The session belongs to another authenticated identity",
-						}),
-					)
-		const handlers = yield* Wire.Session.toHandlers({
-			HighWater: ({ instance }) => supervisor.highWater({ identity, instance }),
-			Open: ({
-				instance,
+) {
+	const identity = yield* Peer
+	const scope = yield* Effect.scope
+	const mux = yield* Multiplex.make(channel)
+	const peer = yield* Port.make(Wire.channel(mux, 0), {
+		session: "session-v1",
+		serve: { session: Wire.Session },
+		call: {},
+	})
+	const attached = yield* Ref.make(Option.none<string>())
+	const loading = yield* Semaphore.make(1)
+	const authorize = (handle: Handle) =>
+		handle.key.identity === identity
+			? Effect.void
+			: Effect.fail(
+					SessionAccessDenied.make({
+						detail: "The session belongs to another authenticated identity",
+					}),
+				)
+	const handlers = yield* Wire.Session.toHandlers({
+		HighWater: ({ instance }) => supervisor.highWater({ identity, instance }),
+		Open: ({ instance, requestId, expectedGeneration, leaseMillis, limits }) =>
+			supervisor.open({
+				key: { identity, instance },
 				requestId,
 				expectedGeneration,
-				leaseMillis,
+				...(leaseMillis === undefined ? {} : { lease: leaseMillis }),
 				limits,
-			}) =>
-				supervisor.open({
-					key: { identity, instance },
-					requestId,
-					expectedGeneration,
-					...(leaseMillis === undefined ? {} : { lease: leaseMillis }),
-					limits,
-				}),
-			Load: ({ handle, ...request }) =>
-				Effect.gen(function* () {
-					yield* authorize(handle)
-					const attachment = yield* Ref.get(attached)
-					if (Option.isSome(attachment) && attachment.value !== handle.token)
-						return yield* SessionConflict.make({
-							detail: "A connection can attach only one execution",
-						})
-					const code = yield* supervisor.load(handle, request)
-					if (Option.isNone(attachment)) {
-						const child = yield* execution
-							.peer(handle.token)
-							.pipe(Scope.provide(scope))
-						yield* Ref.set(attached, Option.some(handle.token))
-						// A child EOF must not destroy the session channel before Dispose can acknowledge exit.
-						yield* Effect.all(
-							[
-								Effect.forever(
-									Effect.flatMap(mux.take(1), (bytes) => child.send(1, bytes)),
-								),
-								Effect.forever(
-									Effect.flatMap(child.take(1), (bytes) => mux.send(1, bytes)),
-								),
-							],
-							{ concurrency: "unbounded" },
-						).pipe(
-							Effect.catchCause((cause) =>
-								Cause.hasInterruptsOnly(cause)
-									? Effect.void
-									: child.fail(TransportError.make({ cause })),
-							),
-							Effect.forkIn(scope),
-						)
-					}
-					return code
-				}).pipe(loading.withPermit),
-			Renew: (handle) =>
-				authorize(handle).pipe(Effect.andThen(supervisor.renew(handle))),
-			Dispose: (handle) =>
-				authorize(handle).pipe(Effect.andThen(supervisor.dispose(handle))),
-			Status: (handle) =>
-				authorize(handle).pipe(Effect.andThen(supervisor.status(handle))),
-		})
-		return yield* RpcServer.make(Wire.Session, {
-			disableFatalDefects: true,
-		}).pipe(
-			Effect.provideContext(handlers),
-			Effect.provideService(RpcServer.Protocol, peer.serverProtocol("session")),
-			Effect.raceFirst(mux.await),
-		)
+			}),
+		Load: Effect.fnUntraced(function* ({ handle, ...request }) {
+			yield* authorize(handle)
+			const attachment = yield* Ref.get(attached)
+			if (Option.isSome(attachment) && attachment.value !== handle.token)
+				return yield* SessionConflict.make({
+					detail: "A connection can attach only one execution",
+				})
+			const code = yield* supervisor.load(handle, request)
+			if (Option.isNone(attachment)) {
+				const child = yield* execution
+					.peer(handle.token)
+					.pipe(Scope.provide(scope))
+				yield* Ref.set(attached, Option.some(handle.token))
+				// A child EOF must not destroy the session channel before Dispose can acknowledge exit.
+				yield* Effect.all(
+					[
+						Effect.forever(
+							Effect.flatMap(mux.take(1), (bytes) => child.send(1, bytes)),
+						),
+						Effect.forever(
+							Effect.flatMap(child.take(1), (bytes) => mux.send(1, bytes)),
+						),
+					],
+					{ concurrency: "unbounded" },
+				).pipe(
+					Effect.catchCause((cause) =>
+						Cause.hasInterruptsOnly(cause)
+							? Effect.void
+							: child.fail(TransportError.make({ cause })),
+					),
+					Effect.forkIn(scope),
+				)
+			}
+			return code
+		}, loading.withPermit),
+		Renew: (handle) =>
+			authorize(handle).pipe(Effect.andThen(supervisor.renew(handle))),
+		Dispose: (handle) =>
+			authorize(handle).pipe(Effect.andThen(supervisor.dispose(handle))),
+		Status: (handle) =>
+			authorize(handle).pipe(Effect.andThen(supervisor.status(handle))),
 	})
+	return yield* RpcServer.make(Wire.Session, {
+		disableFatalDefects: true,
+	}).pipe(
+		Effect.provideContext(handlers),
+		Effect.provideService(RpcServer.Protocol, peer.serverProtocol("session")),
+		Effect.raceFirst(mux.await),
+	)
+})

package/src/internal/runner/model.ts

@@ -337,28 +337,27 @@ export class RemoteTerminationUnconfirmed extends Schema.TaggedError<
 	{ readonly brand: unique symbol }
 >()("RemoteTerminationUnconfirmed", { handle: Handle }) {}
 /** Losing contact never becomes a successful stop merely because a lease duration passed. */
-export const awaitTermination = <E, R>(
+export const awaitTermination = Effect.fnUntraced(function* <E, R>(
 	handle: Handle,
 	confirmation: Effect.Effect<Termination, E, R>,
 	leaseMillis: number,
 	marginMillis: number,
-) =>
-	Effect.gen(function* () {
-		const [elapsed, result] = yield* Effect.exit(
-			Effect.timeoutOption(confirmation, leaseMillis + marginMillis),
-		).pipe(Effect.timed)
-		if (result._tag === "Success") {
-			if (Option.isSome(result.value)) return result.value.value
-			return yield* RemoteTerminationUnconfirmed.make({ handle })
-		}
-		// Confirmation and the disconnected wait share one deadline.
-		yield* Effect.sleep(
-			Math.max(0, leaseMillis + marginMillis - Duration.toMillis(elapsed)),
-		)
-		return yield* Effect.failCause(
-			Cause.combine(
-				result.cause,
-				Cause.fail(RemoteTerminationUnconfirmed.make({ handle })),
-			),
-		)
-	})
+) {
+	const [elapsed, result] = yield* Effect.exit(
+		Effect.timeoutOption(confirmation, leaseMillis + marginMillis),
+	).pipe(Effect.timed)
+	if (result._tag === "Success") {
+		if (Option.isSome(result.value)) return result.value.value
+		return yield* RemoteTerminationUnconfirmed.make({ handle })
+	}
+	// Confirmation and the disconnected wait share one deadline.
+	yield* Effect.sleep(
+		Math.max(0, leaseMillis + marginMillis - Duration.toMillis(elapsed)),
+	)
+	return yield* Effect.failCause(
+		Cause.combine(
+			result.cause,
+			Cause.fail(RemoteTerminationUnconfirmed.make({ handle })),
+		),
+	)
+})

package/src/internal/serve.ts

@@ -69,19 +69,21 @@ const ready = Plugin.make({
 })
 
 /** Loader logs child cleanup errors; the supervisor's release signal also reaches the command exit. */
-const close = (entries: Fork.Fork, lifecycle: typeof ServeLifecycle.Service) =>
-	Effect.gen(function* () {
-		const disposed = yield* Effect.exit(entries.dispose)
-		const released = yield* Effect.exit(Deferred.await(lifecycle.released))
-		const cause = Array.reduce(
-			[disposed, released],
-			Cause.empty,
-			(cause: Cause.Cause<unknown>, exit: Exit.Exit<void, unknown>) =>
-				Exit.isFailure(exit) ? Cause.combine(cause, exit.cause) : cause,
-		)
-		if (cause.reasons.length > 0)
-			return yield* Effect.failCause(cleanupCause(cause))
-	})
+const close = Effect.fnUntraced(function* (
+	entries: Fork.Fork,
+	lifecycle: typeof ServeLifecycle.Service,
+) {
+	const disposed = yield* Effect.exit(entries.dispose)
+	const released = yield* Effect.exit(Deferred.await(lifecycle.released))
+	const cause = Array.reduce(
+		[disposed, released],
+		Cause.empty,
+		(cause: Cause.Cause<unknown>, exit: Exit.Exit<void, unknown>) =>
+			Exit.isFailure(exit) ? Cause.combine(cause, exit.cause) : cause,
+	)
+	if (cause.reasons.length > 0)
+		return yield* Effect.failCause(cleanupCause(cause))
+})
 
 const load = Effect.fnUntraced(function* (config: string, directory: string) {
 	const lifecycle = yield* make

package/src/internal/services.ts

@@ -1,27 +1,9 @@
 import { Array, Context, Effect, Record } from "effect"
 import { Graft } from "@graftland/graft"
 import { RpcClient, RpcServer } from "effect/rpc"
-import type { Scope } from "effect"
 import type { Rpc, RpcClientError, RpcGroup } from "effect/rpc"
-import type * as Port from "./port"
+import type { Service } from "../Contract"
 
-type Peer = Port.Port
-
-/** RPC types stay inside the descriptor; Graft supplies its dynamic activation context. */
-export interface Service<R = never, ClientR = never> {
-	readonly key: Context.Key<unknown, unknown>
-	readonly group: Pick<RpcGroup.RpcGroup<Rpc.Any>, "requests">
-	readonly serve: (
-		port: Pick<Peer, "serverProtocol">,
-	) => Effect.Effect<never, never, R>
-	readonly publish: (
-		port: Pick<Peer, "clientProtocol">,
-	) => Effect.Effect<
-		void,
-		Graft.ServiceConflict,
-		Graft.Graft | Scope.Scope | ClientR
-	>
-}
 export const service = <
 	I,
 	S,

package/src/internal/watchdogMain.ts

@@ -1,6 +1,6 @@
 /** Executable worker: fd 4 and the lease timer remain independent of the plugin thread. */
 import { NodeRuntime, NodeStream } from "@effect/platform-node"
-import { Effect, FiberHandle, Ref, Schema, Stream } from "effect"
+import { Clock, Effect, FiberHandle, Ref, Schema, Stream } from "effect"
 import { Socket } from "node:net"
 import { parentPort } from "node:worker_threads"
 import process from "node:process"
@@ -17,14 +17,19 @@ const notify = (notice: typeof Notice.Type) =>
 			Effect.sync(() => parentPort?.postMessage(message)),
 		),
 	)
-const now = Effect.sync(() => performance.now())
-const expire = (deadline: number): Effect.Effect<never> =>
-	Effect.gen(function* () {
-		const remaining = deadline - (yield* now)
-		if (remaining <= 0) return yield* die
-		yield* Effect.sleep(Math.min(remaining, 2147483647))
-		return yield* expire(deadline)
-	})
+// Milliseconds on the monotonic clock, which the lease sleep also uses.
+const now = Clock.monotonicTimeNanos.pipe(
+	Effect.map((nanos) => Number(nanos) / 1_000_000),
+)
+const expire = Effect.fnUntraced(function* (
+	deadline: number,
+): Effect.fn.Return<never> {
+	const remaining = deadline - (yield* now)
+	if (remaining <= 0) return yield* die
+	// The clock splits sleeps longer than the platform timer limit.
+	yield* Effect.sleep(remaining)
+	return yield* expire(deadline)
+})
 const main = Effect.scoped(
 	Effect.gen(function* () {
 		const lease = yield* Ref.make({
@@ -45,8 +50,8 @@ const main = Effect.scoped(
 			Stream.decodeText(),
 			Stream.splitLines,
 			Stream.mapEffect((line) => Schema.decodeEffect(CommandJson)(line)),
-			Stream.runForEach((command) =>
-				Effect.gen(function* () {
+			Stream.runForEach(
+				Effect.fnUntraced(function* (command: typeof CommandJson.Type) {
 					if (command.kind === "start") return yield* notify("start")
 					if (command.kind === "stop") {
 						yield* Ref.update(lease, (state) => ({ ...state, stopped: true }))

package/src/internal/websocketServer.ts

@@ -12,12 +12,27 @@ import {
 import { HttpServerRequest, HttpServerResponse } from "effect/http"
 import type { Socket } from "effect/socket"
 import { TLSSocket } from "node:tls"
-import { AuthenticationFailed, TransportError } from "../Errors"
+import {
+	type AuthenticationFailed,
+	type AuthenticatorUnavailable,
+	TransportError,
+} from "../Errors"
 import type { Accept, Handshake, Serving } from "../Transport"
 import * as Channel from "./socketChannel"
 import { path, protocol, payloadLimit } from "./websocket"
 
-const rejection = (error: AuthenticationFailed) =>
+const rejection = (error: AuthenticationFailed | AuthenticatorUnavailable) =>
+	error._tag === "AuthenticatorUnavailable"
+		? unavailable(error)
+		: unauthorized(error)
+
+// The credential was not judged, so the client is told to retry rather than to replace it.
+const unavailable = (error: AuthenticatorUnavailable) =>
+	Effect.logError("Remote host authenticator is unavailable", error.cause).pipe(
+		Effect.as(HttpServerResponse.empty({ status: 503 })),
+	)
+
+const unauthorized = (error: AuthenticationFailed) =>
 	Effect.logWarning(
 		"Remote host authentication failed",
 		{
@@ -83,7 +98,7 @@ const open = Effect.fnUntraced(function* (
 		run: <A, E, R>(
 			accept: Effect.Effect<
 				(socket: Socket.Socket) => Effect.Effect<A, E, R>,
-				AuthenticationFailed,
+				AuthenticationFailed | AuthenticatorUnavailable,
 				HttpServerRequest.HttpServerRequest
 			>,
 		) =>

package/src/runner/auth/jwt.ts

@@ -14,7 +14,7 @@ import { Signature } from "effect/crypto"
 import { HttpClient } from "effect/http"
 import { Authenticator } from "../../Auth"
 import { ConfigDirectory } from "@graftland/loader"
-import { AuthenticationFailed } from "../../Errors"
+import { AuthenticationFailed, AuthenticatorUnavailable } from "../../Errors"
 import * as Token from "../../internal/auth/token"
 
 export const ClockTolerance = Schema.DurationFromString.check(
@@ -97,12 +97,16 @@ export default Plugin.make({
 									verified.claims[config.identityClaim],
 								),
 							),
+							// An unreachable key set says nothing about the token; the client must not discard it.
 							Effect.mapError((error) =>
-								AuthenticationFailed.make({
-									reason: "invalid",
-									challenge: 'Bearer error="invalid_token"',
-									cause: Cause.fail(error),
-								}),
+								error._tag === "JoseError" &&
+								error.reason._tag === "KeySetUnavailable"
+									? AuthenticatorUnavailable.make({ cause: Cause.fail(error) })
+									: AuthenticationFailed.make({
+											reason: "invalid",
+											challenge: 'Bearer error="invalid_token"',
+											cause: Cause.fail(error),
+										}),
 							),
 							Effect.provideService(Signature.Signature, signature),
 							Effect.provideContext(services),

package/dist/cleanup-BPWr-5U9.js

@@ -1,13 +0,0 @@
-import { f as CleanupError } from "./Graft-BsYq3F-J.js";
-import { n as close } from "./release-BY4Mlluy.js";
-import { Array, Cause, Effect, Schema, Scope } from "effect";
-// packages/remote/src/internal/cleanup.ts
-/** Finalizers have no typed failure channel. Keep reasons and their annotations flat. */
-const cleanupCause = (cause) => Cause.fromReasons(Array.flatMap(cause.reasons, (reason) => {
-	const error = reason._tag === "Fail" ? reason.error : reason._tag === "Die" ? reason.defect : void 0;
-	if (Schema.is(CleanupError)(error)) return Array.map(cleanupCause(error.cause).reasons, (inner) => inner.annotate(Cause.reasonAnnotations(reason)));
-	return [reason._tag === "Fail" ? Cause.makeDieReason(reason.error).annotate(Cause.reasonAnnotations(reason)) : reason];
-}));
-/** Assembly children close before the entry reports their cleanup as its own result. */
-const children = Effect.acquireRelease(Scope.make(), (scope, exit) => close(scope, exit).pipe(Effect.catchCause((cause) => Effect.failCause(cleanupCause(cause)))));
-export { cleanupCause as n, children as t };

package/dist/connectionEnded-DUgcobEd.js

@@ -1,9 +0,0 @@
-import { c as TransportError } from "./Errors-oPsTLY7l.js";
-import { t as EndOfStream } from "./Framing-zaYdOJnT.js";
-import { t as Peer } from "./Peer-IJgFK6mD.js";
-import { Array, Cause, Effect, Schema } from "effect";
-import { Socket } from "effect/socket";
-// packages/remote/src/internal/runner/connectionEnded.ts
-const closedNormally = (cause) => cause.reasons.length > 0 && Array.every(cause.reasons, (reason) => reason._tag === "Fail" && (Schema.is(TransportError)(reason.error) ? closedNormally(reason.error.cause) : Schema.is(EndOfStream)(reason.error) || Socket.isSocketError(reason.error) && reason.error.reason._tag === "SocketCloseError" && reason.error.reason.code === 1e3));
-const connectionEnded = (cause) => Cause.hasInterruptsOnly(cause) || closedNormally(cause) ? Effect.void : Effect.flatMap(Peer, (identity) => Effect.logWarning("Remote host connection failed", cause).pipe(Effect.annotateLogs({ "remote.peer": identity })));
-export { connectionEnded as n, closedNormally as t };

package/dist/internal/childErrors.d.ts

@@ -1,33 +0,0 @@
-import { Schema } from "effect";
-declare const AlreadyLoaded_base: Schema.Class<AlreadyLoaded, Schema.TaggedStruct<"AlreadyLoaded", {}>, import("effect/Cause").YieldableError & {
-  readonly brand: unique symbol;
-}>;
-export declare class AlreadyLoaded extends AlreadyLoaded_base {}
-declare const ContractNotFound_base: Schema.Class<ContractNotFound, Schema.TaggedStruct<"ContractNotFound", {
-  readonly module: Schema.String;
-}>, import("effect/Cause").YieldableError & {
-  readonly brand: unique symbol;
-}>;
-export declare class ContractNotFound extends ContractNotFound_base {
-  get message(): string;
-}
-declare const ModuleImportFailed_base: Schema.Class<ModuleImportFailed, Schema.TaggedStruct<"ModuleImportFailed", {
-  readonly module: Schema.String;
-  readonly cause: Schema.Defect;
-}>, import("effect/Cause").YieldableError & {
-  readonly brand: unique symbol;
-}>;
-export declare class ModuleImportFailed extends ModuleImportFailed_base {}
-declare const ActivationFailed_base: Schema.Class<ActivationFailed, Schema.TaggedStruct<"ActivationFailed", {
-  readonly detail: Schema.String;
-  readonly cause: Schema.optionalKey<Schema.Cause<Schema.Defect, Schema.Defect>>;
-}>, import("effect/Cause").YieldableError & {
-  readonly brand: unique symbol;
-}>;
-export declare class ActivationFailed extends ActivationFailed_base {
-  get message(): string;
-}
-export declare const ChildFailure: Schema.Union<readonly [typeof AlreadyLoaded, typeof ContractNotFound, typeof ModuleImportFailed, typeof ActivationFailed]>;
-export type ChildFailure = typeof ChildFailure.Type;
-export {};
-//# sourceMappingURL=childErrors.d.ts.map

package/dist/internal/childErrors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"childErrors.d.ts","names":[],"sources":["../../src/internal/childErrors.ts"],"mappings":";;WAImB;;qBAFN,sBAAsB;;;;WAMhB;;qBAFN,yBAAyB;MAIxB;;;;;;WAMK;;qBAFN,2BAA2B;;;;;WASrB;;qBAFN,yBAAyB;MAYxB;;qBAID,cAAY,OAAA,uBAAA,sBAAA,yBAAA,2BAAA;YAMb,sBAAsB,aAAa"}

package/dist/internal/port.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"port.d.ts","names":[],"sources":["../../src/internal/port.ts"],"mappings":";;;;;iBAgDiB;WACP,iBAAiB,qBAAqB,UAAU;WAChD,iBAAiB,qBAAqB,UAAU;WAChD,OAAO,OAAO,cAAc;WAC5B,OAAO,OAAO,mBAAmB,OAAO;WACxC,KAAK,OAAO,aAAa"}

package/dist/internal/runner/Framing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Framing.d.ts","names":[],"sources":["../../../src/internal/runner/Framing.ts"],"mappings":";;;;WAImB;;qBAFN,mBAAmB;MAIlB"}