@graftland/plugin-remote 0.3.2 → 0.4.0

package/dist/port--3x2zJ4D.js

@@ -1,285 +0,0 @@
-import { t as EndOfStream } from "./Framing-G9eSaeLb.js";
-import { t as make$1 } from "./FailureGroup-BgT73AaR.js";
-import { u as TransportError } from "./Errors-DYhsGZcZ.js";
-import { Array, Cause, Context, Data, Deferred, Effect, Fiber, HashMap, Option, Queue, Record, Result, Schema, Stream, TxQueue, TxRef } from "effect";
-import { RpcClient, RpcClientError, RpcSerialization, RpcServer } from "effect/rpc";
-// packages/remote/src/internal/Limits.ts
-const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));
-const PositiveFinite = Schema.Finite.check(Schema.isGreaterThan(0));
-const Limits = Schema.Struct({
-	control: PositiveInt,
-	data: PositiveInt,
-	log: PositiveInt
-});
-const defaults = {
-	control: 8,
-	data: 16,
-	log: 2
-};
-// packages/remote/src/internal/port.ts
-const Priority = Context.Reference("@graftland/plugin-remote/internal/port/Priority", { defaultValue: () => "data" });
-var RequestKey = class extends Data.Class {};
-const Frame = Schema.Struct({
-	session: Schema.String,
-	endpoint: Schema.String,
-	direction: Schema.Literals(["request", "response"]),
-	priority: Schema.Literals([
-		"control",
-		"data",
-		"log"
-	]),
-	message: Schema.Unknown
-});
-const Id = Schema.Union([Schema.String, Schema.Finite]);
-const isRequest = Schema.is(Schema.Union([
-	Schema.TaggedStruct("Request", {
-		id: Id,
-		tag: Schema.String
-	}),
-	Schema.TaggedStruct("Ack", { requestId: Id }),
-	Schema.TaggedStruct("Interrupt", { requestId: Id }),
-	Schema.TaggedStruct("Eof", {})
-]));
-const isResponse = Schema.is(Schema.Union([
-	Schema.TaggedStruct("Exit", { requestId: Id }),
-	Schema.TaggedStruct("Chunk", { requestId: Id }),
-	Schema.TaggedStruct("Defect", { defect: Schema.Unknown })
-]));
-const Request = Schema.declare((input) => isRequest(input));
-const Response = Schema.declare((input) => isResponse(input));
-const error = (message) => TransportError.make({ cause: Cause.die(new Error(message)) });
-const rpcError = (cause) => RpcClientError.RpcClientError.make({ reason: RpcClientError.RpcClientDefect.make({
-	message: "Remote connection failed",
-	cause
-}) });
-const priority = (group, tag) => {
-	const rpc = group.requests.get(tag);
-	return rpc === void 0 ? "data" : Context.get(rpc.annotations, Priority);
-};
-const mailbox = (priority) => Queue.dropping(2).pipe(Effect.map((queue) => ({
-	queue,
-	priority,
-	sent: false
-})));
-const deliver = Effect.fnUntraced(function* (requestState, message) {
-	if (!(yield* Queue.offer(requestState.queue, message))) return yield* error("RPC request mailbox overflow");
-});
-const initialize = Effect.fnUntraced(function* (bytes, options) {
-	return {
-		bytes,
-		options,
-		limits: {
-			...defaults,
-			...options.limits
-		},
-		workers: yield* make$1(),
-		incoming: yield* TxRef.make(HashMap.empty()),
-		outgoing: yield* TxRef.make(HashMap.empty()),
-		queues: {
-			control: yield* TxQueue.unbounded(),
-			data: yield* TxQueue.unbounded(),
-			log: yield* TxQueue.unbounded()
-		},
-		servers: yield* Effect.forEach(Record.toEntries(options.serve), Effect.fnUntraced(function* ([name, group]) {
-			return [name, {
-				group,
-				ready: yield* Deferred.make(),
-				disconnects: yield* Queue.dropping(1)
-			}];
-		})).pipe(Effect.map(HashMap.fromIterable)),
-		clients: yield* Effect.forEach(Record.toEntries(options.call), Effect.fnUntraced(function* ([name, group]) {
-			return [name, {
-				group,
-				ready: yield* Deferred.make()
-			}];
-		})).pipe(Effect.map(HashMap.fromIterable))
-	};
-});
-const admit = Effect.fnUntraced(function* (state, table, key, requestState, direction) {
-	yield* Effect.tx(Effect.gen(function* () {
-		yield* state.workers.check;
-		const current = yield* TxRef.get(table);
-		if (Array.filter(Array.fromIterable(HashMap.values(current)), (entry) => entry.priority === requestState.priority).length >= state.limits[requestState.priority]) {
-			if (direction === "outgoing") return yield* Effect.txRetry;
-			return yield* error(`RPC admission limit exceeded for ${requestState.priority}`);
-		}
-		yield* TxRef.set(table, HashMap.set(current, key, requestState));
-	}));
-});
-const remove = Effect.fnUntraced(function* (table, key, requestState) {
-	yield* TxRef.update(table, HashMap.remove(key));
-	yield* Queue.end(requestState.queue);
-});
-const enqueue = (state, frame, request = Option.none()) => Effect.tx(state.workers.check.pipe(Effect.andThen(TxQueue.offer(state.queues[frame.priority], {
-	frame,
-	request
-}).pipe(Effect.flatMap((accepted) => accepted ? Effect.void : error("Remote output has ended")))), Effect.asVoid));
-const frame = (state, endpoint, direction, p, message) => ({
-	session: state.options.session,
-	endpoint,
-	direction,
-	priority: p,
-	message
-});
-const send = Effect.fnUntraced(function* (state, effect) {
-	const fiber = yield* state.workers.run(state.workers.check.pipe(Effect.andThen(effect)));
-	const result = yield* Fiber.await(fiber).pipe(Effect.onInterrupt(() => Fiber.interrupt(fiber)));
-	yield* state.workers.check;
-	yield* result;
-});
-const cancel = Effect.fnUntraced(function* (state, key) {
-	const canceled = yield* Effect.tx(Effect.gen(function* () {
-		const table = yield* TxRef.get(state.outgoing);
-		const requestState = HashMap.get(table, key);
-		if (Option.isNone(requestState)) return Option.none();
-		if (requestState.value.sent) {
-			yield* enqueue(state, frame(state, key.endpoint, "request", "control", {
-				_tag: "Interrupt",
-				requestId: key.id
-			}));
-			return Option.none();
-		}
-		yield* TxRef.set(state.outgoing, HashMap.remove(table, key));
-		return requestState;
-	}));
-	if (Option.isSome(canceled)) yield* Queue.end(canceled.value.queue);
-});
-const clientProtocol = (state, endpoint) => {
-	const client = Option.getOrThrow(HashMap.get(state.clients, endpoint));
-	return RpcClient.Protocol.of({
-		codecFor: RpcSerialization.json.codecFor,
-		supportsAck: true,
-		supportsTransferables: false,
-		run: (_id, receive) => Deferred.succeed(client.ready, receive).pipe(Effect.andThen(state.workers.await), Effect.catchCause((cause) => receive({
-			_tag: "ClientProtocolError",
-			error: rpcError(cause)
-		})), Effect.andThen(Effect.never)),
-		send: (_id, message) => send(state, Effect.gen(function* () {
-			if (message._tag === "Request") {
-				if (message.discard === true || message.isNotification === true) return yield* error("Discard and notification requests are not supported");
-				const key = new RequestKey({
-					endpoint,
-					id: message.id
-				});
-				const requestState = yield* mailbox(priority(client.group, message.tag));
-				yield* admit(state, state.outgoing, key, requestState, "outgoing");
-				yield* state.workers.run(Stream.fromQueue(requestState.queue).pipe(Stream.runForEach(Effect.fnUntraced(function* (response) {
-					const receive = yield* Deferred.await(client.ready);
-					if (response._tag === "Exit") yield* remove(state.outgoing, key, requestState);
-					yield* receive(response);
-				}))));
-				yield* enqueue(state, frame(state, endpoint, "request", requestState.priority, message), Option.some(key));
-			} else if (message._tag === "Interrupt") yield* cancel(state, new RequestKey({
-				endpoint,
-				id: message.requestId
-			}));
-			else if (message._tag === "Ack") yield* enqueue(state, frame(state, endpoint, "request", "control", message));
-		})).pipe(Effect.mapError((failure) => rpcError(Cause.fail(failure))))
-	});
-};
-const serverProtocol = (state, endpoint) => {
-	const server = Option.getOrThrow(HashMap.get(state.servers, endpoint));
-	return RpcServer.Protocol.of({
-		codecFor: RpcSerialization.json.codecFor,
-		supportsAck: true,
-		supportsTransferables: false,
-		supportsSpanPropagation: false,
-		supportsNotifications: false,
-		clientIds: Effect.succeed(/* @__PURE__ */ new Set([0])),
-		initialMessage: Effect.succeedNone,
-		disconnects: server.disconnects,
-		end: () => Effect.void,
-		run: (receive) => Deferred.succeed(server.ready, receive).pipe(Effect.andThen(Effect.never)),
-		send: (_id, message) => send(state, Effect.gen(function* () {
-			if (message._tag === "Chunk" || message._tag === "Exit") {
-				const key = new RequestKey({
-					endpoint,
-					id: message.requestId
-				});
-				const requestState = yield* TxRef.get(state.incoming).pipe(Effect.map(HashMap.get(key)));
-				if (Option.isNone(requestState)) return;
-				yield* enqueue(state, frame(state, endpoint, "response", message._tag === "Exit" ? "control" : requestState.value.priority, message));
-				if (message._tag === "Exit") yield* remove(state.incoming, key, requestState.value);
-			} else yield* enqueue(state, frame(state, endpoint, "response", "control", message));
-		})).pipe(Effect.catchTag("TransportError", () => Effect.void))
-	});
-};
-const next = Effect.fnUntraced(function* (state) {
-	yield* state.workers.check;
-	for (const p of [
-		"control",
-		"data",
-		"log"
-	]) {
-		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();
-			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))) return yield* Cause.done();
-	return yield* Effect.txRetry;
-}, Effect.tx);
-const writer = (state) => Stream.fromEffectRepeat(next(state)).pipe(Stream.filterMap(Result.fromOption(() => void 0)), Stream.mapEffect((frame) => Schema.encodeEffect(Schema.fromJsonString(Frame))(frame).pipe(Effect.mapError((cause) => TransportError.make({ cause: Cause.fail(cause) })))), Stream.map((json) => new TextEncoder().encode(json + "\n")), Stream.run(state.bytes.output));
-const read = Effect.fnUntraced(function* (state, raw) {
-	const current = yield* Schema.decodeUnknownEffect(Frame)(raw).pipe(Effect.mapError((cause) => TransportError.make({ cause: Cause.fail(cause) })));
-	if (current.session !== state.options.session) return;
-	if (current.direction === "request") {
-		const server = HashMap.get(state.servers, current.endpoint);
-		if (Option.isNone(server)) return yield* error(`Unknown RPC server endpoint: ${current.endpoint}`);
-		const message = yield* Schema.decodeUnknownEffect(Request)(current.message).pipe(Effect.mapError((cause) => TransportError.make({ cause: Cause.fail(cause) })));
-		if (message._tag === "Eof") return yield* TransportError.make({ cause: Cause.fail(EndOfStream.make({})) });
-		const key = new RequestKey({
-			endpoint: current.endpoint,
-			id: message._tag === "Request" ? message.id : message.requestId
-		});
-		if (message._tag === "Request") {
-			const p = priority(server.value.group, message.tag);
-			const requestState = yield* mailbox(p);
-			yield* admit(state, state.incoming, key, requestState, "incoming");
-			yield* state.workers.run(Stream.fromQueue(requestState.queue).pipe(Stream.runForEach(Effect.fnUntraced(function* (request) {
-				yield* (yield* Deferred.await(server.value.ready))(0, request);
-			}))));
-			yield* deliver(requestState, message);
-		} else {
-			const requestState = yield* TxRef.get(state.incoming).pipe(Effect.map(HashMap.get(key)));
-			if (Option.isSome(requestState)) yield* deliver(requestState.value, message);
-		}
-	} else {
-		const message = yield* Schema.decodeUnknownEffect(Response)(current.message).pipe(Effect.mapError((cause) => TransportError.make({ cause: Cause.fail(cause) })));
-		if (message._tag === "Defect") return yield* TransportError.make({ cause: Cause.die(message.defect) });
-		const key = new RequestKey({
-			endpoint: current.endpoint,
-			id: message.requestId
-		});
-		const requestState = yield* TxRef.get(state.outgoing).pipe(Effect.map(HashMap.get(key)));
-		if (Option.isSome(requestState)) yield* deliver(requestState.value, message);
-	}
-});
-const reader = (state) => state.bytes.input.pipe(Stream.decodeText(), Stream.splitLines, Stream.filter((line) => line.length > 0), Stream.mapEffect((line) => Schema.decodeEffect(Schema.fromJsonString(Schema.Unknown))(line).pipe(Effect.mapError((cause) => TransportError.make({ cause: Cause.fail(cause) })))), Stream.runForEach((raw) => read(state, raw)), Effect.andThen(Effect.fail(TransportError.make({ cause: Cause.fail(EndOfStream.make({})) }))));
-/** One RPC client/server per declared endpoint; servers may start after the port. */
-const make = Effect.fnUntraced(function* (bytes, options) {
-	const state = yield* initialize(bytes, options);
-	yield* state.workers.await.pipe(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);
-	const writing = yield* state.workers.run(writer(state));
-	yield* state.workers.run(reader(state));
-	return {
-		clientProtocol: (endpoint) => clientProtocol(state, endpoint),
-		serverProtocol: (endpoint) => serverProtocol(state, endpoint),
-		await: state.workers.await,
-		fail: state.workers.fail,
-		end: Effect.tx(Effect.forEach(Record.values(state.queues), TxQueue.end, { discard: true })).pipe(Effect.andThen(Fiber.join(writing)))
-	};
-});
-export { PositiveInt as a, PositiveFinite as i, make as n, defaults as o, Limits as r, Priority as t };

package/dist/release-DfZPuIcK.js

@@ -1,23 +0,0 @@
-import { Array, Cause, Effect, Exit, Result, Schema, Scope } from "effect";
-// packages/remote/src/internal/release.ts
-/** Resource release was interrupted, rather than successfully cancelled. */
-var ReleaseInterrupted = class extends Schema.TaggedError()("ReleaseInterrupted", { cause: Schema.Cause(Schema.Never, Schema.Unknown) }) {
-	get message() {
-		return "Resource release was interrupted";
-	}
-};
-/** Keep a known release failure distinguishable from cancellation through enclosing scopes. */
-const close = (scope, exit) => Effect.uninterruptible(Scope.close(scope, exit).pipe(Effect.catchCauseIf(Cause.hasInterruptsOnly, Effect.fnUntraced(function* (cause) {
-	const pending = yield* Effect.exit(Effect.interruptible(Effect.void));
-	const [cancelled, interrupted] = Array.partition(cause.reasons, (reason) => Exit.isFailure(pending) && Array.some(pending.cause.reasons, (external) => reason._tag === "Interrupt" && external._tag === "Interrupt" && reason.fiberId === external.fiberId) ? Result.succeed(reason) : Result.fail(reason));
-	if (interrupted.length === 0) return yield* Effect.failCause(cause);
-	return yield* Effect.failCause(Cause.combine(Cause.fromReasons(cancelled), Cause.die(ReleaseInterrupted.make({ cause: Cause.fromReasons(interrupted) }))));
-}))));
-const scoped = (effect) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
-	const scope = yield* Scope.make();
-	const body = yield* Effect.exit(restore(Scope.provide(scope)(effect)));
-	const closed = yield* Effect.exit(close(scope, body));
-	if (Exit.isFailure(closed)) return yield* Effect.failCause(Exit.isFailure(body) ? Cause.combine(body.cause, closed.cause) : closed.cause);
-	return yield* body;
-}));
-export { close as n, scoped as r, ReleaseInterrupted as t };

package/dist/rolldown-runtime-DYf_mQCB.js

@@ -1,34 +0,0 @@
-import { createRequire } from "node:module";
-// \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod, mod.exports), cb = null), mod.exports);
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
-export { __toESM as i, __exportAll as n, __require as r, __commonJSMin as t };