every-plugin 0.1.6 → 0.2.1

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

@@ -1,21 +1,33 @@
-import { Context, Effect, Layer, Scope } from "effect";
+import { Context, Effect, Scope } from "effect";
 import { PluginRuntimeError, toPluginRuntimeError } from "../errors";
 import { validate } from "../validation";
 import { ModuleFederationService } from "./module-federation.service";
 import { SecretsService } from "./secrets.service";
-export class PluginLoaderService extends Context.Tag("PluginLoaderService")() {
-    static Live = (registry, secrets) => Layer.effect(PluginLoaderService, Effect.gen(function* () {
+export class PluginRegistryTag extends Context.Tag("PluginRegistry")() {
+}
+export class RegistryService extends Effect.Service()("RegistryService", {
+    effect: Effect.gen(function* () {
+        const registry = yield* PluginRegistryTag;
+        return {
+            get: (pluginId) => Effect.fromNullable(registry[pluginId]).pipe(Effect.mapError(() => new PluginRuntimeError({
+                pluginId,
+                operation: "load-plugin",
+                cause: new Error(`Plugin ${pluginId} not found in registry`),
+                retryable: false,
+            }))),
+        };
+    }),
+}) {
+}
+export class PluginLoaderService extends Effect.Service()("PluginLoaderService", {
+    effect: Effect.gen(function* () {
         const moduleFederationService = yield* ModuleFederationService;
         const secretsService = yield* SecretsService;
+        const registryService = yield* RegistryService;
         const resolveUrl = (baseUrl, version) => version && version !== "latest"
             ? baseUrl.replace("@latest", `@${version}`)
             : baseUrl;
-        const getMetadata = (pluginId) => Effect.fromNullable(registry[pluginId]).pipe(Effect.mapError(() => new PluginRuntimeError({
-            pluginId,
-            operation: "load-plugin",
-            cause: new Error(`Plugin ${pluginId} not found in registry`),
-            retryable: false,
-        })));
+        const getMetadata = (pluginId) => registryService.get(pluginId);
         return {
             loadPlugin: (pluginId) => Effect.gen(function* () {
                 const metadata = yield* getMetadata(pluginId);
@@ -25,27 +37,23 @@ export class PluginLoaderService extends Context.Tag("PluginLoaderService")() {
                 const ctor = yield* moduleFederationService.loadRemoteConstructor(pluginId, url).pipe(Effect.mapError((error) => toPluginRuntimeError(error.cause, pluginId, undefined, "load-remote", false)));
                 return {
                     ctor,
-                    metadata: {
-                        pluginId,
-                        version: metadata.version,
-                        type: metadata.type,
-                    },
+                    metadata: metadata,
                 };
             }),
-            instantiatePlugin: (pluginConstructor) => Effect.gen(function* () {
-                const instance = yield* Effect.try(() => new pluginConstructor.ctor()).pipe(Effect.mapError((error) => toPluginRuntimeError(error, pluginConstructor.metadata.pluginId, undefined, "instantiate-plugin", false)));
+            instantiatePlugin: (pluginId, loadedPlugin) => Effect.gen(function* () {
+                const instance = yield* Effect.try(() => new loadedPlugin.ctor()).pipe(Effect.mapError((error) => toPluginRuntimeError(error, pluginId, undefined, "instantiate-plugin", false)));
                 // Validate plugin ID matches
-                if (instance.id !== pluginConstructor.metadata.pluginId) {
+                if (instance.id !== pluginId) {
                     return yield* Effect.fail(new PluginRuntimeError({
-                        pluginId: pluginConstructor.metadata.pluginId,
+                        pluginId,
                         operation: "validate-plugin-id",
-                        cause: new Error(`Plugin ID mismatch: expected ${pluginConstructor.metadata.pluginId}, got ${instance.id}`),
+                        cause: new Error(`Plugin ID mismatch: expected ${pluginId}, got ${instance.id}`),
                         retryable: false,
                     }));
                 }
                 return {
                     plugin: instance,
-                    metadata: pluginConstructor.metadata,
+                    metadata: loadedPlugin.metadata,
                 };
             }),
             initializePlugin: (pluginInstance, config) => Effect.gen(function* () {
@@ -57,8 +65,8 @@ export class PluginLoaderService extends Context.Tag("PluginLoaderService")() {
                     cause: validationError.zodError,
                     retryable: false,
                 })));
-                const hydratedConfig = yield* secretsService.hydrateSecrets(validatedConfig, secrets);
-                const finalConfig = yield* validate(plugin.configSchema, hydratedConfig, plugin.id, "config").pipe(Effect.mapError((validationError) => new PluginRuntimeError({
+                const hydratedConfig = yield* secretsService.hydrateSecrets(validatedConfig);
+                const _config = yield* validate(plugin.configSchema, hydratedConfig, plugin.id, "config").pipe(Effect.mapError((validationError) => new PluginRuntimeError({
                     pluginId: plugin.id,
                     operation: "validate-hydrated-config",
                     cause: validationError.zodError,
@@ -67,17 +75,16 @@ export class PluginLoaderService extends Context.Tag("PluginLoaderService")() {
                 // Create a long-lived scope for this plugin instance
                 const scope = yield* Scope.make();
                 // Initialize plugin within the scope
-                const context = yield* plugin.initialize(finalConfig).pipe(Effect.provideService(Scope.Scope, scope), Effect.mapError((error) => toPluginRuntimeError(error, plugin.id, undefined, "initialize-plugin", false)));
+                const context = yield* plugin.initialize(_config).pipe(Effect.provideService(Scope.Scope, scope), Effect.mapError((error) => toPluginRuntimeError(error, plugin.id, undefined, "initialize-plugin", false)));
                 return {
                     plugin,
                     metadata: pluginInstance.metadata,
-                    config: finalConfig,
+                    config: _config,
                     context,
                     scope,
                 };
             }),
         };
-    }));
+    }),
+}) {
 }
-export const PluginLoaderServiceTag = PluginLoaderService;
-export const PluginLoaderServiceLive = PluginLoaderService.Live;

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

@@ -1,21 +1,33 @@
-import { Context, Effect, Layer } from "effect";
-import type { AnyPlugin, InitializedPlugin, PluginConstructor, PluginInstance, PluginRegistry, SecretsConfig } from "../../types";
-import type { PluginRuntimeError } from "../errors";
-export interface IPluginService {
-    readonly loadPlugin: (pluginId: string) => Effect.Effect<PluginConstructor<AnyPlugin>, PluginRuntimeError>;
-    readonly instantiatePlugin: <T extends AnyPlugin>(pluginConstructor: PluginConstructor<T>) => Effect.Effect<PluginInstance<T>, PluginRuntimeError>;
-    readonly initializePlugin: <T extends AnyPlugin>(pluginInstance: PluginInstance<T>, config: {
-        variables: unknown;
-        secrets: unknown;
-    }) => Effect.Effect<InitializedPlugin<T>, PluginRuntimeError>;
-    readonly shutdownPlugin: (plugin: InitializedPlugin<AnyPlugin>) => Effect.Effect<void, PluginRuntimeError>;
-    readonly cleanup: () => Effect.Effect<void, never>;
-}
-declare const PluginService_base: Context.TagClass<PluginService, "PluginService", IPluginService>;
+import { Effect, Layer, Scope } from "effect";
+import type { AnyPlugin, InitializedPlugin, PluginRegistry, SecretsConfig } from "../../types";
+import { PluginLifecycleService } from "./plugin-lifecycle.service";
+import { PluginLoaderService } from "./plugin-loader.service";
+declare const PluginService_base: Effect.Service.Class<PluginService, "PluginService", {
+    readonly scoped: Effect.Effect<{
+        loadPlugin: (pluginId: string) => Effect.Effect<{
+            ctor: new () => AnyPlugin;
+            metadata: import("../../types").PluginMetadata;
+        }, import("../errors").PluginRuntimeError, never>;
+        instantiatePlugin: <T extends AnyPlugin>(pluginId: string, loadedPlugin: import("../..").LoadedPlugin<T>) => Effect.Effect<{
+            plugin: T;
+            metadata: import("../../types").PluginMetadata;
+        }, import("../errors").PluginRuntimeError, never>;
+        initializePlugin: <T extends AnyPlugin>(pluginInstance: import("../..").PluginInstance<T>, config: {
+            variables: unknown;
+            secrets: unknown;
+        }) => Effect.Effect<{
+            plugin: T;
+            metadata: import("../../types").PluginMetadata;
+            config: import("zod").infer<T["configSchema"]>;
+            context: any;
+            scope: Scope.CloseableScope;
+        }, import("../errors").PluginRuntimeError, never>;
+        shutdownPlugin: (plugin: InitializedPlugin<AnyPlugin>) => Effect.Effect<void, never, never>;
+        cleanup: () => Effect.Effect<void, never, never>;
+    }, never, PluginLoaderService | PluginLifecycleService>;
+}>;
 export declare class PluginService extends PluginService_base {
-    static Live: (registry: PluginRegistry, secrets: SecretsConfig) => Layer.Layer<PluginService, never, import("./module-federation.service").ModuleFederationService | import("./secrets.service").SecretsService>;
+    static Live: (registry: PluginRegistry, secrets: SecretsConfig) => Layer.Layer<PluginService, never, never>;
 }
-export declare const PluginServiceTag: typeof PluginService;
-export declare const PluginServiceLive: (registry: PluginRegistry, secrets: SecretsConfig) => Layer.Layer<PluginService, never, import("./module-federation.service").ModuleFederationService | import("./secrets.service").SecretsService>;
 export {};
 //# sourceMappingURL=plugin.service.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"plugin.service.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/plugin.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAQ,KAAK,EAAS,MAAM,QAAQ,CAAC;AAC7D,OAAO,KAAK,EACX,SAAS,EACT,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,aAAa,EACb,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAIpD,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,UAAU,EAAE,CACpB,QAAQ,EAAE,MAAM,KACZ,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,SAAS,CAAC,EAAE,kBAAkB,CAAC,CAAC;IACrE,QAAQ,CAAC,iBAAiB,EAAE,CAAC,CAAC,SAAS,SAAS,EAC/C,iBAAiB,EAAE,iBAAiB,CAAC,CAAC,CAAC,KACnC,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;IAC1D,QAAQ,CAAC,gBAAgB,EAAE,CAAC,CAAC,SAAS,SAAS,EAC9C,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC,EACjC,MAAM,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,KAC5C,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;IAC7D,QAAQ,CAAC,cAAc,EAAE,CAAC,MAAM,EAAE,iBAAiB,CAAC,SAAS,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC;IAC3G,QAAQ,CAAC,OAAO,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;CACnD;;AAED,qBAAa,aAAc,SAAQ,kBAGhC;IACF,MAAM,CAAC,IAAI,GAAI,UAAU,cAAc,EAAE,SAAS,aAAa,mJAkC5D;CACH;AAED,eAAO,MAAM,gBAAgB,sBAAgB,CAAC;AAC9C,eAAO,MAAM,iBAAiB,aAtCJ,cAAc,WAAW,aAAa,kJAsCb,CAAC"}
+{"version":3,"file":"plugin.service.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/plugin.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAQ,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACpD,OAAO,KAAK,EACX,SAAS,EACT,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAsC,MAAM,yBAAyB,CAAC;;;;;;;;;;;;;;;;;;;;;iCAYtE,iBAAiB,CAAC,SAAS,CAAC;;;;AATxD,qBAAa,aAAc,SAAQ,kBAyBjC;IACD,MAAM,CAAC,IAAI,GAAI,UAAU,cAAc,EAAE,SAAS,aAAa,8CAmB9D;CACD"}

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

@@ -1,8 +1,10 @@
-import { Context, Effect, Exit, Layer, Scope } from "effect";
+import { Effect, Exit, Layer, Scope } from "effect";
+import { ModuleFederationService } from "./module-federation.service";
 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* () {
+import { PluginLoaderService, PluginRegistryTag, RegistryService } from "./plugin-loader.service";
+import { SecretsConfigTag, SecretsService } from "./secrets.service";
+export class PluginService extends Effect.Service()("PluginService", {
+    scoped: Effect.gen(function* () {
         const loader = yield* PluginLoaderService;
         const lifecycle = yield* PluginLifecycleService;
         return {
@@ -19,7 +21,11 @@ export class PluginService extends Context.Tag("PluginService")() {
             }),
             cleanup: lifecycle.cleanup,
         };
-    })).pipe(Layer.provide(Layer.mergeAll(PluginLoaderService.Live(registry, secrets), PluginLifecycleService.Live)));
+    }),
+}) {
+    static Live = (registry, secrets) => {
+        const contextLayer = Layer.mergeAll(Layer.succeed(PluginRegistryTag, registry), Layer.succeed(SecretsConfigTag, secrets));
+        const servicesLayer = Layer.mergeAll(ModuleFederationService.Default, SecretsService.Default, RegistryService.Default, PluginLifecycleService.Default).pipe(Layer.provide(contextLayer));
+        return PluginService.Default.pipe(Layer.provide(PluginLoaderService.Default), Layer.provide(servicesLayer));
+    };
 }
-export const PluginServiceTag = PluginService;
-export const PluginServiceLive = PluginService.Live;

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

@@ -1,16 +1,15 @@
-import { Effect, Layer } from "effect";
+import { Context, Effect } from "effect";
 import type { SecretsConfig } from "../../types";
 import { PluginRuntimeError } from "../errors";
-export interface ISecretsService {
-    readonly hydrateSecrets: <T>(config: T, secretsConfig: SecretsConfig) => Effect.Effect<T, PluginRuntimeError>;
+declare const SecretsConfigTag_base: Context.TagClass<SecretsConfigTag, "SecretsConfig", SecretsConfig>;
+export declare class SecretsConfigTag extends SecretsConfigTag_base {
 }
-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>;
-};
+declare const SecretsService_base: Effect.Service.Class<SecretsService, "SecretsService", {
+    readonly effect: Effect.Effect<{
+        hydrateSecrets: <T>(config: T) => Effect.Effect<T, PluginRuntimeError, never>;
+    }, never, SecretsConfigTag>;
+}>;
 export declare class SecretsService extends SecretsService_base {
-    static Live: (secrets: SecretsConfig) => Layer.Layer<SecretsService, never, never>;
 }
-export declare const SecretsServiceTag: typeof SecretsService;
-export declare const SecretsServiceLive: (secrets: SecretsConfig) => Layer.Layer<SecretsService, never, never>;
 export {};
 //# sourceMappingURL=secrets.service.d.ts.map

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;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"}
+{"version":3,"file":"secrets.service.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/secrets.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;;AAM/C,qBAAa,gBAAiB,SAAQ,qBAGnC;CAAI;;;yBAOa,CAAC,UAAU,CAAC;;;AALhC,qBAAa,cAAe,SAAQ,mBA+BlC;CAAI"}

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

@@ -1,34 +1,35 @@
-import { Effect, Layer } from "effect";
+import { Context, Effect } 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* () {
-            const parseResult = configSchema.parse(config);
-            try {
-                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, String(value));
+export class SecretsConfigTag extends Context.Tag("SecretsConfig")() {
+}
+export class SecretsService extends Effect.Service()("SecretsService", {
+    effect: Effect.gen(function* () {
+        const secrets = yield* SecretsConfigTag;
+        return {
+            hydrateSecrets: (config) => Effect.gen(function* () {
+                const parseResult = configSchema.parse(config);
+                try {
+                    const configString = JSON.stringify(parseResult);
+                    let hydratedString = configString;
+                    for (const [key, value] of Object.entries(secrets)) {
+                        const pattern = new RegExp(`{{${key}}}`, "g");
+                        hydratedString = hydratedString.replace(pattern, String(value));
+                    }
+                    return JSON.parse(hydratedString);
+                }
+                catch (error) {
+                    return yield* Effect.fail(new PluginRuntimeError({
+                        operation: "hydrate-secrets",
+                        cause: error instanceof Error ? error : new Error(String(error)),
+                        retryable: false,
+                    }));
                 }
-                return JSON.parse(hydratedString);
-            }
-            catch (error) {
-                return yield* Effect.fail(new PluginRuntimeError({
-                    operation: "hydrate-secrets",
-                    cause: error instanceof Error ? error : new Error(String(error)),
-                    retryable: false,
-                }));
-            }
-        }),
-    });
+            }),
+        };
+    }),
+}) {
 }
-export const SecretsServiceTag = SecretsService;
-export const SecretsServiceLive = SecretsService.Live;

package/dist/runtime/services.d.ts

@@ -1,4 +1,6 @@
+export * from "./services/module-federation.service";
 export * from "./services/plugin.service";
+export * from "./services/plugin-lifecycle.service";
+export * from "./services/plugin-loader.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,2BAA2B,CAAA;AACzC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,sCAAsC,CAAA"}
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/runtime/services.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAA;AACpD,cAAc,2BAA2B,CAAA;AACzC,cAAc,qCAAqC,CAAA;AACnD,cAAc,kCAAkC,CAAA;AAChD,cAAc,4BAA4B,CAAA"}

package/dist/runtime/services.js

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

package/dist/testing/index.d.ts

@@ -1,20 +1,53 @@
-import { Effect, Layer, ManagedRuntime } from "effect";
-import { PluginRuntimeImpl, PluginRuntimeService } from "../runtime";
+import { Layer } from "effect";
+import type { PluginBinding } from "../plugin";
+import { PluginRuntime } from "../runtime";
+import { PluginService } from "../runtime/services";
 import type { PluginRuntimeConfig, RegistryBindings } from "../types";
-import { type TestPluginMap } from "./mocks/module-federation.service";
+import { type PluginMap } from "./mocks/module-federation.service";
+/**
+ * Automatically infer RegistryBindings from a map of locally available plugins.
+ * Eliminates the need for manual binding definitions when using createLocalPluginRuntime.
+ *
+ * @example
+ * ```ts
+ * const pluginMap = { "my-plugin": MyPlugin } as const;
+ * type MyBindings = InferBindingsFromMap<typeof pluginMap>;
+ * ```
+ */
+export type InferBindingsFromMap<T extends PluginMap> = {
+    [K in keyof T]: PluginBinding<T[K]>;
+} & RegistryBindings;
 /**
  * Creates a test layer with mock ModuleFederationService for unit testing.
- * This mirrors PluginRuntimeService.Live but uses mock ModuleFederationService.
+ * This mirrors PluginService.Live() but uses mock ModuleFederationService.
+ */
+export declare const createTestLayer: <R extends RegistryBindings = RegistryBindings>(config: PluginRuntimeConfig<R>, pluginMap: PluginMap) => Layer.Layer<PluginService, never, never>;
+/**
+ * Creates a plugin runtime for locally available plugins (non-remote).
+ * Automatically infers type bindings from the plugin map, eliminating
+ * the need for manual RegistryBindings definitions.
+ *
+ * Ideal for:
+ * - Unit and integration tests
+ * - Local development and debugging
+ * - Monorepo setups where all plugins are in the same workspace
+ *
+ * For production with remote Module Federation plugins, use createPluginRuntime().
+ *
+ * @example
+ * ```ts
+ * const pluginMap = { "my-plugin": MyPlugin } as const;
+ * const runtime = createLocalPluginRuntime({ registry, secrets }, pluginMap);
+ *
+ * // Types are automatically inferred - no manual bindings needed!
+ * const plugin = await runtime.usePlugin("my-plugin", config);
+ * ```
  */
-export declare const createTestLayer: <R extends RegistryBindings = RegistryBindings>(config: PluginRuntimeConfig<R>, pluginMap: TestPluginMap) => Layer.Layer<PluginRuntimeService, never, never>;
+export declare function createLocalPluginRuntime<T extends PluginMap>(config: PluginRuntimeConfig, pluginMap: T): PluginRuntime<InferBindingsFromMap<T>>;
 /**
- * Creates a test plugin runtime using mock services.
- * This mirrors createPluginRuntime exactly but uses test layer.
+ * @deprecated Use `createLocalPluginRuntime` instead. This alias is kept for backward compatibility.
  */
-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 declare const createTestPluginRuntime: typeof createLocalPluginRuntime;
 export type { PluginRegistry, RegistryBindings } from "../types";
-export type { PluginRuntimeConfig, TestPluginMap };
+export type { PluginMap, PluginRuntimeConfig };
 //# 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,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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAkB,MAAM,QAAQ,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAIN,aAAa,EAIb,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACtE,OAAO,EAA0C,KAAK,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAE3G;;;;;;;;;GASG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,SAAS,IAAI;KACtD,CAAC,IAAI,MAAM,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACnC,GAAG,gBAAgB,CAAC;AAErB;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,EAC5E,QAAQ,mBAAmB,CAAC,CAAC,CAAC,EAC9B,WAAW,SAAS,6CAwBpB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,SAAS,EAC3D,MAAM,EAAE,mBAAmB,EAC3B,SAAS,EAAE,CAAC,GACV,aAAa,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAKxC;AAED;;GAEG;AACH,eAAO,MAAM,uBAAuB,iCAA2B,CAAC;AAGhE,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACjE,YAAY,EAAE,SAAS,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/testing/index.js

@@ -1,38 +1,45 @@
-import { Effect, Layer, ManagedRuntime } from "effect";
-import { PluginRuntimeImpl, PluginRuntimeService } from "../runtime";
-// Import the mock service factory and types
-import { PluginService, SecretsService } from "../runtime/services";
+import { Layer, ManagedRuntime } from "effect";
+import { PluginRuntime } from "../runtime";
+import { PluginLifecycleService, PluginLoaderService, PluginRegistryTag, PluginService, RegistryService, SecretsConfigTag, SecretsService } from "../runtime/services";
 import { createMockModuleFederationServiceLayer } from "./mocks/module-federation.service";
 /**
  * Creates a test layer with mock ModuleFederationService for unit testing.
- * This mirrors PluginRuntimeService.Live but uses mock ModuleFederationService.
+ * This mirrors PluginService.Live() but uses mock ModuleFederationService.
  */
 export const createTestLayer = (config, pluginMap) => {
     const secrets = config.secrets || {};
-    // Same structure as PluginRuntimeService.Live but with mock ModuleFederationService
-    return Layer.scoped(PluginRuntimeService, Effect.gen(function* () {
-        const pluginService = yield* PluginService;
-        // 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))))));
+    const contextLayer = Layer.mergeAll(Layer.succeed(PluginRegistryTag, config.registry), Layer.succeed(SecretsConfigTag, secrets));
+    const mockModuleFederationLayer = createMockModuleFederationServiceLayer(pluginMap);
+    const servicesLayer = Layer.mergeAll(mockModuleFederationLayer, SecretsService.Default, RegistryService.Default, PluginLifecycleService.Default).pipe(Layer.provide(contextLayer));
+    return PluginService.Default.pipe(Layer.provide(PluginLoaderService.Default), Layer.provide(servicesLayer));
 };
 /**
- * Creates a test plugin runtime using mock services.
- * This mirrors createPluginRuntime exactly but uses test layer.
+ * Creates a plugin runtime for locally available plugins (non-remote).
+ * Automatically infers type bindings from the plugin map, eliminating
+ * the need for manual RegistryBindings definitions.
+ *
+ * Ideal for:
+ * - Unit and integration tests
+ * - Local development and debugging
+ * - Monorepo setups where all plugins are in the same workspace
+ *
+ * For production with remote Module Federation plugins, use createPluginRuntime().
+ *
+ * @example
+ * ```ts
+ * const pluginMap = { "my-plugin": MyPlugin } as const;
+ * const runtime = createLocalPluginRuntime({ registry, secrets }, pluginMap);
+ *
+ * // Types are automatically inferred - no manual bindings needed!
+ * const plugin = await runtime.usePlugin("my-plugin", config);
+ * ```
  */
-export const createTestPluginRuntime = (config, pluginMap) => {
+export function createLocalPluginRuntime(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))
-    };
-};
+    return new PluginRuntime(runtime, config.registry);
+}
+/**
+ * @deprecated Use `createLocalPluginRuntime` instead. This alias is kept for backward compatibility.
+ */
+export const createTestPluginRuntime = createLocalPluginRuntime;

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

@@ -1,8 +1,6 @@
 import { Layer } from "effect";
+import type { LoadedPluginWithBinding } from "../../plugin";
 import { ModuleFederationService } from "../../runtime/services/module-federation.service";
-import type { AnyPlugin } from "../../types";
-export interface TestPluginMap {
-    [pluginId: string]: new () => AnyPlugin;
-}
-export declare const createMockModuleFederationServiceLayer: (pluginMap: TestPluginMap) => Layer.Layer<ModuleFederationService, never, never>;
+export type PluginMap = Record<string, LoadedPluginWithBinding<any, any, any, any>>;
+export declare const createMockModuleFederationServiceLayer: (pluginMap: PluginMap) => Layer.Layer<ModuleFederationService, never, never>;
 //# sourceMappingURL=module-federation.service.d.ts.map

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,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"}
+{"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;AACvC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAE5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,kDAAkD,CAAC;AAE3F,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;AAEpF,eAAO,MAAM,sCAAsC,GAAI,WAAW,SAAS,uDAoCxE,CAAC"}

package/dist/testing/mocks/module-federation.service.js

@@ -1,35 +1,29 @@
 import { Effect, Layer } from "effect";
 import { ModuleFederationError } from "../../runtime/errors";
 import { ModuleFederationService } from "../../runtime/services/module-federation.service";
-// Create the mock service implementation
-const createMockService = (pluginMap) => ({
+export const createMockModuleFederationServiceLayer = (pluginMap) => Layer.succeed(ModuleFederationService, {
     registerRemote: (pluginId, url) => Effect.gen(function* () {
-        // Mock registration - succeeds if plugin is in the map
-        // Use original pluginId as key since TestPluginMap uses original plugin IDs
-        if (pluginId in pluginMap) {
-            return;
+        console.log(`[MOCK] registerRemote called for ${pluginId}`);
+        if (!(pluginId in pluginMap)) {
+            return yield* Effect.fail(new ModuleFederationError({
+                pluginId,
+                remoteUrl: url,
+                cause: new Error(`Mock: Plugin ${pluginId} not available in test plugin map`),
+            }));
         }
-        // Fail for plugins not in the map
-        return yield* Effect.fail(new ModuleFederationError({
-            pluginId,
-            remoteUrl: url,
-            cause: new Error(`Mock: Plugin ${pluginId} not available in test plugin map`),
-        }));
+        console.log(`[MOCK] registerRemote succeeded for ${pluginId}`);
     }),
     loadRemoteConstructor: (pluginId, url) => Effect.gen(function* () {
-        // Return the plugin constructor from the map
-        // Use original pluginId as key since TestPluginMap uses original plugin IDs
+        console.log(`[MOCK] loadRemoteConstructor called for ${pluginId}`);
         const PluginConstructor = pluginMap[pluginId];
-        if (PluginConstructor) {
-            return PluginConstructor;
+        if (!PluginConstructor) {
+            return yield* Effect.fail(new ModuleFederationError({
+                pluginId,
+                remoteUrl: url,
+                cause: new Error(`Mock: Constructor for ${pluginId} not found in test plugin map`),
+            }));
         }
-        // Fail for plugins not in the map
-        return yield* Effect.fail(new ModuleFederationError({
-            pluginId,
-            remoteUrl: url,
-            cause: new Error(`Mock: Constructor for ${pluginId} not found in test plugin map`),
-        }));
+        console.log(`[MOCK] loadRemoteConstructor succeeded for ${pluginId}`);
+        return PluginConstructor;
     }),
 });
-// Create a Layer that provides the mock ModuleFederationService
-export const createMockModuleFederationServiceLayer = (pluginMap) => Layer.succeed(ModuleFederationService, createMockService(pluginMap));