every-plugin 0.0.4 → 0.0.6

package/dist/runtime/runtime.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.test.d.ts","sourceRoot":"","sources":["../../src/runtime/runtime.test.ts"],"names":[],"mappings":""}

package/dist/runtime/runtime.test.js

@@ -0,0 +1,308 @@
+import { describe, it, expect } from "vitest";
+import { Effect, Duration } from "effect";
+import { PluginRuntime, createPluginRuntime } from "./index";
+// Local template plugin for testing
+const TEST_REGISTRY = {
+    "test-plugin": {
+        remoteUrl: "http://localhost:3000/remoteEntry.js",
+        type: "transformer",
+        version: "0.0.1",
+        description: "Local template plugin for testing",
+    },
+};
+const TEST_CONFIG = {
+    variables: {
+        baseUrl: "http://localhost:1337",
+        timeout: 5000,
+    },
+    secrets: {
+        apiKey: "{{API_KEY}}", // This will be hydrated from secrets config
+    },
+};
+const TEST_INPUT = {
+    query: "test query for processing",
+    options: {
+        limit: 2,
+    },
+};
+// Secrets configuration for hydration
+const SECRETS_CONFIG = {
+    API_KEY: "test-api-key-value",
+};
+describe("Plugin Runtime Integration", () => {
+    it("should create and execute plugin end-to-end", async () => {
+        // Create the managed runtime
+        const runtime = createPluginRuntime({
+            registry: TEST_REGISTRY,
+            secrets: SECRETS_CONFIG,
+        });
+        // Execute the test within the runtime
+        const result = await runtime.runPromise(Effect.gen(function* () {
+            const pluginRuntime = yield* PluginRuntime;
+            // Create plugin (load → instantiate → initialize)
+            const initializedPlugin = yield* pluginRuntime.createPlugin("test-plugin", TEST_CONFIG);
+            // Verify plugin was initialized
+            expect(initializedPlugin).toBeDefined();
+            expect(initializedPlugin.metadata.pluginId).toBe("test-plugin");
+            expect(initializedPlugin.plugin).toBeDefined();
+            // Execute plugin
+            const output = yield* pluginRuntime.executePlugin(initializedPlugin, TEST_INPUT);
+            return output;
+        }));
+        // Validate output structure
+        expect(result).toBeDefined();
+        expect(typeof result).toBe("object");
+        const typedResult = result;
+        // Verify success wrapper structure
+        expect(typedResult).toHaveProperty("success");
+        expect(typedResult).toHaveProperty("data");
+        expect(typedResult.success).toBe(true);
+        // Verify data content
+        expect(typedResult.data).toHaveProperty("results");
+        expect(typedResult.data).toHaveProperty("count");
+        expect(Array.isArray(typedResult.data.results)).toBe(true);
+        expect(typedResult.data.count).toBe(2); // Should match the limit we set
+        expect(typedResult.data.results).toHaveLength(2);
+        // Verify results contain processed query
+        expect(typedResult.data.results[0]).toHaveProperty("id");
+        expect(typedResult.data.results[0]).toHaveProperty("content");
+        expect(typedResult.data.results[0].content).toContain("test query for processing");
+        expect(typedResult.data.results[1].content).toContain("test query for processing");
+    });
+    it("should handle plugin lifecycle correctly", async () => {
+        const runtime = createPluginRuntime({
+            registry: TEST_REGISTRY,
+            secrets: SECRETS_CONFIG,
+        });
+        await runtime.runPromise(Effect.gen(function* () {
+            const pluginRuntime = yield* PluginRuntime;
+            // Test individual lifecycle steps
+            // 1. Load plugin
+            const pluginConstructor = yield* pluginRuntime.loadPlugin("test-plugin");
+            expect(pluginConstructor).toBeDefined();
+            expect(pluginConstructor.metadata.pluginId).toBe("test-plugin");
+            // 2. Instantiate plugin
+            const pluginInstance = yield* pluginRuntime.instantiatePlugin(pluginConstructor);
+            expect(pluginInstance).toBeDefined();
+            expect(pluginInstance.plugin).toBeDefined();
+            expect(pluginInstance.metadata.pluginId).toBe("test-plugin");
+            // 3. Initialize plugin
+            const initializedPlugin = yield* pluginRuntime.initializePlugin(pluginInstance, TEST_CONFIG);
+            expect(initializedPlugin).toBeDefined();
+            expect(initializedPlugin.config).toBeDefined();
+            // 4. Execute plugin
+            const output = yield* pluginRuntime.executePlugin(initializedPlugin, TEST_INPUT);
+            expect(output).toBeDefined();
+        }));
+    });
+    it("should handle secret hydration", async () => {
+        const configWithSecrets = {
+            variables: {
+                baseUrl: "http://localhost:1337",
+                timeout: 10000,
+            },
+            secrets: {
+                apiKey: "{{API_KEY}}", // This should be hydrated
+            },
+        };
+        const secretsConfig = {
+            API_KEY: "hydrated-api-key-value",
+        };
+        const runtime = createPluginRuntime({
+            registry: TEST_REGISTRY,
+            secrets: secretsConfig,
+        });
+        await runtime.runPromise(Effect.gen(function* () {
+            const pluginRuntime = yield* PluginRuntime;
+            const initializedPlugin = yield* pluginRuntime.createPlugin("test-plugin", configWithSecrets);
+            // Verify secrets were hydrated in the config
+            expect(initializedPlugin.config).toBeDefined();
+            // Verify the config structure and that secrets were hydrated
+            const config = initializedPlugin.config;
+            expect(config).toHaveProperty("secrets");
+            expect(config.secrets).toHaveProperty("apiKey");
+            expect(config.secrets.apiKey).toBe("hydrated-api-key-value");
+            // Verify variables are also present
+            expect(config).toHaveProperty("variables");
+            expect(config.variables.baseUrl).toBe("http://localhost:1337");
+            expect(config.variables.timeout).toBe(10000);
+            // Verify the plugin was successfully initialized with hydrated secrets
+            // by executing it to ensure it works with the hydrated config
+            const output = yield* pluginRuntime.executePlugin(initializedPlugin, TEST_INPUT);
+            expect(output).toBeDefined();
+        }));
+    });
+    it("should handle validation error for missing apiKey", async () => {
+        const configWithoutApiKey = {
+            variables: {
+                baseUrl: "http://localhost:1337",
+                timeout: 5000,
+            },
+            secrets: {
+            // Missing required apiKey
+            },
+        };
+        const runtime = createPluginRuntime({
+            registry: TEST_REGISTRY,
+            secrets: SECRETS_CONFIG,
+        });
+        const result = await runtime.runPromise(Effect.gen(function* () {
+            const pluginRuntime = yield* PluginRuntime;
+            return yield* pluginRuntime.createPlugin("test-plugin", configWithoutApiKey).pipe(Effect.catchTag("PluginRuntimeError", (error) => {
+                // Should catch validation error
+                expect(error.operation).toBe("validate-config");
+                expect(error.retryable).toBe(false);
+                expect(error.pluginId).toBe("test-plugin");
+                expect(error.cause).toBeDefined();
+                // The error should mention the missing apiKey
+                const errorMessage = error.cause?.message || "";
+                // Zod validation errors might be in JSON format, so check for both formats
+                const lowerMessage = errorMessage.toLowerCase();
+                const hasApiKeyError = lowerMessage.includes("api key") ||
+                    lowerMessage.includes("apikey") ||
+                    lowerMessage.includes("required");
+                expect(hasApiKeyError).toBe(true);
+                console.log("Caught expected validation error:", {
+                    operation: error.operation,
+                    pluginId: error.pluginId,
+                    retryable: error.retryable,
+                    cause: error.cause?.message,
+                });
+                return Effect.succeed("validation-error-handled-properly");
+            }), Effect.catchAll((unexpectedError) => {
+                console.error("Unexpected error type:", unexpectedError);
+                expect.fail(`Expected PluginRuntimeError but got: ${unexpectedError._tag || typeof unexpectedError}`);
+                return Effect.succeed("should-not-reach-here");
+            }));
+        }));
+        expect(result).toBe("validation-error-handled-properly");
+    });
+    it("should handle runtime shutdown gracefully", async () => {
+        const runtime = createPluginRuntime({
+            registry: TEST_REGISTRY,
+            secrets: SECRETS_CONFIG,
+        });
+        await runtime.runPromise(Effect.gen(function* () {
+            const pluginRuntime = yield* PluginRuntime;
+            // Test shutdown
+            yield* pluginRuntime.shutdown();
+            // Shutdown should complete without errors
+            expect(true).toBe(true); // If we reach here, shutdown was successful
+        }));
+    });
+    it("should handle invalid remoteUrl with proper error handling", async () => {
+        const INVALID_REGISTRY = {
+            "invalid-plugin": {
+                remoteUrl: "https://invalid-plugin-url-that-does-not-exist.com/plugin.js",
+                type: "transformer",
+                version: "1.0.0",
+                description: "Invalid plugin for testing error handling",
+            },
+        };
+        const runtime = createPluginRuntime({
+            registry: INVALID_REGISTRY,
+            secrets: {},
+        });
+        const result = await runtime.runPromise(Effect.gen(function* () {
+            const pluginRuntime = yield* PluginRuntime;
+            return yield* pluginRuntime.createPlugin("invalid-plugin", {}).pipe(Effect.catchTag("PluginRuntimeError", (error) => {
+                expect(error.operation).toBe("register-remote");
+                expect(error.retryable).toBe(true);
+                expect(error.pluginId).toBe("invalid-plugin");
+                expect(error.cause).toBeDefined();
+                console.debug("Caught expected PluginRuntimeError:", {
+                    operation: error.operation,
+                    pluginId: error.pluginId,
+                    retryable: error.retryable,
+                    cause: error.cause?.message,
+                });
+                return Effect.succeed("error-handled-properly");
+            }), Effect.catchAll((unexpectedError) => {
+                // If any other error type is thrown, fail the test
+                console.error("Unexpected error type:", unexpectedError);
+                expect.fail(`Expected PluginRuntimeError but got: ${unexpectedError._tag || typeof unexpectedError}`);
+                return Effect.succeed("should-not-reach-here");
+            }));
+        }));
+        expect(result).toBe("error-handled-properly");
+    });
+    it("should handle plugin not found in registry", async () => {
+        // Empty registry to test missing plugin
+        const EMPTY_REGISTRY = {};
+        const runtime = createPluginRuntime({
+            registry: EMPTY_REGISTRY,
+            secrets: {},
+        });
+        const result = await runtime.runPromise(Effect.gen(function* () {
+            const pluginRuntime = yield* PluginRuntime;
+            return yield* pluginRuntime.loadPlugin("non-existent-plugin").pipe(Effect.catchTag("PluginRuntimeError", (error) => {
+                // Validate error properties
+                expect(error.operation).toBe("load-plugin");
+                expect(error.retryable).toBe(false);
+                expect(error.pluginId).toBe("non-existent-plugin");
+                expect(error.cause).toBeDefined();
+                expect(error.cause?.message).toContain("not found in registry");
+                // Log error details for debugging
+                console.log("Caught expected PluginRuntimeError for missing plugin:", {
+                    operation: error.operation,
+                    pluginId: error.pluginId,
+                    retryable: error.retryable,
+                    cause: error.cause?.message,
+                });
+                // Return success to make test pass
+                return Effect.succeed("plugin-not-found-handled-properly");
+            }), Effect.catchAll((unexpectedError) => {
+                // If any other error type is thrown, fail the test
+                console.error("Unexpected error type:", unexpectedError);
+                expect.fail(`Expected PluginRuntimeError but got: ${unexpectedError._tag || typeof unexpectedError}`);
+                return Effect.succeed("should-not-reach-here");
+            }));
+        }));
+        expect(result).toBe("plugin-not-found-handled-properly");
+    });
+    it("should handle constructor instantiation failure", async () => {
+        // Registry with real remote that should fail during instantiation/initialization
+        const REAL_REMOTE_REGISTRY = {
+            "simple-transform": {
+                remoteUrl: "https://unpkg.com/@curatedotfun/simple-transform@latest/dist/remoteEntry.js",
+                type: "transformer",
+                version: "latest",
+                description: "Real remote plugin for testing constructor failure",
+            },
+        };
+        const runtime = createPluginRuntime({
+            registry: REAL_REMOTE_REGISTRY,
+            secrets: {},
+        });
+        const result = await runtime.runPromise(Effect.gen(function* () {
+            const pluginRuntime = yield* PluginRuntime;
+            return yield* pluginRuntime.createPlugin("simple-transform", {}).pipe(Effect.timeout(Duration.seconds(1)), // Timeout after 3 seconds
+            Effect.catchTag("PluginRuntimeError", (error) => {
+                // Validate error properties
+                expect(["load-remote"]).toContain(error.operation);
+                expect(error.retryable).toBe(true);
+                expect(error.pluginId).toBe("simple-transform");
+                expect(error.cause).toBeDefined();
+                // Log error details for debugging
+                console.log("Caught expected PluginRuntimeError for constructor failure:", {
+                    operation: error.operation,
+                    pluginId: error.pluginId,
+                    retryable: error.retryable,
+                    cause: error.cause?.message,
+                });
+                // Return success to make test pass
+                return Effect.succeed("constructor-failure-handled-properly");
+            }), Effect.catchTag("TimeoutException", () => {
+                // Handle timeout as expected failure - remote is too slow
+                console.log("Plugin creation timed out - treating as expected failure");
+                return Effect.succeed("timeout-handled-properly");
+            }), Effect.catchAll((unexpectedError) => {
+                // If any other error type is thrown, fail the test
+                console.error("Unexpected error type:", unexpectedError);
+                expect.fail(`Expected PluginRuntimeError or TimeoutException but got: ${unexpectedError._tag || typeof unexpectedError}`);
+                return Effect.succeed("should-not-reach-here");
+            }));
+        }));
+        expect(["constructor-failure-handled-properly", "timeout-handled-properly"]).toContain(result);
+    });
+});

package/dist/runtime/services/module-federation.service.d.ts

@@ -0,0 +1,17 @@
+import * as EffectModule from "effect";
+import { Effect } from "effect";
+import { ModuleFederationError } from "../errors";
+export interface IModuleFederationService {
+    readonly registerRemote: (pluginId: string, url: string) => Effect.Effect<void, ModuleFederationError>;
+    readonly loadRemoteConstructor: (pluginId: string, url: string) => Effect.Effect<any, ModuleFederationError>;
+}
+declare const ModuleFederationService_base: EffectModule.Context.TagClass<ModuleFederationService, "ModuleFederationService", IModuleFederationService> & EffectModule.Effect.Tag.Proxy<ModuleFederationService, IModuleFederationService> & {
+    use: <X>(body: (_: IModuleFederationService) => X) => [X] extends [EffectModule.Effect.Effect<infer A, infer E, infer R>] ? EffectModule.Effect.Effect<A, E, R | ModuleFederationService> : [X] extends [PromiseLike<infer A_1>] ? EffectModule.Effect.Effect<A_1, EffectModule.Cause.UnknownException, ModuleFederationService> : EffectModule.Effect.Effect<X, never, ModuleFederationService>;
+};
+export declare class ModuleFederationService extends ModuleFederationService_base {
+    static Live: EffectModule.Layer.Layer<ModuleFederationService, never, never>;
+}
+export declare const ModuleFederationServiceTag: typeof ModuleFederationService;
+export declare const ModuleFederationServiceLive: EffectModule.Layer.Layer<ModuleFederationService, never, never>;
+export {};
+//# sourceMappingURL=module-federation.service.d.ts.map

package/dist/runtime/services/module-federation.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-federation.service.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/module-federation.service.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,MAAM,EAAS,MAAM,QAAQ,CAAC;AAEvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAElD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,cAAc,EAAE,CACvB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,KACR,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAC;IAChD,QAAQ,CAAC,qBAAqB,EAAE,CAC9B,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,KACR,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,qBAAqB,CAAC,CAAC;CAChD;;;;AAyCD,qBAAa,uBAAwB,SAAQ,4BAG1C;IACD,MAAM,CAAC,IAAI,kEAqFT;CACH;AAED,eAAO,MAAM,0BAA0B,gCAA0B,CAAC;AAClE,eAAO,MAAM,2BAA2B,iEAA+B,CAAC"}

package/dist/runtime/services/module-federation.service.js

@@ -0,0 +1,108 @@
+import { betterFetch } from "@better-fetch/fetch";
+import { createInstance, getInstance, } from "@module-federation/enhanced/runtime";
+import { setGlobalFederationInstance } from "@module-federation/runtime-core";
+import * as EffectModule from "effect";
+import { Effect, Layer } from "effect";
+import * as ZodModule from "zod";
+import { ModuleFederationError } from "../errors";
+const createModuleFederationInstance = Effect.cached(Effect.sync(() => {
+    try {
+        let instance = getInstance();
+        if (!instance) {
+            instance = createInstance({
+                name: "host",
+                remotes: [],
+                shared: {
+                    effect: {
+                        shareConfig: {
+                            singleton: true,
+                            requiredVersion: "^3.17.6",
+                            eager: true,
+                        },
+                        lib: () => EffectModule,
+                    },
+                    zod: {
+                        shareConfig: {
+                            singleton: true,
+                            requiredVersion: "^4.0.8",
+                            eager: true,
+                        },
+                        lib: () => ZodModule,
+                    },
+                },
+            });
+            setGlobalFederationInstance(instance);
+        }
+        return instance;
+    }
+    catch (error) {
+        throw new Error(`Failed to initialize Module Federation: ${error}`);
+    }
+}));
+export class ModuleFederationService extends Effect.Tag("ModuleFederationService")() {
+    static Live = Layer.effect(ModuleFederationService, Effect.gen(function* () {
+        const mf = yield* Effect.flatten(createModuleFederationInstance);
+        return {
+            registerRemote: (pluginId, url) => Effect.gen(function* () {
+                // Check if remote is available
+                const { error } = yield* Effect.tryPromise({
+                    try: () => betterFetch(url, { method: "HEAD" }),
+                    catch: (error) => new ModuleFederationError({
+                        pluginId,
+                        remoteUrl: url,
+                        cause: error instanceof Error ? error : new Error(String(error)),
+                    }),
+                });
+                if (error) {
+                    return yield* Effect.fail(new ModuleFederationError({
+                        pluginId,
+                        remoteUrl: url,
+                        cause: new Error(`Remote not available: ${error}`),
+                    }));
+                }
+                // Register remote
+                const remoteName = pluginId
+                    .toLowerCase()
+                    .replace("@", "")
+                    .replace("/", "_");
+                yield* Effect.try({
+                    try: () => mf.registerRemotes([{ name: remoteName, entry: url }]),
+                    catch: (error) => new ModuleFederationError({
+                        pluginId,
+                        remoteUrl: url,
+                        cause: error instanceof Error ? error : new Error(String(error)),
+                    }),
+                });
+            }),
+            loadRemoteConstructor: (pluginId, url) => Effect.gen(function* () {
+                const remoteName = pluginId
+                    .toLowerCase()
+                    .replace("@", "")
+                    .replace("/", "_");
+                const modulePath = `${remoteName}/plugin`;
+                return yield* Effect.tryPromise({
+                    try: async () => {
+                        const container = await mf.loadRemote(modulePath);
+                        if (!container) {
+                            throw new Error(`No container returned for ${modulePath}`);
+                        }
+                        const Constructor = typeof container === "function"
+                            ? container
+                            : container?.default;
+                        if (!Constructor || typeof Constructor !== "function") {
+                            throw new Error(`No valid constructor found. Container type: ${typeof container}`);
+                        }
+                        return Constructor;
+                    },
+                    catch: (error) => new ModuleFederationError({
+                        pluginId,
+                        remoteUrl: url,
+                        cause: error instanceof Error ? error : new Error(String(error)),
+                    }),
+                });
+            }),
+        };
+    }));
+}
+export const ModuleFederationServiceTag = ModuleFederationService;
+export const ModuleFederationServiceLive = ModuleFederationService.Live;

package/dist/runtime/services/plugin-cache.service.d.ts

@@ -0,0 +1,18 @@
+import { Effect, Layer } from "effect";
+import { PluginRuntimeError } from "../errors";
+import type { PluginConstructor } from "../types";
+import { ModuleFederationService } from "./module-federation.service";
+export interface IPluginCacheService {
+    readonly getCachedConstructor: (cacheKey: string) => Effect.Effect<PluginConstructor, PluginRuntimeError>;
+    readonly invalidate: (cacheKey: string) => Effect.Effect<void>;
+}
+declare const PluginCacheService_base: import("effect/Context").TagClass<PluginCacheService, "PluginCacheService", IPluginCacheService> & Effect.Tag.Proxy<PluginCacheService, IPluginCacheService> & {
+    use: <X>(body: (_: IPluginCacheService) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, R | PluginCacheService> : [X] extends [PromiseLike<infer A_1>] ? Effect.Effect<A_1, import("effect/Cause").UnknownException, PluginCacheService> : Effect.Effect<X, never, PluginCacheService>;
+};
+export declare class PluginCacheService extends PluginCacheService_base {
+    static Live: Layer.Layer<PluginCacheService, never, ModuleFederationService>;
+}
+export declare const PluginCacheServiceTag: typeof PluginCacheService;
+export declare const PluginCacheServiceLive: Layer.Layer<PluginCacheService, never, ModuleFederationService>;
+export {};
+//# sourceMappingURL=plugin-cache.service.d.ts.map

package/dist/runtime/services/plugin-cache.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-cache.service.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/plugin-cache.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAEtE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,oBAAoB,EAAE,CAC7B,QAAQ,EAAE,MAAM,KACb,MAAM,CAAC,MAAM,CAAC,iBAAiB,EAAE,kBAAkB,CAAC,CAAC;IAC1D,QAAQ,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CAChE;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAGrC;IACD,MAAM,CAAC,IAAI,kEAoET;CACH;AAED,eAAO,MAAM,qBAAqB,2BAAqB,CAAC;AACxD,eAAO,MAAM,sBAAsB,iEAA0B,CAAC"}

package/dist/runtime/services/plugin-cache.service.js

@@ -0,0 +1,55 @@
+import { Cache, Duration, Effect, Layer } from "effect";
+import { PluginRuntimeError } from "../errors";
+import { ModuleFederationService } from "./module-federation.service";
+export class PluginCacheService extends Effect.Tag("PluginCacheService")() {
+    static Live = Layer.effect(PluginCacheService, Effect.gen(function* () {
+        const mfService = yield* ModuleFederationService;
+        const cache = yield* Cache.make({
+            capacity: 50,
+            timeToLive: Duration.minutes(30),
+            lookup: (cacheKey) => {
+                // Parse cache key: "pluginId:url"
+                const colonIndex = cacheKey.indexOf(":");
+                if (colonIndex === -1) {
+                    return Effect.fail(new PluginRuntimeError({
+                        pluginId: cacheKey,
+                        operation: "cache-lookup",
+                        cause: new Error(`Invalid cache key format: ${cacheKey}`),
+                        retryable: false,
+                    }));
+                }
+                const pluginId = cacheKey.substring(0, colonIndex);
+                const url = cacheKey.substring(colonIndex + 1);
+                return Effect.gen(function* () {
+                    yield* mfService.registerRemote(pluginId, url).pipe(Effect.mapError((mfError) => new PluginRuntimeError({
+                        pluginId,
+                        operation: "register-remote",
+                        cause: mfError.cause,
+                        retryable: true,
+                    })));
+                    const ctor = yield* mfService.loadRemoteConstructor(pluginId, url).pipe(Effect.mapError((mfError) => new PluginRuntimeError({
+                        pluginId,
+                        operation: "load-remote",
+                        cause: mfError.cause,
+                        retryable: true,
+                    })));
+                    return {
+                        ctor,
+                        metadata: {
+                            pluginId,
+                            version: "unknown", // Will be resolved from registry
+                            description: "Loaded from remote",
+                            type: "unknown",
+                        },
+                    };
+                });
+            },
+        });
+        return {
+            getCachedConstructor: (cacheKey) => cache.get(cacheKey),
+            invalidate: (cacheKey) => cache.invalidate(cacheKey),
+        };
+    }));
+}
+export const PluginCacheServiceTag = PluginCacheService;
+export const PluginCacheServiceLive = PluginCacheService.Live;

package/dist/runtime/services/plugin.service.d.ts

@@ -0,0 +1,22 @@
+import { Effect, Layer } from "effect";
+import { PluginLoggerTag, type PluginRegistry } from "../../plugin";
+import { PluginRuntimeError } from "../errors";
+import type { AnyPlugin, InitializedPlugin, PluginConstructor, PluginInstance, SecretsConfig } from "../types";
+import { PluginCacheService } from "./plugin-cache.service";
+import { SecretsService } from "./secrets.service";
+export interface IPluginService {
+    readonly loadPlugin: (pluginId: string) => Effect.Effect<PluginConstructor, PluginRuntimeError>;
+    readonly instantiatePlugin: <T extends AnyPlugin>(pluginConstructor: PluginConstructor) => Effect.Effect<PluginInstance<T>, PluginRuntimeError>;
+    readonly initializePlugin: <T extends AnyPlugin>(pluginInstance: PluginInstance<T>, config: unknown) => Effect.Effect<InitializedPlugin<T>, PluginRuntimeError>;
+    readonly executePlugin: <T extends AnyPlugin>(initializedPlugin: InitializedPlugin<T>, input: unknown) => Effect.Effect<any, PluginRuntimeError>;
+}
+declare const PluginService_base: import("effect/Context").TagClass<PluginService, "PluginService", IPluginService> & Effect.Tag.Proxy<PluginService, IPluginService> & {
+    use: <X>(body: (_: IPluginService) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, R | PluginService> : [X] extends [PromiseLike<infer A_1>] ? Effect.Effect<A_1, import("effect/Cause").UnknownException, PluginService> : Effect.Effect<X, never, PluginService>;
+};
+export declare class PluginService extends PluginService_base {
+    static Live: (registry: PluginRegistry, secrets: SecretsConfig) => Layer.Layer<PluginService, never, PluginLoggerTag | PluginCacheService | SecretsService>;
+}
+export declare const PluginServiceTag: typeof PluginService;
+export declare const PluginServiceLive: (registry: PluginRegistry, secrets: SecretsConfig) => Layer.Layer<PluginService, never, PluginLoggerTag | PluginCacheService | SecretsService>;
+export {};
+//# sourceMappingURL=plugin.service.d.ts.map

package/dist/runtime/services/plugin.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.service.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/plugin.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,MAAM,EAAE,KAAK,EAAY,MAAM,QAAQ,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EACV,SAAS,EACT,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACd,aAAa,EACd,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,UAAU,EAAE,CACnB,QAAQ,EAAE,MAAM,KACb,MAAM,CAAC,MAAM,CAAC,iBAAiB,EAAE,kBAAkB,CAAC,CAAC;IAC1D,QAAQ,CAAC,iBAAiB,EAAE,CAAC,CAAC,SAAS,SAAS,EAC9C,iBAAiB,EAAE,iBAAiB,KACjC,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;IAC1D,QAAQ,CAAC,gBAAgB,EAAE,CAAC,CAAC,SAAS,SAAS,EAC7C,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC,EACjC,MAAM,EAAE,OAAO,KACZ,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;IAC7D,QAAQ,CAAC,aAAa,EAAE,CAAC,CAAC,SAAS,SAAS,EAC1C,iBAAiB,EAAE,iBAAiB,CAAC,CAAC,CAAC,EACvC,KAAK,EAAE,OAAO,KACX,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC;CAC7C;;;;AAED,qBAAa,aAAc,SAAQ,kBAGhC;IACD,MAAM,CAAC,IAAI,GAAI,UAAU,cAAc,EAAE,SAAS,aAAa,8FA0O3D;CACL;AAED,eAAO,MAAM,gBAAgB,sBAAgB,CAAC;AAC9C,eAAO,MAAM,iBAAiB,aA9OH,cAAc,WAAW,aAAa,6FA8Od,CAAC"}