every-plugin 0.1.2 → 0.1.4

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

@@ -1,275 +1,25 @@
-import { call } from "@orpc/server";
-import { Cache, Duration, Effect, Hash, Layer, Schedule } from "effect";
-import { PluginLoggerTag } from "../../plugin";
-import { PluginRuntimeError } from "../errors";
-import { createSourceStream } from "../streaming";
-import { validate } from "../validation";
-import { ModuleFederationService } from "./module-federation.service";
-import { SecretsService } from "./secrets.service";
-export class PluginService extends Effect.Tag("PluginService")() {
-    static Live = (registry, secrets) => Layer.effect(PluginService, Effect.gen(function* () {
-        const moduleFederationService = yield* ModuleFederationService;
-        const secretsService = yield* SecretsService;
-        const logger = yield* PluginLoggerTag;
-        const activePlugins = new Set();
-        const retrySchedule = Schedule.exponential(Duration.millis(100)).pipe(Schedule.compose(Schedule.recurs(2)));
-        const resolveUrl = (baseUrl, version) => version && version !== "latest"
-            ? baseUrl.replace("@latest", `@${version}`)
-            : baseUrl;
-        // Implementation functions
-        const loadPluginImpl = (pluginId) => Effect.gen(function* () {
-            const metadata = registry[pluginId];
-            if (!metadata) {
-                return yield* Effect.fail(new PluginRuntimeError({
-                    pluginId,
-                    operation: "load-plugin",
-                    cause: new Error(`Plugin ${pluginId} not found in registry`),
-                    retryable: false,
-                }));
-            }
-            const url = resolveUrl(metadata.remoteUrl);
-            // Register and load the remote constructor
-            yield* moduleFederationService.registerRemote(pluginId, url).pipe(Effect.mapError((error) => new PluginRuntimeError({
-                pluginId,
-                operation: "register-remote",
-                cause: error.cause,
-                retryable: true,
-            })));
-            logger.logDebug(`Trying to load ${pluginId}:${url}`);
-            const ctor = yield* moduleFederationService.loadRemoteConstructor(pluginId, url).pipe(Effect.mapError((error) => new PluginRuntimeError({
-                pluginId,
-                operation: "load-remote",
-                cause: error.cause,
-                retryable: false
-            })));
-            return {
-                ctor,
-                metadata: {
-                    pluginId,
-                    version: metadata.version,
-                    description: metadata.description,
-                    type: metadata.type,
-                },
-            };
-        });
-        const instantiatePluginImpl = (pluginConstructor) => Effect.gen(function* () {
-            const instance = yield* Effect.try({
-                try: () => new pluginConstructor.ctor(),
-                catch: (error) => new PluginRuntimeError({
-                    pluginId: pluginConstructor.metadata.pluginId,
-                    operation: "instantiate-plugin",
-                    cause: error instanceof Error ? error : new Error(String(error)),
-                    retryable: false,
-                }),
-            });
-            // Validate plugin ID matches
-            if (instance.id !== pluginConstructor.metadata.pluginId) {
-                return yield* Effect.fail(new PluginRuntimeError({
-                    pluginId: pluginConstructor.metadata.pluginId,
-                    operation: "validate-plugin-id",
-                    cause: new Error(`Plugin ID mismatch: expected ${pluginConstructor.metadata.pluginId}, got ${instance.id}`),
-                    retryable: false,
-                }));
-            }
-            return {
-                plugin: instance,
-                metadata: pluginConstructor.metadata,
-            };
-        });
-        const initializePluginImpl = (pluginInstance, config) => Effect.gen(function* () {
-            const { plugin } = pluginInstance;
-            // Validate raw config using plugin's Zod schema
-            const validatedConfig = yield* validate(plugin.configSchema, config, plugin.id, "config").pipe(Effect.mapError((validationError) => new PluginRuntimeError({
-                pluginId: plugin.id,
-                operation: "validate-config",
-                cause: validationError.zodError,
-                retryable: false,
-            })));
-            // Hydrate secrets
-            const hydratedConfig = yield* secretsService.hydrateSecrets(validatedConfig, secrets);
-            // Validate hydrated config
-            const finalConfig = yield* validate(plugin.configSchema, hydratedConfig, plugin.id, "config").pipe(Effect.mapError((validationError) => new PluginRuntimeError({
-                pluginId: plugin.id,
-                operation: "validate-hydrated-config",
-                cause: validationError.zodError,
-                retryable: false,
-            })));
-            // Initialize plugin with retry logic
-            const pluginLayer = Layer.succeed(PluginLoggerTag, logger);
-            yield* plugin.initialize(finalConfig).pipe(Effect.mapError((error) => new PluginRuntimeError({
-                pluginId: plugin.id,
-                operation: "initialize-plugin",
-                cause: error,
-                retryable: error.retryable ?? false,
-            })), Effect.retry(retrySchedule.pipe(Schedule.whileInput((error) => error.retryable))), Effect.provide(pluginLayer));
-            const initializedPlugin = {
-                plugin,
-                metadata: pluginInstance.metadata,
-                config: finalConfig, // TODO: config type
-            };
-            activePlugins.add(initializedPlugin);
-            return initializedPlugin;
-        });
-        // Cache functionality
-        const generateConfigHash = (config) => {
-            return Hash.structure(config).toString();
-        };
-        // Store original config by hash for cache lookup
-        const configByHash = new Map();
-        const cache = yield* Cache.make({
-            capacity: 1024,
-            timeToLive: Duration.minutes(60),
-            lookup: (cacheKey) => {
-                const [pluginId, configHash] = cacheKey.split(':');
-                if (!pluginId || !configHash) {
-                    return Effect.fail(new PluginRuntimeError({
-                        operation: "cache-lookup",
-                        cause: new Error(`Invalid cache key format: ${cacheKey}`),
-                        retryable: false,
-                    }));
-                }
-                const config = configByHash.get(configHash);
-                if (!config) {
-                    return Effect.fail(new PluginRuntimeError({
-                        operation: "cache-lookup",
-                        cause: new Error(`No config found for hash: ${configHash}`),
-                        retryable: false,
-                    }));
-                }
-                return Effect.gen(function* () {
-                    const ctor = yield* loadPluginImpl(pluginId);
-                    const instance = yield* instantiatePluginImpl(ctor);
-                    return yield* initializePluginImpl(instance, config);
-                });
-            },
-        });
-        const usePluginImpl = (pluginId, config) => {
-            const configHash = generateConfigHash(config);
-            const cacheKey = `${pluginId}:${configHash}`;
-            // Store config for cache lookup
-            configByHash.set(configHash, config);
-            return cache.get(cacheKey).pipe(Effect.map(plugin => plugin));
-        };
-        // Extract executePlugin implementation for reuse
-        const executePluginImpl = (initializedPlugin, input) => Effect.gen(function* () {
-            const { plugin } = initializedPlugin;
-            // Validate input
-            const validatedInput = yield* validate(plugin.inputSchema, input, plugin.id, "input").pipe(Effect.mapError((validationError) => {
-                return new PluginRuntimeError({
-                    pluginId: plugin.id,
-                    operation: "validate-input",
-                    cause: validationError.zodError,
-                    retryable: false,
-                });
-            }));
-            // Get oRPC router and call procedure directly
-            const router = plugin.createRouter();
-            const procedureName = validatedInput.procedure;
-            if (!(procedureName in router)) {
-                return yield* Effect.fail(new PluginRuntimeError({
-                    pluginId: plugin.id,
-                    operation: "execute-plugin",
-                    cause: new Error(`Unknown procedure: ${procedureName}`),
-                    retryable: false,
-                }));
-            }
-            const context = 'state' in validatedInput ? { state: validatedInput.state } : {};
-            const output = yield* Effect.tryPromise({
-                try: () => {
-                    const procedure = router[procedureName];
-                    ;
-                    if (!procedure) {
-                        throw new Error(`Procedure ${procedureName} not found in router`);
-                    }
-                    // Use oRPC call utility as per docs
-                    return call(procedure, validatedInput.input, { context });
-                },
-                catch: (error) => new PluginRuntimeError({
-                    pluginId: plugin.id,
-                    operation: "execute-plugin",
-                    cause: error instanceof Error ? error : new Error(String(error)),
-                    retryable: true,
-                }),
-            }).pipe(Effect.retry(retrySchedule.pipe(Schedule.whileInput((error) => error.retryable))));
-            return output;
-        });
+import { Context, Effect, Exit, Layer, Scope } from "effect";
+import { PluginLifecycleService } from "./plugin-lifecycle.service";
+import { PluginLoaderService } from "./plugin-loader.service";
+export class PluginService extends Context.Tag("PluginService")() {
+    static Live = (registry, secrets) => Layer.scoped(PluginService, Effect.gen(function* () {
+        const loader = yield* PluginLoaderService;
+        const lifecycle = yield* PluginLifecycleService;
         return {
-            loadPlugin: loadPluginImpl,
-            instantiatePlugin: instantiatePluginImpl,
-            initializePlugin: initializePluginImpl,
-            executePlugin: executePluginImpl,
-            usePlugin: usePluginImpl,
-            streamPlugin: (pluginId, config, input, options) => Effect.gen(function* () {
-                const initializedPlugin = yield* usePluginImpl(pluginId, config);
-                // Check if procedure is streamable and validate state
-                const procedureName = input.procedure;
-                const isStreamable = initializedPlugin.plugin.isStreamable(procedureName);
-                if (!isStreamable) {
-                    return yield* Effect.fail(new PluginRuntimeError({
-                        pluginId,
-                        operation: "stream-plugin-validate",
-                        cause: new Error(`Procedure ${procedureName} is not streamable`),
-                        retryable: false,
-                    }));
-                }
-                // Check stateSchema exists for streamable procedures
-                if (!('stateSchema' in initializedPlugin.plugin) || !initializedPlugin.plugin.stateSchema) {
-                    return yield* Effect.fail(new PluginRuntimeError({
-                        pluginId: initializedPlugin.plugin.id,
-                        operation: "validate-state",
-                        cause: new Error(`Streamable plugin ${initializedPlugin.plugin.id} must have a stateSchema`),
-                        retryable: false,
-                    }));
-                }
-                // Validate initial state - allow null for initial calls
-                const nullableStateSchema = initializedPlugin.plugin.stateSchema.nullable();
-                yield* validate(nullableStateSchema, input.state, initializedPlugin.plugin.id, "state").pipe(Effect.mapError((validationError) => new PluginRuntimeError({
-                    pluginId: initializedPlugin.plugin.id,
-                    operation: "validate-state",
-                    cause: validationError.zodError,
-                    retryable: false,
-                })));
-                // Create and return the stream
-                return createSourceStream(initializedPlugin, executePluginImpl, input, options);
-            }),
+            loadPlugin: loader.loadPlugin,
+            instantiatePlugin: loader.instantiatePlugin,
+            initializePlugin: loader.initializePlugin,
             shutdownPlugin: (plugin) => Effect.gen(function* () {
-                const pluginLayer = Layer.succeed(PluginLoggerTag, logger);
-                // Remove from active plugins
-                activePlugins.delete(plugin);
-                // Try to invalidate from cache if it exists there
-                const configHash = generateConfigHash(plugin.config);
-                const cacheKey = `${plugin.plugin.id}:${configHash}`;
-                yield* cache.invalidate(cacheKey).pipe(Effect.catchAll(() => Effect.void) // Ignore if not in cache
-                );
-                // Clean up config hash
-                configByHash.delete(configHash);
-                // Shutdown the plugin
-                yield* plugin.plugin.shutdown().pipe(Effect.mapError((error) => new PluginRuntimeError({
-                    pluginId: plugin.plugin.id,
-                    operation: "shutdown-plugin",
-                    cause: error,
-                    retryable: false,
-                })), Effect.provide(pluginLayer));
-            }),
-            clearCache: () => Effect.sync(() => {
-                configByHash.clear();
-            }),
-            cleanup: () => Effect.gen(function* () {
-                const pluginLayer = Layer.succeed(PluginLoggerTag, logger);
-                // Call shutdown on all active plugins
-                for (const initializedPlugin of activePlugins) {
-                    yield* initializedPlugin.plugin.shutdown().pipe(Effect.catchAll((error) => {
-                        // Log shutdown errors but don't fail the cleanup
-                        return logger.logError(`Failed to shutdown plugin ${initializedPlugin.plugin.id}`, error, { pluginId: initializedPlugin.plugin.id });
-                    }), Effect.provide(pluginLayer));
-                }
-                // Clear the active plugins set
-                activePlugins.clear();
-                // Clear cache
-                configByHash.clear();
+                // Shutdown the plugin first (graceful cleanup)
+                yield* plugin.plugin.shutdown().pipe(Effect.catchAll(() => Effect.void));
+                // Close the plugin scope to interrupt fibers and release resources
+                yield* Scope.close(plugin.scope, Exit.succeed(undefined));
+                // Unregister from lifecycle tracking
+                yield* lifecycle.unregister(plugin);
             }),
+            cleanup: lifecycle.cleanup,
         };
-    }));
+    })).pipe(Layer.provide(Layer.mergeAll(PluginLoaderService.Live(registry, secrets), PluginLifecycleService.Live)));
 }
 export const PluginServiceTag = PluginService;
 export const PluginServiceLive = PluginService.Live;

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

@@ -1,9 +1,8 @@
 import { Effect, Layer } from "effect";
+import type { SecretsConfig } from "../../types";
 import { PluginRuntimeError } from "../errors";
-import type { SecretsConfig } from "../types";
 export interface ISecretsService {
-    readonly hydrateSecrets: (config: any, // TODO:
-    secretsConfig: SecretsConfig) => Effect.Effect<any, PluginRuntimeError>;
+    readonly hydrateSecrets: <T>(config: T, secretsConfig: SecretsConfig) => Effect.Effect<T, PluginRuntimeError>;
 }
 declare const SecretsService_base: import("effect/Context").TagClass<SecretsService, "SecretsService", ISecretsService> & Effect.Tag.Proxy<SecretsService, ISecretsService> & {
     use: <X>(body: (_: ISecretsService) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, R | SecretsService> : [X] extends [PromiseLike<infer A_1>] ? Effect.Effect<A_1, import("effect/Cause").UnknownException, SecretsService> : Effect.Effect<X, never, SecretsService>;

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

@@ -1 +1 @@
-{"version":3,"file":"secrets.service.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/secrets.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,cAAc,EAAE,CACxB,MAAM,EAAE,GAAG,EAAE,QAAQ;IACrB,aAAa,EAAE,aAAa,KACxB,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC;CAC5C;;;;AAED,qBAAa,cAAe,SAAQ,mBAGjC;IACF,MAAM,CAAC,IAAI,GAAI,SAAS,aAAa,+CAiCjC;CACJ;AAED,eAAO,MAAM,iBAAiB,uBAAiB,CAAC;AAChD,eAAO,MAAM,kBAAkB,YArCN,aAAa,8CAqCe,CAAC"}
+{"version":3,"file":"secrets.service.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/secrets.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAEvC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAE/C,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,cAAc,EAAE,CAAC,CAAC,EAC1B,MAAM,EAAE,CAAC,EACT,aAAa,EAAE,aAAa,KACxB,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;CAC1C;;;;AAMD,qBAAa,cAAe,SAAQ,mBAGjC;IACF,MAAM,CAAC,IAAI,GAAI,SAAS,aAAa,+CA8BjC;CACJ;AAED,eAAO,MAAM,iBAAiB,uBAAiB,CAAC;AAChD,eAAO,MAAM,kBAAkB,YAlCN,aAAa,8CAkCe,CAAC"}

package/dist/runtime/services/secrets.service.js

@@ -1,20 +1,22 @@
 import { Effect, Layer } from "effect";
+import { z } from "zod";
 import { PluginRuntimeError } from "../errors";
+const configSchema = z.object({
+    secrets: z.record(z.string(), z.unknown())
+}).loose();
 export class SecretsService extends Effect.Tag("SecretsService")() {
     static Live = (secrets) => Layer.succeed(SecretsService, {
         hydrateSecrets: (config, secretsConfig) => Effect.gen(function* () {
-            if (!config || typeof config !== "object" || !config.secrets) {
-                return config;
-            }
+            const parseResult = configSchema.parse(config);
             try {
-                const configString = JSON.stringify(config);
+                const configString = JSON.stringify(parseResult);
                 let hydratedString = configString;
                 // Use provided secrets or fallback to secretsConfig
                 const effectiveSecrets = { ...secretsConfig, ...secrets };
                 // Simple template replacement for {{SECRET_NAME}} patterns
                 for (const [key, value] of Object.entries(effectiveSecrets)) {
                     const pattern = new RegExp(`{{${key}}}`, "g");
-                    hydratedString = hydratedString.replace(pattern, value);
+                    hydratedString = hydratedString.replace(pattern, String(value));
                 }
                 return JSON.parse(hydratedString);
             }

package/dist/runtime/services.d.ts

@@ -1,4 +1,4 @@
-export * from "./services/module-federation.service";
 export * from "./services/plugin.service";
 export * from "./services/secrets.service";
+export * from "./services/module-federation.service";
 //# sourceMappingURL=services.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/runtime/services.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAC;AACrD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/runtime/services.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAA;AACzC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,sCAAsC,CAAA"}

package/dist/runtime/services.js

@@ -1,3 +1,3 @@
-export * from "./services/module-federation.service";
 export * from "./services/plugin.service";
 export * from "./services/secrets.service";
+export * from "./services/module-federation.service";

package/dist/testing/index.d.ts

@@ -1,25 +1,20 @@
 import { Effect, Layer, ManagedRuntime } from "effect";
-import { type PluginRegistry } from "../plugin";
-import { PluginRuntime } from "../runtime";
-import type { PluginRuntimeConfig } from "../runtime/types";
+import { PluginRuntimeImpl, PluginRuntimeService } from "../runtime";
+import type { PluginRuntimeConfig, RegistryBindings } from "../types";
 import { type TestPluginMap } from "./mocks/module-federation.service";
-export declare const createTestLogger: () => {
-    logInfo: (message: string, context?: unknown) => Effect.Effect<void, never, never>;
-    logWarning: (message: string, context?: unknown) => Effect.Effect<void, never, never>;
-    logError: (message: string, error?: unknown, context?: unknown) => Effect.Effect<void, never, never>;
-    logDebug: (message: string, context?: unknown) => Effect.Effect<void, never, never>;
-};
 /**
  * Creates a test layer with mock ModuleFederationService for unit testing.
- * This layer provides all the necessary services for testing plugin runtime
- * without requiring real module federation infrastructure.
+ * This mirrors PluginRuntimeService.Live but uses mock ModuleFederationService.
  */
-export declare const createTestLayer: (config: PluginRuntimeConfig, pluginMap: TestPluginMap) => Layer.Layer<PluginRuntime, never, never>;
+export declare const createTestLayer: <R extends RegistryBindings = RegistryBindings>(config: PluginRuntimeConfig<R>, pluginMap: TestPluginMap) => Layer.Layer<PluginRuntimeService, never, never>;
 /**
  * Creates a test plugin runtime using mock services.
- * This is similar to createPluginRuntime but uses MockModuleFederationService
- * instead of the real one, making it suitable for unit tests.
+ * This mirrors createPluginRuntime exactly but uses test layer.
  */
-export declare const createTestPluginRuntime: (config: PluginRuntimeConfig, pluginMap: TestPluginMap) => ManagedRuntime.ManagedRuntime<PluginRuntime, never>;
-export type { PluginRegistry, PluginRuntimeConfig, TestPluginMap };
+export declare const createTestPluginRuntime: <R extends RegistryBindings = RegistryBindings>(config: PluginRuntimeConfig<R>, pluginMap: TestPluginMap) => {
+    runtime: ManagedRuntime.ManagedRuntime<PluginRuntimeService, never>;
+    PluginRuntime: Effect.Effect<PluginRuntimeImpl<R>, never, never>;
+};
+export type { PluginRegistry, RegistryBindings } from "../types";
+export type { PluginRuntimeConfig, TestPluginMap };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AACvD,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAG5D,OAAO,EAA0C,KAAK,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAG/G,eAAO,MAAM,gBAAgB;uBACR,MAAM,YAAY,OAAO;0BAEtB,MAAM,YAAY,OAAO;wBAE3B,MAAM,UAAU,OAAO,YAAY,OAAO;wBAE1C,MAAM,YAAY,OAAO;CAE7C,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,QAAQ,mBAAmB,EAAE,WAAW,aAAa,6CAgCpF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,GAAI,QAAQ,mBAAmB,EAAE,WAAW,aAAa,wDACpC,CAAC;AAG1D,YAAY,EAAE,cAAc,EAAE,mBAAmB,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGrE,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACtE,OAAO,EAA0C,KAAK,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAG/G;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,EAC3E,QAAQ,mBAAmB,CAAC,CAAC,CAAC,EAC9B,WAAW,aAAa,oDA+BzB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAAI,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,EACnF,QAAQ,mBAAmB,CAAC,CAAC,CAAC,EAC9B,WAAW,aAAa;;;CAezB,CAAC;AAGF,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACjE,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,CAAC"}

package/dist/testing/index.js

@@ -1,40 +1,38 @@
 import { Effect, Layer, ManagedRuntime } from "effect";
-import { PluginLoggerTag } from "../plugin";
-import { PluginRuntime } from "../runtime";
-import { PluginService, SecretsService } from "../runtime/services";
+import { PluginRuntimeImpl, PluginRuntimeService } from "../runtime";
 // Import the mock service factory and types
+import { PluginService, SecretsService } from "../runtime/services";
 import { createMockModuleFederationServiceLayer } from "./mocks/module-federation.service";
-// Create test logger
-export const createTestLogger = () => ({
-    logInfo: (message, context) => Effect.sync(() => console.log(`[INFO] ${message}`, context || '')),
-    logWarning: (message, context) => Effect.sync(() => console.warn(`[WARNING] ${message}`, context || '')),
-    logError: (message, error, context) => Effect.sync(() => console.error(`[ERROR] ${message}`, error, context || '')),
-    logDebug: (message, context) => Effect.sync(() => console.log(`[DEBUG] ${message}`, context || '')),
-});
 /**
  * Creates a test layer with mock ModuleFederationService for unit testing.
- * This layer provides all the necessary services for testing plugin runtime
- * without requiring real module federation infrastructure.
+ * This mirrors PluginRuntimeService.Live but uses mock ModuleFederationService.
  */
 export const createTestLayer = (config, pluginMap) => {
     const secrets = config.secrets || {};
-    const logger = config.logger || createTestLogger();
-    return Layer.effect(PluginRuntime, Effect.gen(function* () {
+    // Same structure as PluginRuntimeService.Live but with mock ModuleFederationService
+    return Layer.scoped(PluginRuntimeService, Effect.gen(function* () {
         const pluginService = yield* PluginService;
-        return {
-            loadPlugin: pluginService.loadPlugin,
-            instantiatePlugin: pluginService.instantiatePlugin,
-            initializePlugin: pluginService.initializePlugin,
-            executePlugin: pluginService.executePlugin,
-            usePlugin: pluginService.usePlugin,
-            streamPlugin: pluginService.streamPlugin,
-            shutdown: () => pluginService.cleanup(),
-        };
-    })).pipe(Layer.provide(PluginService.Live(config.registry, secrets).pipe(Layer.provide(Layer.mergeAll(createMockModuleFederationServiceLayer(pluginMap), SecretsService.Live(secrets), Layer.succeed(PluginLoggerTag, logger))))));
+        // Register cleanup finalizer for automatic resource management
+        yield* Effect.addFinalizer(() => pluginService.cleanup().pipe(Effect.catchAll(() => Effect.void) // Ensure cleanup never fails
+        ));
+        return pluginService;
+    })).pipe(Layer.provide(PluginService.Live(config.registry, secrets).pipe(Layer.provide(Layer.mergeAll(createMockModuleFederationServiceLayer(pluginMap), // Mock instead of real
+    SecretsService.Live(secrets))))));
 };
 /**
  * Creates a test plugin runtime using mock services.
- * This is similar to createPluginRuntime but uses MockModuleFederationService
- * instead of the real one, making it suitable for unit tests.
+ * This mirrors createPluginRuntime exactly but uses test layer.
  */
-export const createTestPluginRuntime = (config, pluginMap) => ManagedRuntime.make(createTestLayer(config, pluginMap));
+export const createTestPluginRuntime = (config, pluginMap) => {
+    const layer = createTestLayer(config, pluginMap);
+    const runtime = ManagedRuntime.make(layer);
+    // Same exact pattern as createPluginRuntime
+    const createTypedRuntime = Effect.gen(function* () {
+        const pluginService = yield* PluginRuntimeService;
+        return new PluginRuntimeImpl(pluginService, config.registry);
+    });
+    return {
+        runtime,
+        PluginRuntime: createTypedRuntime.pipe(Effect.provide(runtime))
+    };
+};

package/dist/testing/mocks/module-federation.service.d.ts

@@ -1,6 +1,6 @@
 import { Layer } from "effect";
 import { ModuleFederationService } from "../../runtime/services/module-federation.service";
-import type { AnyPlugin } from "../../runtime/types";
+import type { AnyPlugin } from "../../types";
 export interface TestPluginMap {
     [pluginId: string]: new () => AnyPlugin;
 }

package/dist/testing/mocks/module-federation.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-federation.service.d.ts","sourceRoot":"","sources":["../../../src/testing/mocks/module-federation.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,EAAE,MAAM,QAAQ,CAAC;AAGvC,OAAO,EAAE,uBAAuB,EAAE,MAAM,kDAAkD,CAAC;AAC3F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD,MAAM,WAAW,aAAa;IAC5B,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,SAAS,CAAC;CACzC;AA6CD,eAAO,MAAM,sCAAsC,GAAI,WAAW,aAAa,uDACT,CAAC"}
+{"version":3,"file":"module-federation.service.d.ts","sourceRoot":"","sources":["../../../src/testing/mocks/module-federation.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,EAAE,MAAM,QAAQ,CAAC;AAGvC,OAAO,EAAE,uBAAuB,EAAE,MAAM,kDAAkD,CAAC;AAC3F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,WAAW,aAAa;IAC5B,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,SAAS,CAAC;CACzC;AA6CD,eAAO,MAAM,sCAAsC,GAAI,WAAW,aAAa,uDACT,CAAC"}