@graftland/plugin-remote 0.3.2 → 0.3.3

package/dist/host/auth/bearer.d.ts

@@ -1,4 +1,12 @@
 import { Config } from "../../internal/auth/tokenCredentials.js";
-declare const capability: any;
+declare const capability: import("@graftland/graft/Plugin").Definition<{
+  readonly token: import("effect/Redacted").Redacted<string> | {
+    readonly file: string;
+  };
+}, {
+  readonly token: string | {
+    readonly file: string;
+  };
+}, import("effect/Schema").SchemaError | import("@graftland/graft/Graft").ServiceConflict>;
 export { Config, capability as default };
 //# sourceMappingURL=bearer.d.ts.map

package/dist/host/auth/bearer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bearer.d.ts","names":[],"sources":["../../../src/host/auth/bearer.ts"],"mappings":";cAGM"}
+{"version":3,"file":"bearer.d.ts","names":[],"sources":["../../../src/host/auth/bearer.ts"],"mappings":";cAGM,8CAAU;;;;;;;;2BAAsC,+CAAA"}

package/dist/host/auth/jwt.d.ts

@@ -1,4 +1,12 @@
 import { Config } from "../../internal/auth/tokenCredentials.js";
-declare const capability: any;
+declare const capability: import("@graftland/graft/Plugin").Definition<{
+  readonly token: import("effect/Redacted").Redacted<string> | {
+    readonly file: string;
+  };
+}, {
+  readonly token: string | {
+    readonly file: string;
+  };
+}, import("effect/Schema").SchemaError | import("@graftland/graft/Graft").ServiceConflict>;
 export { Config, capability as default };
 //# sourceMappingURL=jwt.d.ts.map

package/dist/host/auth/jwt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jwt.d.ts","names":[],"sources":["../../../src/host/auth/jwt.ts"],"mappings":";cAGM"}
+{"version":3,"file":"jwt.d.ts","names":[],"sources":["../../../src/host/auth/jwt.ts"],"mappings":";cAGM,8CAAU;;;;;;;;2BAAmC,+CAAA"}

package/dist/host/auth/mtls.d.ts

@@ -1,8 +1,15 @@
+import { Graft, Plugin } from "@graftland/graft";
 import { Schema } from "effect";
 export declare const Config: Schema.Struct<{
   readonly cert: Schema.String;
   readonly key: Schema.String;
 }>;
-declare const _default: any;
+declare const _default: Plugin.Definition<{
+  readonly cert: string;
+  readonly key: string;
+}, {
+  readonly cert: string;
+  readonly key: string;
+}, Schema.SchemaError | Graft.ServiceConflict>;
 export { _default as default };
 //# sourceMappingURL=mtls.d.ts.map

package/dist/host/auth/mtls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mtls.d.ts","names":[],"sources":["../../../src/host/auth/mtls.ts"],"mappings":";qBAca,QAAM,OAAA"}
+{"version":3,"file":"mtls.d.ts","names":[],"sources":["../../../src/host/auth/mtls.ts"],"mappings":";;qBAca,QAAM,OAAA"}

package/dist/host/auth/none.d.ts

@@ -1,3 +1,5 @@
-declare const _default: any;
+import { Graft, Plugin } from "@graftland/graft";
+import { Schema } from "effect";
+declare const _default: Plugin.Definition<{}, {}, Schema.SchemaError | Graft.ServiceConflict>;
 export { _default as default };
 //# sourceMappingURL=none.d.ts.map

package/dist/host/command.d.ts

@@ -1,5 +1,6 @@
 import { ConnectorApi } from "../Transport.js";
 import { CommandOptions } from "../internal/transportOptions.js";
+import { Graft, Plugin } from "@graftland/graft";
 import { Cause, Effect, Schema } from "effect";
 import { ChildProcessSpawner } from "effect/process";
 declare const CommandExited_base: Schema.Class<CommandExited, Schema.TaggedStruct<"CommandExited", {
@@ -17,6 +18,18 @@ export declare const Config: Schema.Struct<{
   readonly cwd: Schema.optionalKey<Schema.String>;
   readonly env: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
 }>;
-declare const _default: any;
+declare const _default: Plugin.Definition<{
+  readonly argv: readonly [string, ...string[]];
+  readonly cwd?: string;
+  readonly env?: {
+    readonly [x: string]: string;
+  };
+}, {
+  readonly argv: readonly [string, ...string[]];
+  readonly cwd?: string;
+  readonly env?: {
+    readonly [x: string]: string;
+  };
+}, Schema.SchemaError | Graft.ServiceConflict>;
 export { type CommandOptions as Options, _default as default };
 //# sourceMappingURL=command.d.ts.map

package/dist/host/command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command.d.ts","names":["_$___Transport0.ConnectorApi"],"sources":["../../src/host/command.ts"],"mappings":";;;;;;;;;WAwBmB;;qBAFN,sBAAsB;;qBAUtB,OAAI,SAAa,mBAAc,OAAA,OAAdA,qBAAc,oBAAA;qBA2E/B,QAAM,OAAA"}
+{"version":3,"file":"command.d.ts","names":["_$___Transport0.ConnectorApi"],"sources":["../../src/host/command.ts"],"mappings":";;;;;;;;;;WAwBmB;;qBAFN,sBAAsB;;qBAUtB,OAAI,SAAa,mBAAc,OAAA,OAAdA,qBAAc,oBAAA;qBA2E/B,QAAM,OAAA"}

package/dist/host/local.d.ts

@@ -1,3 +1,4 @@
-declare const plugin: any;
+import { Plugin } from "@graftland/graft";
+declare const plugin: Plugin.Definition<void, void, import("effect/Schema").SchemaError | import("@graftland/graft/Graft").ServiceConflict>;
 export { plugin as default };
 //# sourceMappingURL=local.d.ts.map

package/dist/host/local.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"local.d.ts","names":[],"sources":["../../src/host/local.ts"],"mappings":"A,cA+BM"}
+{"version":3,"file":"local.d.ts","names":[],"sources":["../../src/host/local.ts"],"mappings":";cA+BM,QAAM,OAAA,+CAAA,+CAAA"}

package/dist/host/unix.d.ts

@@ -1,11 +1,16 @@
 import { UnixOptions } from "../internal/transportOptions.js";
 import { ConnectorApi } from "../Transport.js";
+import { Graft, Plugin } from "@graftland/graft";
 import { Schema } from "effect";
 export declare const properties: ConnectorApi["properties"];
 export declare const make: (options: UnixOptions) => ConnectorApi;
 export declare const Config: Schema.Struct<{
   readonly path: Schema.String;
 }>;
-declare const _default: any;
+declare const _default: Plugin.Definition<{
+  readonly path: string;
+}, {
+  readonly path: string;
+}, Schema.SchemaError | Graft.ServiceConflict>;
 export { type UnixOptions as Options, _default as default };
 //# sourceMappingURL=unix.d.ts.map

package/dist/host/unix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unix.d.ts","names":[],"sources":["../../src/host/unix.ts"],"mappings":";;;qBAca,YAAY;qBAmBZ,OAAI,SAAa,gBAAc;qBAe/B,QAAM,OAAA"}
+{"version":3,"file":"unix.d.ts","names":[],"sources":["../../src/host/unix.ts"],"mappings":";;;;qBAca,YAAY;qBAmBZ,OAAI,SAAa,gBAAc;qBAe/B,QAAM,OAAA"}

package/dist/host/websocket.d.ts

@@ -1,5 +1,6 @@
 import { WebsocketOptions } from "../internal/transportOptions.js";
 import { ConnectorApi } from "../Transport.js";
+import { Graft, Plugin } from "@graftland/graft";
 import { Schema } from "effect";
 /** Configured Connector; certificate paths belong to the enclosing configuration. */
 export declare const Config: Schema.Struct<{
@@ -8,6 +9,14 @@ export declare const Config: Schema.Struct<{
   readonly servername: Schema.optionalKey<Schema.String>;
 }>;
 export declare const make: (options: WebsocketOptions, properties: ConnectorApi["properties"]) => ConnectorApi;
-declare const _default: any;
+declare const _default: Plugin.Definition<{
+  readonly url: URL;
+  readonly ca?: string;
+  readonly servername?: string;
+}, {
+  readonly url: string;
+  readonly ca?: string;
+  readonly servername?: string;
+}, import("effect/PlatformError").PlatformError | Schema.SchemaError | Graft.ServiceConflict>;
 export { type WebsocketOptions as Options, _default as default };
 //# sourceMappingURL=websocket.d.ts.map

package/dist/host/websocket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"websocket.d.ts","names":[],"sources":["../../src/host/websocket.ts"],"mappings":";;;;qBAYa,QAAM,OAAA;;;;;qBAKN,OAAI,SACP,kBAAgB,YACb,+BACV"}
+{"version":3,"file":"websocket.d.ts","names":[],"sources":["../../src/host/websocket.ts"],"mappings":";;;;;qBAYa,QAAM,OAAA;;;;;qBAKN,OAAI,SACP,kBAAgB,YACb,+BACV"}

package/dist/host/worker.d.ts

@@ -1,3 +1,5 @@
-declare const plugin: any;
+import { Plugin } from "@graftland/graft";
+import { Schema } from "effect";
+declare const plugin: Plugin.Definition<void, void, Schema.SchemaError | import("@graftland/graft/Graft").ServiceConflict>;
 export { plugin as default };
 //# sourceMappingURL=worker.d.ts.map

package/dist/host/worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker.d.ts","names":[],"sources":["../../src/host/worker.ts"],"mappings":"A,cAoFM"}
+{"version":3,"file":"worker.d.ts","names":[],"sources":["../../src/host/worker.ts"],"mappings":";;cAoFM,QAAM,OAAA,uBAAA,OAAA,+CAAA"}

package/dist/internal/assembly.d.ts

@@ -1,5 +1,6 @@
-import "./port.js";
 import "../Errors.js";
+import "./port.js";
 import "../Auth.js";
 import "../Transport.js";
+import { Fork, Graft, Plugin } from "@graftland/graft";
 import { Effect, Schema } from "effect";

package/dist/internal/auth/tokenCredentials.d.ts

@@ -1,4 +1,5 @@
-import { Schema } from "effect";
+import { Graft, Plugin } from "@graftland/graft";
+import { Redacted, Schema } from "effect";
 export declare const Config: Schema.Struct<{
   readonly token: Schema.Union<readonly [Schema.RedactedFromValue<Schema.String>, Schema.Struct<{
     readonly file: Schema.String;

package/dist/internal/auth/tokenCredentials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tokenCredentials.d.ts","names":[],"sources":["../../../src/internal/auth/tokenCredentials.ts"],"mappings":";qBAea,QAAM,OAAA"}
+{"version":3,"file":"tokenCredentials.d.ts","names":[],"sources":["../../../src/internal/auth/tokenCredentials.ts"],"mappings":";;qBAea,QAAM,OAAA"}

package/dist/internal/credentials.d.ts

@@ -1,6 +1,6 @@
 import { ClientCertificate } from "../Auth.js";
 import { Connect as Connect$1 } from "./entryConfig.js";
-import { Plugin } from "@graftland/graft";
+import { Graft, Plugin } from "@graftland/graft";
 import { Effect, Redacted, Scope } from "effect";
 export type Source<A, D extends ReadonlyArray<Plugin.Dependency>, E = unknown> = Effect.Effect<A, E, Scope.Scope> | {
   readonly inject: D;

package/dist/internal/entry.d.ts

@@ -1,8 +1,420 @@
+import "./runner/model.js";
 import "../Contract.js";
-import "../Errors.js";
+import { RemoteEntryError } from "../Errors.js";
 import "./directTransport.js";
 import "./execution.js";
 import { Fork, Graft, Plugin } from "@graftland/graft";
-import { Cause, Effect, Schema, Scope } from "effect";
-export declare const host: any;
+import { ModuleResolver } from "@graftland/loader";
+import { Cause, Effect, Path, Schema, Scope } from "effect";
+import { SecureRandom } from "effect/crypto";
+import { ChildProcessSpawner } from "effect/process";
+export declare const host: Plugin.Definition<{
+  readonly contract: string;
+  readonly connect: {
+    readonly unix?: never;
+    readonly command?: never;
+    readonly stdio?: never;
+    readonly local?: never;
+    readonly worker?: never;
+    readonly transport?: never;
+    readonly instance?: string;
+    readonly lease?: import("effect/Duration").Duration;
+    readonly margin?: import("effect/Duration").Duration;
+    readonly expect?: {
+      readonly version?: string;
+      readonly digest?: string;
+    };
+    readonly auth?: {
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly name: string;
+      readonly config?: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly mtls: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly bearer: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly none?: never;
+      readonly jwt: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none: unknown;
+    };
+    readonly url: string;
+    readonly ca?: string;
+    readonly servername?: string;
+  } | {
+    readonly url?: never;
+    readonly command?: never;
+    readonly stdio?: never;
+    readonly local?: never;
+    readonly worker?: never;
+    readonly transport?: never;
+    readonly instance?: string;
+    readonly lease?: import("effect/Duration").Duration;
+    readonly margin?: import("effect/Duration").Duration;
+    readonly expect?: {
+      readonly version?: string;
+      readonly digest?: string;
+    };
+    readonly auth?: {
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly name: string;
+      readonly config?: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly mtls: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly bearer: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly none?: never;
+      readonly jwt: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none: unknown;
+    };
+    readonly unix: string;
+  } | {
+    readonly url?: never;
+    readonly unix?: never;
+    readonly stdio?: never;
+    readonly local?: never;
+    readonly worker?: never;
+    readonly transport?: never;
+    readonly instance?: string;
+    readonly lease?: import("effect/Duration").Duration;
+    readonly margin?: import("effect/Duration").Duration;
+    readonly expect?: {
+      readonly version?: string;
+      readonly digest?: string;
+    };
+    readonly command: readonly [string, ...string[]];
+    readonly auth?: never;
+    readonly cwd?: string;
+    readonly env?: {
+      readonly [x: string]: string;
+    };
+  } | {
+    readonly url?: never;
+    readonly unix?: never;
+    readonly command?: never;
+    readonly stdio?: never;
+    readonly worker?: never;
+    readonly transport?: never;
+    readonly auth?: never;
+    readonly local: {
+      readonly command?: readonly [string, ...string[]];
+    };
+  } | {
+    readonly url?: never;
+    readonly unix?: never;
+    readonly command?: never;
+    readonly stdio?: never;
+    readonly local?: never;
+    readonly transport?: never;
+    readonly auth?: never;
+    readonly worker: {
+      readonly execArgv?: readonly string[];
+    };
+  } | {
+    readonly url?: never;
+    readonly unix?: never;
+    readonly command?: never;
+    readonly stdio?: never;
+    readonly local?: never;
+    readonly worker?: never;
+    readonly instance?: string;
+    readonly lease?: import("effect/Duration").Duration;
+    readonly margin?: import("effect/Duration").Duration;
+    readonly expect?: {
+      readonly version?: string;
+      readonly digest?: string;
+    };
+    readonly auth?: {
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly name: string;
+      readonly config?: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly mtls: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly bearer: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly none?: never;
+      readonly jwt: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none: unknown;
+    };
+    readonly transport: {
+      readonly name: string;
+      readonly config?: unknown;
+    };
+  };
+  readonly config: Schema.Json;
+}, {
+  readonly contract: string;
+  readonly connect: {
+    readonly unix?: never;
+    readonly command?: never;
+    readonly stdio?: never;
+    readonly local?: never;
+    readonly worker?: never;
+    readonly transport?: never;
+    readonly instance?: string;
+    readonly lease?: string;
+    readonly margin?: string;
+    readonly expect?: {
+      readonly version?: string;
+      readonly digest?: string;
+    };
+    readonly auth?: {
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly name: string;
+      readonly config?: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly mtls: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly bearer: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly none?: never;
+      readonly jwt: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none: unknown;
+    };
+    readonly url: string;
+    readonly ca?: string;
+    readonly servername?: string;
+  } | {
+    readonly url?: never;
+    readonly command?: never;
+    readonly stdio?: never;
+    readonly local?: never;
+    readonly worker?: never;
+    readonly transport?: never;
+    readonly instance?: string;
+    readonly lease?: string;
+    readonly margin?: string;
+    readonly expect?: {
+      readonly version?: string;
+      readonly digest?: string;
+    };
+    readonly auth?: {
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly name: string;
+      readonly config?: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly mtls: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly bearer: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly none?: never;
+      readonly jwt: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none: unknown;
+    };
+    readonly unix: string;
+  } | {
+    readonly url?: never;
+    readonly unix?: never;
+    readonly stdio?: never;
+    readonly local?: never;
+    readonly worker?: never;
+    readonly transport?: never;
+    readonly instance?: string;
+    readonly lease?: string;
+    readonly margin?: string;
+    readonly expect?: {
+      readonly version?: string;
+      readonly digest?: string;
+    };
+    readonly command: readonly [string, ...string[]];
+    readonly auth?: never;
+    readonly cwd?: string;
+    readonly env?: {
+      readonly [x: string]: string;
+    };
+  } | {
+    readonly url?: never;
+    readonly unix?: never;
+    readonly command?: never;
+    readonly stdio?: never;
+    readonly worker?: never;
+    readonly transport?: never;
+    readonly auth?: never;
+    readonly local: {
+      readonly command?: readonly [string, ...string[]];
+    };
+  } | {
+    readonly url?: never;
+    readonly unix?: never;
+    readonly command?: never;
+    readonly stdio?: never;
+    readonly local?: never;
+    readonly transport?: never;
+    readonly auth?: never;
+    readonly worker: {
+      readonly execArgv?: readonly string[];
+    };
+  } | {
+    readonly url?: never;
+    readonly unix?: never;
+    readonly command?: never;
+    readonly stdio?: never;
+    readonly local?: never;
+    readonly worker?: never;
+    readonly instance?: string;
+    readonly lease?: string;
+    readonly margin?: string;
+    readonly expect?: {
+      readonly version?: string;
+      readonly digest?: string;
+    };
+    readonly auth?: {
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly name: string;
+      readonly config?: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly mtls: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly bearer: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly none?: never;
+      readonly jwt: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none: unknown;
+    };
+    readonly transport: {
+      readonly name: string;
+      readonly config?: unknown;
+    };
+  };
+  readonly config?: Schema.Json;
+}, RemoteEntryError | Schema.SchemaError>;
 //# sourceMappingURL=entry.d.ts.map

package/dist/internal/entry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entry.d.ts","names":[],"sources":["../../src/internal/entry.ts"],"mappings":";;;;;;qBAuQa"}
+{"version":3,"file":"entry.d.ts","names":["EntryError"],"sources":["../../src/internal/entry.ts"],"mappings":";;;;;;;;;;qBAuQa,MAAI,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAUfA,mBAAA,OAAA"}

package/dist/runner/auth/bearer.d.ts

@@ -1,7 +1,12 @@
+import { Graft, Plugin } from "@graftland/graft";
 import { Schema } from "effect";
 export declare const Config: Schema.Struct<{
   readonly tokens: Schema.String;
 }>;
-declare const _default: any;
+declare const _default: Plugin.Definition<{
+  readonly tokens: string;
+}, {
+  readonly tokens: string;
+}, import("effect/encoding/EncodingError").EncodingError | import("effect/PlatformError").PlatformError | Schema.SchemaError | Graft.ServiceConflict>;
 export { _default as default };
 //# sourceMappingURL=bearer.d.ts.map

package/dist/runner/auth/bearer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bearer.d.ts","names":[],"sources":["../../../src/runner/auth/bearer.ts"],"mappings":";qBAmBa,QAAM,OAAA"}
+{"version":3,"file":"bearer.d.ts","names":[],"sources":["../../../src/runner/auth/bearer.ts"],"mappings":";;qBAmBa,QAAM,OAAA"}

package/dist/runner/auth/jwt.d.ts

@@ -1,4 +1,5 @@
-import { Schema } from "effect";
+import { Graft, Plugin } from "@graftland/graft";
+import { Duration, Schema } from "effect";
 export declare const ClockTolerance: Schema.DurationFromString;
 export declare const Config: Schema.Struct<{
   readonly issuer: Schema.NonEmptyString;
@@ -14,6 +15,32 @@ export declare const Config: Schema.Struct<{
     readonly jwksUrl: Schema.optionalKey<Schema.Never>;
   }>]>;
 }>;
-declare const _default: any;
+declare const _default: Plugin.Definition<{
+  readonly issuer: string;
+  readonly audience: readonly [string, ...string[]];
+  readonly algorithms: readonly ["ES256" | "ES384" | "ES512" | "EdDSA" | "PS256" | "PS384" | "PS512" | "RS256" | "RS384" | "RS512", ...("ES256" | "ES384" | "ES512" | "EdDSA" | "PS256" | "PS384" | "PS512" | "RS256" | "RS384" | "RS512")[]];
+  readonly identityClaim: string;
+  readonly clockTolerance: Duration.Duration;
+  readonly keys: {
+    readonly jwksUrl: string;
+    readonly publicKey?: never;
+  } | {
+    readonly publicKey: string;
+    readonly jwksUrl?: never;
+  };
+}, {
+  readonly issuer: string;
+  readonly audience: readonly [string, ...string[]];
+  readonly algorithms: readonly ["ES256" | "ES384" | "ES512" | "EdDSA" | "PS256" | "PS384" | "PS512" | "RS256" | "RS384" | "RS512", ...("ES256" | "ES384" | "ES512" | "EdDSA" | "PS256" | "PS384" | "PS512" | "RS256" | "RS384" | "RS512")[]];
+  readonly identityClaim?: string;
+  readonly clockTolerance?: string;
+  readonly keys: {
+    readonly jwksUrl: string;
+    readonly publicKey?: never;
+  } | {
+    readonly publicKey: string;
+    readonly jwksUrl?: never;
+  };
+}, import("effect/jose/JoseError").JoseError | import("effect/PlatformError").PlatformError | Schema.SchemaError | Graft.ServiceConflict>;
 export { _default as default };
 //# sourceMappingURL=jwt.d.ts.map

package/dist/runner/auth/jwt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jwt.d.ts","names":[],"sources":["../../../src/runner/auth/jwt.ts"],"mappings":";qBAmBa,gBAAc,OAAA;qBAOd,QAAM,OAAA"}
+{"version":3,"file":"jwt.d.ts","names":[],"sources":["../../../src/runner/auth/jwt.ts"],"mappings":";;qBAmBa,gBAAc,OAAA;qBAOd,QAAM,OAAA"}

package/dist/runner/auth/mtls.d.ts

@@ -1,4 +1,5 @@
 import { AuthenticatorApi } from "../../Auth.js";
+import { Graft, Plugin } from "@graftland/graft";
 import { Schema } from "effect";
 export declare const Config: Schema.Struct<{
   readonly ca: Schema.String;
@@ -6,6 +7,10 @@ export declare const Config: Schema.Struct<{
 export declare const make: (ca: string) => Extract<AuthenticatorApi, {
   readonly _tag: "Mtls";
 }>;
-declare const _default: any;
+declare const _default: Plugin.Definition<{
+  readonly ca: string;
+}, {
+  readonly ca: string;
+}, import("effect/PlatformError").PlatformError | Schema.SchemaError | Graft.ServiceConflict>;
 export { _default as default };
 //# sourceMappingURL=mtls.d.ts.map

package/dist/runner/auth/mtls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mtls.d.ts","names":[],"sources":["../../../src/runner/auth/mtls.ts"],"mappings":";;qBAMa,QAAM,OAAA;;;qBASN,OAAI,eAEd,QAAQ;WAA6B"}
+{"version":3,"file":"mtls.d.ts","names":[],"sources":["../../../src/runner/auth/mtls.ts"],"mappings":";;;qBAMa,QAAM,OAAA;;;qBASN,OAAI,eAEd,QAAQ;WAA6B"}

package/dist/runner/auth/none.d.ts

@@ -1,3 +1,9 @@
-declare const _default: any;
+import { Graft, Plugin } from "@graftland/graft";
+import { Schema } from "effect";
+declare const _default: Plugin.Definition<{
+  readonly identity: string;
+}, {
+  readonly identity?: string;
+}, Schema.SchemaError | Graft.ServiceConflict>;
 export { _default as default };
 //# sourceMappingURL=none.d.ts.map

package/dist/runner/index.d.ts

@@ -1,3 +1,312 @@
-declare const _default: any;
+import { RemoteEntryError } from "../Errors.js";
+import { Plugin } from "@graftland/graft";
+import { Schema } from "effect";
+declare const _default: Plugin.Definition<{
+  readonly root: string;
+  readonly state: string;
+  readonly lease?: import("effect/Duration").Duration;
+  readonly grace?: import("effect/Duration").Duration;
+  readonly listen: readonly ({
+    readonly unix?: never;
+    readonly command?: never;
+    readonly stdio?: never;
+    readonly local?: never;
+    readonly worker?: never;
+    readonly transport?: never;
+    readonly auth?: {
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly name: string;
+      readonly config?: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly mtls: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly bearer: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly none?: never;
+      readonly jwt: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none: unknown;
+    };
+    readonly url: string;
+    readonly cert?: string;
+    readonly key?: string;
+  } | {
+    readonly url?: never;
+    readonly command?: never;
+    readonly stdio?: never;
+    readonly local?: never;
+    readonly worker?: never;
+    readonly transport?: never;
+    readonly auth?: {
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly name: string;
+      readonly config?: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly mtls: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly bearer: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly none?: never;
+      readonly jwt: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none: unknown;
+    };
+    readonly unix: string;
+  } | {
+    readonly url?: never;
+    readonly unix?: never;
+    readonly command?: never;
+    readonly local?: never;
+    readonly worker?: never;
+    readonly transport?: never;
+    readonly stdio: true;
+    readonly auth?: never;
+    readonly identity?: string;
+  } | {
+    readonly url?: never;
+    readonly unix?: never;
+    readonly command?: never;
+    readonly stdio?: never;
+    readonly local?: never;
+    readonly worker?: never;
+    readonly auth?: {
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly name: string;
+      readonly config?: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly mtls: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly bearer: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly none?: never;
+      readonly jwt: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none: unknown;
+    };
+    readonly transport: {
+      readonly name: string;
+      readonly config?: unknown;
+    };
+  })[];
+}, {
+  readonly root: string;
+  readonly state: string;
+  readonly lease?: string;
+  readonly grace?: string;
+  readonly listen: readonly ({
+    readonly unix?: never;
+    readonly command?: never;
+    readonly stdio?: never;
+    readonly local?: never;
+    readonly worker?: never;
+    readonly transport?: never;
+    readonly auth?: {
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly name: string;
+      readonly config?: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly mtls: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly bearer: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly none?: never;
+      readonly jwt: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none: unknown;
+    };
+    readonly url: string;
+    readonly cert?: string;
+    readonly key?: string;
+  } | {
+    readonly url?: never;
+    readonly command?: never;
+    readonly stdio?: never;
+    readonly local?: never;
+    readonly worker?: never;
+    readonly transport?: never;
+    readonly auth?: {
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly name: string;
+      readonly config?: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly mtls: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly bearer: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly none?: never;
+      readonly jwt: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none: unknown;
+    };
+    readonly unix: string;
+  } | {
+    readonly url?: never;
+    readonly unix?: never;
+    readonly command?: never;
+    readonly local?: never;
+    readonly worker?: never;
+    readonly transport?: never;
+    readonly stdio: true;
+    readonly auth?: never;
+    readonly identity?: string;
+  } | {
+    readonly url?: never;
+    readonly unix?: never;
+    readonly command?: never;
+    readonly stdio?: never;
+    readonly local?: never;
+    readonly worker?: never;
+    readonly auth?: {
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly name: string;
+      readonly config?: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly mtls: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly jwt?: never;
+      readonly none?: never;
+      readonly bearer: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly none?: never;
+      readonly jwt: unknown;
+    } | {
+      readonly name?: never;
+      readonly config?: never;
+      readonly mtls?: never;
+      readonly bearer?: never;
+      readonly jwt?: never;
+      readonly none: unknown;
+    };
+    readonly transport: {
+      readonly name: string;
+      readonly config?: unknown;
+    };
+  })[];
+}, RemoteEntryError | Schema.SchemaError>;
 export { _default as default };
 //# sourceMappingURL=index.d.ts.map

package/dist/runner/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/runner/index.ts"],"mappings":""}
+{"version":3,"file":"index.d.ts","names":["_$___Errors0.RemoteEntryError"],"sources":["../../src/runner/index.ts"],"mappings":""}

package/dist/runner/stdio.d.ts

@@ -1,7 +1,12 @@
+import { Graft, Plugin } from "@graftland/graft";
 import { Schema } from "effect";
 export declare const Config: Schema.Struct<{
   readonly auth: Schema.optionalKey<Schema.Never>;
 }>;
-declare const _default: any;
+declare const _default: Plugin.Definition<{
+  readonly auth?: never;
+}, {
+  readonly auth?: never;
+}, Schema.SchemaError | Graft.ServiceConflict>;
 export { _default as default };
 //# sourceMappingURL=stdio.d.ts.map

package/dist/runner/stdio.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stdio.d.ts","names":[],"sources":["../../src/runner/stdio.ts"],"mappings":";qBAgBa,QAAM,OAAA"}
+{"version":3,"file":"stdio.d.ts","names":[],"sources":["../../src/runner/stdio.ts"],"mappings":";;qBAgBa,QAAM,OAAA"}

package/dist/runner/unix.d.ts

@@ -1,7 +1,12 @@
+import { Graft, Plugin } from "@graftland/graft";
 import { Schema } from "effect";
 export declare const Config: Schema.Struct<{
   readonly path: Schema.String;
 }>;
-declare const _default: any;
+declare const _default: Plugin.Definition<{
+  readonly path: string;
+}, {
+  readonly path: string;
+}, Schema.SchemaError | Graft.ServiceConflict>;
 export { _default as default };
 //# sourceMappingURL=unix.d.ts.map

package/dist/runner/unix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unix.d.ts","names":[],"sources":["../../src/runner/unix.ts"],"mappings":";qBASa,QAAM,OAAA"}
+{"version":3,"file":"unix.d.ts","names":[],"sources":["../../src/runner/unix.ts"],"mappings":";;qBASa,QAAM,OAAA"}

package/dist/runner/websocket.d.ts

@@ -1,3 +1,4 @@
+import { Graft, Plugin } from "@graftland/graft";
 import { Schema } from "effect";
 export declare const Config: Schema.Union<readonly [Schema.decodeTo<Schema.Struct<{
   readonly auth: Schema.toType<Schema.optionalKey<Schema.Never>>;
@@ -23,6 +24,28 @@ export declare const Config: Schema.Union<readonly [Schema.decodeTo<Schema.Struc
   readonly key: Schema.String;
 }>, never, never>]>;
 /** Configured Listener; authentication is supplied to bind, never injected here. */
-declare const _default: any;
+declare const _default: Plugin.Definition<{
+  readonly auth?: never;
+  readonly url: URL;
+  readonly cert?: never;
+  readonly key?: never;
+  readonly _tag: "ws";
+} | {
+  readonly auth?: never;
+  readonly url: URL;
+  readonly cert: string;
+  readonly key: string;
+  readonly _tag: "wss";
+}, {
+  readonly auth?: never;
+  readonly url: string;
+  readonly cert?: never;
+  readonly key?: never;
+} | {
+  readonly auth?: never;
+  readonly url: string;
+  readonly cert: string;
+  readonly key: string;
+}, Schema.SchemaError | Graft.ServiceConflict>;
 export { _default as default };
 //# sourceMappingURL=websocket.d.ts.map

package/dist/runner/websocket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"websocket.d.ts","names":[],"sources":["../../src/runner/websocket.ts"],"mappings":";qBA8Ca,QAAM,OAAA,gBAAA,OAAA,SAAA,OAAA"}
+{"version":3,"file":"websocket.d.ts","names":[],"sources":["../../src/runner/websocket.ts"],"mappings":";;qBA8Ca,QAAM,OAAA,gBAAA,OAAA,SAAA,OAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graftland/plugin-remote",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "type": "module",
   "description": "Local and authenticated network execution for Graft plugins",
   "license": "Apache-2.0",
@@ -49,9 +49,9 @@
     "effect": "4.1.*"
   },
   "dependencies": {
-    "@graftland/graft": "0.3.2",
+    "@graftland/graft": "0.3.3",
     "@effect/platform-node": "4.1.2",
-    "@graftland/loader": "0.3.2",
+    "@graftland/loader": "0.3.3",
     "pkijs": "4.0.1",
     "asn1js": "4.0.0",
     "ws": "8.22.1"
@@ -66,7 +66,7 @@
     "graft-remote": "./dist/bin.js"
   },
   "scripts": {
-    "build": "tsdown",
+    "build": "tsc -b && tsdown",
     "test": "vitest run"
   }
 }