@graftland/plugin-remote 0.0.0-stage → 0.3.0

package/dist/Instance.d.ts

@@ -0,0 +1,7 @@
+import { Context, Schema } from "effect";
+/** Outside a remote activation the identity is local/0. Local activations use a fresh UUID/1; runners allocate persistent generations. */
+export declare const Instance: Context.Reference<{
+  readonly id: string;
+  readonly generation: number;
+}>;
+//# sourceMappingURL=Instance.d.ts.map

package/dist/Instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Instance.d.ts","names":[],"sources":["../src/Instance.ts"],"mappings":";;qBAMa,UAAQ,QAAA"}

package/dist/Instance.js

@@ -0,0 +1,14 @@
+import { Context, Schema } from "effect";
+// src/Instance.ts
+const Identity = Schema.Struct({
+	id: Schema.String,
+	generation: Schema.Int
+});
+/** Outside a remote activation the identity is local/0. Local activations use a fresh UUID/1; runners allocate persistent generations. */
+const Instance = Context.Reference("@graftland/plugin-remote/Instance/Instance", { defaultValue: () => ({
+	id: "local",
+	generation: 0
+}) });
+export { Identity, Instance };
+
+//# sourceMappingURL=Instance.js.map

package/dist/Instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Instance.js","names":[],"sources":["../src/Instance.ts"],"sourcesContent":["import { Context, Schema } from \"effect\"\nexport const Identity = Schema.Struct({\n\tid: Schema.String,\n\tgeneration: Schema.Int,\n})\n/** Outside a remote activation the identity is local/0. Local activations use a fresh UUID/1; runners allocate persistent generations. */\nexport const Instance = Context.Reference<typeof Identity.Type>(\n\t\"@graftland/plugin-remote/Instance/Instance\",\n\t{\n\t\tdefaultValue: () => ({ id: \"local\", generation: 0 }),\n\t},\n)\n"],"mappings":";;AACA,MAAa,WAAW,OAAO,OAAO;CACrC,IAAI,OAAO;CACX,YAAY,OAAO;AACpB,CAAC;;AAED,MAAa,WAAW,QAAQ,UAC/B,8CACA,EACC,qBAAqB;CAAE,IAAI;CAAS,YAAY;AAAE,GACnD,CACD"}

package/dist/Packages-B1TPk8pa.js

@@ -0,0 +1,111 @@
+import { c as PackageError } from "./Peer-IJgFK6mD.js";
+import { Array, Cause, Context, Duration, Effect, FileSystem, Order, Path, Schema, Stream, String } from "effect";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
+import { createHash } from "node:crypto";
+// packages/remote/src/internal/config.ts
+const PositiveDuration = Schema.DurationFromString.check(Schema.makeFilter((value) => Duration.isFinite(value) && Duration.toMillis(value) > 0, { expected: "a finite, positive duration" }));
+// packages/remote/src/internal/Supervisor.ts
+/** A listener hands an authenticated byte channel to the supervisor. */
+var Supervisor = class extends Context.Service()("@graftland/plugin-remote/internal/Supervisor") {};
+// packages/remote/src/internal/runner/Packages.ts
+const Manifest = Schema.Struct({
+	name: Schema.String,
+	version: Schema.String
+});
+const verify = (actual, expected = {}) => expected.version !== void 0 && actual.version !== expected.version ? Effect.fail(PackageError.make({ detail: `Package version mismatch: expected ${expected.version}, received ${actual.version}` })) : expected.digest !== void 0 && actual.digest !== expected.digest ? Effect.fail(PackageError.make({ detail: `Package digest mismatch: expected ${expected.digest}, received ${actual.digest}` })) : Effect.void;
+/** A path-sensitive SHA-256 of sorted entries and bytes, excluding every node_modules subtree. */
+const digest = Effect.fnUntraced(function* (directory) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const hash = yield* Effect.sync(() => createHash("sha256").update("graft-package-sha256-v1\0"));
+	const visit = (relative) => Effect.gen(function* () {
+		const filename = path.join(directory, relative);
+		const info = yield* fs.stat(filename);
+		if (info.type !== "File" && info.type !== "Directory") return yield* PackageError.make({ detail: `Unsupported package entry: ${relative}` });
+		const name = new TextEncoder().encode(relative);
+		yield* Effect.sync(() => {
+			hash.update(`${info.type}:${name.byteLength}:${info.type === "File" ? info.size : 0}:`);
+			hash.update(name);
+		});
+		if (info.type === "File") yield* fs.stream(filename).pipe(Stream.runForEach((bytes) => Effect.sync(() => {
+			hash.update(bytes);
+		})));
+		else {
+			const entries = yield* fs.readDirectory(filename);
+			for (const entry of Array.sort(entries, Order.String)) {
+				if (entry === "node_modules") continue;
+				yield* visit(relative === "" ? entry : `${relative}/${entry}`);
+			}
+		}
+	});
+	yield* visit("");
+	return yield* Effect.sync(() => hash.digest("hex"));
+});
+/**
+* Resolve using Node's import conditions without importing executable package code.
+* The helper's cwd is the installation root and it inherits no NODE_OPTIONS/loaders.
+* The installation directory and its package exports are trusted.
+*/
+const resolve = Effect.fnUntraced(function* (root, specifier, includeDigest = false) {
+	const segments = String.split(specifier, "/");
+	const scoped = String.startsWith("@")(specifier);
+	const name = Array.join(Array.take(segments, scoped ? 2 : 1), "/");
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const installation = yield* fs.realPath(root);
+	const directory = yield* fs.realPath(path.join(installation, "node_modules", name));
+	const manifest = yield* fs.readFileString(path.join(directory, "package.json")).pipe(Effect.flatMap(Schema.decodeEffect(Schema.fromJsonString(Manifest))));
+	const resolved = yield* resolveEntry(installation, specifier);
+	const filename = yield* Effect.try({
+		try: () => fileURLToPath(resolved),
+		catch: (error) => PackageError.make({
+			detail: "The package export is not a file URL",
+			cause: Cause.die(error)
+		})
+	});
+	return {
+		directory,
+		entry: yield* fs.realPath(filename),
+		identity: {
+			...manifest,
+			...includeDigest ? { digest: yield* digest(directory) } : {}
+		}
+	};
+}, Effect.catchTags({
+	PlatformError: (error) => Effect.fail(PackageError.make({
+		detail: "Reading the installed package failed",
+		cause: Cause.fail(error)
+	})),
+	SchemaError: (error) => Effect.fail(PackageError.make({
+		detail: "Reading the package manifest failed",
+		cause: Cause.fail(error)
+	}))
+}));
+const resolveEntry = (installation, specifier) => Effect.gen(function* () {
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	return yield* Effect.scoped(Effect.gen(function* () {
+		const child = yield* spawner.spawn(ChildProcess.make(process.execPath, [
+			"--input-type=module",
+			"--eval",
+			"process.stdout.write(import.meta.resolve(process.argv[1]))",
+			"--",
+			specifier
+		], {
+			cwd: installation,
+			env: {},
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "pipe"
+		}));
+		const [code, stdout, stderr] = yield* Effect.all([
+			child.exitCode,
+			child.stdout.pipe(Stream.decodeText(), Stream.mkString),
+			child.stderr.pipe(Stream.decodeText(), Stream.mkString)
+		], { concurrency: "unbounded" });
+		if (code !== 0) return yield* PackageError.make({ detail: `Package resolution failed: ${stderr}` });
+		return stdout;
+	}));
+});
+export { PositiveDuration as a, Supervisor as i, resolveEntry as n, verify as r, resolve as t };

package/dist/Peer-IJgFK6mD.js

@@ -0,0 +1,342 @@
+import { c as TransportError } from "./Errors-oPsTLY7l.js";
+import { i as encode, r as decoder, t as EndOfStream } from "./Framing-zaYdOJnT.js";
+import { t as make$1 } from "./FailureGroup-BcH0XOBi.js";
+import { a as PositiveInt, i as PositiveFinite, r as Limits, t as Priority } from "./port-Blbh8tms.js";
+import { Array, Cause, Context, Data, Duration, Effect, Fiber, Option, Queue, Schema, Sink, Stream, TxQueue } from "effect";
+import { Rpc, RpcGroup } from "effect/rpc";
+// packages/remote/src/Instance.ts
+const Identity = Schema.Struct({
+	id: Schema.String,
+	generation: Schema.Int
+});
+/** Outside a remote activation the identity is local/0. Local activations use a fresh UUID/1; runners allocate persistent generations. */
+const Instance = Context.Reference("@graftland/plugin-remote/Instance/Instance", { defaultValue: () => ({
+	id: "local",
+	generation: 0
+}) });
+// packages/remote/src/internal/runner/Multiplex.ts
+/** Ports own admission and ACK backpressure. This layer only frames and separates session/instance bytes. */
+const make = Effect.fnUntraced(function* (channel) {
+	const group = yield* make$1();
+	const incoming = {
+		0: yield* Queue.unbounded(),
+		1: yield* Queue.unbounded()
+	};
+	const outgoing = {
+		0: yield* TxQueue.unbounded(),
+		1: yield* TxQueue.unbounded()
+	};
+	const next = Effect.tx(Effect.gen(function* () {
+		const session = yield* TxQueue.poll(outgoing[0]);
+		if (Option.isSome(session)) return session.value;
+		const instance = yield* TxQueue.poll(outgoing[1]);
+		if (Option.isSome(instance)) return instance.value;
+		if ((yield* TxQueue.isDone(outgoing[0])) && (yield* TxQueue.isDone(outgoing[1]))) return yield* Cause.done();
+		return yield* Effect.txRetry;
+	}));
+	const writing = yield* group.run(Stream.fromEffectRepeat(next).pipe(Stream.run(channel.output), Effect.asVoid));
+	const decoder$1 = decoder();
+	yield* group.run(channel.input.pipe(Stream.runForEach((bytes) => Effect.fromResult(decoder$1.decode(bytes)).pipe(Effect.flatMap((frames) => Effect.forEach(frames, (frame) => Queue.offer(incoming[frame.channel], frame.payload), { discard: true })))), Effect.andThen(decoder$1.finish), Effect.andThen(Effect.fail(EndOfStream.make({}))), Effect.mapError((error) => error._tag === "TransportError" ? error : TransportError.make({ cause: Cause.fail(error) }))));
+	return {
+		await: group.await,
+		fail: group.fail,
+		end: Effect.tx(TxQueue.end(outgoing[0]).pipe(Effect.andThen(TxQueue.end(outgoing[1])))).pipe(Effect.andThen(Fiber.join(writing))),
+		send: (id, payload) => group.race(encode({
+			channel: id,
+			payload
+		}).pipe(Effect.flatMap((bytes) => TxQueue.offer(outgoing[id], bytes)), Effect.asVoid)),
+		take: (id) => group.race(Queue.take(incoming[id]))
+	};
+});
+Effect.fnUntraced(function* (socket) {
+	const reader = yield* socket.reader;
+	const writer = yield* socket.writer;
+	return yield* make({
+		input: Stream.fromEffectRepeat(reader.pull).pipe(Stream.flattenIterable, Stream.map((bytes) => typeof bytes === "string" ? new TextEncoder().encode(bytes) : bytes), Stream.mapError((error) => TransportError.make({ cause: Cause.fail(error) }))),
+		output: Sink.forEach((bytes) => writer.write(bytes)).pipe(Sink.mapError((error) => TransportError.make({ cause: Cause.fail(error) })))
+	});
+});
+// packages/remote/src/internal/runner/model.ts
+const diagnosticCause = Schema.Cause(Schema.Defect({ includeStack: true }), Schema.Defect({ includeStack: true }));
+var PackageError = class extends Schema.TaggedError()("PackageError", {
+	detail: Schema.String,
+	cause: Schema.optionalKey(diagnosticCause)
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+var SessionAccessDenied = class extends Schema.TaggedError()("SessionAccessDenied", {
+	detail: Schema.String,
+	cause: Schema.optionalKey(diagnosticCause)
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+var StaleSession = class extends Schema.TaggedError()("StaleSession", {
+	detail: Schema.String,
+	cause: Schema.optionalKey(diagnosticCause)
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+var LeaseExpired = class extends Schema.TaggedError()("LeaseExpired", {
+	detail: Schema.String,
+	cause: Schema.optionalKey(diagnosticCause)
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+var SessionStopped = class extends Schema.TaggedError()("SessionStopped", {
+	detail: Schema.String,
+	cause: Schema.optionalKey(diagnosticCause)
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+var SessionConflict = class extends Schema.TaggedError()("SessionConflict", {
+	detail: Schema.String,
+	cause: Schema.optionalKey(diagnosticCause)
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+var StateStorageError = class extends Schema.TaggedError()("StateStorageError", {
+	detail: Schema.String,
+	cause: Schema.optionalKey(diagnosticCause)
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+var ExecutionError = class extends Schema.TaggedError()("ExecutionError", {
+	detail: Schema.String,
+	cause: Schema.optionalKey(diagnosticCause)
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+var TerminationUnconfirmed = class extends Schema.TaggedError()("TerminationUnconfirmed", {
+	detail: Schema.String,
+	cause: Schema.optionalKey(diagnosticCause)
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+var RunnerClosing = class extends Schema.TaggedError()("RunnerClosing", {
+	detail: Schema.String,
+	cause: Schema.optionalKey(diagnosticCause)
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+var StateDirectoryLocked = class extends Schema.TaggedError()("StateDirectoryLocked", {
+	detail: Schema.String,
+	cause: Schema.optionalKey(diagnosticCause)
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+const Key = Schema.Struct({
+	identity: Schema.NonEmptyString,
+	instance: Schema.NonEmptyString
+});
+/** Structural keys keep identity namespaces separate without delimiter conventions. */
+var SessionKey = class extends Data.Class {};
+const keyOf = (key) => new SessionKey(key);
+const negotiate = (local, peer) => ({
+	control: Math.min(local.control, peer.control),
+	data: Math.min(local.data, peer.data),
+	log: Math.min(local.log, peer.log)
+});
+const Handle = Schema.Struct({
+	key: Key,
+	token: Schema.NonEmptyString,
+	generation: PositiveInt
+});
+const ProcessIdentity = Schema.Struct({
+	pid: Schema.Int,
+	start: Schema.Struct({ born: Schema.String })
+});
+const ExitStatus = Schema.Struct({
+	stderr: Schema.optionalKey(Schema.String),
+	cause: Schema.optionalKey(diagnosticCause),
+	code: Schema.NullOr(Schema.Int),
+	signal: Schema.NullOr(Schema.String)
+});
+const CodeIdentity = Schema.Struct({
+	name: Schema.String,
+	version: Schema.String,
+	digest: Schema.optionalKey(Schema.String)
+});
+const Load = Schema.Struct({
+	specifier: Schema.String,
+	digest: Schema.optionalKey(Schema.Boolean)
+});
+const Termination = Schema.Struct({
+	kind: Schema.Literals(["Exited", "Killed"]),
+	exit: ExitStatus,
+	cause: diagnosticCause
+});
+const Fields = {
+	version: Schema.Literal(1),
+	handle: Handle,
+	requestId: Schema.String,
+	leaseMillis: Schema.Finite,
+	limits: Limits
+};
+const OpenRecord = Schema.Struct({
+	...Fields,
+	phase: Schema.Literal("Open")
+});
+const Launch = Schema.Union([Schema.TaggedStruct("Starting", {}), Schema.TaggedStruct("Registered", { child: ProcessIdentity })]);
+const LoadingRecord = Schema.Struct({
+	...Fields,
+	phase: Schema.Literal("Loading"),
+	load: Load,
+	launch: Launch
+});
+const LoadedRecord = Schema.Struct({
+	...Fields,
+	phase: Schema.Literal("Loaded"),
+	load: Load,
+	child: ProcessIdentity,
+	code: CodeIdentity
+});
+const ActiveRecord = Schema.Union([
+	OpenRecord,
+	LoadingRecord,
+	LoadedRecord
+]);
+const StopReason = Schema.Union([...Array.map([
+	"Disposed",
+	"Expired",
+	"Superseded",
+	"Recovery",
+	"Shutdown",
+	"Exited"
+], (tag) => Schema.TaggedStruct(tag, {})), Schema.TaggedStruct("LoadFailed", { cause: diagnosticCause })]);
+const StoppingRecord = Schema.Struct({
+	...Fields,
+	phase: Schema.Literal("Stopping"),
+	previous: ActiveRecord,
+	reason: StopReason
+});
+const StoppedRecord = Schema.Struct({
+	...Fields,
+	phase: Schema.Literal("Stopped"),
+	previous: ActiveRecord,
+	reason: StopReason,
+	termination: Termination
+});
+const SessionRecord = Schema.Union([
+	OpenRecord,
+	LoadingRecord,
+	LoadedRecord,
+	StoppingRecord,
+	StoppedRecord
+]);
+const childOf = (record) => {
+	switch (record.phase) {
+		case "Open": return Option.none();
+		case "Loading": return record.launch._tag === "Registered" ? Option.some(record.launch.child) : Option.none();
+		case "Loaded": return Option.some(record.child);
+		case "Stopping":
+		case "Stopped": return childOf(record.previous);
+	}
+};
+const stoppingRecord = (previous, reason) => ({
+	version: previous.version,
+	handle: previous.handle,
+	requestId: previous.requestId,
+	leaseMillis: previous.leaseMillis,
+	limits: previous.limits,
+	phase: "Stopping",
+	previous,
+	reason
+});
+const stoppedRecord = (previous, reason, termination) => ({
+	...stoppingRecord(previous, reason),
+	phase: "Stopped",
+	termination
+});
+var Store = class extends Context.Service()("@graftland/plugin-remote/internal/runner/model/Store") {};
+var Execution = class extends Context.Service()("@graftland/plugin-remote/internal/runner/model/Execution") {};
+var RemoteTerminationUnconfirmed = class extends Schema.TaggedError()("RemoteTerminationUnconfirmed", { handle: Handle }) {};
+/** Losing contact never becomes a successful stop merely because a lease duration passed. */
+const awaitTermination = (handle, confirmation, leaseMillis, marginMillis) => 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 });
+	}
+	yield* Effect.sleep(Math.max(0, leaseMillis + marginMillis - Duration.toMillis(elapsed)));
+	return yield* Effect.failCause(Cause.combine(result.cause, Cause.fail(RemoteTerminationUnconfirmed.make({ handle }))));
+});
+// packages/remote/src/internal/runner/Wire.ts
+/** The RPC boundary is the only place that assembles the runner's error schema. */
+const SessionError = Schema.Union([
+	SessionAccessDenied,
+	StaleSession,
+	LeaseExpired,
+	SessionStopped,
+	SessionConflict,
+	StateStorageError,
+	ExecutionError,
+	PackageError,
+	TerminationUnconfirmed,
+	RunnerClosing,
+	StateDirectoryLocked
+]);
+const Session = RpcGroup.make(Rpc.make("HighWater", {
+	payload: { instance: Schema.NonEmptyString },
+	success: Schema.NullOr(PositiveInt),
+	error: SessionError
+}), Rpc.make("Open", {
+	payload: {
+		instance: Schema.NonEmptyString,
+		requestId: Schema.NonEmptyString,
+		expectedGeneration: Schema.NullOr(PositiveInt),
+		leaseMillis: Schema.optionalKey(PositiveFinite),
+		limits: Limits
+	},
+	success: SessionRecord,
+	error: SessionError
+}), Rpc.make("Load", {
+	payload: {
+		handle: Handle,
+		specifier: Schema.NonEmptyString,
+		digest: Schema.optionalKey(Schema.Boolean)
+	},
+	success: CodeIdentity,
+	error: SessionError
+}), Rpc.make("Renew", {
+	payload: Handle,
+	success: Schema.Finite,
+	error: SessionError
+}), Rpc.make("Dispose", {
+	payload: Handle,
+	success: Termination,
+	error: SessionError
+}), Rpc.make("Status", {
+	payload: Handle,
+	success: SessionRecord,
+	error: SessionError
+})).annotateRpcs(Priority, "control");
+/** Preserve the port writer order within each byte channel. */
+const channel = (peer, id) => ({
+	input: Stream.fromEffectRepeat(peer.take(id)),
+	output: Sink.forEach((bytes) => peer.send(id, bytes).pipe(Effect.mapError((error) => TransportError.make({ cause: Cause.fail(error) }))))
+});
+// packages/remote/src/internal/Peer.ts
+var Peer = class extends Context.Service()("@graftland/plugin-remote/internal/Peer") {};
+export { negotiate as C, Identity as D, make as E, Instance as O, keyOf as S, stoppingRecord as T, StateStorageError as _, ExecutionError as a, awaitTermination as b, PackageError as c, SessionAccessDenied as d, SessionConflict as f, StateDirectoryLocked as g, StaleSession as h, Execution as i, RemoteTerminationUnconfirmed as l, SessionStopped as m, Session as n, Key as o, SessionRecord as p, channel as r, LeaseExpired as s, Peer as t, RunnerClosing as u, Store as v, stoppedRecord as w, childOf as x, TerminationUnconfirmed as y };

package/dist/ProcessObservation-DEGrEMfP.js

@@ -0,0 +1,38 @@
+import { t as make } from "./FailureGroup-BcH0XOBi.js";
+import { Array, Cause, Effect, Exit, Fiber, Ref, Schedule, Stream, String } from "effect";
+// packages/remote/src/internal/runner/ProcessObservation.ts
+/** Time allowed for a direct execution unit or launcher to exit after input EOF. */
+const stdinExitTimeout = "1 second";
+/** Readers outlive the failure monitor so forced termination still captures its diagnostic tail. */
+const observe = Effect.fnUntraced(function* (child, options = {}) {
+	const failures = yield* make();
+	const tail = yield* Ref.make("");
+	const stdout = yield* (options.drainStdout === false ? Effect.void : Stream.runDrain(child.stdout)).pipe(Effect.forkScoped);
+	const stderr = yield* child.stderr.pipe(Stream.decodeText(), Stream.runForEach((text) => Ref.update(tail, (old) => String.takeRight(old + text, 8192))), Effect.forkScoped);
+	yield* failures.run(Fiber.join(stdout));
+	yield* failures.run(Fiber.join(stderr));
+	const exited = yield* Effect.gen(function* () {
+		const result = yield* Effect.exit(child.exitCode);
+		yield* child.isRunning.pipe(Effect.repeat({
+			schedule: Schedule.spaced("25 millis"),
+			while: (running) => running
+		}));
+		const err = yield* Fiber.await(stderr);
+		const out = yield* Fiber.await(stdout);
+		return {
+			code: Exit.isSuccess(result) ? result.value : null,
+			signal: null,
+			stderr: yield* Ref.get(tail),
+			cause: Array.reduce([
+				Exit.asVoid(result),
+				err,
+				out
+			], Cause.empty, (cause, exit) => Exit.isFailure(exit) ? Cause.combine(cause, exit.cause) : cause)
+		};
+	}).pipe(Effect.forkScoped);
+	return {
+		exited: Fiber.join(exited),
+		failure: failures.await
+	};
+});
+export { stdinExitTimeout as n, observe as t };

package/dist/ServeLifecycle-CJM0gG5B.js

@@ -0,0 +1,24 @@
+import { n as close } from "./release-BY4Mlluy.js";
+import { Context, Deferred, Effect, Exit, Option, Schema, Scope } from "effect";
+// packages/remote/src/internal/ServeLifecycle.ts
+var StartupError = class extends Schema.TaggedError()("RunnerStartupError", {
+	detail: Schema.String,
+	cause: Schema.optionalKey(Schema.Cause(Schema.Unknown, Schema.Defect()))
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+var ServeLifecycle = class extends Context.Service()("@graftland/plugin-remote/internal/ServeLifecycle") {};
+const make = Effect.all({
+	ended: Deferred.make(),
+	released: Deferred.make()
+});
+/** Observe shutdown independently of the loader, which logs child cleanup failures. */
+const resources = Effect.fnUntraced(function* (lifecycle) {
+	return yield* Effect.acquireRelease(Scope.make(), (scope, exit) => close(scope, exit).pipe(Effect.onExit((released) => Option.isNone(lifecycle) ? Effect.void : Deferred.done(lifecycle.value.released, Exit.isSuccess(released) ? Exit.void : Exit.fail(StartupError.make({
+		detail: "Supervisor shutdown failed",
+		cause: released.cause
+	}))).pipe(Effect.asVoid))));
+});
+export { resources as i, StartupError as n, make as r, ServeLifecycle as t };

package/dist/Testing.d.ts

@@ -0,0 +1,26 @@
+import { TransportError } from "./Errors.js";
+import { Channel } from "./Transport.js";
+import { FrameError } from "./internal/runner/Framing.js";
+import { Plugin } from "@graftland/graft";
+import { Effect, Schema } from "effect";
+declare const ConformanceError_base: Schema.Class<ConformanceError, Schema.TaggedStruct<"ConformanceError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class ConformanceError extends ConformanceError_base {}
+export interface Capabilities {
+  readonly connector: Plugin.Plugin;
+  readonly listener: Plugin.Plugin;
+  readonly credentials: Plugin.Plugin;
+  readonly authenticator: Plugin.Plugin;
+}
+/** The fixture supplies addresses/credentials and an echo session; no full runner is required. */
+export declare const transport: <E, R>(plugins: Capabilities, fixture: (plugins: Capabilities) => Effect.Effect<Channel, E, R>) => {
+  chunks: Effect.Effect<void, E | ConformanceError | FrameError | TransportError, R | import("effect/Scope").Scope>;
+  eof: Effect.Effect<void, E | ConformanceError | TransportError, R>;
+};
+/** HTTP implementations reject before accepting a session, preserving the challenge. */
+export declare const rejection: <E, R>(response: Effect.Effect<string, E, R>, challenge?: string) => Effect.Effect<string, E | ConformanceError, R>;
+export {};
+//# sourceMappingURL=Testing.d.ts.map

package/dist/Testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Testing.d.ts","names":["Framing.FrameError","_$__Errors0.TransportError"],"sources":["../src/Testing.ts"],"mappings":";;;;;;;;WAgBmB;;qBAFN,yBAAyB;iBAMrB;WACP,WAAW,OAAO;WAClB,UAAU,OAAO;WACjB,aAAa,OAAO;WACpB,eAAe,OAAO;;;qBAGnB,YAAa,GAAG,GAAC,SACpB,cAAY,UACX,SAAS,iBAAiB,OAAO,OAAO,SAAS,GAAG;EAI7D,QAAM,OAAA,aAAA,IAAA,mBAAAA,aAAAC,gBAAA,2BAAA;EA0DN,KAAG,OAAA,aAAA,IAAA,mBAAAA,gBAAA;;;qBAaQ,YAAa,GAAG,GAAC,UACnB,OAAO,eAAe,GAAG,IAAE,uBACnB,OAAA,eAAA,IAAA,kBAAA"}

package/dist/Testing.js

@@ -0,0 +1,69 @@
+import { decoder, encode } from "./internal/runner/Framing.js";
+import { Array, Deferred, Effect, Equivalence, Fiber, Schema, Stream, String } from "effect";
+// src/Testing.ts
+var ConformanceError = class extends Schema.TaggedError()("ConformanceError", { message: Schema.String }) {};
+const check = (condition, message) => condition ? Effect.void : Effect.fail(ConformanceError.make({ message }));
+/** The fixture supplies addresses/credentials and an echo session; no full runner is required. */
+const transport = (plugins, fixture) => {
+	const connect = fixture(plugins);
+	return {
+		chunks: Effect.gen(function* () {
+			const channel = yield* connect;
+			const first = yield* encode({
+				channel: 0,
+				payload: new Uint8Array([
+					1,
+					2,
+					3
+				])
+			});
+			const second = yield* encode({
+				channel: 1,
+				payload: new Uint8Array([4, 5])
+			});
+			const combined = new Uint8Array(first.length + second.length);
+			combined.set(first);
+			combined.set(second, first.length);
+			const done = yield* Deferred.make();
+			const sending = yield* Stream.make(combined.subarray(0, 2), combined.subarray(2)).pipe(Stream.concat(Stream.fromEffect(Deferred.await(done)).pipe(Stream.drain)), Stream.run(channel.output), Effect.forkScoped);
+			const frames = decoder();
+			const reply = yield* channel.input.pipe(Stream.mapEffect((chunk) => Effect.fromResult(frames.decode(chunk))), Stream.flattenIterable, Stream.zipWithIndex, Stream.tap(([, index]) => index === 1 ? Deferred.succeed(done, void 0) : Effect.void), Stream.map(([frame]) => frame), Stream.runCollect);
+			yield* frames.finish;
+			yield* Deferred.succeed(done, void 0);
+			yield* Fiber.join(sending);
+			yield* check(Array.makeEquivalence(Equivalence.Struct({
+				channel: Equivalence.Number,
+				payload: Array.makeEquivalence(Equivalence.Number)
+			}))(Array.map(reply, (frame) => ({
+				channel: frame.channel,
+				payload: Array.fromIterable(frame.payload)
+			})), [{
+				channel: 0,
+				payload: [
+					1,
+					2,
+					3
+				]
+			}, {
+				channel: 1,
+				payload: [4, 5]
+			}]), "The channel changed byte order across split or coalesced chunks");
+		}),
+		eof: Effect.gen(function* () {
+			const channel = yield* connect;
+			yield* Stream.empty.pipe(Stream.run(channel.output));
+			const remaining = yield* Stream.runCollect(channel.input);
+			yield* check(remaining.length === 0, "The channel produced bytes after EOF");
+		})
+	};
+};
+/** HTTP implementations reject before accepting a session, preserving the challenge. */
+const rejection = (response, challenge) => response.pipe(Effect.tap((response) => Effect.all([
+	check(String.includes("HTTP/1.1 401")(response), "Expected HTTP 401"),
+	check(!String.includes("101 Switching Protocols")(response), "Rejected credentials opened a WebSocket"),
+	check(!String.includes("sec-websocket-accept:")(String.toLowerCase(response)), "Rejected credentials received a WebSocket accept header"),
+	check(challenge === void 0 || String.includes("www-authenticate: " + String.toLowerCase(challenge))(String.toLowerCase(response)), "The authentication challenge was lost")
+], { discard: true })));
+export { ConformanceError, rejection, transport };
+
+//# sourceMappingURL=Testing.js.map

package/dist/Testing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Testing.js","names":["Framing.encode","Framing.decoder"],"sources":["../src/Testing.ts"],"sourcesContent":["import type { Plugin } from \"@graftland/graft\"\nimport {\n\tArray,\n\tEquivalence,\n\tDeferred,\n\tEffect,\n\tFiber,\n\tStream,\n\tString,\n\tSchema,\n} from \"effect\"\nimport type { Channel } from \"./Transport\"\nimport * as Framing from \"./internal/runner/Framing\"\n\nexport class ConformanceError extends Schema.TaggedError<\n\tConformanceError,\n\t{ readonly brand: unique symbol }\n>()(\"ConformanceError\", { message: Schema.String }) {}\nconst check = (condition: boolean, message: string) =>\n\tcondition ? Effect.void : Effect.fail(ConformanceError.make({ message }))\nexport interface Capabilities {\n\treadonly connector: Plugin.Plugin\n\treadonly listener: Plugin.Plugin\n\treadonly credentials: Plugin.Plugin\n\treadonly authenticator: Plugin.Plugin\n}\n/** The fixture supplies addresses/credentials and an echo session; no full runner is required. */\nexport const transport = <E, R>(\n\tplugins: Capabilities,\n\tfixture: (plugins: Capabilities) => Effect.Effect<Channel, E, R>,\n) => {\n\tconst connect = fixture(plugins)\n\treturn {\n\t\tchunks: Effect.gen(function* () {\n\t\t\tconst channel = yield* connect\n\t\t\tconst first = yield* Framing.encode({\n\t\t\t\tchannel: 0,\n\t\t\t\tpayload: new Uint8Array([1, 2, 3]),\n\t\t\t})\n\t\t\tconst second = yield* Framing.encode({\n\t\t\t\tchannel: 1,\n\t\t\t\tpayload: new Uint8Array([4, 5]),\n\t\t\t})\n\t\t\tconst combined = new Uint8Array(first.length + second.length)\n\t\t\tcombined.set(first)\n\t\t\tcombined.set(second, first.length)\n\t\t\t// Split the header, then put the remainder and the next frame in one chunk.\n\t\t\tconst done = yield* Deferred.make<void>()\n\t\t\tconst sending = yield* Stream.make(\n\t\t\t\tcombined.subarray(0, 2),\n\t\t\t\tcombined.subarray(2),\n\t\t\t).pipe(\n\t\t\t\tStream.concat(\n\t\t\t\t\tStream.fromEffect(Deferred.await(done)).pipe(Stream.drain),\n\t\t\t\t),\n\t\t\t\tStream.run(channel.output),\n\t\t\t\tEffect.forkScoped,\n\t\t\t)\n\t\t\tconst frames = Framing.decoder()\n\t\t\tconst reply = yield* channel.input.pipe(\n\t\t\t\tStream.mapEffect((chunk) => Effect.fromResult(frames.decode(chunk))),\n\t\t\t\tStream.flattenIterable,\n\t\t\t\tStream.zipWithIndex,\n\t\t\t\tStream.tap(([, index]) =>\n\t\t\t\t\tindex === 1 ? Deferred.succeed(done, undefined) : Effect.void,\n\t\t\t\t),\n\t\t\t\tStream.map(([frame]) => frame),\n\t\t\t\tStream.runCollect,\n\t\t\t)\n\t\t\tyield* frames.finish\n\t\t\tyield* Deferred.succeed(done, undefined)\n\t\t\tyield* Fiber.join(sending)\n\t\t\tyield* check(\n\t\t\t\tArray.makeEquivalence(\n\t\t\t\t\tEquivalence.Struct({\n\t\t\t\t\t\tchannel: Equivalence.Number,\n\t\t\t\t\t\tpayload: Array.makeEquivalence(Equivalence.Number),\n\t\t\t\t\t}),\n\t\t\t\t)(\n\t\t\t\t\tArray.map(reply, (frame) => ({\n\t\t\t\t\t\tchannel: frame.channel,\n\t\t\t\t\t\tpayload: Array.fromIterable(frame.payload),\n\t\t\t\t\t})),\n\t\t\t\t\t[\n\t\t\t\t\t\t{ channel: 0, payload: [1, 2, 3] },\n\t\t\t\t\t\t{ channel: 1, payload: [4, 5] },\n\t\t\t\t\t],\n\t\t\t\t),\n\t\t\t\t\"The channel changed byte order across split or coalesced chunks\",\n\t\t\t)\n\t\t}),\n\t\teof: Effect.gen(function* () {\n\t\t\tconst channel = yield* connect\n\t\t\tyield* Stream.empty.pipe(Stream.run(channel.output))\n\t\t\tconst remaining = yield* Stream.runCollect(channel.input)\n\t\t\tyield* check(\n\t\t\t\tremaining.length === 0,\n\t\t\t\t\"The channel produced bytes after EOF\",\n\t\t\t)\n\t\t}),\n\t}\n}\n\n/** HTTP implementations reject before accepting a session, preserving the challenge. */\nexport const rejection = <E, R>(\n\tresponse: Effect.Effect<string, E, R>,\n\tchallenge?: string,\n) =>\n\tresponse.pipe(\n\t\tEffect.tap((response) =>\n\t\t\tEffect.all(\n\t\t\t\t[\n\t\t\t\t\tcheck(String.includes(\"HTTP/1.1 401\")(response), \"Expected HTTP 401\"),\n\t\t\t\t\tcheck(\n\t\t\t\t\t\t!String.includes(\"101 Switching Protocols\")(response),\n\t\t\t\t\t\t\"Rejected credentials opened a WebSocket\",\n\t\t\t\t\t),\n\t\t\t\t\tcheck(\n\t\t\t\t\t\t!String.includes(\"sec-websocket-accept:\")(\n\t\t\t\t\t\t\tString.toLowerCase(response),\n\t\t\t\t\t\t),\n\t\t\t\t\t\t\"Rejected credentials received a WebSocket accept header\",\n\t\t\t\t\t),\n\t\t\t\t\tcheck(\n\t\t\t\t\t\tchallenge === undefined ||\n\t\t\t\t\t\t\tString.includes(\n\t\t\t\t\t\t\t\t\"www-authenticate: \" + String.toLowerCase(challenge),\n\t\t\t\t\t\t\t)(String.toLowerCase(response)),\n\t\t\t\t\t\t\"The authentication challenge was lost\",\n\t\t\t\t\t),\n\t\t\t\t],\n\t\t\t\t{ discard: true },\n\t\t\t),\n\t\t),\n\t)\n"],"mappings":"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"}

package/dist/Transport-DULzpsgR.js

@@ -0,0 +1,6 @@
+import { Context } from "effect";
+// packages/remote/src/Transport.ts
+/** Execution and byte-channel capabilities; implementations live in host plugins. */
+var Connector = class extends Context.Service()("@graftland/plugin-remote/Transport/Connector") {};
+var Listener = class extends Context.Service()("@graftland/plugin-remote/Transport/Listener") {};
+export { Listener as n, Connector as t };