@graftland/plugin-remote 0.3.3 → 0.4.1

package/dist/Contract-DsJtisvL.js

@@ -1,83 +0,0 @@
-import { n as __exportAll } from "./rolldown-runtime-DYf_mQCB.js";
-import { t as Priority } from "./port--3x2zJ4D.js";
-import { a as provide } from "./Graft-B71CPA2Y.js";
-import { Array, Context, Effect, Predicate, Record, Schema } from "effect";
-import { Rpc, RpcClient, RpcGroup, RpcServer } from "effect/rpc";
-// packages/remote/src/internal/control.ts
-const Log = Schema.Struct({
-	level: Schema.Literals([
-		"Fatal",
-		"Error",
-		"Warn",
-		"Info",
-		"Debug",
-		"Trace",
-		"All",
-		"None"
-	]),
-	message: Schema.Defect({ includeStack: true }),
-	cause: Schema.Json,
-	annotations: Schema.Record(Schema.String, Schema.Defect({ includeStack: true }))
-});
-const Event = Schema.Union([
-	Schema.TaggedStruct("Failed", { cause: Schema.Json }),
-	Schema.TaggedStruct("Stopped", {}),
-	Schema.TaggedStruct("Withdrawing", {})
-]);
-const LogEvent = Schema.Union([Schema.TaggedStruct("Log", {
-	entry: Log,
-	dropped: Schema.Int
-}), Schema.TaggedStruct("LogsEnded", { dropped: Schema.Int })]);
-const endpoint = "@graftland/plugin-remote/control";
-const make$1 = (cause) => RpcGroup.make(Rpc.make("Load", {
-	payload: { input: Schema.Json },
-	error: cause
-}), Rpc.make("Events", {
-	success: Event,
-	stream: true
-}), Rpc.make("Dispose", { error: cause })).annotateRpcs(Priority, "control").add(Rpc.make("Logs", {
-	success: LogEvent,
-	stream: true
-}).annotate(Priority, "log"));
-// packages/remote/src/internal/services.ts
-const service = (key, group, mapping) => ({
-	key,
-	group,
-	serve: Effect.fnUntraced(function* (port) {
-		const context = yield* Effect.context();
-		const value = yield* Effect.fromOption(Context.getOption(context, key)).pipe(Effect.orDie);
-		const handlers = yield* group.toHandlers(mapping.toHandlers(value));
-		return yield* RpcServer.make(group, { disableFatalDefects: true }).pipe(Effect.provideContext(handlers), Effect.provideService(RpcServer.Protocol, port.serverProtocol(key.key)));
-	}),
-	publish: Effect.fnUntraced(function* (port) {
-		const client = yield* RpcClient.make(group).pipe(Effect.provideService(RpcClient.Protocol, port.clientProtocol(key.key)));
-		yield* provide(key, mapping.fromClient(client));
-	})
-});
-const endpoints = (services) => Record.fromEntries(Array.map(services, (service) => [service.key.key, service.group]));
-// packages/remote/src/Contract.ts
-var Contract_exports = /* @__PURE__ */ __exportAll({
-	UndeclaredFailure: () => UndeclaredFailure,
-	fromModule: () => fromModule,
-	isContract: () => isContract,
-	make: () => make,
-	service: () => service
-});
-const TypeId = "~@graftland/plugin-remote/Contract";
-/** An undeclared failure still crosses the boundary, with its diagnostic value. */
-var UndeclaredFailure = class extends Schema.TaggedError()("UndeclaredFailure", { original: Schema.Defect({ includeStack: true }) }) {};
-function make(options) {
-	const keys = Array.map([...options.inject ?? [], ...options.provides ?? []], (service) => service.key.key);
-	if (Array.dedupe(keys).length !== keys.length || keys.includes("@graftland/plugin-remote/control")) throw new Error("Service keys must be unique within a remote contract and must not use the control endpoint");
-	return {
-		...options,
-		error: options.error ?? Schema.Never,
-		inject: options.inject ?? [],
-		provides: options.provides ?? [],
-		[TypeId]: TypeId
-	};
-}
-const isContract = (value) => Predicate.hasProperty(value, TypeId) && value[TypeId] === TypeId;
-/** A contract module exports either default or a named contract. */
-const fromModule = (module) => Array.findFirst([Predicate.hasProperty(module, "default") ? module.default : void 0, Predicate.hasProperty(module, "contract") ? module.contract : void 0], isContract);
-export { make as a, endpoint as c, isContract as i, make$1 as l, UndeclaredFailure as n, endpoints as o, fromModule as r, service as s, Contract_exports as t };

package/dist/Errors-DYhsGZcZ.js

@@ -1,58 +0,0 @@
-import { Option, Schema } from "effect";
-// packages/remote/src/Errors.ts
-var ProcessExited = class extends Schema.TaggedError()("ProcessExited", {
-	pid: Schema.Option(Schema.Int),
-	threadId: Schema.optionalKey(Schema.Int),
-	exitCode: Schema.NullOr(Schema.Int),
-	stderr: Schema.String,
-	statusCause: Schema.Cause(Schema.Unknown, Schema.Unknown)
-}) {
-	get message() {
-		return this.threadId !== void 0 ? `Remote worker ${this.threadId} exited unexpectedly (${this.exitCode})` : `Remote process${Option.isSome(this.pid) ? ` ${this.pid.value}` : ""} exited unexpectedly (${this.exitCode ?? "signal"})`;
-	}
-};
-var TransportError = class extends Schema.TaggedError()("TransportError", { cause: Schema.Cause(Schema.Unknown, Schema.Unknown) }) {};
-/** The remote export lease was withdrawn; host consumers must drain before Dispose. */
-var RemoteWithdrawn = class extends Schema.TaggedError()("RemoteWithdrawn", {}) {
-	get message() {
-		return "Remote services were withdrawn";
-	}
-};
-/** Infrastructure failure at the plugin boundary; the complete underlying cause remains inspectable. */
-var RemoteError = class extends Schema.TaggedError()("RemoteError", { cause: Schema.Cause(Schema.Unknown, Schema.Unknown) }) {};
-/** A network execution needs a stable logical identity across host restarts. */
-var MissingInstance = class extends Schema.TaggedError()("MissingInstance", {}) {
-	get message() {
-		return "A runner connection requires an instance or a loader entry id; set connect.instance when loading without Loader.";
-	}
-};
-/** Dispose completed, but Node still owns live handles; process-scope cleanup must terminate it. */
-var LocalTerminationTimeout = class extends Schema.TaggedError()("LocalTerminationTimeout", {
-	pid: Schema.optionalKey(Schema.Int),
-	threadId: Schema.optionalKey(Schema.Int)
-}) {
-	get message() {
-		return this.threadId !== void 0 ? `Remote worker ${this.threadId} did not exit within one second after Dispose; terminating it` : `Remote process ${this.pid} did not exit within one second after Dispose; terminating it`;
-	}
-};
-/** A credential source failed; the original failure remains available. */
-var CredentialsError = class extends Schema.TaggedError()("CredentialsError", { cause: Schema.Cause(Schema.Unknown, Schema.Unknown) }) {};
-var AuthenticationFailed = class extends Schema.TaggedError()("AuthenticationFailed", {
-	reason: Schema.Literals(["missing", "invalid"]),
-	challenge: Schema.optionalKey(Schema.String),
-	cause: Schema.optionalKey(Schema.Cause(Schema.Unknown, Schema.Unknown))
-}) {};
-/** The authenticator could not reach what it needs to decide, such as its key set; the credential may still be valid. */
-var AuthenticatorUnavailable = class extends Schema.TaggedError()("AuthenticatorUnavailable", { cause: Schema.Cause(Schema.Unknown, Schema.Unknown) }) {};
-/** A remote entry could not be resolved or configured at the indicated field. */
-var RemoteEntryError = class extends Schema.TaggedError()("RemoteEntryError", {
-	entry: Schema.Option(Schema.String),
-	directory: Schema.Option(Schema.String),
-	field: Schema.String,
-	cause: Schema.Cause(Schema.Unknown, Schema.Unknown)
-}) {
-	get message() {
-		return `Remote entry ${Option.getOrElse(this.entry, () => "<programmatic>")} failed at ${this.field}`;
-	}
-};
-export { MissingInstance as a, RemoteError as c, LocalTerminationTimeout as i, RemoteWithdrawn as l, AuthenticatorUnavailable as n, ProcessExited as o, CredentialsError as r, RemoteEntryError as s, AuthenticationFailed as t, TransportError as u };

package/dist/FailureGroup-BgT73AaR.js

@@ -1,63 +0,0 @@
-import { n as close, t as ReleaseInterrupted } from "./release-DfZPuIcK.js";
-import { f as CleanupError } from "./Graft-B71CPA2Y.js";
-import { Array, Cause, Data, Deferred, Effect, Exit, Fiber, FiberSet, Ref, Schema, Scope, TxRef } 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)))));
-// packages/remote/src/internal/FailureGroup.ts
-const State = Data.taggedEnum();
-/** One owner for first failure, transaction wakeups, and interruption of sibling work. */
-const make = Effect.fnUntraced(function* () {
-	const fibers = yield* FiberSet.make();
-	const state = yield* TxRef.make(State.Open());
-	const failures = yield* Ref.make(Cause.empty);
-	const cleanup = yield* Ref.make(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) => TxRef.update(state, (s) => s._tag === "Open" ? State.Failed({ cause }) : s);
-	const observe = (effect) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
-		const scope = yield* Scope.make();
-		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(close(scope, body));
-		const expected = Exit.isFailure(waiting) && Exit.isFailure(body) && Array.every(body.cause.reasons, (reason) => reason._tag === "Interrupt" && reason.fiberId === ownerId);
-		const bodyCause = Exit.isFailure(body) && !expected ? body.cause : Cause.empty;
-		const releaseCause = Exit.isFailure(closed) && !Cause.hasInterruptsOnly(closed.cause) ? closed.cause : Cause.empty;
-		const failure = Cause.combine(bodyCause, releaseCause);
-		const closing = Cause.combine(Cause.hasInterrupts(bodyCause) || Array.some(bodyCause.reasons, (reason) => reason._tag === "Die" && Schema.is(ReleaseInterrupted)(reason.defect)) ? 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);
-		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);
-	const failure = Effect.tx(check.pipe(Effect.andThen(Effect.txRetry)));
-	const failCause = (cause) => FiberSet.run(fibers, observe(Effect.failCause(cause))).pipe(Effect.asVoid);
-	const close$1 = 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);
-	yield* Effect.addFinalizer(() => close$1.pipe(Effect.catchCause((cause) => Effect.failCause(cleanupCause(cause)))));
-	return {
-		await: failure,
-		check,
-		cause: Ref.get(failures),
-		runtime: () => FiberSet.runtime(fibers)().pipe(Effect.map((run) => (effect) => 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: close$1
-	};
-});
-export { children as n, cleanupCause as r, make as t };

package/dist/Framing-G9eSaeLb.js

@@ -1,61 +0,0 @@
-import { Array, Effect, MutableRef, Option, Result, Schema } from "effect";
-// packages/remote/src/internal/runner/Framing.ts
-var FrameError = class extends Schema.TaggedError()("FrameError", { detail: Schema.String }) {
-	get message() {
-		return this.detail;
-	}
-};
-/** A complete byte stream ended; malformed trailing bytes remain FrameError. */
-var EndOfStream = class extends Schema.TaggedError()("RunnerEndOfStream", {}) {
-	get message() {
-		return "Runner byte channel ended";
-	}
-};
-const maxPayload = 1048576;
-const invalid = (detail) => FrameError.make({ detail });
-/** Version 2 carries only channel and length; request admission belongs to port. */
-const encode = Effect.fnUntraced(function* (frame) {
-	if (frame.payload.byteLength > 1048576) return yield* invalid("Runner frame exceeds the payload limit");
-	const bytes = new Uint8Array(8 + frame.payload.byteLength);
-	bytes.set([
-		2,
-		frame.channel,
-		0,
-		0
-	]);
-	new DataView(bytes.buffer).setUint32(4, frame.payload.byteLength);
-	bytes.set(frame.payload, 8);
-	return bytes;
-});
-/** Check a message boundary; the decoder still validates the frame's contents. */
-const isCompleteFrame = (bytes) => bytes.byteLength >= 8 && new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(4) === bytes.byteLength - 8;
-/** The decoder owns its byte buffer. Results expose malformed frames without throwing through a generator. */
-const decoder = () => {
-	const pending = MutableRef.make(Result.succeed(/* @__PURE__ */ new Uint8Array(0)));
-	const decode = (chunk) => Result.flatMap(MutableRef.get(pending), (previous) => {
-		const bytes = new Uint8Array(previous.length + chunk.length);
-		bytes.set(previous);
-		bytes.set(chunk, previous.length);
-		const frames = Array.unfold(0, (offset) => {
-			if (bytes.length - offset < 8) return Option.none();
-			const header = new DataView(bytes.buffer, offset, 8);
-			const channel = header.getUint8(1);
-			const length = header.getUint32(4);
-			if (header.getUint8(0) !== 2 || channel !== 0 && channel !== 1 || header.getUint16(2) !== 0 || length > 1048576) return Option.some([Result.fail(invalid("Invalid runner frame header or payload length")), bytes.length]);
-			const end = offset + 8 + length;
-			if (end > bytes.length) return Option.none();
-			return Option.some([Result.succeed({
-				channel,
-				payload: bytes.subarray(offset + 8, end)
-			}), end]);
-		});
-		const result = Result.all(frames);
-		MutableRef.set(pending, Result.map(result, (frames) => bytes.subarray(Array.reduce(frames, 0, (used, frame) => used + 8 + frame.payload.length))));
-		return result;
-	});
-	return {
-		decode,
-		finish: Effect.suspend(() => Effect.fromResult(Result.flatMap(MutableRef.get(pending), (bytes) => bytes.length === 0 ? Result.succeed(void 0) : Result.fail(invalid("Runner connection ended inside a frame")))))
-	};
-};
-export { isCompleteFrame as a, encode as i, FrameError as n, maxPayload as o, decoder as r, EndOfStream as t };