@graftland/plugin-remote 0.0.0-stage → 0.2.0-beta.2

package/dist/Contract.d.ts

@@ -0,0 +1,71 @@
+import { ActivationFailed, AlreadyLoaded, ChildFailure, ContractNotFound, ModuleImportFailed } from "./internal/childErrors.js";
+import { Service, service } from "./internal/services.js";
+import { Cause, Schema } from "effect";
+declare namespace Contract_d_exports {
+  export { ChildFailure, Contract, RunnerContract, UndeclaredFailure, fromModule, isContract, make, service };
+}
+declare const UndeclaredFailure_base: Schema.Class<UndeclaredFailure, Schema.TaggedStruct<"UndeclaredFailure", {
+  readonly original: Schema.Defect;
+}>, Cause.YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** An undeclared failure still crosses the boundary, with its diagnostic value. */
+export declare class UndeclaredFailure extends UndeclaredFailure_base {}
+/** Pure metadata shared by the host and the executable runner bootstrap. */
+export declare const make: <S extends Schema.Top & {
+  readonly Encoded: Schema.Json;
+  readonly DecodingServices: never;
+  readonly EncodingServices: never;
+}, E extends Schema.Top & {
+  readonly DecodingServices: never;
+  readonly EncodingServices: never;
+}>(options: {
+  readonly name: string;
+  readonly config: S;
+  readonly error: E;
+  readonly module: string;
+  readonly inject?: ReadonlyArray<Service>;
+  readonly provides?: ReadonlyArray<Service>;
+}) => {
+  name: string;
+  config: S;
+  error: E;
+  module: string;
+  control: import("effect/rpc/RpcGroup").RpcGroup<import("effect/rpc/Rpc").Rpc<"Dispose", Schema.Void, Schema.Void, Schema.toCodecJson<Schema.Cause<Schema.Union<readonly [E, typeof UndeclaredFailure, Schema.Union<readonly [typeof AlreadyLoaded, typeof ContractNotFound, typeof ModuleImportFailed, typeof ActivationFailed]>]>, Schema.Defect>>, never, never> | import("effect/rpc/Rpc").Rpc<"Events", Schema.Void, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.TaggedStruct<"Failed", {
+    readonly cause: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  }>, Schema.TaggedStruct<"Stopped", {}>, Schema.TaggedStruct<"Withdrawing", {}>]>, Schema.Never>, Schema.Never, never, never> | import("effect/rpc/Rpc").Rpc<"Load", Schema.Struct<{
+    input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  }>, Schema.Void, Schema.toCodecJson<Schema.Cause<Schema.Union<readonly [E, typeof UndeclaredFailure, Schema.Union<readonly [typeof AlreadyLoaded, typeof ContractNotFound, typeof ModuleImportFailed, typeof ActivationFailed]>]>, Schema.Defect>>, never, never> | import("effect/rpc/Rpc").Rpc<"Logs", Schema.Void, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.TaggedStruct<"Log", {
+    readonly entry: Schema.Struct<{
+      readonly level: Schema.Literals<readonly ["Fatal", "Error", "Warn", "Info", "Debug", "Trace", "All", "None"]>;
+      readonly message: Schema.Defect;
+      readonly cause: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+      readonly annotations: Schema.$Record<Schema.String, Schema.Defect>;
+    }>;
+    readonly dropped: Schema.Int;
+  }>, Schema.TaggedStruct<"LogsEnded", {
+    readonly dropped: Schema.Int;
+  }>]>, Schema.Never>, Schema.Never, never, never>>;
+  normalizeCause: (cause: Cause.Cause<unknown>) => Cause.Cause<ActivationFailed | AlreadyLoaded | ContractNotFound | ModuleImportFailed | UndeclaredFailure | E["Type"]>;
+  inject: readonly Service<never, never>[];
+  provides: readonly Service<never, never>[];
+  "~@graftland/plugin-remote/Contract": string;
+  encodeCause: (cause: Cause.Cause<unknown>) => import("effect/Effect").Effect<Schema.Json, Schema.SchemaError, E["EncodingServices"]>;
+  decodeCause: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<Cause.Cause<ActivationFailed | AlreadyLoaded | ContractNotFound | ModuleImportFailed | UndeclaredFailure | E["Type"]>, Schema.SchemaError, E["DecodingServices"]>;
+};
+/** The shared config, error codecs, and service declarations for one remote plugin. */
+export type Contract<S extends Schema.Top & {
+  readonly Encoded: Schema.Json;
+  readonly DecodingServices: never;
+  readonly EncodingServices: never;
+}, E extends Schema.Top & {
+  readonly DecodingServices: never;
+  readonly EncodingServices: never;
+}> = ReturnType<typeof make<S, E>>;
+/** Dynamic imports retain the control server and cause normalization; hosts retain the declared error type. */
+export type RunnerContract = Contract<Schema.Codec<unknown, Schema.Json>, Schema.Codec<unknown>>;
+export declare const isContract: (value: unknown) => value is RunnerContract;
+/** A contract module exports either default or a named contract. */
+export declare const fromModule: (module: unknown) => import("effect/Option").Option<RunnerContract>;
+export { ChildFailure, Contract_d_exports, service };
+//# sourceMappingURL=Contract.d.ts.map

package/dist/Contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Contract.d.ts","names":["_$__internal_childErrors0.AlreadyLoaded","_$__internal_childErrors0.ContractNotFound","_$__internal_childErrors0.ModuleImportFailed","_$__internal_childErrors0.ActivationFailed"],"sources":["../src/Contract.ts"],"mappings":";;;;;;;;;WAamB;;;qBAFN,0BAA0B;;qBAM1B,OACZ,UAAU,OAAO;WACP,SAAS,OAAO;WAChB;WACA;GAEV,UAAU,OAAO;WACP;WACA;GACT;WAEQ;WACA,QAAQ;WACR,OAAO;WACP;WACA,SAAS,cAAc;WACvB,WAAW,cAAc;;EALnB;EACE,QAAA;EACD,OAAA;EACC;;;;;;;;;;;;;;;;EAqBc,iBAAA,OAAA,MAAM,mBAAc,MAAA,MAAdG,mBAAcH,gBAAAC,mBAAAC,qBAAA,oBAAA;;;;EAW7B,cAAA,OAAA,MAAM,2CAAc,OAAA,OAAA,MAAA,OAAA,aAAA;E,+HAAAC,mB;;;YAO/B,SACX,UAAU,OAAO;WACP,SAAS,OAAO;WAChB;WACA;GAEV,UAAU,OAAO;WACP;WACA;KAEP,kBAAkB,KAAK,GAAG;;YAGlB,iBAAiB,SAC5B,OAAO,eAAe,OAAO,OAC7B,OAAO;qBAGK,aAAU,mBAAqB,SAAS;;qBAIxC,aAAU,4CAAmB,OAAA"}

package/dist/Contract.js

@@ -0,0 +1 @@
+export { d as ChildFailure, n as UndeclaredFailure, r as fromModule, i as isContract, a as make, s as service } from "./Contract-CcpSIJm4.js";

package/dist/Contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Contract.js","names":["Control.make"],"sources":["../src/Contract.ts"],"sourcesContent":["import { ChildFailure } from \"./internal/childErrors\"\nexport { ChildFailure }\nimport { Array, Cause, Predicate, Schema } from \"effect\"\n\nimport type { Service } from \"./internal/services\"\nimport * as Control from \"./internal/control\"\nexport { service } from \"./internal/services\"\n\nconst TypeId = \"~@graftland/plugin-remote/Contract\"\n\n/** An undeclared failure still crosses the boundary, with its diagnostic value. */\nexport class UndeclaredFailure extends Schema.TaggedError<\n\tUndeclaredFailure,\n\t{ readonly brand: unique symbol }\n>()(\"UndeclaredFailure\", { original: Schema.Defect({ includeStack: true }) }) {}\n\n/** Pure metadata shared by the host and the executable runner bootstrap. */\nexport const make = <\n\tS extends Schema.Top & {\n\t\treadonly Encoded: Schema.Json\n\t\treadonly DecodingServices: never\n\t\treadonly EncodingServices: never\n\t},\n\tE extends Schema.Top & {\n\t\treadonly DecodingServices: never\n\t\treadonly EncodingServices: never\n\t},\n>(options: {\n\treadonly name: string\n\treadonly config: S\n\treadonly error: E\n\treadonly module: string\n\treadonly inject?: ReadonlyArray<Service>\n\treadonly provides?: ReadonlyArray<Service>\n}) => {\n\t// Keys are runtime strings; tuple types cannot distinguish independently created keys.\n\tconst keys = Array.map(\n\t\t[...(options.inject ?? []), ...(options.provides ?? [])],\n\t\t(service) => service.key.key,\n\t)\n\tif (\n\t\tArray.dedupe(keys).length !== keys.length ||\n\t\tkeys.includes(Control.endpoint)\n\t)\n\t\tthrow new Error(\n\t\t\t\"Service keys must be unique within a remote contract and must not use the control endpoint\",\n\t\t)\n\tconst failure = Schema.Union([options.error, UndeclaredFailure, ChildFailure])\n\tconst codec = Schema.toCodecJson(\n\t\tSchema.Cause(failure, Schema.Defect({ includeStack: true })),\n\t)\n\tconst declared = Schema.is(failure)\n\tconst normalizeCause = (cause: Cause.Cause<unknown>) =>\n\t\tCause.map(cause, (error) =>\n\t\t\tdeclared(error) ? error : UndeclaredFailure.make({ original: error }),\n\t\t)\n\treturn {\n\t\t...options,\n\t\tcontrol: Control.make(codec),\n\t\tnormalizeCause,\n\t\tinject: options.inject ?? [],\n\t\tprovides: options.provides ?? [],\n\t\t[TypeId]: TypeId,\n\t\tencodeCause: (cause: Cause.Cause<unknown>) =>\n\t\t\tnormalizeCause(cause).pipe(Schema.encodeEffect(codec)),\n\t\tdecodeCause: Schema.decodeUnknownEffect(codec),\n\t}\n}\n\n/** The shared config, error codecs, and service declarations for one remote plugin. */\nexport type Contract<\n\tS extends Schema.Top & {\n\t\treadonly Encoded: Schema.Json\n\t\treadonly DecodingServices: never\n\t\treadonly EncodingServices: never\n\t},\n\tE extends Schema.Top & {\n\t\treadonly DecodingServices: never\n\t\treadonly EncodingServices: never\n\t},\n> = ReturnType<typeof make<S, E>>\n\n/** Dynamic imports retain the control server and cause normalization; hosts retain the declared error type. */\nexport type RunnerContract = Contract<\n\tSchema.Codec<unknown, Schema.Json>,\n\tSchema.Codec<unknown>\n>\n\nexport const isContract = (value: unknown): value is RunnerContract =>\n\tPredicate.hasProperty(value, TypeId) && value[TypeId] === TypeId\n\n/** A contract module exports either default or a named contract. */\nexport const fromModule = (module: unknown) =>\n\tArray.findFirst(\n\t\t[\n\t\t\tPredicate.hasProperty(module, \"default\") ? module.default : undefined,\n\t\t\tPredicate.hasProperty(module, \"contract\") ? module.contract : undefined,\n\t\t],\n\t\tisContract,\n\t)\n"],"mappings":";;;;;;;;;;;;;;AAQA,MAAM,SAAS;;AAGf,IAAa,oBAAb,cAAuC,OAAO,YAG5C,CAAC,CAAC,qBAAqB,EAAE,UAAU,OAAO,OAAO,EAAE,cAAc,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;;AAG/E,MAAa,QAUX,YAOI;CAEL,MAAM,OAAO,MAAM,IAClB,CAAC,GAAI,QAAQ,UAAU,CAAC,GAAI,GAAI,QAAQ,YAAY,CAAC,CAAE,IACtD,YAAY,QAAQ,IAAI,GAC1B;CACA,IACC,MAAM,OAAO,IAAI,CAAC,CAAC,WAAW,KAAK,UACnC,KAAK,SAAS,kCAAgB,GAE9B,MAAM,IAAI,MACT,4FACD;CACD,MAAM,UAAU,OAAO,MAAM;EAAC,QAAQ;EAAO;EAAmB;CAAY,CAAC;CAC7E,MAAM,QAAQ,OAAO,YACpB,OAAO,MAAM,SAAS,OAAO,OAAO,EAAE,cAAc,KAAK,CAAC,CAAC,CAC5D;CACA,MAAM,WAAW,OAAO,GAAG,OAAO;CAClC,MAAM,kBAAkB,UACvB,MAAM,IAAI,QAAQ,UACjB,SAAS,KAAK,IAAI,QAAQ,kBAAkB,KAAK,EAAE,UAAU,MAAM,CAAC,CACrE;CACD,OAAO;EACN,GAAG;EACH,SAASA,OAAa,KAAK;EAC3B;EACA,QAAQ,QAAQ,UAAU,CAAC;EAC3B,UAAU,QAAQ,YAAY,CAAC;GAC9B,SAAS;EACV,cAAc,UACb,eAAe,KAAK,CAAC,CAAC,KAAK,OAAO,aAAa,KAAK,CAAC;EACtD,aAAa,OAAO,oBAAoB,KAAK;CAC9C;AACD;AAqBA,MAAa,cAAc,UAC1B,UAAU,YAAY,OAAO,MAAM,KAAK,MAAM,YAAY;;AAG3D,MAAa,cAAc,WAC1B,MAAM,UACL,CACC,UAAU,YAAY,QAAQ,SAAS,IAAI,OAAO,UAAU,KAAA,GAC5D,UAAU,YAAY,QAAQ,UAAU,IAAI,OAAO,WAAW,KAAA,CAC/D,GACA,UACD"}

package/dist/Errors-oPsTLY7l.js

@@ -0,0 +1,45 @@
+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))
+}) {};
+export { ProcessExited as a, TransportError as c, MissingInstance as i, CredentialsError as n, RemoteError as o, LocalTerminationTimeout as r, RemoteWithdrawn as s, AuthenticationFailed as t };

package/dist/Errors.d.ts

@@ -0,0 +1,67 @@
+import { Schema } from "effect";
+declare const ProcessExited_base: Schema.Class<ProcessExited, Schema.TaggedStruct<"ProcessExited", {
+  readonly pid: Schema.Option<Schema.Int>;
+  readonly threadId: Schema.optionalKey<Schema.Int>;
+  readonly exitCode: Schema.NullOr<Schema.Int>;
+  readonly stderr: Schema.String;
+  readonly statusCause: Schema.Cause<Schema.Unknown, Schema.Unknown>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class ProcessExited extends ProcessExited_base {
+  get message(): string;
+}
+declare const TransportError_base: Schema.Class<TransportError, Schema.TaggedStruct<"TransportError", {
+  readonly cause: Schema.Cause<Schema.Unknown, Schema.Unknown>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class TransportError extends TransportError_base {}
+declare const RemoteWithdrawn_base: Schema.Class<RemoteWithdrawn, Schema.TaggedStruct<"RemoteWithdrawn", {}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** The remote export lease was withdrawn; host consumers must drain before Dispose. */
+export declare class RemoteWithdrawn extends RemoteWithdrawn_base {
+  get message(): string;
+}
+declare const RemoteError_base: Schema.Class<RemoteError, Schema.TaggedStruct<"RemoteError", {
+  readonly cause: Schema.Cause<Schema.Unknown, Schema.Unknown>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** Infrastructure failure at the plugin boundary; the complete underlying cause remains inspectable. */
+export declare class RemoteError extends RemoteError_base {}
+declare const MissingInstance_base: Schema.Class<MissingInstance, Schema.TaggedStruct<"MissingInstance", {}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** A network execution needs a stable logical identity across host restarts. */
+export declare class MissingInstance extends MissingInstance_base {
+  get message(): string;
+}
+declare const LocalTerminationTimeout_base: Schema.Class<LocalTerminationTimeout, Schema.TaggedStruct<"LocalTerminationTimeout", {
+  readonly pid: Schema.optionalKey<Schema.Int>;
+  readonly threadId: Schema.optionalKey<Schema.Int>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** Dispose completed, but Node still owns live handles; process-scope cleanup must terminate it. */
+export declare class LocalTerminationTimeout extends LocalTerminationTimeout_base {
+  get message(): string;
+}
+declare const CredentialsError_base: Schema.Class<CredentialsError, Schema.TaggedStruct<"CredentialsError", {
+  readonly cause: Schema.Cause<Schema.Unknown, Schema.Unknown>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** A credential source failed; the original failure remains available. */
+export declare class CredentialsError extends CredentialsError_base {}
+declare const AuthenticationFailed_base: Schema.Class<AuthenticationFailed, Schema.TaggedStruct<"AuthenticationFailed", {
+  readonly reason: Schema.Literals<readonly ["missing", "invalid"]>;
+  readonly challenge: Schema.optionalKey<Schema.String>;
+  readonly cause: Schema.optionalKey<Schema.Cause<Schema.Unknown, Schema.Unknown>>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class AuthenticationFailed extends AuthenticationFailed_base {}
+export {};
+//# sourceMappingURL=Errors.d.ts.map

package/dist/Errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.d.ts","names":[],"sources":["../src/Errors.ts"],"mappings":";;;;;;;;WAImB;;qBAFN,sBAAsB;MAUrB;;;;;WAQK;;qBAFN,uBAAuB;;WAUjB;;;qBAFN,wBAAwB;MAIvB;;;;;WAQK;;;qBAFN,oBAAoB;;WAQd;;;qBAFN,wBAAwB;MAIvB;;;;;;WAQK;;;qBAFN,gCAAgC;MAO/B;;;;;WAUK;;;qBAFN,yBAAyB;;;;;;WASnB;;qBAFN,6BAA6B"}

package/dist/Errors.js

@@ -0,0 +1,47 @@
+import { Option, Schema } from "effect";
+// 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))
+}) {};
+export { AuthenticationFailed, CredentialsError, LocalTerminationTimeout, MissingInstance, ProcessExited, RemoteError, RemoteWithdrawn, TransportError };
+
+//# sourceMappingURL=Errors.js.map

package/dist/Errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.js","names":[],"sources":["../src/Errors.ts"],"sourcesContent":["import { Option, Schema } from \"effect\"\n\nexport class ProcessExited extends Schema.TaggedError<\n\tProcessExited,\n\t{ readonly brand: unique symbol }\n>()(\"ProcessExited\", {\n\tpid: Schema.Option(Schema.Int),\n\tthreadId: Schema.optionalKey(Schema.Int),\n\texitCode: Schema.NullOr(Schema.Int),\n\tstderr: Schema.String,\n\tstatusCause: Schema.Cause(Schema.Unknown, Schema.Unknown),\n}) {\n\toverride get message() {\n\t\treturn this.threadId !== undefined\n\t\t\t? `Remote worker ${this.threadId} exited unexpectedly (${this.exitCode})`\n\t\t\t: `Remote process${Option.isSome(this.pid) ? ` ${this.pid.value}` : \"\"} exited unexpectedly (${this.exitCode ?? \"signal\"})`\n\t}\n}\nexport class TransportError extends Schema.TaggedError<\n\tTransportError,\n\t{ readonly brand: unique symbol }\n>()(\"TransportError\", {\n\tcause: Schema.Cause(Schema.Unknown, Schema.Unknown),\n}) {}\n\n/** The remote export lease was withdrawn; host consumers must drain before Dispose. */\nexport class RemoteWithdrawn extends Schema.TaggedError<\n\tRemoteWithdrawn,\n\t{ readonly brand: unique symbol }\n>()(\"RemoteWithdrawn\", {}) {\n\toverride get message() {\n\t\treturn \"Remote services were withdrawn\"\n\t}\n}\n\n/** Infrastructure failure at the plugin boundary; the complete underlying cause remains inspectable. */\nexport class RemoteError extends Schema.TaggedError<\n\tRemoteError,\n\t{ readonly brand: unique symbol }\n>()(\"RemoteError\", { cause: Schema.Cause(Schema.Unknown, Schema.Unknown) }) {}\n\n/** A network execution needs a stable logical identity across host restarts. */\nexport class MissingInstance extends Schema.TaggedError<\n\tMissingInstance,\n\t{ readonly brand: unique symbol }\n>()(\"MissingInstance\", {}) {\n\toverride get message() {\n\t\treturn \"A runner connection requires an instance or a loader entry id; set connect.instance when loading without Loader.\"\n\t}\n}\n\n/** Dispose completed, but Node still owns live handles; process-scope cleanup must terminate it. */\nexport class LocalTerminationTimeout extends Schema.TaggedError<\n\tLocalTerminationTimeout,\n\t{ readonly brand: unique symbol }\n>()(\"LocalTerminationTimeout\", {\n\tpid: Schema.optionalKey(Schema.Int),\n\tthreadId: Schema.optionalKey(Schema.Int),\n}) {\n\toverride get message() {\n\t\treturn this.threadId !== undefined\n\t\t\t? `Remote worker ${this.threadId} did not exit within one second after Dispose; terminating it`\n\t\t\t: `Remote process ${this.pid} did not exit within one second after Dispose; terminating it`\n\t}\n}\n\n/** A credential source failed; the original failure remains available. */\nexport class CredentialsError extends Schema.TaggedError<\n\tCredentialsError,\n\t{ readonly brand: unique symbol }\n>()(\"CredentialsError\", {\n\tcause: Schema.Cause(Schema.Unknown, Schema.Unknown),\n}) {}\n\nexport class AuthenticationFailed extends Schema.TaggedError<\n\tAuthenticationFailed,\n\t{ readonly brand: unique symbol }\n>()(\"AuthenticationFailed\", {\n\treason: Schema.Literals([\"missing\", \"invalid\"]),\n\tchallenge: Schema.optionalKey(Schema.String),\n\tcause: Schema.optionalKey(Schema.Cause(Schema.Unknown, Schema.Unknown)),\n}) {}\n"],"mappings":";;AAEA,IAAa,gBAAb,cAAmC,OAAO,YAGxC,CAAC,CAAC,iBAAiB;CACpB,KAAK,OAAO,OAAO,OAAO,GAAG;CAC7B,UAAU,OAAO,YAAY,OAAO,GAAG;CACvC,UAAU,OAAO,OAAO,OAAO,GAAG;CAClC,QAAQ,OAAO;CACf,aAAa,OAAO,MAAM,OAAO,SAAS,OAAO,OAAO;AACzD,CAAC,CAAC,CAAC;CACF,IAAa,UAAU;EACtB,OAAO,KAAK,aAAa,KAAA,IACtB,iBAAiB,KAAK,SAAS,wBAAwB,KAAK,SAAS,KACrE,iBAAiB,OAAO,OAAO,KAAK,GAAG,IAAI,IAAI,KAAK,IAAI,UAAU,GAAG,wBAAwB,KAAK,YAAY,SAAS;CAC3H;AACD;AACA,IAAa,iBAAb,cAAoC,OAAO,YAGzC,CAAC,CAAC,kBAAkB,EACrB,OAAO,OAAO,MAAM,OAAO,SAAS,OAAO,OAAO,EACnD,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,kBAAb,cAAqC,OAAO,YAG1C,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;CAC1B,IAAa,UAAU;EACtB,OAAO;CACR;AACD;;AAGA,IAAa,cAAb,cAAiC,OAAO,YAGtC,CAAC,CAAC,eAAe,EAAE,OAAO,OAAO,MAAM,OAAO,SAAS,OAAO,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;;AAG7E,IAAa,kBAAb,cAAqC,OAAO,YAG1C,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;CAC1B,IAAa,UAAU;EACtB,OAAO;CACR;AACD;;AAGA,IAAa,0BAAb,cAA6C,OAAO,YAGlD,CAAC,CAAC,2BAA2B;CAC9B,KAAK,OAAO,YAAY,OAAO,GAAG;CAClC,UAAU,OAAO,YAAY,OAAO,GAAG;AACxC,CAAC,CAAC,CAAC;CACF,IAAa,UAAU;EACtB,OAAO,KAAK,aAAa,KAAA,IACtB,iBAAiB,KAAK,SAAS,iEAC/B,kBAAkB,KAAK,IAAI;CAC/B;AACD;;AAGA,IAAa,mBAAb,cAAsC,OAAO,YAG3C,CAAC,CAAC,oBAAoB,EACvB,OAAO,OAAO,MAAM,OAAO,SAAS,OAAO,OAAO,EACnD,CAAC,CAAC,CAAC,CAAC;AAEJ,IAAa,uBAAb,cAA0C,OAAO,YAG/C,CAAC,CAAC,wBAAwB;CAC3B,QAAQ,OAAO,SAAS,CAAC,WAAW,SAAS,CAAC;CAC9C,WAAW,OAAO,YAAY,OAAO,MAAM;CAC3C,OAAO,OAAO,YAAY,OAAO,MAAM,OAAO,SAAS,OAAO,OAAO,CAAC;AACvE,CAAC,CAAC,CAAC,CAAC"}

package/dist/FailureGroup-BcH0XOBi.js

@@ -0,0 +1,53 @@
+import { n as close, t as ReleaseInterrupted } from "./release-BY4Mlluy.js";
+import { Array, Cause, Data, Deferred, Effect, Exit, Fiber, FiberSet, Ref, Schema, Scope, TxRef } from "effect";
+// 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.gen(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.orDie));
+	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 { make as t };

package/dist/Framing-zaYdOJnT.js

@@ -0,0 +1,61 @@
+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 = (frame) => Effect.gen(function* () {
+	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 };