every-plugin 0.4.17 → 0.5.1

package/dist/testing/index.mjs

@@ -1,75 +1,55 @@
-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-BYDchBFq.mjs";
-import "../normalize-D7nae0Hn.mjs";
-import "../package-B0vvsKXO.mjs";
-import { Effect, Layer, ManagedRuntime } from "effect";
+import { createPluginRuntime } from "../runtime/index.mjs";
 
-//#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.
+* Converts old pluginMap format to new registry format
 */
-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));
-};
+function convertPluginMapToRegistry(oldRegistry, pluginMap) {
+	const registry = {};
+	for (const [pluginId, ctor] of Object.entries(pluginMap)) {
+		const oldEntry = oldRegistry[pluginId];
+		registry[pluginId] = {
+			module: ctor,
+			remote: oldEntry?.remoteUrl,
+			version: oldEntry?.version,
+			description: oldEntry?.description
+		};
+	}
+	return registry;
+}
 /**
 * 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().
-*
+* @deprecated Use `createPluginRuntime` with module entries directly instead.
 * @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);
+* // Old API (deprecated)
+* const runtime = createLocalPluginRuntime(
+*   { registry: { "my-plugin": { remoteUrl: "..." } }, secrets },
+*   { "my-plugin": MyPlugin }
+* );
+* 
+* // New API (recommended)
+* const runtime = createPluginRuntime({
+*   registry: { "my-plugin": { module: MyPlugin } },
+*   secrets
+* });
 * ```
 */
 function createLocalPluginRuntime(config, pluginMap) {
-	const layer = createTestLayer(config, pluginMap);
-	return new PluginRuntime(ManagedRuntime.make(layer), config.registry);
+	return createPluginRuntime({
+		registry: convertPluginMapToRegistry(config.registry, pluginMap),
+		secrets: config.secrets,
+		options: config.options
+	});
 }
 /**
-* @deprecated Use `createLocalPluginRuntime` instead. This alias is kept for backward compatibility.
+* @deprecated Use `createLocalPluginRuntime` or `createPluginRuntime` instead.
 */
 const createTestPluginRuntime = createLocalPluginRuntime;
 
 //#endregion
-export { createLocalPluginRuntime, createTestLayer, createTestPluginRuntime };
+export { createLocalPluginRuntime, createTestPluginRuntime };
 //# sourceMappingURL=index.mjs.map

package/dist/testing/index.mjs.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"index.mjs","names":["registry: Record<string, PluginRegistryEntry>"],"sources":["../../src/testing/index.ts"],"sourcesContent":["import type { AnyPluginConstructor, InferRegistryFromEntries, PluginRegistryEntry, PluginRuntimeConfig } from \"../types\";\nimport { createPluginRuntime } from \"../runtime\";\nimport type { LoadedPluginWithBinding } from \"../plugin\";\n\nexport type PluginMap = Record<string, LoadedPluginWithBinding<any, any, any, any>>;\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};\n\n/**\n * Converts old pluginMap format to new registry format\n */\nfunction convertPluginMapToRegistry<T extends PluginMap>(\n\toldRegistry: Record<string, { remoteUrl: string; version?: string; description?: string }>,\n\tpluginMap: T\n): Record<keyof T, PluginRegistryEntry> {\n\tconst registry: Record<string, PluginRegistryEntry> = {};\n\t\n\tfor (const [pluginId, ctor] of Object.entries(pluginMap)) {\n\t\tconst oldEntry = oldRegistry[pluginId];\n\t\tregistry[pluginId] = {\n\t\t\tmodule: ctor as AnyPluginConstructor,\n\t\t\tremote: oldEntry?.remoteUrl,\n\t\t\tversion: oldEntry?.version,\n\t\t\tdescription: oldEntry?.description,\n\t\t};\n\t}\n\t\n\treturn registry as Record<keyof T, PluginRegistryEntry>;\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 * @deprecated Use `createPluginRuntime` with module entries directly instead.\n * @example\n * ```ts\n * // Old API (deprecated)\n * const runtime = createLocalPluginRuntime(\n *   { registry: { \"my-plugin\": { remoteUrl: \"...\" } }, secrets },\n *   { \"my-plugin\": MyPlugin }\n * );\n * \n * // New API (recommended)\n * const runtime = createPluginRuntime({\n *   registry: { \"my-plugin\": { module: MyPlugin } },\n *   secrets\n * });\n * ```\n */\nexport function createLocalPluginRuntime<TMap extends PluginMap>(\n\tconfig: {\n\t\tregistry: Record<string, { remoteUrl: string; version?: string; description?: string }>;\n\t\tsecrets?: Record<string, string>;\n\t\toptions?: any;\n\t},\n\tpluginMap: TMap\n) {\n\tconst newRegistry = convertPluginMapToRegistry(config.registry, pluginMap);\n\t\n\treturn createPluginRuntime({\n\t\tregistry: newRegistry,\n\t\tsecrets: config.secrets,\n\t\toptions: config.options,\n\t});\n}\n\n/**\n * @deprecated Use `createLocalPluginRuntime` or `createPluginRuntime` instead.\n */\nexport const createTestPluginRuntime = createLocalPluginRuntime;\n\nexport type { EveryPlugin, PluginRegistry, RegisteredPlugins } from \"../types\";\nexport type { PluginRuntimeConfig };\n"],"mappings":";;;;;;AAuBA,SAAS,2BACR,aACA,WACuC;CACvC,MAAMA,WAAgD,EAAE;AAExD,MAAK,MAAM,CAAC,UAAU,SAAS,OAAO,QAAQ,UAAU,EAAE;EACzD,MAAM,WAAW,YAAY;AAC7B,WAAS,YAAY;GACpB,QAAQ;GACR,QAAQ,UAAU;GAClB,SAAS,UAAU;GACnB,aAAa,UAAU;GACvB;;AAGF,QAAO;;;;;;;;;;;;;;;;;;;;;;;AAwBR,SAAgB,yBACf,QAKA,WACC;AAGD,QAAO,oBAAoB;EAC1B,UAHmB,2BAA2B,OAAO,UAAU,UAAU;EAIzE,SAAS,OAAO;EAChB,SAAS,OAAO;EAChB,CAAC;;;;;AAMH,MAAa,0BAA0B"}

package/dist/types.d.cts

@@ -0,0 +1,261 @@
+import { Plugin } from "./plugin.cjs";
+import { Scope } from "effect";
+import { AnyContractRouter, AnySchema, InferSchemaInput, InferSchemaOutput } from "@orpc/contract";
+import { Context as Context$1, Router, RouterClient } from "@orpc/server";
+
+//#region src/types.d.ts
+
+/**
+ * Registry bindings interface - populated via module augmentation
+ * Only needed for remote-only plugin entries.
+ * @example
+ * ```typescript
+ * declare module "every-plugin" {
+ *   interface RegisteredPlugins {
+ *     "my-plugin": typeof MyPlugin;
+ *   }
+ * }
+ * ```
+ */
+interface RegisteredPlugins {}
+/**
+ * Base type for any plugin instance.
+ */
+type AnyPlugin = Plugin<AnyContractRouter, AnySchema, AnySchema, any>;
+/**
+ * Loaded plugin constructor with binding information
+ */
+type AnyPluginConstructor = {
+  new (): AnyPlugin;
+  binding: {
+    contract: AnyContractRouter;
+    variables: AnySchema;
+    secrets: AnySchema;
+    context: Context$1;
+  };
+};
+/**
+ * Registry entry that supports both direct module imports and remote URLs
+ */
+type PluginRegistryEntry = {
+  module: AnyPluginConstructor;
+  remote?: string;
+  version?: string;
+  description?: string;
+} | {
+  remote: string;
+  version?: string;
+  description?: string;
+};
+/**
+ * Extract plugin constructor type from registry entry
+ */
+type ExtractPluginType<E> = E extends {
+  module: infer M;
+} ? M : never;
+/**
+ * Infer registry types from plugin entries with module constructors
+ */
+type InferRegistryFromEntries<R$1 extends Record<string, PluginRegistryEntry>> = { [K in keyof R$1]: R$1[K] extends {
+  module: infer M;
+} ? M : K extends keyof RegisteredPlugins ? RegisteredPlugins[K] : never };
+/**
+* Extract contract type from plugin binding
+*/
+type PluginContract<T> = T extends {
+  binding: {
+    contract: infer C extends AnyContractRouter;
+  };
+} ? C : never;
+/**
+ * Extract variables type from plugin binding
+ */
+type PluginVariables<T> = T extends {
+  binding: {
+    variables: infer V extends AnySchema;
+  };
+} ? V : never;
+/**
+ * Extract secrets type from plugin binding
+ */
+type PluginSecrets<T> = T extends {
+  binding: {
+    secrets: infer S extends AnySchema;
+  };
+} ? S : never;
+/**
+ * Extract context type from plugin binding
+ */
+type PluginContext<T> = T extends {
+  binding: {
+    context: infer C extends Context$1;
+  };
+} ? C : never;
+/**
+ * Extract router type from plugin binding
+ * Uses 'any' for context to support nested router compositions
+ */
+type PluginRouterType<T> = Router<PluginContract<T>, any>;
+/**
+ * Extract client type from plugin binding
+ */
+type PluginClientType<T> = RouterClient<PluginRouterType<T>>;
+/**
+ * Extract plugin type from registered plugins by key
+ * @param K - The plugin key
+ * @param R - The registry type (defaults to RegisteredPlugins for module augmentation pattern)
+ */
+type RegisteredPlugin<K$1 extends keyof R$1, R$1 = RegisteredPlugins> = R$1[K$1] extends {
+  binding: infer B;
+} ? B extends {
+  contract: infer C extends AnyContractRouter;
+  variables: infer V extends AnySchema;
+  secrets: infer S extends AnySchema;
+  context: infer TContext extends Context$1;
+} ? Plugin<C, V, S, TContext> : never : never;
+/**
+ * Extract config input type from plugin binding
+ */
+type PluginConfigInput<T> = {
+  variables: InferSchemaInput<PluginVariables<T>>;
+  secrets: InferSchemaInput<PluginSecrets<T>>;
+};
+/**
+ * Extract context type from plugin instance
+ */
+type ContextOf<T extends AnyPlugin> = T extends Plugin<AnyContractRouter, AnySchema, AnySchema, infer TContext> ? TContext : never;
+/**
+ * Plugin metadata for remote loading
+ */
+type PluginMetadata = {
+  readonly remoteUrl: string;
+  readonly version?: string;
+  readonly description?: string;
+};
+/**
+ * Runtime registry configuration supporting both module and remote entries
+ */
+type PluginRegistry = Record<string, PluginRegistryEntry>;
+/**
+ * Legacy metadata-only registry (for backwards compatibility)
+ */
+type PluginMetadataRegistry = Record<string, PluginMetadata>;
+/**
+ * Configuration for secrets injection.
+ * Secrets are hydrated into plugin configs using template replacement.
+ */
+interface SecretsConfig {
+  [key: string]: string;
+}
+/**
+ * Loaded plugin
+ */
+interface LoadedPlugin<T extends AnyPlugin = AnyPlugin> {
+  readonly ctor: new () => T;
+  readonly metadata: PluginMetadata;
+}
+/**
+ * Instantiated plugin
+ */
+interface PluginInstance<T extends AnyPlugin = AnyPlugin> {
+  readonly plugin: T;
+  readonly metadata: PluginMetadata;
+}
+/**
+ * Fully initialized plugin ready for use
+ */
+interface InitializedPlugin<T extends AnyPlugin = AnyPlugin> {
+  readonly plugin: T;
+  readonly metadata: PluginMetadata;
+  readonly config: {
+    variables: InferSchemaOutput<T["configSchema"]["variables"]>;
+    secrets: InferSchemaOutput<T["configSchema"]["secrets"]>;
+  };
+  readonly context: ContextOf<T>;
+  readonly scope: Scope.CloseableScope;
+}
+/**
+ * Helper type to detect type errors when looking up RegisteredPlugins
+ */
+type VerifyPluginBinding<K$1 extends keyof R$1, R$1 = RegisteredPlugins> = R$1[K$1] extends {
+  binding: infer B;
+} ? B extends {
+  contract: AnyContractRouter;
+  variables: AnySchema;
+  secrets: AnySchema;
+  context: Context$1;
+} ? true : `❌ Plugin "${K$1 & string}" is not properly registered. Ensure it extends plugin binding layout { contract, variables, secrets, context }.` : `❌ Plugin "${K$1 & string}" is not properly registered. Missing binding property.`;
+/**
+* Result of runtime.usePlugin() call
+* @param K - The plugin key
+* @param R - The registry type (defaults to RegisteredPlugins for module augmentation pattern)
+*/
+type UsePluginResult<K$1 extends keyof R$1, R$1 = RegisteredPlugins> = VerifyPluginBinding<K$1, R$1> extends true ? {
+  readonly client: PluginClientType<R$1[K$1]>;
+  readonly router: PluginRouterType<R$1[K$1]>;
+  readonly metadata: PluginMetadata;
+  readonly initialized: InitializedPlugin<RegisteredPlugin<K$1, R$1>>;
+} : VerifyPluginBinding<K$1, R$1>;
+/**
+ * Runtime options
+ */
+interface RuntimeOptions {
+  isolation?: "strict" | "shared" | "none";
+  memoryLimit?: string;
+  concurrency?: number;
+  resourceTimeout?: string;
+  debug?: boolean;
+  metrics?: boolean;
+}
+/**
+ * Extract registry type from runtime instance or use type directly
+ * This allows EveryPlugin.Infer to work with both:
+ * - typeof runtime (extracts registry from PluginRuntime<R> via __registryType)
+ * - Registry types directly
+ */
+type RegistryOf<T> = T extends {
+  __registryType?: infer R;
+} ? R : T;
+/**
+ * Namespace containing type utilities for working with plugin results.
+ */
+declare namespace EveryPlugin {
+  /**
+   * Extract plugin runtime instance type from registered plugins or runtime.
+   * Provides full type safety for plugin clients, routers, and metadata.
+   *
+   * @example
+   * ```ts
+   * // From RegisteredPlugins (module augmentation)
+   * type Plugin = EveryPlugin.Infer<"my-plugin">;
+   *
+   * // From runtime instance (when using module entries)
+   * const runtime = createPluginRuntime({ registry: { "my-plugin": { module: MyPlugin } } });
+   * type Plugin = EveryPlugin.Infer<"my-plugin", typeof runtime>;
+   *
+   * // From explicit registry type
+   * type Plugin = EveryPlugin.Infer<"my-plugin", MyRegistryType>;
+   * ```
+   */
+  type Infer<K$1 extends string, Source = RegisteredPlugins> = K$1 extends keyof RegistryOf<Source> ? UsePluginResult<K$1, RegistryOf<Source>> : never;
+}
+/**
+ * Plugin runtime configuration with support for both module and remote entries
+ */
+interface PluginRuntimeConfig<R$1 extends Record<string, PluginRegistryEntry> = Record<string, PluginRegistryEntry>> {
+  registry: R$1;
+  secrets?: SecretsConfig;
+  options?: RuntimeOptions;
+}
+/**
+ * Legacy plugin runtime configuration (metadata-only registry)
+ * @deprecated Use PluginRuntimeConfig with module/remote entries instead
+ */
+interface LegacyPluginRuntimeConfig {
+  registry: PluginMetadataRegistry;
+  secrets?: SecretsConfig;
+  options?: RuntimeOptions;
+}
+//#endregion
+export { AnyPlugin, AnyPluginConstructor, ContextOf, EveryPlugin, ExtractPluginType, InferRegistryFromEntries, InitializedPlugin, LegacyPluginRuntimeConfig, LoadedPlugin, PluginClientType, PluginConfigInput, PluginContext, PluginContract, PluginInstance, PluginMetadata, PluginMetadataRegistry, PluginRegistry, PluginRegistryEntry, PluginRouterType, PluginRuntimeConfig, PluginSecrets, PluginVariables, RegisteredPlugin, RegisteredPlugins, RuntimeOptions, SecretsConfig, UsePluginResult };
+//# sourceMappingURL=types.d.cts.map

package/dist/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/types.d.mts

@@ -0,0 +1,261 @@
+import { Plugin } from "./plugin.mjs";
+import { Scope } from "effect";
+import { Context as Context$1, Router, RouterClient } from "@orpc/server";
+import { AnyContractRouter, AnySchema, InferSchemaInput, InferSchemaOutput } from "@orpc/contract";
+
+//#region src/types.d.ts
+
+/**
+ * Registry bindings interface - populated via module augmentation
+ * Only needed for remote-only plugin entries.
+ * @example
+ * ```typescript
+ * declare module "every-plugin" {
+ *   interface RegisteredPlugins {
+ *     "my-plugin": typeof MyPlugin;
+ *   }
+ * }
+ * ```
+ */
+interface RegisteredPlugins {}
+/**
+ * Base type for any plugin instance.
+ */
+type AnyPlugin = Plugin<AnyContractRouter, AnySchema, AnySchema, any>;
+/**
+ * Loaded plugin constructor with binding information
+ */
+type AnyPluginConstructor = {
+  new (): AnyPlugin;
+  binding: {
+    contract: AnyContractRouter;
+    variables: AnySchema;
+    secrets: AnySchema;
+    context: Context$1;
+  };
+};
+/**
+ * Registry entry that supports both direct module imports and remote URLs
+ */
+type PluginRegistryEntry = {
+  module: AnyPluginConstructor;
+  remote?: string;
+  version?: string;
+  description?: string;
+} | {
+  remote: string;
+  version?: string;
+  description?: string;
+};
+/**
+ * Extract plugin constructor type from registry entry
+ */
+type ExtractPluginType<E> = E extends {
+  module: infer M;
+} ? M : never;
+/**
+ * Infer registry types from plugin entries with module constructors
+ */
+type InferRegistryFromEntries<R$1 extends Record<string, PluginRegistryEntry>> = { [K in keyof R$1]: R$1[K] extends {
+  module: infer M;
+} ? M : K extends keyof RegisteredPlugins ? RegisteredPlugins[K] : never };
+/**
+* Extract contract type from plugin binding
+*/
+type PluginContract<T> = T extends {
+  binding: {
+    contract: infer C extends AnyContractRouter;
+  };
+} ? C : never;
+/**
+ * Extract variables type from plugin binding
+ */
+type PluginVariables<T> = T extends {
+  binding: {
+    variables: infer V extends AnySchema;
+  };
+} ? V : never;
+/**
+ * Extract secrets type from plugin binding
+ */
+type PluginSecrets<T> = T extends {
+  binding: {
+    secrets: infer S extends AnySchema;
+  };
+} ? S : never;
+/**
+ * Extract context type from plugin binding
+ */
+type PluginContext<T> = T extends {
+  binding: {
+    context: infer C extends Context$1;
+  };
+} ? C : never;
+/**
+ * Extract router type from plugin binding
+ * Uses 'any' for context to support nested router compositions
+ */
+type PluginRouterType<T> = Router<PluginContract<T>, any>;
+/**
+ * Extract client type from plugin binding
+ */
+type PluginClientType<T> = RouterClient<PluginRouterType<T>>;
+/**
+ * Extract plugin type from registered plugins by key
+ * @param K - The plugin key
+ * @param R - The registry type (defaults to RegisteredPlugins for module augmentation pattern)
+ */
+type RegisteredPlugin<K$1 extends keyof R$1, R$1 = RegisteredPlugins> = R$1[K$1] extends {
+  binding: infer B;
+} ? B extends {
+  contract: infer C extends AnyContractRouter;
+  variables: infer V extends AnySchema;
+  secrets: infer S extends AnySchema;
+  context: infer TContext extends Context$1;
+} ? Plugin<C, V, S, TContext> : never : never;
+/**
+ * Extract config input type from plugin binding
+ */
+type PluginConfigInput<T> = {
+  variables: InferSchemaInput<PluginVariables<T>>;
+  secrets: InferSchemaInput<PluginSecrets<T>>;
+};
+/**
+ * Extract context type from plugin instance
+ */
+type ContextOf<T extends AnyPlugin> = T extends Plugin<AnyContractRouter, AnySchema, AnySchema, infer TContext> ? TContext : never;
+/**
+ * Plugin metadata for remote loading
+ */
+type PluginMetadata = {
+  readonly remoteUrl: string;
+  readonly version?: string;
+  readonly description?: string;
+};
+/**
+ * Runtime registry configuration supporting both module and remote entries
+ */
+type PluginRegistry = Record<string, PluginRegistryEntry>;
+/**
+ * Legacy metadata-only registry (for backwards compatibility)
+ */
+type PluginMetadataRegistry = Record<string, PluginMetadata>;
+/**
+ * Configuration for secrets injection.
+ * Secrets are hydrated into plugin configs using template replacement.
+ */
+interface SecretsConfig {
+  [key: string]: string;
+}
+/**
+ * Loaded plugin
+ */
+interface LoadedPlugin<T extends AnyPlugin = AnyPlugin> {
+  readonly ctor: new () => T;
+  readonly metadata: PluginMetadata;
+}
+/**
+ * Instantiated plugin
+ */
+interface PluginInstance<T extends AnyPlugin = AnyPlugin> {
+  readonly plugin: T;
+  readonly metadata: PluginMetadata;
+}
+/**
+ * Fully initialized plugin ready for use
+ */
+interface InitializedPlugin<T extends AnyPlugin = AnyPlugin> {
+  readonly plugin: T;
+  readonly metadata: PluginMetadata;
+  readonly config: {
+    variables: InferSchemaOutput<T["configSchema"]["variables"]>;
+    secrets: InferSchemaOutput<T["configSchema"]["secrets"]>;
+  };
+  readonly context: ContextOf<T>;
+  readonly scope: Scope.CloseableScope;
+}
+/**
+ * Helper type to detect type errors when looking up RegisteredPlugins
+ */
+type VerifyPluginBinding<K$1 extends keyof R$1, R$1 = RegisteredPlugins> = R$1[K$1] extends {
+  binding: infer B;
+} ? B extends {
+  contract: AnyContractRouter;
+  variables: AnySchema;
+  secrets: AnySchema;
+  context: Context$1;
+} ? true : `❌ Plugin "${K$1 & string}" is not properly registered. Ensure it extends plugin binding layout { contract, variables, secrets, context }.` : `❌ Plugin "${K$1 & string}" is not properly registered. Missing binding property.`;
+/**
+* Result of runtime.usePlugin() call
+* @param K - The plugin key
+* @param R - The registry type (defaults to RegisteredPlugins for module augmentation pattern)
+*/
+type UsePluginResult<K$1 extends keyof R$1, R$1 = RegisteredPlugins> = VerifyPluginBinding<K$1, R$1> extends true ? {
+  readonly client: PluginClientType<R$1[K$1]>;
+  readonly router: PluginRouterType<R$1[K$1]>;
+  readonly metadata: PluginMetadata;
+  readonly initialized: InitializedPlugin<RegisteredPlugin<K$1, R$1>>;
+} : VerifyPluginBinding<K$1, R$1>;
+/**
+ * Runtime options
+ */
+interface RuntimeOptions {
+  isolation?: "strict" | "shared" | "none";
+  memoryLimit?: string;
+  concurrency?: number;
+  resourceTimeout?: string;
+  debug?: boolean;
+  metrics?: boolean;
+}
+/**
+ * Extract registry type from runtime instance or use type directly
+ * This allows EveryPlugin.Infer to work with both:
+ * - typeof runtime (extracts registry from PluginRuntime<R> via __registryType)
+ * - Registry types directly
+ */
+type RegistryOf<T> = T extends {
+  __registryType?: infer R;
+} ? R : T;
+/**
+ * Namespace containing type utilities for working with plugin results.
+ */
+declare namespace EveryPlugin {
+  /**
+   * Extract plugin runtime instance type from registered plugins or runtime.
+   * Provides full type safety for plugin clients, routers, and metadata.
+   *
+   * @example
+   * ```ts
+   * // From RegisteredPlugins (module augmentation)
+   * type Plugin = EveryPlugin.Infer<"my-plugin">;
+   *
+   * // From runtime instance (when using module entries)
+   * const runtime = createPluginRuntime({ registry: { "my-plugin": { module: MyPlugin } } });
+   * type Plugin = EveryPlugin.Infer<"my-plugin", typeof runtime>;
+   *
+   * // From explicit registry type
+   * type Plugin = EveryPlugin.Infer<"my-plugin", MyRegistryType>;
+   * ```
+   */
+  type Infer<K$1 extends string, Source = RegisteredPlugins> = K$1 extends keyof RegistryOf<Source> ? UsePluginResult<K$1, RegistryOf<Source>> : never;
+}
+/**
+ * Plugin runtime configuration with support for both module and remote entries
+ */
+interface PluginRuntimeConfig<R$1 extends Record<string, PluginRegistryEntry> = Record<string, PluginRegistryEntry>> {
+  registry: R$1;
+  secrets?: SecretsConfig;
+  options?: RuntimeOptions;
+}
+/**
+ * Legacy plugin runtime configuration (metadata-only registry)
+ * @deprecated Use PluginRuntimeConfig with module/remote entries instead
+ */
+interface LegacyPluginRuntimeConfig {
+  registry: PluginMetadataRegistry;
+  secrets?: SecretsConfig;
+  options?: RuntimeOptions;
+}
+//#endregion
+export { AnyPlugin, AnyPluginConstructor, ContextOf, EveryPlugin, ExtractPluginType, InferRegistryFromEntries, InitializedPlugin, LegacyPluginRuntimeConfig, LoadedPlugin, PluginClientType, PluginConfigInput, PluginContext, PluginContract, PluginInstance, PluginMetadata, PluginMetadataRegistry, PluginRegistry, PluginRegistryEntry, PluginRouterType, PluginRuntimeConfig, PluginSecrets, PluginVariables, RegisteredPlugin, RegisteredPlugins, RuntimeOptions, SecretsConfig, UsePluginResult };
+//# sourceMappingURL=types.d.mts.map