every-plugin 0.1.0 → 0.1.1

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

@@ -2,36 +2,16 @@ import { Effect, Layer } from "effect";
 import { PluginRuntimeError } from "../errors";
 import type { SecretsConfig } from "../types";
 export interface ISecretsService {
-	readonly hydrateSecrets: (
-		config: any, // TODO:
-		secretsConfig: SecretsConfig,
-	) => Effect.Effect<any, PluginRuntimeError>;
+    readonly hydrateSecrets: (config: any, // TODO:
+    secretsConfig: SecretsConfig) => Effect.Effect<any, PluginRuntimeError>;
 }
-declare const SecretsService_base: import("effect/Context").TagClass<
-	SecretsService,
-	"SecretsService",
-	ISecretsService
-> &
-	Effect.Tag.Proxy<SecretsService, ISecretsService> & {
-		use: <X>(
-			body: (_: ISecretsService) => X,
-		) => [X] extends [Effect.Effect<infer A, infer E, infer R>]
-			? Effect.Effect<A, E, R | SecretsService>
-			: [X] extends [PromiseLike<infer A_1>]
-				? Effect.Effect<
-						A_1,
-						import("effect/Cause").UnknownException,
-						SecretsService
-					>
-				: Effect.Effect<X, never, SecretsService>;
-	};
+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>;
+};
 export declare class SecretsService extends SecretsService_base {
-	static Live: (
-		secrets: SecretsConfig,
-	) => Layer.Layer<SecretsService, never, never>;
+    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>;
-//# sourceMappingURL=secrets.service.d.ts.map
+export declare const SecretsServiceLive: (secrets: SecretsConfig) => Layer.Layer<SecretsService, never, never>;
+export {};
+//# sourceMappingURL=secrets.service.d.ts.map

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

@@ -1,36 +1,32 @@
 import { Effect, Layer } from "effect";
 import { PluginRuntimeError } from "../errors";
 export class SecretsService extends Effect.Tag("SecretsService")() {
-	static Live = (secrets) =>
-		Layer.succeed(SecretsService, {
-			hydrateSecrets: (config, secretsConfig) =>
-				Effect.gen(function* () {
-					if (!config || typeof config !== "object" || !config.secrets) {
-						return config;
-					}
-					try {
-						const configString = JSON.stringify(config);
-						let hydratedString = configString;
-						// Use provided secrets or fallback to secretsConfig
-						const effectiveSecrets = { ...secretsConfig, ...secrets };
-						// Simple template replacement for {{SECRET_NAME}} patterns
-						for (const [key, value] of Object.entries(effectiveSecrets)) {
-							const pattern = new RegExp(`{{${key}}}`, "g");
-							hydratedString = hydratedString.replace(pattern, value);
-						}
-						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,
-							}),
-						);
-					}
-				}),
-		});
+    static Live = (secrets) => Layer.succeed(SecretsService, {
+        hydrateSecrets: (config, secretsConfig) => Effect.gen(function* () {
+            if (!config || typeof config !== "object" || !config.secrets) {
+                return config;
+            }
+            try {
+                const configString = JSON.stringify(config);
+                let hydratedString = configString;
+                // Use provided secrets or fallback to secretsConfig
+                const effectiveSecrets = { ...secretsConfig, ...secrets };
+                // Simple template replacement for {{SECRET_NAME}} patterns
+                for (const [key, value] of Object.entries(effectiveSecrets)) {
+                    const pattern = new RegExp(`{{${key}}}`, "g");
+                    hydratedString = hydratedString.replace(pattern, value);
+                }
+                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,4 @@
 export * from "./services/module-federation.service";
 export * from "./services/plugin.service";
 export * from "./services/secrets.service";
-//# sourceMappingURL=services.d.ts.map
+//# sourceMappingURL=services.d.ts.map

package/dist/runtime/streaming/index.d.ts

@@ -0,0 +1,4 @@
+export { pipe, StateTransitions } from './state-effects';
+export { createSourceStream } from './streaming';
+export type { StreamingOptions, StreamState } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/streaming/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/streaming/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}

package/dist/runtime/streaming/index.js

@@ -0,0 +1,2 @@
+export { pipe, StateTransitions } from './state-effects';
+export { createSourceStream } from './streaming';

package/dist/runtime/streaming/state-effects.d.ts

@@ -0,0 +1,28 @@
+/**
+ * State transition helpers for common patterns
+ */
+export declare const StateTransitions: {
+    /**
+     * Transition to a new phase with optional updates
+     */
+    to: <T extends {
+        phase?: string;
+    }>(phase: string, updates?: Partial<T>) => (state: T) => T;
+    /**
+     * Add polling delay to state
+     */
+    withPolling: <T>(delayMs: number) => (state: T) => T;
+    /**
+     * Set error state with message and stop polling
+     */
+    withError: <T>(errorMessage: string) => (state: T) => T;
+    /**
+     * Preserve existing state with updates
+     */
+    update: <T>(updates: Partial<T>) => (state: T) => T;
+};
+/**
+ * Simple pipe utility for composing state transformations
+ */
+export declare const pipe: <T>(value: T, ...fns: Array<(val: T) => T>) => T;
+//# sourceMappingURL=state-effects.d.ts.map

package/dist/runtime/streaming/state-effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-effects.d.ts","sourceRoot":"","sources":["../../../src/runtime/streaming/state-effects.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;SACE,CAAC,SAAS;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,SAAS,MAAM,YAAW,OAAO,CAAC,CAAC,CAAC,MAClE,OAAO,CAAC,KAAG,CAAC;IAEf;;OAEG;kBACW,CAAC,WAAW,MAAM,MAC7B,OAAO,CAAC,KAAG,CAAC;IAEf;;OAEG;gBACS,CAAC,gBAAgB,MAAM,MAChC,OAAO,CAAC,KAAG,CAAC;IAOf;;OAEG;aACM,CAAC,WAAW,OAAO,CAAC,CAAC,CAAC,MAC5B,OAAO,CAAC,KAAG,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,KAAG,CACxB,CAAC"}

package/dist/runtime/streaming/state-effects.js

@@ -0,0 +1,30 @@
+/**
+ * State transition helpers for common patterns
+ */
+export const StateTransitions = {
+    /**
+     * Transition to a new phase with optional updates
+     */
+    to: (phase, updates = {}) => (state) => ({ ...state, phase, ...updates }),
+    /**
+     * Add polling delay to state
+     */
+    withPolling: (delayMs) => (state) => ({ ...state, nextPollMs: delayMs }),
+    /**
+     * Set error state with message and stop polling
+     */
+    withError: (errorMessage) => (state) => ({
+        ...state,
+        phase: 'error',
+        errorMessage,
+        nextPollMs: null
+    }),
+    /**
+     * Preserve existing state with updates
+     */
+    update: (updates) => (state) => ({ ...state, ...updates }),
+};
+/**
+ * Simple pipe utility for composing state transformations
+ */
+export const pipe = (value, ...fns) => fns.reduce((acc, fn) => fn(acc), value);

package/dist/runtime/streaming/streaming.d.ts

@@ -0,0 +1,8 @@
+import { Effect, Stream } from "effect";
+import type { z } from "zod";
+import type { Plugin } from "../../plugin";
+import type { PluginRuntimeError } from "../errors";
+import type { InitializedPlugin } from "../types";
+import type { StreamingOptions } from "./types";
+export declare const createSourceStream: <T extends Plugin, TInput extends z.infer<T["inputSchema"]>, TItem, TPluginState extends z.infer<T["stateSchema"]>>(initializedPlugin: InitializedPlugin<T>, executePlugin: (plugin: InitializedPlugin<T>, input: TInput) => Effect.Effect<any, PluginRuntimeError>, input: TInput, options?: StreamingOptions<TItem, TPluginState>) => Stream.Stream<TItem, PluginRuntimeError>;
+//# sourceMappingURL=streaming.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["../../../src/runtime/streaming/streaming.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,MAAM,EAAyB,MAAM,EAAE,MAAM,QAAQ,CAAC;AACzE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAe,MAAM,SAAS,CAAC;AA8B7D,eAAO,MAAM,kBAAkB,GAC7B,CAAC,SAAS,MAAM,EAChB,MAAM,SAAS,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,EACxC,KAAK,EACL,YAAY,SAAS,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,EAE9C,mBAAmB,iBAAiB,CAAC,CAAC,CAAC,EACvC,eAAe,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,kBAAkB,CAAC,EACtG,OAAO,MAAM,EACb,UAAS,gBAAgB,CAAC,KAAK,EAAE,YAAY,CAAM,KAClD,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,kBAAkB,CAyGzC,CAAC"}

package/dist/runtime/streaming/streaming.js

@@ -0,0 +1,107 @@
+import { Duration, Effect, Stream } from "effect";
+/**
+ * Extract delay from plugin state (nextPollMs field)
+ * Returns null if nextPollMs is null (signals termination) or undefined (no delay specified)
+ */
+const extractDelayFromState = (state) => {
+    const stateWithPolling = state;
+    if (stateWithPolling?.nextPollMs === null) {
+        return null; // Explicit termination signal
+    }
+    return stateWithPolling?.nextPollMs ? Duration.millis(stateWithPolling.nextPollMs) : null;
+};
+/**
+ * Check if plugin state signals stream termination
+ */
+const isTerminalState = (state) => {
+    const stateWithPolling = state;
+    return stateWithPolling?.nextPollMs === null;
+};
+export const createSourceStream = (initializedPlugin, executePlugin, input, options = {}) => {
+    // Create initial stream state with plugin's initial state
+    const initialStreamState = {
+        invocations: 0,
+        pluginState: input.state,
+        lastItemCount: 0,
+    };
+    // Use Stream.async for full control over emission timing and delays
+    return Stream.async((emit) => {
+        let currentStreamState = initialStreamState;
+        let totalItemsEmitted = 0;
+        const loop = async () => {
+            try {
+                while (true) {
+                    console.log(`[STREAMING] Starting iteration ${currentStreamState.invocations + 1}`);
+                    // Check invocation limit BEFORE executing
+                    if (options.maxInvocations && currentStreamState.invocations >= options.maxInvocations) {
+                        console.log(`[STREAMING] Reached maxInvocations limit: ${options.maxInvocations}`);
+                        break;
+                    }
+                    // Check maxItems limit BEFORE executing
+                    if (options.maxItems && totalItemsEmitted >= options.maxItems) {
+                        console.log(`[STREAMING] Reached maxItems limit: ${options.maxItems}`);
+                        break;
+                    }
+                    // Execute plugin with current plugin state
+                    const pluginInput = {
+                        ...input,
+                        state: currentStreamState.pluginState ?? null
+                    };
+                    console.log(`[STREAMING] About to execute plugin with input:`, JSON.stringify(pluginInput, null, 2));
+                    console.log(`[STREAMING] Plugin state:`, JSON.stringify(currentStreamState.pluginState, null, 2));
+                    const rawResult = await Effect.runPromise(executePlugin(initializedPlugin, pluginInput));
+                    console.log(`[STREAMING] Plugin execution completed`);
+                    // Transform raw plugin result to streaming format
+                    const resultObj = rawResult;
+                    const items = Array.isArray(resultObj.items) ? resultObj.items : [];
+                    const nextPluginState = resultObj.nextState;
+                    console.log(`[STREAMING] Transformed result: ${items.length} items`);
+                    // Update stream state (increment AFTER execution)
+                    currentStreamState = {
+                        invocations: currentStreamState.invocations + 1,
+                        pluginState: nextPluginState,
+                        lastItemCount: items.length,
+                    };
+                    console.log(`[STREAMING] Invocation ${currentStreamState.invocations}, Items: ${items.length}`);
+                    // Call state change hook if provided
+                    if (options.onStateChange) {
+                        await Effect.runPromise(options.onStateChange(nextPluginState, items));
+                    }
+                    // Emit items immediately (before any delays)
+                    for (const item of items) {
+                        if (options.maxItems && totalItemsEmitted >= options.maxItems) {
+                            console.log(`[STREAMING] Stopping emission at maxItems limit: ${options.maxItems}`);
+                            break;
+                        }
+                        emit.single(item);
+                        totalItemsEmitted++;
+                    }
+                    // Check for termination conditions
+                    if (nextPluginState && isTerminalState(nextPluginState)) {
+                        console.log(`[STREAMING] Plugin signaled termination`);
+                        break;
+                    }
+                    // Check stopWhenEmpty condition
+                    if (options.stopWhenEmpty && items.length === 0) {
+                        console.log(`[STREAMING] Stopping due to empty result and stopWhenEmpty=true`);
+                        break;
+                    }
+                    // Handle delay AFTER emission, BEFORE next iteration
+                    const nextDelay = extractDelayFromState(nextPluginState);
+                    if (nextDelay && Duration.toMillis(nextDelay) > 0) {
+                        console.log(`[STREAMING] Sleeping for ${Duration.toMillis(nextDelay)}ms before next iteration`);
+                        await Effect.runPromise(Effect.sleep(nextDelay));
+                    }
+                }
+                // End the stream
+                emit.end();
+            }
+            catch (error) {
+                console.log(`[STREAMING] Error occurred:`, error);
+                emit.fail(error);
+            }
+        };
+        // Start the loop
+        loop();
+    });
+};

package/dist/runtime/streaming/types.d.ts

@@ -0,0 +1,19 @@
+import type { Effect } from "effect";
+/**
+ * Internal stream state managed by the runtime
+ */
+export interface StreamState<TPluginState> {
+    readonly invocations: number;
+    readonly pluginState: TPluginState;
+    readonly lastItemCount: number;
+}
+/**
+ * Enhanced streaming options with Effect-based hooks
+ */
+export interface StreamingOptions<TItem = unknown, TPluginState = unknown> {
+    maxItems?: number;
+    maxInvocations?: number;
+    stopWhenEmpty?: boolean;
+    onStateChange?: (newPluginState: TPluginState, items: TItem[]) => Effect.Effect<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/streaming/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/streaming/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,YAAY;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAC;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,KAAK,GAAG,OAAO,EAAE,YAAY,GAAG,OAAO;IACvE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;IAGxB,aAAa,CAAC,EAAE,CAAC,cAAc,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CACvF"}

package/dist/runtime/streaming/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/test-utils.d.ts

@@ -1,3 +1,3 @@
 import type { PluginLogger } from "../plugin";
 export declare const createTestLogger: () => PluginLogger;
-//# sourceMappingURL=test-utils.d.ts.map
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/runtime/test-utils.js

@@ -1,13 +1,7 @@
 import { Effect } from "effect";
 export const createTestLogger = () => ({
-	logInfo: (message, context) =>
-		Effect.sync(() => console.log(`[INFO] ${message}`, context || "")),
-	logWarning: (message, context) =>
-		Effect.sync(() => console.warn(`[WARNING] ${message}`, context || "")),
-	logError: (message, error, context) =>
-		Effect.sync(() =>
-			console.error(`[ERROR] ${message}`, error, context || ""),
-		),
-	logDebug: (message, context) =>
-		Effect.sync(() => console.log(`[DEBUG] ${message}`, context || "")),
+    logInfo: (message, context) => Effect.sync(() => console.log(`[INFO] ${message}`, context || '')),
+    logWarning: (message, context) => Effect.sync(() => console.warn(`[WARNING] ${message}`, context || '')),
+    logError: (message, error, context) => Effect.sync(() => console.error(`[ERROR] ${message}`, error, context || '')),
+    logDebug: (message, context) => Effect.sync(() => console.log(`[DEBUG] ${message}`, context || '')),
 });

package/dist/runtime/types.d.ts

@@ -1,40 +1,40 @@
 import type { z } from "zod";
 import type { Plugin, PluginLogger, PluginRegistry } from "../plugin";
 export interface PluginRuntimeConfig {
-	registry: PluginRegistry;
-	secrets?: SecretsConfig;
-	logger?: PluginLogger;
+    registry: PluginRegistry;
+    secrets?: SecretsConfig;
+    logger?: PluginLogger;
 }
 export interface SecretsConfig {
-	[key: string]: string;
+    [key: string]: string;
 }
-export type AnyPlugin = Plugin<z.ZodTypeAny, z.ZodTypeAny, z.ZodTypeAny>;
+export type AnyPlugin = Plugin<any, z.ZodTypeAny, z.ZodTypeAny>;
 export interface PluginConstructor {
-	readonly ctor: new () => AnyPlugin;
-	readonly metadata: {
-		readonly pluginId: string;
-		readonly version?: string;
-		readonly description?: string;
-		readonly type?: string;
-	};
+    readonly ctor: new () => AnyPlugin;
+    readonly metadata: {
+        readonly pluginId: string;
+        readonly version?: string;
+        readonly description?: string;
+        readonly type?: string;
+    };
 }
 export interface PluginInstance<T extends AnyPlugin = AnyPlugin> {
-	readonly plugin: T;
-	readonly metadata: {
-		readonly pluginId: string;
-		readonly version?: string;
-		readonly description?: string;
-		readonly type?: string;
-	};
+    readonly plugin: T;
+    readonly metadata: {
+        readonly pluginId: string;
+        readonly version?: string;
+        readonly description?: string;
+        readonly type?: string;
+    };
 }
 export interface InitializedPlugin<T extends AnyPlugin = AnyPlugin> {
-	readonly plugin: T;
-	readonly metadata: {
-		readonly pluginId: string;
-		readonly version?: string;
-		readonly description?: string;
-		readonly type?: string;
-	};
-	readonly config: z.infer<T["configSchema"]>;
+    readonly plugin: T;
+    readonly metadata: {
+        readonly pluginId: string;
+        readonly version?: string;
+        readonly description?: string;
+        readonly type?: string;
+    };
+    readonly config: z.infer<T["configSchema"]>;
 }
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/runtime/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAGtE,MAAM,WAAW,mBAAmB;IACnC,QAAQ,EAAE,cAAc,CAAC;IACzB,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,MAAM,CAAC,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC7B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACtB;AAGD,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC;AAEzE,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,IAAI,EAAE,UAAU,SAAS,CAAC;IACnC,QAAQ,CAAC,QAAQ,EAAE;QAClB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;CACF;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IAC9D,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IACnB,QAAQ,CAAC,QAAQ,EAAE;QAClB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;CACF;AAED,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IACjE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IACnB,QAAQ,CAAC,QAAQ,EAAE;QAClB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;IACF,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC;CAC5C"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/runtime/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAGtE,MAAM,WAAW,mBAAmB;IACnC,QAAQ,EAAE,cAAc,CAAC;IACzB,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,MAAM,CAAC,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC7B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACtB;AAGD,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC;AAEhE,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,IAAI,EAAE,UAAU,SAAS,CAAC;IACnC,QAAQ,CAAC,QAAQ,EAAE;QAClB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;CACF;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IAC9D,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IACnB,QAAQ,CAAC,QAAQ,EAAE;QAClB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;CACF;AAED,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IACjE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;IAClB,QAAQ,CAAC,QAAQ,EAAE;QAClB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;IACF,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC;CAC5C"}

package/dist/runtime/validation.d.ts

@@ -1,10 +1,5 @@
 import { Effect } from "effect";
 import type { z } from "zod";
 import { ValidationError } from "./errors";
-export declare const validate: <T>(
-	schema: z.ZodSchema<T>,
-	data: unknown,
-	pluginId: string,
-	stage: "config" | "input" | "output" | "state",
-) => Effect.Effect<T, ValidationError>;
-//# sourceMappingURL=validation.d.ts.map
+export declare const validate: <T>(schema: z.ZodSchema<T>, data: unknown, pluginId: string, stage: "config" | "input" | "output" | "state") => Effect.Effect<T, ValidationError>;
+//# sourceMappingURL=validation.d.ts.map

package/dist/runtime/validation.js

@@ -1,16 +1,13 @@
 import { Effect } from "effect";
 import { ValidationError } from "./errors";
-export const validate = (schema, data, pluginId, stage) =>
-	Effect.gen(function* () {
-		const result = schema.safeParse(data);
-		if (result.success) {
-			return result.data;
-		}
-		return yield* Effect.fail(
-			new ValidationError({
-				pluginId,
-				stage,
-				zodError: result.error,
-			}),
-		);
-	});
+export const validate = (schema, data, pluginId, stage) => Effect.gen(function* () {
+    const result = schema.safeParse(data);
+    if (result.success) {
+        return result.data;
+    }
+    return yield* Effect.fail(new ValidationError({
+        pluginId,
+        stage,
+        zodError: result.error,
+    }));
+});

package/dist/testing/index.d.ts

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

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

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

package/dist/testing/index.js

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+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) => ({
+    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;
+        }
+        // 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`),
+        }));
+    }),
+    loadRemoteConstructor: (pluginId, url) => Effect.gen(function* () {
+        // Return the plugin constructor from the map
+        // Use original pluginId as key since TestPluginMap uses original plugin IDs
+        const PluginConstructor = pluginMap[pluginId];
+        if (PluginConstructor) {
+            return PluginConstructor;
+        }
+        // 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`),
+        }));
+    }),
+});
+// Create a Layer that provides the mock ModuleFederationService
+export const createMockModuleFederationServiceLayer = (pluginMap) => Layer.succeed(ModuleFederationService, createMockService(pluginMap));