every-plugin 0.1.0 → 0.1.2

package/README.md

@@ -1,329 +1 @@
-# every-plugin
-
-A modular plugin runtime & system built with [Effect.TS](https://effect.website/) for loading, initializing, and executing remote plugins via [Module Federation](https://module-federation.io/).
-
-## Installation
-
-```bash
-npm install every-plugin
-# or
-bun add every-plugin
-```
-
-## Quick Start
-
-### Basic Plugin Usage
-
-```typescript
-import { Effect } from "effect";
-import { createPluginRuntime, PluginRuntime } from "every-plugin/runtime";
-
-// Create a managed runtime (do this once per application/worker)
-const runtime = createPluginRuntime({
-  registry: {
-    "@my-org/data-processor": {
-      version: "1.0.0",
-      remoteUrl: "https://cdn.example.com/plugins/data-processor@latest/remoteEntry.js",
-      description: "Processes data items",
-      type: "pipeline"
-    }
-  },
-  secrets: {
-    API_KEY: "your-secret-key",
-    DATABASE_URL: "postgresql://..."
-  },
-  logger: customLogger // optional
-});
-
-// Use the runtime to execute plugins
-const result = await runtime.runPromise(
-  Effect.gen(function* () {
-    const pluginRuntime = yield* PluginRuntime;
-    
-    // Load, instantiate and initialize a plugin
-    const plugin = yield* pluginRuntime.usePlugin("@my-org/data-processor", {
-      apiKey: "{{API_KEY}}", // Will be hydrated from secrets
-      batchSize: 100
-    });
-    
-    const output = yield* pluginRuntime.executePlugin(plugin, {
-      items: ["item1", "item2", "item3"]
-    });
-    
-    return output;
-  })
-);
-
-console.log(result);
-
-// Clean up when done
-await runtime.dispose();
-```
-
-### Alternative: Direct Layer Construction
-
-If you prefer more explicit control over the runtime construction:
-
-```typescript
-import { Effect, ManagedRuntime } from "effect";
-import { PluginRuntime } from "every-plugin/runtime";
-
-// This is equivalent to createPluginRuntime(config)
-const runtime = ManagedRuntime.make(PluginRuntime.Live({
-  registry: { /* ... */ },
-  secrets: { /* ... */ }
-}));
-
-const result = await runtime.runPromise(
-  Effect.gen(function* () {
-    const pluginRuntime = yield* PluginRuntime;
-    const plugin = yield* pluginRuntime.usePlugin(pluginId, config);
-    return yield* pluginRuntime.executePlugin(plugin, input);
-  })
-);
-```
-
-### Advanced Usage - Granular Control
-
-```typescript
-import { Effect } from "effect";
-import { PluginRuntime } from "every-plugin/runtime";
-
-const processWithGranularControl = Effect.gen(function* () {
-  const pluginRuntime = yield* PluginRuntime;
-  
-  // Step-by-step plugin lifecycle
-  const constructor = yield* pluginRuntime.loadPlugin("@my-org/data-processor");
-  const instance = yield* pluginRuntime.instantiatePlugin(constructor);
-  const initialized = yield* pluginRuntime.initializePlugin(instance, config);
-  const output = yield* pluginRuntime.executePlugin(initialized, input);
-  
-  return output;
-});
-
-await runtime.runPromise(processWithGranularControl);
-```
-
-### Worker Integration
-
-Perfect for BullMQ workers or similar job processing systems:
-
-```typescript
-import { Job } from "bullmq";
-import { Effect } from "effect";
-import { createPluginRuntime, PluginRuntime } from "every-plugin/runtime";
-
-// Initialize runtime once per worker
-const runtime = createPluginRuntime({
-  registry: pluginRegistry,
-  secrets: await loadSecrets(),
-});
-
-// Job processor
-const processJob = (job: Job) => 
-  runtime.runPromise(
-    Effect.gen(function* () {
-      const pluginRuntime = yield* PluginRuntime;
-      const { pluginId, config, input } = job.data;
-      
-      const plugin = yield* pluginRuntime.usePlugin(pluginId, config);
-      return yield* pluginRuntime.executePlugin(plugin, input);
-    })
-  );
-
-// Worker setup
-const worker = new Worker("my-queue", processJob);
-
-// Cleanup on shutdown
-process.on("SIGTERM", async () => {
-  await worker.close();
-  await runtime.dispose();
-});
-```
-
-```typescript
-import { Effect } from "effect";
-import { createPluginRuntime, PluginRuntime } from "every-plugin/runtime";
-
-// Create a managed runtime (do this once per application/worker)
-const runtime = createPluginRuntime({
-  registry: {
-    "@my-org/data-processor": {
-      version: "1.0.0",
-      remoteUrl: "https://cdn.example.com/plugins/data-processor@latest/remoteEntry.js",
-      description: "Processes data items",
-      type: "pipeline"
-    }
-  },
-  secrets: {
-    API_KEY: "your-secret-key",
-    DATABASE_URL: "postgresql://..."
-  },
-  logger: customLogger // optional
-});
-
-// Use the runtime to execute plugins
-const result = await runtime.runPromise(
-  Effect.gen(function* () {
-    const pluginRuntime = yield* PluginRuntime;
-
-    return yield* pluginRuntime.streamPlugin(
-          "test-source-plugin",
-          TEST_CONFIG,
-          TEST_SEARCH_INPUT,
-        ).pipe(
-          Effect.flatMap(stream => stream.pipe(Stream.runCollect)),
-          Effect.catchAll((error: unknown) => {
-            // Should handle callback errors
-            expect(error).toBeDefined();
-            return Effect.succeed("callback-error-handled");
-          }),
-        );
-    
-    // Load, instantiate and initialize a plugin
-    const plugin = yield* pluginRuntime.usePlugin("@my-org/data-processor", {
-      apiKey: "{{API_KEY}}", // Will be hydrated from secrets
-      batchSize: 100
-    });
-    
-    // I want to do this in the source stream
-    const output = yield* pluginRuntime.executePlugin(plugin, {
-      items: ["item1", "item2", "item3"]
-    });
-
-    
-    
-    return output;
-  })
-);
-
-console.log(result);
-
-// Clean up when done
-await runtime.dispose();
-```
-
-### React/Next.js Integration
-
-```typescript
-import { createPluginRuntime, PluginRuntime } from "every-plugin/runtime";
-import { Effect } from "effect";
-
-// Create runtime at app level
-const pluginRuntime = createPluginRuntime({
-  registry: clientSideRegistry,
-  secrets: {} // No secrets on client side
-});
-
-// In a React component or API route
-export async function executePlugin(pluginId: string, config: any, input: any) {
-  return pluginRuntime.runPromise(
-    Effect.gen(function* () {
-      const runtime = yield* PluginRuntime;
-      const plugin = yield* runtime.usePlugin(pluginId, config);
-      return yield* runtime.executePlugin(plugin, input);
-    })
-  );
-}
-
-// Cleanup in app teardown
-export function cleanup() {
-  return pluginRuntime.dispose();
-}
-```
-
-## Core Concepts
-
-### Plugin Registry
-
-The registry defines available plugins and their remote locations:
-
-```typescript
-type PluginRegistry = {
-  [pluginId: string]: {
-    version: string;
-    remoteUrl: string;
-    description?: string;
-    type?: string;
-  };
-};
-```
-
-### Secret Hydration
-
-Secrets are automatically hydrated using Mustache-style templating:
-
-```typescript
-const config = {
-  apiKey: "{{API_KEY}}", // Will be replaced with actual secret
-  endpoint: "https://api.example.com"
-};
-```
-
-### Plugin Lifecycle
-
-1. **Load**: Download and cache the remote plugin module
-2. **Instantiate**: Create a new instance of the plugin class
-3. **Initialize**: Configure the plugin with validated config and secrets
-4. **Execute**: Run the plugin with validated input, return validated output
-
-### Error Handling
-
-All operations return Effect types with proper error handling:
-
-```typescript
-const result = await runtime.runPromise(
-  Effect.gen(function* () {
-    const pluginRuntime = yield* PluginRuntime;
-    return yield* pluginRuntime.usePlugin(pluginId, config);
-  }).pipe(
-    Effect.catchAll((error) => {
-      console.error("Plugin execution failed:", error);
-      return Effect.succeed(null); // Fallback value
-    })
-  )
-);
-```
-
-## API Reference
-
-### `createPluginRuntime(config)`
-
-Creates a managed runtime for plugin execution.
-
-**Parameters:**
-
-- `config.registry`: Plugin registry mapping
-- `config.secrets`: Secret values for hydration (optional)
-- `config.logger`: Custom logger implementation (optional)
-
-**Returns:** `ManagedRuntime` instance
-
-### `PluginRuntime`
-
-Effect service tag for accessing the plugin runtime within Effect workflows.
-
-### Plugin Runtime Methods
-
-- `loadPlugin(pluginId)`: Load plugin constructor from registry
-- `instantiatePlugin(constructor)`: Create plugin instance
-- `initializePlugin(instance, config)`: Initialize with config and secrets
-- `executePlugin(plugin, input)`: Execute plugin with input
-- `usePlugin(pluginId, config)`: Load + instantiate + initialize in one step (does not execute)
-
-## Development
-
-```bash
-# Install dependencies
-bun install
-
-# Build the package
-bun run build
-
-# Run tests
-bun test
-```
-
-## License
-
-MIT
+# every-plugin

package/dist/errors.d.ts

@@ -1,8 +1,12 @@
-export declare class PluginExecutionError extends Error {
-	readonly retryable: boolean;
-	constructor(message: string, retryable?: boolean);
+declare const PluginConfigurationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PluginConfigurationError";
+} & Readonly<A>;
+export declare class PluginConfigurationError extends PluginConfigurationError_base<{
+    readonly message: string;
+    readonly retryable: boolean;
+    readonly cause?: Error;
+}> {
+    get name(): string;
 }
-export declare class ConfigurationError extends PluginExecutionError {
-	constructor(message: string);
-}
-//# sourceMappingURL=errors.d.ts.map
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AACA,qBAAa,oBAAqB,SAAQ,KAAK;aAG7B,SAAS,EAAE,OAAO;gBADlC,OAAO,EAAE,MAAM,EACC,SAAS,GAAE,OAAc;CAK1C;AAED,qBAAa,kBAAmB,SAAQ,oBAAoB;gBAC/C,OAAO,EAAE,MAAM;CAI3B"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";;;AAEA,qBAAa,wBAAyB,SAAQ,8BAA6C;IAC1F,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;CACvB,CAAC;IACD,IAAa,IAAI,WAAyC;CAC1D"}

package/dist/errors.js

@@ -1,15 +1,4 @@
-// Plugin execution errors
-export class PluginExecutionError extends Error {
-	retryable;
-	constructor(message, retryable = true) {
-		super(message);
-		this.retryable = retryable;
-		this.name = "PluginExecutionError";
-	}
-}
-export class ConfigurationError extends PluginExecutionError {
-	constructor(message) {
-		super(message, false); // Configuration errors are not retryable
-		this.name = "ConfigurationError";
-	}
+import { Data } from "effect";
+export class PluginConfigurationError extends Data.TaggedError("PluginConfigurationError") {
+    get name() { return "PluginConfigurationError"; }
 }

package/dist/index.d.ts

@@ -1,6 +1,4 @@
-export { Effect } from "effect";
-export { z } from "zod";
 export * from "./errors";
 export * from "./plugin";
-export * from "./source";
-//# sourceMappingURL=index.d.ts.map
+export * from "./runtime";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC"}

package/dist/index.js

@@ -1,5 +1,3 @@
-export { Effect } from "effect";
-export { z } from "zod";
 export * from "./errors";
 export * from "./plugin";
-export * from "./source";
+export * from "./runtime";

package/dist/plugin.d.ts

@@ -1,111 +1,157 @@
-import { Context, type Effect } from "effect";
+import type { ContractRouter, Meta } from "@orpc/server";
+import { Context, Effect } from "effect";
 import { z } from "zod";
-import type { ConfigurationError, PluginExecutionError } from "./errors";
-export declare const createOutputSchema: <T extends z.ZodTypeAny>(
-	dataSchema: T,
-) => z.ZodObject<
-	{
-		success: z.ZodBoolean;
-		data: z.ZodOptional<T>;
-		errors: z.ZodOptional<
-			z.ZodArray<
-				z.ZodObject<
-					{
-						message: z.ZodString;
-						details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-						stack: z.ZodOptional<z.ZodString>;
-					},
-					z.core.$strip
-				>
-			>
-		>;
-	},
-	z.core.$strip
->;
-export declare function createConfigSchema<
-	V extends z.ZodTypeAny,
-	S extends z.ZodTypeAny,
->(
-	variablesSchema?: V,
-	secretsSchema?: S,
-): z.ZodObject<{
-	variables: z.ZodOptional<V>;
-	secrets: z.ZodOptional<S>;
-}>;
-export declare function createInputSchema<I extends z.ZodTypeAny>(
-	inputSchema: I,
-): I;
-export declare const ErrorDetailsSchema: z.ZodObject<
-	{
-		message: z.ZodString;
-		details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-		stack: z.ZodOptional<z.ZodString>;
-	},
-	z.core.$strip
->;
-export type ErrorDetails = z.infer<typeof ErrorDetailsSchema>;
-export type Config<
-	V extends z.ZodTypeAny = z.ZodRecord<z.ZodString, z.ZodUnknown>,
-	S extends z.ZodTypeAny = z.ZodRecord<z.ZodString, z.ZodUnknown>,
-> = z.infer<ReturnType<typeof createConfigSchema<V, S>>>;
-export type Input<I extends z.ZodTypeAny> = z.infer<
-	ReturnType<typeof createInputSchema<I>>
->;
-export type Output<T extends z.ZodTypeAny> = z.infer<
-	ReturnType<typeof createOutputSchema<T>>
->;
-export interface Plugin<
-	TInputSchema extends z.ZodTypeAny,
-	TOutputSchema extends z.ZodTypeAny,
-	TConfigSchema extends z.ZodTypeAny,
-> {
-	readonly id: string;
-	readonly type: PluginType;
-	readonly inputSchema: TInputSchema;
-	readonly outputSchema: TOutputSchema;
-	readonly configSchema: TConfigSchema;
-	initialize(
-		config?: z.infer<TConfigSchema>,
-	): Effect.Effect<void, ConfigurationError, PluginLoggerTag>;
-	execute(
-		input: z.infer<TInputSchema>,
-	): Effect.Effect<
-		z.infer<TOutputSchema>,
-		PluginExecutionError,
-		PluginLoggerTag
-	>;
-	shutdown(): Effect.Effect<void, never, PluginLoggerTag>;
-}
+import type { PluginConfigurationError } from "./errors";
+export type Contract = ContractRouter<Meta>;
+export declare function createConfigSchema<V extends z.ZodTypeAny, S extends z.ZodTypeAny>(variablesSchema: V, secretsSchema: S): z.ZodObject<{
+    variables: V;
+    secrets: S;
+}, z.core.$strip>;
+export declare function createStateSchema<T extends z.ZodTypeAny>(pluginStateSchema: T): z.ZodIntersection<z.ZodObject<{
+    nextPollMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>, T>;
 export type PluginType = "transformer" | "distributor" | "source";
 export interface PluginMetadata {
-	remoteUrl: string;
-	type?: PluginType;
-	version?: string;
-	description?: string;
+    remoteUrl: string;
+    type?: PluginType;
+    version?: string;
+    description?: string;
 }
 export interface PluginRegistry {
-	[pluginId: string]: PluginMetadata;
+    [pluginId: string]: PluginMetadata;
 }
 export interface PluginLogger {
-	readonly logInfo: (message: string, context?: unknown) => Effect.Effect<void>;
-	readonly logWarning: (
-		message: string,
-		context?: unknown,
-	) => Effect.Effect<void>;
-	readonly logError: (
-		message: string,
-		error?: unknown,
-		context?: unknown,
-	) => Effect.Effect<void>;
-	readonly logDebug: (
-		message: string,
-		context?: unknown,
-	) => Effect.Effect<void>;
+    readonly logInfo: (message: string, context?: unknown) => Effect.Effect<void>;
+    readonly logWarning: (message: string, context?: unknown) => Effect.Effect<void>;
+    readonly logError: (message: string, error?: unknown, context?: unknown) => Effect.Effect<void>;
+    readonly logDebug: (message: string, context?: unknown) => Effect.Effect<void>;
+}
+declare const PluginLoggerTag_base: Context.TagClass<PluginLoggerTag, "PluginLogger", PluginLogger>;
+export declare class PluginLoggerTag extends PluginLoggerTag_base {
+}
+/**
+ * Common error schemas that all plugins can use
+ * These provide consistent error handling across the plugin ecosystem
+ */
+export declare const CommonPluginErrors: {
+    UNAUTHORIZED: {
+        data: z.ZodObject<{
+            apiKeyProvided: z.ZodBoolean;
+            provider: z.ZodOptional<z.ZodString>;
+            authType: z.ZodOptional<z.ZodEnum<{
+                apiKey: "apiKey";
+                oauth: "oauth";
+                token: "token";
+            }>>;
+        }, z.core.$strip>;
+    };
+    RATE_LIMITED: {
+        data: z.ZodObject<{
+            retryAfter: z.ZodNumber;
+            remainingRequests: z.ZodOptional<z.ZodNumber>;
+            resetTime: z.ZodOptional<z.ZodString>;
+            limitType: z.ZodOptional<z.ZodEnum<{
+                requests: "requests";
+                tokens: "tokens";
+                bandwidth: "bandwidth";
+            }>>;
+        }, z.core.$strip>;
+    };
+    SERVICE_UNAVAILABLE: {
+        data: z.ZodObject<{
+            retryAfter: z.ZodOptional<z.ZodNumber>;
+            maintenanceWindow: z.ZodDefault<z.ZodBoolean>;
+            estimatedUptime: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    BAD_REQUEST: {
+        data: z.ZodObject<{
+            invalidFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            validationErrors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                message: z.ZodString;
+                code: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+    NOT_FOUND: {
+        data: z.ZodObject<{
+            resource: z.ZodOptional<z.ZodString>;
+            resourceId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    FORBIDDEN: {
+        data: z.ZodObject<{
+            requiredPermissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            action: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Schema creators for contract-based plugins
+ */
+export declare function createPluginInputSchema<TContract extends Contract, TStateSchema extends z.ZodTypeAny>(contract: TContract, stateSchema: TStateSchema): z.ZodDiscriminatedUnion<[z.ZodObject<any, z.core.$strip>, ...z.ZodObject<any, z.core.$strip>[]], "procedure">;
+export declare function createPluginOutputSchema<TContract extends Contract, TStateSchema extends z.ZodTypeAny>(contract: TContract, stateSchema: TStateSchema): z.ZodUnion<[z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, ...z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>[]]>;
+/**
+ * Unified Plugin interface for all plugin types
+ */
+export interface Plugin<TContract extends Contract, TConfigSchema extends z.ZodTypeAny = z.ZodTypeAny, TStateSchema extends z.ZodTypeAny = z.ZodNull> {
+    readonly id: string;
+    readonly type: PluginType;
+    readonly contract: TContract;
+    readonly configSchema: TConfigSchema;
+    readonly stateSchema: TStateSchema;
+    readonly inputSchema: ReturnType<typeof createPluginInputSchema<TContract, TStateSchema>>;
+    readonly outputSchema: ReturnType<typeof createPluginOutputSchema<TContract, TStateSchema>>;
+    initialize(config?: z.infer<TConfigSchema>): Effect.Effect<void, PluginConfigurationError, PluginLoggerTag>;
+    shutdown(): Effect.Effect<void, never, PluginLoggerTag>;
+    createRouter(): Contract;
+    isStreamable(procedureName: string): boolean;
+}
+/**
+ * State transition utilities for plugins
+ * These provide a functional approach to state updates while keeping the API simple
+ */
+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;
+/**
+ * Simple plugin base class that uses pure oRPC patterns
+ * Plugin just needs to define contract, config, and create oRPC router
+ */
+export declare abstract class SimplePlugin<TContract extends Contract, TConfigSchema extends z.ZodTypeAny, TStateSchema extends z.ZodTypeAny = z.ZodNull> implements Plugin<TContract, TConfigSchema, TStateSchema> {
+    abstract readonly id: string;
+    abstract readonly type: PluginType;
+    abstract readonly contract: TContract;
+    abstract readonly configSchema: TConfigSchema;
+    abstract readonly stateSchema: TStateSchema;
+    get inputSchema(): z.ZodDiscriminatedUnion<[z.ZodObject<any, z.core.$strip>, ...z.ZodObject<any, z.core.$strip>[]], "procedure">;
+    get outputSchema(): z.ZodUnion<[z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, ...z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>[]]>;
+    initialize(config?: z.infer<TConfigSchema>): Effect.Effect<void, PluginConfigurationError, PluginLoggerTag>;
+    abstract createRouter(): Contract;
+    shutdown(): Effect.Effect<void, never, PluginLoggerTag>;
+    isStreamable(procedureName: string): boolean;
 }
-declare const PluginLoggerTag_base: Context.TagClass<
-	PluginLoggerTag,
-	"PluginLogger",
-	PluginLogger
->;
-export declare class PluginLoggerTag extends PluginLoggerTag_base {}
-//# sourceMappingURL=plugin.d.ts.map
+export {};
+//# sourceMappingURL=plugin.d.ts.map