every-plugin 0.4.3 → 0.4.5

package/dist/testing/index.cjs

@@ -0,0 +1,78 @@
+const require_chunk = require('../chunk-zltIcp7o.cjs');
+const require_runtime = require('../runtime-CdAK1Q5M.cjs');
+require('../normalize-D4Qh0wVk.cjs');
+require('../package-C09aaCqd.cjs');
+let effect = require("effect");
+
+//#region src/testing/mocks/module-federation.service.ts
+const createMockModuleFederationServiceLayer = (pluginMap) => effect.Layer.succeed(require_runtime.ModuleFederationService, {
+	registerRemote: (pluginId, url) => effect.Effect.gen(function* () {
+		console.log(`[MOCK] registerRemote called for ${pluginId}`);
+		if (!(pluginId in pluginMap)) return yield* effect.Effect.fail(new require_runtime.ModuleFederationError({
+			pluginId,
+			remoteUrl: url,
+			cause: /* @__PURE__ */ new Error(`Mock: Plugin ${pluginId} not available in test plugin map`)
+		}));
+		console.log(`[MOCK] registerRemote succeeded for ${pluginId}`);
+	}),
+	loadRemoteConstructor: (pluginId, url) => effect.Effect.gen(function* () {
+		console.log(`[MOCK] loadRemoteConstructor called for ${pluginId}`);
+		const PluginConstructor = pluginMap[pluginId];
+		if (!PluginConstructor) return yield* effect.Effect.fail(new require_runtime.ModuleFederationError({
+			pluginId,
+			remoteUrl: url,
+			cause: /* @__PURE__ */ new Error(`Mock: Constructor for ${pluginId} not found in test plugin map`)
+		}));
+		console.log(`[MOCK] loadRemoteConstructor succeeded for ${pluginId}`);
+		return PluginConstructor;
+	})
+});
+
+//#endregion
+//#region src/testing/index.ts
+/**
+* Creates a test layer with mock ModuleFederationService for unit testing.
+* This mirrors PluginService.Live() but uses mock ModuleFederationService.
+*/
+const createTestLayer = (config, pluginMap) => {
+	const secrets = config.secrets || {};
+	const contextLayer = effect.Layer.mergeAll(effect.Layer.succeed(require_runtime.PluginRegistryTag, config.registry), effect.Layer.succeed(require_runtime.SecretsConfigTag, secrets));
+	const mockModuleFederationLayer = createMockModuleFederationServiceLayer(pluginMap);
+	const servicesLayer = effect.Layer.mergeAll(mockModuleFederationLayer, require_runtime.SecretsService.Default, require_runtime.RegistryService.Default, require_runtime.PluginLifecycleService.Default).pipe(effect.Layer.provide(contextLayer));
+	return require_runtime.PluginService.Default.pipe(effect.Layer.provide(require_runtime.PluginLoaderService.Default), effect.Layer.provide(servicesLayer));
+};
+/**
+* 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);
+* ```
+*/
+function createLocalPluginRuntime(config, pluginMap) {
+	const layer = createTestLayer(config, pluginMap);
+	return new require_runtime.PluginRuntime(effect.ManagedRuntime.make(layer), config.registry);
+}
+/**
+* @deprecated Use `createLocalPluginRuntime` instead. This alias is kept for backward compatibility.
+*/
+const createTestPluginRuntime = createLocalPluginRuntime;
+
+//#endregion
+exports.createLocalPluginRuntime = createLocalPluginRuntime;
+exports.createTestLayer = createTestLayer;
+exports.createTestPluginRuntime = createTestPluginRuntime;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.cjs","names":["Layer","ModuleFederationService","Effect","ModuleFederationError","Layer","PluginRegistryTag","SecretsConfigTag","SecretsService","RegistryService","PluginLifecycleService","PluginService","PluginLoaderService","PluginRuntime","ManagedRuntime"],"sources":["../../src/testing/mocks/module-federation.service.ts","../../src/testing/index.ts"],"sourcesContent":["import { Effect, Layer } from \"effect\";\nimport type { LoadedPluginWithBinding } from \"../../plugin\";\nimport { ModuleFederationError } from \"../../runtime/errors\";\nimport { ModuleFederationService } from \"../../runtime/services/module-federation.service\";\n\nexport type PluginMap = Record<string, LoadedPluginWithBinding<any, any, any, any>>;\n\nexport const createMockModuleFederationServiceLayer = (pluginMap: PluginMap) =>\n  Layer.succeed(\n    ModuleFederationService,\n    {\n      registerRemote: (pluginId: string, url: string) =>\n        Effect.gen(function* () {\n          console.log(`[MOCK] registerRemote called for ${pluginId}`);\n          if (!(pluginId in pluginMap)) {\n            return yield* Effect.fail(\n              new ModuleFederationError({\n                pluginId,\n                remoteUrl: url,\n                cause: new Error(`Mock: Plugin ${pluginId} not available in test plugin map`),\n              }),\n            );\n          }\n          console.log(`[MOCK] registerRemote succeeded for ${pluginId}`);\n        }),\n\n      loadRemoteConstructor: (pluginId: string, url: string) =>\n        Effect.gen(function* () {\n          console.log(`[MOCK] loadRemoteConstructor called for ${pluginId}`);\n          const PluginConstructor = pluginMap[pluginId];\n          if (!PluginConstructor) {\n            return yield* Effect.fail(\n              new ModuleFederationError({\n                pluginId,\n                remoteUrl: url,\n                cause: new Error(`Mock: Constructor for ${pluginId} not found in test plugin map`),\n              }),\n            );\n          }\n          console.log(`[MOCK] loadRemoteConstructor succeeded for ${pluginId}`);\n          return PluginConstructor;\n        }),\n    } as any\n  );\n","import { Layer, ManagedRuntime } from \"effect\";\nimport { PluginRuntime } from \"../runtime\";\nimport {\n\tPluginLifecycleService,\n\tPluginLoaderService,\n\tPluginRegistryTag,\n\tPluginService,\n\tRegistryService,\n\tSecretsConfigTag,\n\tSecretsService\n} from \"../runtime/services\";\nimport type { PluginRuntimeConfig, RegisteredPlugins } from \"../types\";\nimport { createMockModuleFederationServiceLayer, type PluginMap } from \"./mocks/module-federation.service\";\n\n/**\n * Validates that all plugin map keys exist in RegisteredPlugins.\n * This ensures proper type inference for client methods.\n */\ntype ValidatePluginMap<T extends PluginMap> = {\n\t[K in keyof T]: K extends keyof RegisteredPlugins\n\t\t? T[K]\n\t\t: `❌ Plugin key \"${K & string}\" not registered in RegisteredPlugins. Add it to your types.d.ts file.`;\n};\n\n/**\n * Simplified type inference for local plugin maps.\n * Just use the constructor types directly.\n *\n * @example\n * ```ts\n * const pluginMap = { \"my-plugin\": MyPlugin } as const;\n * type MyBindings = InferBindingsFromMap<typeof pluginMap>;\n * ```\n */\nexport type InferBindingsFromMap<T extends PluginMap> = {\n\t[K in keyof T]: T[K]\n} & RegisteredPlugins;\n\n/**\n * Creates a test layer with mock ModuleFederationService for unit testing.\n * This mirrors PluginService.Live() but uses mock ModuleFederationService.\n */\nexport const createTestLayer = <R extends RegisteredPlugins = RegisteredPlugins>(\n\tconfig: PluginRuntimeConfig<R>,\n\tpluginMap: PluginMap\n) => {\n\tconst secrets = config.secrets || {};\n\n\tconst contextLayer = Layer.mergeAll(\n\t\tLayer.succeed(PluginRegistryTag, config.registry),\n\t\tLayer.succeed(SecretsConfigTag, secrets),\n\t);\n\n\tconst mockModuleFederationLayer = createMockModuleFederationServiceLayer(pluginMap);\n\n\tconst servicesLayer = Layer.mergeAll(\n\t\tmockModuleFederationLayer,\n\t\tSecretsService.Default,\n\t\tRegistryService.Default,\n\t\tPluginLifecycleService.Default,\n\t).pipe(\n\t\tLayer.provide(contextLayer)\n\t);\n\n\treturn PluginService.Default.pipe(\n\t\tLayer.provide(PluginLoaderService.Default),\n\t\tLayer.provide(servicesLayer)\n\t);\n};\n\n/**\n * Creates a plugin runtime for locally available plugins (non-remote).\n * Automatically infers type bindings from the plugin map, eliminating\n * the need for manual RegistryBindings definitions.\n *\n * Ideal for:\n * - Unit and integration tests\n * - Local development and debugging\n * - Monorepo setups where all plugins are in the same workspace\n *\n * For production with remote Module Federation plugins, use createPluginRuntime().\n *\n * @example\n * ```ts\n * const pluginMap = { \"my-plugin\": MyPlugin } as const;\n * const runtime = createLocalPluginRuntime({ registry, secrets }, pluginMap);\n *\n * // Types are automatically inferred - no manual bindings needed!\n * const plugin = await runtime.usePlugin(\"my-plugin\", config);\n * ```\n */\nexport function createLocalPluginRuntime<TMap extends PluginMap & ValidatePluginMap<TMap>>(\n\tconfig: PluginRuntimeConfig,\n\tpluginMap: TMap\n): PluginRuntime<InferBindingsFromMap<TMap>> {\n\tconst layer = createTestLayer(config, pluginMap);\n\tconst runtime = ManagedRuntime.make(layer);\n\n\treturn new PluginRuntime<InferBindingsFromMap<TMap>>(runtime, config.registry);\n}\n\n/**\n * @deprecated Use `createLocalPluginRuntime` instead. This alias is kept for backward compatibility.\n */\nexport const createTestPluginRuntime = createLocalPluginRuntime;\n\n// Re-export useful types for tests\nexport type { EveryPlugin, PluginRegistry, RegisteredPlugins } from \"../types\";\nexport type { PluginMap, PluginRuntimeConfig };\n"],"mappings":";;;;;;;AAOA,MAAa,0CAA0C,cACrDA,aAAM,QACJC,yCACA;CACE,iBAAiB,UAAkB,QACjCC,cAAO,IAAI,aAAa;AACtB,UAAQ,IAAI,oCAAoC,WAAW;AAC3D,MAAI,EAAE,YAAY,WAChB,QAAO,OAAOA,cAAO,KACnB,IAAIC,sCAAsB;GACxB;GACA,WAAW;GACX,uBAAO,IAAI,MAAM,gBAAgB,SAAS,mCAAmC;GAC9E,CAAC,CACH;AAEH,UAAQ,IAAI,uCAAuC,WAAW;GAC9D;CAEJ,wBAAwB,UAAkB,QACxCD,cAAO,IAAI,aAAa;AACtB,UAAQ,IAAI,2CAA2C,WAAW;EAClE,MAAM,oBAAoB,UAAU;AACpC,MAAI,CAAC,kBACH,QAAO,OAAOA,cAAO,KACnB,IAAIC,sCAAsB;GACxB;GACA,WAAW;GACX,uBAAO,IAAI,MAAM,yBAAyB,SAAS,+BAA+B;GACnF,CAAC,CACH;AAEH,UAAQ,IAAI,8CAA8C,WAAW;AACrE,SAAO;GACP;CACL,CACF;;;;;;;;ACDH,MAAa,mBACZ,QACA,cACI;CACJ,MAAM,UAAU,OAAO,WAAW,EAAE;CAEpC,MAAM,eAAeC,aAAM,SAC1BA,aAAM,QAAQC,mCAAmB,OAAO,SAAS,EACjDD,aAAM,QAAQE,kCAAkB,QAAQ,CACxC;CAED,MAAM,4BAA4B,uCAAuC,UAAU;CAEnF,MAAM,gBAAgBF,aAAM,SAC3B,2BACAG,+BAAe,SACfC,gCAAgB,SAChBC,uCAAuB,QACvB,CAAC,KACDL,aAAM,QAAQ,aAAa,CAC3B;AAED,QAAOM,8BAAc,QAAQ,KAC5BN,aAAM,QAAQO,oCAAoB,QAAQ,EAC1CP,aAAM,QAAQ,cAAc,CAC5B;;;;;;;;;;;;;;;;;;;;;;;AAwBF,SAAgB,yBACf,QACA,WAC4C;CAC5C,MAAM,QAAQ,gBAAgB,QAAQ,UAAU;AAGhD,QAAO,IAAIQ,8BAFKC,sBAAe,KAAK,MAAM,EAEoB,OAAO,SAAS;;;;;AAM/E,MAAa,0BAA0B"}

package/dist/testing/index.d.cts

@@ -0,0 +1,60 @@
+import "../zod-A7Pti5IV.cjs";
+import "../errors-DKPPPYYT.cjs";
+import { a as EveryPlugin, g as PluginRuntimeConfig, m as PluginRegistry, r as PluginService, t as PluginRuntime, x as LoadedPluginWithBinding, y as RegisteredPlugins } from "../index-matrPV4m.cjs";
+import "../normalize-BW7kk8Lk.cjs";
+import { Layer } from "effect";
+
+//#region src/testing/mocks/module-federation.service.d.ts
+type PluginMap = Record<string, LoadedPluginWithBinding<any, any, any, any>>;
+//#endregion
+//#region src/testing/index.d.ts
+/**
+ * Validates that all plugin map keys exist in RegisteredPlugins.
+ * This ensures proper type inference for client methods.
+ */
+type ValidatePluginMap<T extends PluginMap> = { [K in keyof T]: K extends keyof RegisteredPlugins ? T[K] : `❌ Plugin key "${K & string}" not registered in RegisteredPlugins. Add it to your types.d.ts file.` };
+/**
+ * Simplified type inference for local plugin maps.
+ * Just use the constructor types directly.
+ *
+ * @example
+ * ```ts
+ * const pluginMap = { "my-plugin": MyPlugin } as const;
+ * type MyBindings = InferBindingsFromMap<typeof pluginMap>;
+ * ```
+ */
+type InferBindingsFromMap<T extends PluginMap> = { [K in keyof T]: T[K] } & RegisteredPlugins;
+/**
+ * Creates a test layer with mock ModuleFederationService for unit testing.
+ * This mirrors PluginService.Live() but uses mock ModuleFederationService.
+ */
+declare const createTestLayer: <R extends RegisteredPlugins = RegisteredPlugins>(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);
+ * ```
+ */
+declare function createLocalPluginRuntime<TMap extends PluginMap & ValidatePluginMap<TMap>>(config: PluginRuntimeConfig, pluginMap: TMap): PluginRuntime<InferBindingsFromMap<TMap>>;
+/**
+ * @deprecated Use `createLocalPluginRuntime` instead. This alias is kept for backward compatibility.
+ */
+declare const createTestPluginRuntime: typeof createLocalPluginRuntime;
+//#endregion
+export { type EveryPlugin, InferBindingsFromMap, type PluginMap, type PluginRegistry, type PluginRuntimeConfig, type RegisteredPlugins, createLocalPluginRuntime, createTestLayer, createTestPluginRuntime };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Rlc3RpbmcvbW9ja3MvbW9kdWxlLWZlZGVyYXRpb24uc2VydmljZS50cyIsIi4uLy4uL3NyYy90ZXN0aW5nL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7S0FLWSxTQUFBLEdBQVksZUFBZTs7Ozs7QUFBdkM7O0tDYUssNEJBQTRCLDJCQUNwQixJQUFJLGdCQUFnQixvQkFDN0IsRUFBRSxzQkFDZSxvRkFUc0Y7Ozs7Ozs7OztBQXNCM0c7O0FBQ2EsS0FERCxvQkFDQyxDQUFBLFVBRDhCLFNBQzlCLENBQUEsR0FBQSxRQUFJLE1BQUosQ0FBSSxHQUFBLENBQUEsQ0FBRSxDQUFGLENBQUEsRUFBRSxHQUNmLGlCQURlOzs7QUFPbkI7O0FBQThELGNBQWpELGVBQWlELEVBQUEsQ0FBQSxVQUFwQixpQkFBb0IsR0FBQSxpQkFBQSxDQUFBLENBQUEsTUFBQSxFQUNyRCxtQkFEcUQsQ0FDakMsQ0FEaUMsQ0FBQSxFQUFBLFNBQUEsRUFFbEQsU0FGa0QsRUFBQSxHQUV6QyxLQUFBLENBQUEsS0FGeUMsQ0FFekMsYUFGeUMsRUFBQSxLQUFBLEVBQUEsS0FBQSxDQUFBOzs7Ozs7O0FBaUQ5RDs7Ozs7Ozs7OztBQWFBOzs7OztpQkFiZ0Isc0NBQXNDLFlBQVksa0JBQWtCLGVBQzNFLGdDQUNHLE9BQ1QsY0FBYyxxQkFBcUI7Ozs7Y0FVekIsZ0NBQXVCIn0=

package/dist/testing/index.d.mts

@@ -0,0 +1,60 @@
+import "../zod-D4CFw8d9.mjs";
+import "../errors-Car4tFVP.mjs";
+import { a as EveryPlugin, g as PluginRuntimeConfig, m as PluginRegistry, r as PluginService, t as PluginRuntime, x as LoadedPluginWithBinding, y as RegisteredPlugins } from "../index-bwAhA9ca.mjs";
+import "../normalize-BLTyqFww.mjs";
+import { Layer } from "effect";
+
+//#region src/testing/mocks/module-federation.service.d.ts
+type PluginMap = Record<string, LoadedPluginWithBinding<any, any, any, any>>;
+//#endregion
+//#region src/testing/index.d.ts
+/**
+ * Validates that all plugin map keys exist in RegisteredPlugins.
+ * This ensures proper type inference for client methods.
+ */
+type ValidatePluginMap<T extends PluginMap> = { [K in keyof T]: K extends keyof RegisteredPlugins ? T[K] : `❌ Plugin key "${K & string}" not registered in RegisteredPlugins. Add it to your types.d.ts file.` };
+/**
+ * Simplified type inference for local plugin maps.
+ * Just use the constructor types directly.
+ *
+ * @example
+ * ```ts
+ * const pluginMap = { "my-plugin": MyPlugin } as const;
+ * type MyBindings = InferBindingsFromMap<typeof pluginMap>;
+ * ```
+ */
+type InferBindingsFromMap<T extends PluginMap> = { [K in keyof T]: T[K] } & RegisteredPlugins;
+/**
+ * Creates a test layer with mock ModuleFederationService for unit testing.
+ * This mirrors PluginService.Live() but uses mock ModuleFederationService.
+ */
+declare const createTestLayer: <R extends RegisteredPlugins = RegisteredPlugins>(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);
+ * ```
+ */
+declare function createLocalPluginRuntime<TMap extends PluginMap & ValidatePluginMap<TMap>>(config: PluginRuntimeConfig, pluginMap: TMap): PluginRuntime<InferBindingsFromMap<TMap>>;
+/**
+ * @deprecated Use `createLocalPluginRuntime` instead. This alias is kept for backward compatibility.
+ */
+declare const createTestPluginRuntime: typeof createLocalPluginRuntime;
+//#endregion
+export { type EveryPlugin, InferBindingsFromMap, type PluginMap, type PluginRegistry, type PluginRuntimeConfig, type RegisteredPlugins, createLocalPluginRuntime, createTestLayer, createTestPluginRuntime };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC5tdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Rlc3RpbmcvbW9ja3MvbW9kdWxlLWZlZGVyYXRpb24uc2VydmljZS50cyIsIi4uLy4uL3NyYy90ZXN0aW5nL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7S0FLWSxTQUFBLEdBQVksZUFBZTs7Ozs7QUFBdkM7O0tDYUssNEJBQTRCLDJCQUNwQixJQUFJLGdCQUFnQixvQkFDN0IsRUFBRSxzQkFDZSxvRkFUc0Y7Ozs7Ozs7OztBQXNCM0c7O0FBQ2EsS0FERCxvQkFDQyxDQUFBLFVBRDhCLFNBQzlCLENBQUEsR0FBQSxRQUFJLE1BQUosQ0FBSSxHQUFBLENBQUEsQ0FBRSxDQUFGLENBQUEsRUFBRSxHQUNmLGlCQURlOzs7QUFPbkI7O0FBQThELGNBQWpELGVBQWlELEVBQUEsQ0FBQSxVQUFwQixpQkFBb0IsR0FBQSxpQkFBQSxDQUFBLENBQUEsTUFBQSxFQUNyRCxtQkFEcUQsQ0FDakMsQ0FEaUMsQ0FBQSxFQUFBLFNBQUEsRUFFbEQsU0FGa0QsRUFBQSxHQUV6QyxLQUFBLENBQUEsS0FGeUMsQ0FFekMsYUFGeUMsRUFBQSxLQUFBLEVBQUEsS0FBQSxDQUFBOzs7Ozs7O0FBaUQ5RDs7Ozs7Ozs7OztBQWFBOzs7OztpQkFiZ0Isc0NBQXNDLFlBQVksa0JBQWtCLGVBQzNFLGdDQUNHLE9BQ1QsY0FBYyxxQkFBcUI7Ozs7Y0FVekIsZ0NBQXVCIn0=

package/dist/testing/index.mjs

@@ -0,0 +1,75 @@
+import { a as PluginRegistryTag, c as SecretsService, d as ModuleFederationError, i as PluginLoaderService, l as PluginLifecycleService, o as RegistryService, r as PluginService, s as SecretsConfigTag, t as PluginRuntime, u as ModuleFederationService } from "../runtime-I62RA1Vo.mjs";
+import "../normalize-D7nae0Hn.mjs";
+import "../package-Ba1JsQFb.mjs";
+import { Effect, Layer, ManagedRuntime } from "effect";
+
+//#region src/testing/mocks/module-federation.service.ts
+const createMockModuleFederationServiceLayer = (pluginMap) => Layer.succeed(ModuleFederationService, {
+	registerRemote: (pluginId, url) => Effect.gen(function* () {
+		console.log(`[MOCK] registerRemote called for ${pluginId}`);
+		if (!(pluginId in pluginMap)) return yield* Effect.fail(new ModuleFederationError({
+			pluginId,
+			remoteUrl: url,
+			cause: /* @__PURE__ */ new Error(`Mock: Plugin ${pluginId} not available in test plugin map`)
+		}));
+		console.log(`[MOCK] registerRemote succeeded for ${pluginId}`);
+	}),
+	loadRemoteConstructor: (pluginId, url) => Effect.gen(function* () {
+		console.log(`[MOCK] loadRemoteConstructor called for ${pluginId}`);
+		const PluginConstructor = pluginMap[pluginId];
+		if (!PluginConstructor) return yield* Effect.fail(new ModuleFederationError({
+			pluginId,
+			remoteUrl: url,
+			cause: /* @__PURE__ */ new Error(`Mock: Constructor for ${pluginId} not found in test plugin map`)
+		}));
+		console.log(`[MOCK] loadRemoteConstructor succeeded for ${pluginId}`);
+		return PluginConstructor;
+	})
+});
+
+//#endregion
+//#region src/testing/index.ts
+/**
+* Creates a test layer with mock ModuleFederationService for unit testing.
+* This mirrors PluginService.Live() but uses mock ModuleFederationService.
+*/
+const createTestLayer = (config, pluginMap) => {
+	const secrets = config.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 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);
+* ```
+*/
+function createLocalPluginRuntime(config, pluginMap) {
+	const layer = createTestLayer(config, pluginMap);
+	return new PluginRuntime(ManagedRuntime.make(layer), config.registry);
+}
+/**
+* @deprecated Use `createLocalPluginRuntime` instead. This alias is kept for backward compatibility.
+*/
+const createTestPluginRuntime = createLocalPluginRuntime;
+
+//#endregion
+export { createLocalPluginRuntime, createTestLayer, createTestPluginRuntime };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.mjs","names":[],"sources":["../../src/testing/mocks/module-federation.service.ts","../../src/testing/index.ts"],"sourcesContent":["import { Effect, Layer } from \"effect\";\nimport type { LoadedPluginWithBinding } from \"../../plugin\";\nimport { ModuleFederationError } from \"../../runtime/errors\";\nimport { ModuleFederationService } from \"../../runtime/services/module-federation.service\";\n\nexport type PluginMap = Record<string, LoadedPluginWithBinding<any, any, any, any>>;\n\nexport const createMockModuleFederationServiceLayer = (pluginMap: PluginMap) =>\n  Layer.succeed(\n    ModuleFederationService,\n    {\n      registerRemote: (pluginId: string, url: string) =>\n        Effect.gen(function* () {\n          console.log(`[MOCK] registerRemote called for ${pluginId}`);\n          if (!(pluginId in pluginMap)) {\n            return yield* Effect.fail(\n              new ModuleFederationError({\n                pluginId,\n                remoteUrl: url,\n                cause: new Error(`Mock: Plugin ${pluginId} not available in test plugin map`),\n              }),\n            );\n          }\n          console.log(`[MOCK] registerRemote succeeded for ${pluginId}`);\n        }),\n\n      loadRemoteConstructor: (pluginId: string, url: string) =>\n        Effect.gen(function* () {\n          console.log(`[MOCK] loadRemoteConstructor called for ${pluginId}`);\n          const PluginConstructor = pluginMap[pluginId];\n          if (!PluginConstructor) {\n            return yield* Effect.fail(\n              new ModuleFederationError({\n                pluginId,\n                remoteUrl: url,\n                cause: new Error(`Mock: Constructor for ${pluginId} not found in test plugin map`),\n              }),\n            );\n          }\n          console.log(`[MOCK] loadRemoteConstructor succeeded for ${pluginId}`);\n          return PluginConstructor;\n        }),\n    } as any\n  );\n","import { Layer, ManagedRuntime } from \"effect\";\nimport { PluginRuntime } from \"../runtime\";\nimport {\n\tPluginLifecycleService,\n\tPluginLoaderService,\n\tPluginRegistryTag,\n\tPluginService,\n\tRegistryService,\n\tSecretsConfigTag,\n\tSecretsService\n} from \"../runtime/services\";\nimport type { PluginRuntimeConfig, RegisteredPlugins } from \"../types\";\nimport { createMockModuleFederationServiceLayer, type PluginMap } from \"./mocks/module-federation.service\";\n\n/**\n * Validates that all plugin map keys exist in RegisteredPlugins.\n * This ensures proper type inference for client methods.\n */\ntype ValidatePluginMap<T extends PluginMap> = {\n\t[K in keyof T]: K extends keyof RegisteredPlugins\n\t\t? T[K]\n\t\t: `❌ Plugin key \"${K & string}\" not registered in RegisteredPlugins. Add it to your types.d.ts file.`;\n};\n\n/**\n * Simplified type inference for local plugin maps.\n * Just use the constructor types directly.\n *\n * @example\n * ```ts\n * const pluginMap = { \"my-plugin\": MyPlugin } as const;\n * type MyBindings = InferBindingsFromMap<typeof pluginMap>;\n * ```\n */\nexport type InferBindingsFromMap<T extends PluginMap> = {\n\t[K in keyof T]: T[K]\n} & RegisteredPlugins;\n\n/**\n * Creates a test layer with mock ModuleFederationService for unit testing.\n * This mirrors PluginService.Live() but uses mock ModuleFederationService.\n */\nexport const createTestLayer = <R extends RegisteredPlugins = RegisteredPlugins>(\n\tconfig: PluginRuntimeConfig<R>,\n\tpluginMap: PluginMap\n) => {\n\tconst secrets = config.secrets || {};\n\n\tconst contextLayer = Layer.mergeAll(\n\t\tLayer.succeed(PluginRegistryTag, config.registry),\n\t\tLayer.succeed(SecretsConfigTag, secrets),\n\t);\n\n\tconst mockModuleFederationLayer = createMockModuleFederationServiceLayer(pluginMap);\n\n\tconst servicesLayer = Layer.mergeAll(\n\t\tmockModuleFederationLayer,\n\t\tSecretsService.Default,\n\t\tRegistryService.Default,\n\t\tPluginLifecycleService.Default,\n\t).pipe(\n\t\tLayer.provide(contextLayer)\n\t);\n\n\treturn PluginService.Default.pipe(\n\t\tLayer.provide(PluginLoaderService.Default),\n\t\tLayer.provide(servicesLayer)\n\t);\n};\n\n/**\n * Creates a plugin runtime for locally available plugins (non-remote).\n * Automatically infers type bindings from the plugin map, eliminating\n * the need for manual RegistryBindings definitions.\n *\n * Ideal for:\n * - Unit and integration tests\n * - Local development and debugging\n * - Monorepo setups where all plugins are in the same workspace\n *\n * For production with remote Module Federation plugins, use createPluginRuntime().\n *\n * @example\n * ```ts\n * const pluginMap = { \"my-plugin\": MyPlugin } as const;\n * const runtime = createLocalPluginRuntime({ registry, secrets }, pluginMap);\n *\n * // Types are automatically inferred - no manual bindings needed!\n * const plugin = await runtime.usePlugin(\"my-plugin\", config);\n * ```\n */\nexport function createLocalPluginRuntime<TMap extends PluginMap & ValidatePluginMap<TMap>>(\n\tconfig: PluginRuntimeConfig,\n\tpluginMap: TMap\n): PluginRuntime<InferBindingsFromMap<TMap>> {\n\tconst layer = createTestLayer(config, pluginMap);\n\tconst runtime = ManagedRuntime.make(layer);\n\n\treturn new PluginRuntime<InferBindingsFromMap<TMap>>(runtime, config.registry);\n}\n\n/**\n * @deprecated Use `createLocalPluginRuntime` instead. This alias is kept for backward compatibility.\n */\nexport const createTestPluginRuntime = createLocalPluginRuntime;\n\n// Re-export useful types for tests\nexport type { EveryPlugin, PluginRegistry, RegisteredPlugins } from \"../types\";\nexport type { PluginMap, PluginRuntimeConfig };\n"],"mappings":";;;;;;AAOA,MAAa,0CAA0C,cACrD,MAAM,QACJ,yBACA;CACE,iBAAiB,UAAkB,QACjC,OAAO,IAAI,aAAa;AACtB,UAAQ,IAAI,oCAAoC,WAAW;AAC3D,MAAI,EAAE,YAAY,WAChB,QAAO,OAAO,OAAO,KACnB,IAAI,sBAAsB;GACxB;GACA,WAAW;GACX,uBAAO,IAAI,MAAM,gBAAgB,SAAS,mCAAmC;GAC9E,CAAC,CACH;AAEH,UAAQ,IAAI,uCAAuC,WAAW;GAC9D;CAEJ,wBAAwB,UAAkB,QACxC,OAAO,IAAI,aAAa;AACtB,UAAQ,IAAI,2CAA2C,WAAW;EAClE,MAAM,oBAAoB,UAAU;AACpC,MAAI,CAAC,kBACH,QAAO,OAAO,OAAO,KACnB,IAAI,sBAAsB;GACxB;GACA,WAAW;GACX,uBAAO,IAAI,MAAM,yBAAyB,SAAS,+BAA+B;GACnF,CAAC,CACH;AAEH,UAAQ,IAAI,8CAA8C,WAAW;AACrE,SAAO;GACP;CACL,CACF;;;;;;;;ACDH,MAAa,mBACZ,QACA,cACI;CACJ,MAAM,UAAU,OAAO,WAAW,EAAE;CAEpC,MAAM,eAAe,MAAM,SAC1B,MAAM,QAAQ,mBAAmB,OAAO,SAAS,EACjD,MAAM,QAAQ,kBAAkB,QAAQ,CACxC;CAED,MAAM,4BAA4B,uCAAuC,UAAU;CAEnF,MAAM,gBAAgB,MAAM,SAC3B,2BACA,eAAe,SACf,gBAAgB,SAChB,uBAAuB,QACvB,CAAC,KACD,MAAM,QAAQ,aAAa,CAC3B;AAED,QAAO,cAAc,QAAQ,KAC5B,MAAM,QAAQ,oBAAoB,QAAQ,EAC1C,MAAM,QAAQ,cAAc,CAC5B;;;;;;;;;;;;;;;;;;;;;;;AAwBF,SAAgB,yBACf,QACA,WAC4C;CAC5C,MAAM,QAAQ,gBAAgB,QAAQ,UAAU;AAGhD,QAAO,IAAI,cAFK,eAAe,KAAK,MAAM,EAEoB,OAAO,SAAS;;;;;AAM/E,MAAa,0BAA0B"}

package/dist/zod-A7Pti5IV.d.cts

@@ -0,0 +1,4 @@
+import * as import_zod from "zod";
+//#endregion
+export { import_zod as t };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiem9kLUE3UHRpNUlWLmQuY3RzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uL3NyYy96b2QudHMiXSwic291cmNlc0NvbnRlbnQiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/zod-BVo51kgJ.mjs

@@ -0,0 +1,10 @@
+import { n as __reExport } from "./chunk-QQAxy9l9.mjs";
+
+//#region src/zod.ts
+var zod_exports = {};
+import * as import_zod from "zod";
+__reExport(zod_exports, import_zod);
+
+//#endregion
+export { zod_exports as t };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiem9kLUJWbzUxa2dKLm1qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi9zcmMvem9kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCJ6b2RcIjtcbiJdLCJtYXBwaW5ncyI6IiJ9

package/dist/zod-D4CFw8d9.d.mts

@@ -0,0 +1,4 @@
+import * as import_zod from "zod";
+//#endregion
+export { import_zod as t };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiem9kLUQ0Q0Z3OGQ5LmQubXRzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uL3NyYy96b2QudHMiXSwic291cmNlc0NvbnRlbnQiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/zod-DYghWCz1.cjs

@@ -0,0 +1,14 @@
+const require_chunk = require('./chunk-zltIcp7o.cjs');
+
+//#region src/zod.ts
+var zod_exports = {};
+require_chunk.__reExport(zod_exports, require("zod"));
+
+//#endregion
+Object.defineProperty(exports, 'zod_exports', {
+  enumerable: true,
+  get: function () {
+    return zod_exports;
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiem9kLURZZ2hXQ3oxLmNqcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi9zcmMvem9kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCJ6b2RcIjtcbiJdLCJtYXBwaW5ncyI6IiJ9

package/dist/zod.cjs

@@ -0,0 +1,10 @@
+const require_zod = require('./zod-DYghWCz1.cjs');
+
+
+var zod = require("zod");
+Object.keys(zod).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return zod[k]; }
+  });
+});

package/dist/zod.d.cts

@@ -0,0 +1,2 @@
+import "./zod-A7Pti5IV.cjs";
+export * from "zod";

package/dist/zod.d.mts

@@ -0,0 +1,2 @@
+import "./zod-D4CFw8d9.mjs";
+export * from "zod";

package/dist/zod.mjs

@@ -0,0 +1,5 @@
+import "./zod-BVo51kgJ.mjs";
+
+export * from "zod"
+
+export {  };