@graftland/plugin-remote 0.3.3 → 0.4.0

package/src/internal/execution.ts

@@ -1,4 +1,3 @@
-import { Plugin } from "@graftland/graft"
 import {
 	Array,
 	Cause,
@@ -7,29 +6,32 @@ import {
 	PlatformError,
 	Schema,
 	Scope,
+	type Duration,
 } from "effect"
 import { SecureRandom } from "effect/crypto"
 import { RpcClientError } from "effect/rpc"
+
+import { Plugin } from "@graftland/graft"
+import { ReleaseInterrupted } from "@graftland/graft/Release"
+
+import { Credentials } from "../Auth"
+import * as Contract from "../Contract"
+import * as Errors from "../Errors"
+import { MissingInstance, RemoteError, RemoteWithdrawn } from "../Errors"
+import { Connector } from "../Transport"
+import * as Assembly from "./assembly"
+import * as ChildErrors from "./childErrors"
+import { prepare } from "./contract"
+import * as Control from "./control"
+import { LocalTransport, WorkerTransport } from "./directTransport"
+import * as Host from "./host"
 import type {
 	LocalTarget as Local,
 	WorkerTarget as Worker,
 } from "./runner/Connection"
-import { Connector } from "../Transport"
-import { LocalTransport, WorkerTransport } from "./directTransport"
-import { Credentials } from "../Auth"
-import type { Duration } from "effect"
 import * as Connection from "./runner/Connection"
-import * as Services from "./services"
-import * as Host from "./host"
-import * as Errors from "../Errors"
-import { RemoteWithdrawn, RemoteError, MissingInstance } from "../Errors"
-import * as ChildErrors from "./childErrors"
-import * as Assembly from "./assembly"
 import * as Model from "./runner/model"
-import { ReleaseInterrupted } from "./release"
-import * as Contract from "../Contract"
-import * as Control from "./control"
-import { prepare } from "./contract"
+import * as Services from "./services"
 
 export interface ExecutionOptions {
 	readonly contractModule: string

package/src/internal/follow.ts

@@ -1,6 +1,7 @@
-import { Plugin, type Fork, type Graft } from "@graftland/graft"
 import { Effect, Stream, type Cause, type Schema } from "effect"
 
+import { Plugin, type Fork, type Graft } from "@graftland/graft"
+
 /** Follow startup and later failures without changing the caller's error boundary. */
 export const follow = Effect.fnUntraced(function* <I, E, F>(
 	fork: Fork.Fork<I, E>,

package/src/internal/forkTree.ts

@@ -1,6 +1,7 @@
-import type { Fork } from "@graftland/graft"
 import { Array, Option } from "effect"
 
+import type { Fork } from "@graftland/graft"
+
 export const findSubtree = (
 	trees: ReadonlyArray<Fork.ForkTree>,
 	id: number,

package/src/internal/host/local.ts

@@ -1,5 +1,6 @@
 import { Cause, Effect, Fiber, Option, Sink, Stream } from "effect"
 import type { ChildProcessSpawner } from "effect/process"
+
 import { ProcessExited, TransportError } from "../../Errors"
 import * as ProcessObservation from "../runner/ProcessObservation"
 

package/src/internal/host/runner.ts

@@ -1,8 +1,7 @@
-import * as FailureGroup from "../FailureGroup"
 import {
 	Cause,
-	Effect,
 	Duration,
+	Effect,
 	Exit,
 	Fiber,
 	Option,
@@ -10,15 +9,18 @@ import {
 	Scope,
 } from "effect"
 import { RpcClient } from "effect/rpc"
-import { connectWith as connectCapability } from "../assembly"
-import type { ConfiguredRunner, Connected } from "../runner/Connection"
+
 import { ProcessExited, TransportError } from "../../Errors"
+import { connectWith as connectCapability } from "../assembly"
 import { cleanupCause } from "../cleanup"
+import * as FailureGroup from "../FailureGroup"
 import * as Port from "../port"
+import type { ConfiguredRunner, Connected } from "../runner/Connection"
+import { awaitTermination, childOf, defaults } from "../runner/model"
 import * as Multiplex from "../runner/Multiplex"
 import * as Packages from "../runner/Packages"
 import * as Wire from "../runner/Wire"
-import { awaitTermination, defaults, childOf } from "../runner/model"
+
 export const connect = Effect.fnUntraced(function* (
 	target: ConfiguredRunner,
 	contractModule: string,

package/src/internal/host.ts

@@ -1,24 +1,25 @@
-import * as FailureGroup from "./FailureGroup"
-import * as ContractModule from "../Contract"
 import {
-	Cause,
 	Array,
+	Cause,
 	Deferred,
 	Effect,
-	Ref,
 	Option,
+	Ref,
 	Schema,
 	Scope,
 	Stream,
 } from "effect"
 import { RpcClient, type RpcClientError } from "effect/rpc"
-import { RemoteWithdrawn } from "../Errors"
-import * as Control from "./control"
-import { cleanupCause } from "./cleanup"
-import { Connection } from "./runner/Connection"
+
+import * as ContractModule from "../Contract"
 import type { Service } from "../Contract"
+import { RemoteWithdrawn } from "../Errors"
 import type { ChildFailure } from "./childErrors"
+import { cleanupCause } from "./cleanup"
 import type { prepare } from "./contract"
+import * as Control from "./control"
+import * as FailureGroup from "./FailureGroup"
+import { Connection } from "./runner/Connection"
 
 type ErrorSchema = Schema.Top & {
 	readonly DecodingServices: never

package/src/internal/importer.ts

@@ -1,6 +1,7 @@
+import { registerHooks } from "node:module"
+
 import { Effect, Path, String } from "effect"
 import { SecureRandom } from "effect/crypto"
-import { registerHooks } from "node:module"
 
 /** Bare names resolve from the application; imported dependencies keep their own parent URLs. */
 export const make = Effect.fnUntraced(function* (directory: string) {
@@ -8,7 +9,7 @@ export const make = Effect.fnUntraced(function* (directory: string) {
 	const base = yield* path.toFileUrl(path.join(directory, "graft.yml"))
 	const random = yield* SecureRandom.SecureRandom
 	const id = yield* random.uuidV4()
-	const prefix = `graft-remote-${id}:`
+	const prefix = `graft-module-${id}:`
 	yield* Effect.acquireRelease(
 		Effect.sync(() =>
 			registerHooks({

package/src/internal/listenerStartup.ts

@@ -1,5 +1,7 @@
-import type { Fork } from "@graftland/graft"
 import { Array, Deferred, Effect, HashSet, Option, Stream } from "effect"
+
+import type { Fork } from "@graftland/graft"
+
 import type { AuthenticatorApi } from "../Auth"
 import type { Properties } from "../Transport"
 import { CapabilityCombinationError, CapabilityFailed } from "./assembly"
@@ -33,7 +35,7 @@ export const validate = (listeners: ReadonlyArray<Description>) => {
 	)
 		return Effect.fail(
 			CapabilityCombinationError.make({
-				detail: "A stdio listener must be the only listener in serve",
+				detail: "A stdio listener must be the only listener in the runner",
 			}),
 		)
 	const issuers = HashSet.fromIterable(

package/src/internal/loadModule.ts

@@ -1,4 +1,5 @@
 import { Cause, Effect } from "effect"
+
 import { ModuleImportFailed } from "./childErrors"
 
 /** Native imports cannot be cancelled; late rejection still belongs to the importing context. */

package/src/internal/platform.ts

@@ -1,12 +1 @@
-import { NodeServices } from "@effect/platform-node"
-import { Layer } from "effect"
-import { Digest, SecureRandom, Signature } from "effect/crypto"
-import { FetchHttpClient } from "effect/http"
-
-export const platform = Layer.mergeAll(
-	NodeServices.layer,
-	FetchHttpClient.layer,
-	Digest.layerWebCrypto,
-	SecureRandom.layerWebCrypto,
-	Signature.layerWebCrypto.pipe(Layer.provide(SecureRandom.layerWebCrypto)),
-)
+export { platform } from "@graftland/cli/Application"

package/src/internal/port.ts

@@ -1,6 +1,3 @@
-import { EndOfStream } from "./runner/Framing"
-export type { Channel } from "../Transport"
-import type { Channel } from "../Transport"
 import {
 	Array,
 	Cause,
@@ -15,21 +12,29 @@ import {
 	Record,
 	Result,
 	Schema,
-	type Scope,
 	Stream,
 	TxQueue,
 	TxRef,
+	type Scope,
 } from "effect"
 import {
 	RpcClient,
 	RpcClientError,
 	RpcSerialization,
 	RpcServer,
+	type Rpc,
+	type RpcGroup,
+	type RpcMessage,
 } from "effect/rpc"
-import type { Rpc, RpcGroup, RpcMessage } from "effect/rpc"
-import * as FailureGroup from "./FailureGroup"
+
 import { TransportError } from "../Errors"
+import type { Channel } from "../Transport"
+import * as FailureGroup from "./FailureGroup"
 import { defaults, type Limits } from "./Limits"
+import { EndOfStream } from "./runner/Framing"
+
+export type { Channel } from "../Transport"
+
 export type Priority = keyof Limits
 
 export const Priority = Context.Reference<Priority>(

package/src/internal/runner/Bootstrap.ts

@@ -1,4 +1,5 @@
 import { Schema } from "effect"
+
 import { Identity } from "../../Instance"
 import { Limits } from "./model"
 

package/src/internal/runner/Connection.ts

@@ -1,24 +1,18 @@
-import {
-	LocalTransport,
-	WorkerTransport,
-	type Execution,
-} from "../directTransport"
-import * as RunnerConnection from "../host/runner"
 import {
 	Array,
 	Cause,
 	Context,
-	Effect,
 	Duration,
+	Effect,
 	Exit,
 	Option,
 	Scope,
+	type PlatformError,
+	type Schema,
 } from "effect"
-import * as Release from "../release"
 import type { RpcClientError } from "effect/rpc"
-import type { Schema, PlatformError } from "effect"
-import type { RemoteTerminationUnconfirmed } from "./model"
-import type { Expected } from "./Packages"
+
+import * as Release from "@graftland/graft/Release"
 
 import {
 	LocalTerminationTimeout,
@@ -26,8 +20,16 @@ import {
 	TransportError,
 } from "../../Errors"
 import { cleanupCause } from "../cleanup"
+import {
+	LocalTransport,
+	WorkerTransport,
+	type Execution,
+} from "../directTransport"
+import * as RunnerConnection from "../host/runner"
 import * as Port from "../port"
 import * as LocalProcess from "./Local"
+import type { RemoteTerminationUnconfirmed } from "./model"
+import type { Expected } from "./Packages"
 import * as Wire from "./Wire"
 
 export interface LocalTarget {

package/src/internal/runner/Execution.ts

@@ -1,36 +1,37 @@
-import * as ProcessObservation from "./ProcessObservation"
-import * as FailureGroup from "../FailureGroup"
-import { Command, CommandJson } from "./WatchdogProtocol"
 import {
 	Array,
 	Cause,
-	FileSystem,
-	Path,
-	Schema,
 	Context,
 	Effect,
+	FileSystem,
 	HashMap,
 	HashSet,
+	Layer,
+	Path,
 	Queue,
 	Ref,
+	Schema,
+	Scope,
 	Sink,
 	Stream,
-	Layer,
-	Scope,
 } from "effect"
 import { ChildProcess, ChildProcessSpawner } from "effect/process"
+
 import { TransportError } from "../../Errors"
-import * as Multiplex from "./Multiplex"
-import * as Packages from "./Packages"
-import * as Processes from "./Processes"
+import * as FailureGroup from "../FailureGroup"
+import { Bootstrap } from "./Bootstrap"
+import { command } from "./command"
 import {
 	Execution,
 	ExecutionError,
 	SessionConflict,
 	SessionStopped,
 } from "./model"
-import { Bootstrap } from "./Bootstrap"
-import { command } from "./command"
+import * as Multiplex from "./Multiplex"
+import * as Packages from "./Packages"
+import * as Processes from "./Processes"
+import * as ProcessObservation from "./ProcessObservation"
+import { Command, CommandJson } from "./WatchdogProtocol"
 
 export class Channels extends Context.Service<
 	Channels,

package/src/internal/runner/Local.ts

@@ -1,11 +1,12 @@
 import { Cause, Effect, Fiber, Option } from "effect"
-import type { Execution } from "../directTransport"
-import * as FailureGroup from "../FailureGroup"
+
 import {
 	LocalTerminationTimeout,
 	ProcessExited,
 	TransportError,
 } from "../../Errors"
+import type { Execution } from "../directTransport"
+import * as FailureGroup from "../FailureGroup"
 import * as Port from "../port"
 import { stdinExitTimeout } from "./ProcessObservation"
 

package/src/internal/runner/Lock.ts

@@ -1,4 +1,5 @@
 import { Cause, Effect, FileSystem, Path } from "effect"
+
 import { StateDirectoryLocked } from "./model"
 
 /** SQLite owns the local directory lock for the enclosing scope, including failed startup. */

package/src/internal/runner/Multiplex.ts

@@ -9,9 +9,10 @@ import {
 	TxQueue,
 } from "effect"
 import type { Socket } from "effect/socket"
+
 import { TransportError } from "../../Errors"
-import type { Channel as ByteChannel } from "../port"
 import * as FailureGroup from "../FailureGroup"
+import type { Channel as ByteChannel } from "../port"
 import * as Framing from "./Framing"
 
 export interface Peer {

package/src/internal/runner/Packages.ts

@@ -1,3 +1,8 @@
+// @effect-diagnostics-next-line nodeBuiltinImport:off -- WebCrypto has no incremental digest API; package files are hashed as streams without buffering the directory.
+import { createHash } from "node:crypto"
+import process from "node:process"
+import { fileURLToPath } from "node:url"
+
 import {
 	Array,
 	Cause,
@@ -8,13 +13,10 @@ import {
 	Schema,
 	Stream,
 	String,
+	type PlatformError,
 } from "effect"
-import type { PlatformError } from "effect"
 import { ChildProcess, ChildProcessSpawner } from "effect/process"
-// @effect-diagnostics-next-line nodeBuiltinImport:off -- WebCrypto has no incremental digest API; package files are hashed as streams without buffering the directory.
-import { createHash } from "node:crypto"
-import process from "node:process"
-import { fileURLToPath } from "node:url"
+
 import { PackageError, type CodeIdentity } from "./model"
 
 const Manifest = Schema.Struct({ name: Schema.String, version: Schema.String })

package/src/internal/runner/ProcessObservation.ts

@@ -8,9 +8,10 @@ import {
 	Schedule,
 	Stream,
 	String,
+	type PlatformError,
 } from "effect"
-import type { PlatformError } from "effect"
 import type { ChildProcessSpawner } from "effect/process"
+
 import * as FailureGroup from "../FailureGroup"
 
 /** Time allowed for a direct execution unit or launcher to exit after input EOF. */

package/src/internal/runner/Processes.ts

@@ -1,6 +1,8 @@
+import process from "node:process"
+
 import { Cause, Effect, Option, Schedule, Stream, String } from "effect"
 import { ChildProcess, ChildProcessSpawner } from "effect/process"
-import process from "node:process"
+
 import {
 	ExecutionError,
 	TerminationUnconfirmed,

package/src/internal/runner/Retention.ts

@@ -1,4 +1,5 @@
 import { Array, HashMap, Option } from "effect"
+
 import { keyOf, type SessionKey, type SessionRecord } from "./model"
 
 /** A terminal high-water record fences every older Open, even after its request id is forgotten. */

package/src/internal/runner/Store.ts

@@ -1,11 +1,11 @@
 import {
 	Array,
 	Cause,
-	Layer,
 	Effect,
 	FileSystem,
 	HashMap,
 	HashSet,
+	Layer,
 	Path,
 	Ref,
 	Schema,
@@ -14,7 +14,8 @@ import {
 	type PlatformError,
 } from "effect"
 import { Digest, SecureRandom } from "effect/crypto"
-import { Key, SessionRecord, Store, StateStorageError } from "./model"
+
+import { Key, SessionRecord, StateStorageError, Store } from "./model"
 import * as Retention from "./Retention"
 
 /** Injectable store used by deterministic supervisor tests. */

package/src/internal/runner/Supervisor.ts

@@ -1,4 +1,3 @@
-import * as FailureGroup from "../FailureGroup"
 import {
 	Array,
 	Cause,
@@ -22,28 +21,30 @@ import {
 	Semaphore,
 	SynchronizedRef,
 } from "effect"
-import * as Release from "../release"
 import { SecureRandom } from "effect/crypto"
-import * as Retention from "./Retention"
+
+import * as Release from "@graftland/graft/Release"
+
 import { cleanupCause } from "../cleanup"
+import * as FailureGroup from "../FailureGroup"
 import {
-	Execution,
-	Store,
-	StaleSession,
-	LeaseExpired,
-	SessionStopped,
-	SessionConflict,
-	StateStorageError,
-	ExecutionError,
-	PackageError,
-	TerminationUnconfirmed,
-	RunnerClosing,
 	childOf,
 	defaults,
+	Execution,
+	ExecutionError,
 	keyOf,
+	LeaseExpired,
 	negotiate,
-	stoppingRecord,
+	PackageError,
+	RunnerClosing,
+	SessionConflict,
+	SessionStopped,
+	StaleSession,
+	StateStorageError,
 	stoppedRecord,
+	stoppingRecord,
+	Store,
+	TerminationUnconfirmed,
 	type ActiveRecord,
 	type CodeIdentity,
 	type ExitStatus,
@@ -51,16 +52,17 @@ import {
 	type Key,
 	type Limits,
 	type Load,
-	type SessionRecord,
+	type LoadedRecord,
+	type OpenRecord,
 	type SessionKey,
+	type SessionRecord,
+	type StoppedRecord,
+	type StoppingRecord,
 	type StopReason,
 	type Termination,
 	type Unit,
-	type OpenRecord,
-	type LoadedRecord,
-	type StoppingRecord,
-	type StoppedRecord,
 } from "./model"
+import * as Retention from "./Retention"
 
 export type SupervisorError =
 	| StaleSession

package/src/internal/runner/Watchdog.ts

@@ -1,6 +1,8 @@
+import { Worker } from "node:worker_threads"
+
 import { Cause, Deferred, Effect, Schema } from "effect"
+
 import * as FailureGroup from "../FailureGroup"
-import { Worker } from "node:worker_threads"
 import { ExecutionError } from "./model"
 import { Notice } from "./WatchdogProtocol"
 

package/src/internal/runner/Wire.ts

@@ -1,28 +1,29 @@
-import { Cause, Effect, Sink, Stream, Schema } from "effect"
+import { Cause, Effect, Schema, Sink, Stream } from "effect"
 import { Rpc, RpcGroup } from "effect/rpc"
+
 import { TransportError } from "../../Errors"
 import * as Port from "../port"
-import type * as Multiplex from "./Multiplex"
 import {
 	CodeIdentity,
+	ExecutionError,
 	Handle,
+	LeaseExpired,
 	Limits,
-	PositiveInt,
+	PackageError,
 	PositiveFinite,
-	SessionRecord,
+	PositiveInt,
+	RunnerClosing,
 	SessionAccessDenied,
-	StaleSession,
-	LeaseExpired,
-	SessionStopped,
 	SessionConflict,
-	StateStorageError,
-	ExecutionError,
-	PackageError,
-	TerminationUnconfirmed,
-	RunnerClosing,
+	SessionRecord,
+	SessionStopped,
+	StaleSession,
 	StateDirectoryLocked,
+	StateStorageError,
 	Termination,
+	TerminationUnconfirmed,
 } from "./model"
+import type * as Multiplex from "./Multiplex"
 
 /** The RPC boundary is the only place that assembles the runner's error schema. */
 export const SessionError = Schema.Union([

package/src/internal/runner/accept.ts

@@ -1,14 +1,15 @@
-import { Cause, Effect, Ref, Option, Scope, Semaphore } from "effect"
+import { Cause, Effect, Option, Ref, Scope, Semaphore } from "effect"
 import { RpcServer } from "effect/rpc"
-import { Peer } from "../Peer"
+
 import { TransportError } from "../../Errors"
 import type { Channel } from "../../Transport"
-import type { Supervisor } from "./Supervisor"
-import type { Channels } from "./Execution"
+import { Peer } from "../Peer"
 import * as Port from "../port"
+import type { Channels } from "./Execution"
+import { SessionAccessDenied, SessionConflict, type Handle } from "./model"
 import * as Multiplex from "./Multiplex"
+import type { Supervisor } from "./Supervisor"
 import * as Wire from "./Wire"
-import { SessionAccessDenied, SessionConflict, type Handle } from "./model"
 
 export const accept = Effect.fnUntraced(function* (
 	supervisor: typeof Supervisor.Service,

package/src/internal/runner/command.ts

@@ -1,7 +1,8 @@
-import { Effect } from "effect"
 import process from "node:process"
 import { fileURLToPath } from "node:url"
 
+import { Effect } from "effect"
+
 /** Resolve the executable through the installed package export, never a relative dist path. */
 export const command = (override?: readonly [string, ...string[]]) =>
 	Effect.sync(
@@ -9,7 +10,7 @@ export const command = (override?: readonly [string, ...string[]]) =>
 			override ?? [
 				process.execPath,
 				fileURLToPath(
-					import.meta.resolve("@graftland/plugin-remote/internal/bin"),
+					import.meta.resolve("@graftland/plugin-remote/internal/child"),
 				),
 			],
 	)

package/src/internal/runner/connectionEnded.ts

@@ -1,8 +1,9 @@
 import { Array, Cause, Effect, Schema } from "effect"
 import { Socket } from "effect/socket"
+
 import { TransportError } from "../../Errors"
-import { EndOfStream } from "./Framing"
 import { Peer } from "../Peer"
+import { EndOfStream } from "./Framing"
 
 // Multiplex preserves the socket reason inside TransportError; only an entirely normal close is silent.
 export const closedNormally = (cause: Cause.Cause<unknown>): boolean =>

package/src/internal/runner/model.ts

@@ -1,5 +1,3 @@
-import { Limits, PositiveInt } from "../Limits"
-export { Limits, PositiveInt, PositiveFinite, defaults } from "../Limits"
 import {
 	Array,
 	Cause,
@@ -9,8 +7,12 @@ import {
 	Effect,
 	Option,
 	Schema,
+	type Scope,
 } from "effect"
-import type { Scope } from "effect"
+
+import { Limits, PositiveInt } from "../Limits"
+
+export { Limits, PositiveInt, PositiveFinite, defaults } from "../Limits"
 
 const diagnosticCause = Schema.Cause(
 	Schema.Defect({ includeStack: true }),