@danielfgray/pg-sourcerer 0.2.1 → 0.2.2

package/dist/services/plugin.d.ts

@@ -1,289 +1,421 @@
 /**
- * Plugin Types
+ * Plugin System
  *
- * Defines the Effect-native plugin interface where plugins are Effects
- * that yield the services they need from context.
+ * A generic request/plugin coordination system. Core routes requests to plugins
+ * without understanding what resources represent (schemas, queries, routes, etc.).
+ *
+ * Key concepts:
+ * - Plugin: Handles requests for a resource kind
+ * - Request: A need for a resource with specific params
+ * - DeferredResource: A placeholder resolved after plugin execution
+ *
+ * Execution phases:
+ * 1. Registration - Plugins registered, singletons identified
+ * 2. Collection - Requests collected via ctx.request()
+ * 3. Resolution - Match requests to plugins, build DAG
+ * 4. Execution - Run plugins in topological order
+ * 5. Finalization - Emit files, resolve imports
  */
-import { Effect, Schema as S } from "effect";
-import type { namedTypes as n } from "ast-types";
-import type { Artifact, CapabilityKey, SemanticIR, Entity } from "../ir/semantic-ir.js";
-import { PluginExecutionFailed } from "../errors.js";
-import type { CoreInflection, InflectionConfig } from "./inflection.js";
+import { Context, Layer, Schema as S } from "effect";
+import type { FileBuilder } from "./file-builder.js";
 import type { SymbolRegistry } from "./symbols.js";
+import type { SemanticIR } from "../ir/semantic-ir.js";
 import type { TypeHintRegistry } from "./type-hints.js";
-import type { FileBuilder } from "./file-builder.js";
-import { IR } from "./ir.js";
-import { ArtifactStore } from "./artifact-store.js";
-import { PluginMeta } from "./plugin-meta.js";
-import { Inflection } from "./inflection.js";
-import { Emissions } from "./emissions.js";
-import { Symbols } from "./symbols.js";
-import { TypeHints } from "./type-hints.js";
+import type { CoreInflection } from "./inflection.js";
 /**
- * Context provided to fileName function for output file path generation.
+ * A request for a resource of a specific kind with arbitrary params.
  *
- * This gives plugins full programmatic control over file naming,
- * with access to entity info and inflection utilities.
+ * Core does not interpret the params - they are opaque data passed to providers.
  */
-export interface FileNameContext {
-    /** Already-inflected entity name */
-    readonly entityName: string;
-    /** Raw PostgreSQL object name (table, view, or type name) */
-    readonly pgName: string;
-    /** Schema name */
-    readonly schema: string;
-    /** Inflection utilities (singularize, pluralize, etc.) */
-    readonly inflection: CoreInflection;
-    /** Full entity from IR for advanced use cases */
-    readonly entity: Entity;
+export interface ResourceRequest {
+    /** The resource kind (e.g., "validation-schema", "query-functions") */
+    readonly kind: string;
+    /** Opaque params interpreted by the provider */
+    readonly params: unknown;
+}
+/**
+ * A service handler function that processes requests for a specific kind.
+ *
+ * Registered by plugins via ctx.registerHandler() and invoked by ctx.request().
+ * This enables on-demand generation where a later plugin can request resources
+ * from an earlier plugin's handler.
+ *
+ * @typeParam TParams - The request params shape
+ * @typeParam TResult - The result shape
+ */
+export type ServiceHandler<TParams = unknown, TResult = unknown> = (params: TParams, ctx: PluginContext) => TResult;
+/**
+ * A deferred resource reference.
+ *
+ * Created when a provider calls ctx.request(). The result is populated
+ * after the resolution and execution phases complete.
+ */
+export interface DeferredResource<T = unknown> {
+    /** The resource kind this request is for */
+    readonly kind: string;
+    /** The params used for this request */
+    readonly params: unknown;
+    /**
+     * The resolved result. Accessing before resolution throws.
+     * After resolution, contains the provider's return value.
+     */
+    readonly result: T;
 }
 /**
- * Plugin-specific inflection for output file and symbol naming
+ * Context provided to plugins during the provide() call.
+ *
+ * Allows plugins to:
+ * - Access the semantic IR
+ * - Access type hints and inflection
+ * - Register service handlers for on-demand requests
+ * - Make requests to other plugins' handlers
+ * - Emit files
+ * - Register symbols
  */
-export interface PluginInflection {
+export interface PluginContext {
     /**
-     * Generate output file path for an entity.
+     * The semantic IR containing all entities, enums, relations, etc.
+     */
+    readonly ir: SemanticIR;
+    /**
+     * Type hint registry for user-configured type overrides.
+     */
+    readonly typeHints: TypeHintRegistry;
+    /**
+     * Inflection service for naming transformations.
+     */
+    readonly inflection: CoreInflection;
+    /**
+     * Register a service handler for a resource kind.
      *
-     * @param ctx - Context with entity info and inflection utilities
-     * @returns File path relative to outputDir (include extension)
+     * Other plugins can then call ctx.request(kind, params) to invoke this handler.
+     * This enables on-demand generation patterns where consumers drive what gets generated.
      *
      * @example
      * ```typescript
-     * // Default: entity name as file
-     * fileName: (ctx) => `${ctx.entityName}.ts`
+     * // In zod plugin:
+     * ctx.registerHandler("schemas", (params, ctx) => {
+     *   if (params.variant === "params") {
+     *     return generateParamSchema(params.entity, params.method)
+     *   }
+     *   return generateEntitySchema(params.entity, params.shape)
+     * })
      *
-     * // Lowercase files
-     * fileName: (ctx) => `${ctx.entityName.toLowerCase()}.ts`
+     * // In http-elysia plugin:
+     * const schema = ctx.request("schemas", { entity: "User", method: "findById", variant: "params" })
+     * ```
      *
-     * // Singular lowercase
-     * fileName: (ctx) => `${ctx.inflection.singularize(ctx.entityName).toLowerCase()}.ts`
+     * @param kind - Resource kind this handler provides
+     * @param handler - Function to handle requests
+     */
+    readonly registerHandler: <TParams = unknown, TResult = unknown>(kind: string, handler: ServiceHandler<TParams, TResult>) => void;
+    /**
+     * Request a resource from a registered handler.
      *
-     * // Schema-scoped
-     * fileName: (ctx) => `${ctx.schema}/${ctx.entityName}.ts`
+     * Invokes the handler registered for the given kind with the provided params.
+     * If no handler is registered, falls back to the result cache (for static dependencies).
      *
-     * // Single file for all entities
-     * fileName: () => `all-models.ts`
-     * ```
+     * @param kind - Resource kind to request
+     * @param params - Opaque params for the handler
+     * @returns The result from the handler
+     * @throws If no handler is registered and no cached result exists
+     */
+    readonly request: <T = unknown>(kind: string, params: unknown) => T;
+    /**
+     * Create a FileBuilder for structured file emission.
+     *
+     * @param path - Output file path relative to outputDir
+     */
+    readonly file: (path: string) => FileBuilder;
+    /**
+     * Symbol registry for cross-file imports.
+     * Also used for method symbol registration (plugin-to-plugin coordination).
      */
-    readonly outputFile: (ctx: FileNameContext) => string;
-    readonly symbolName: (entityName: string, artifactKind: string) => string;
+    readonly symbols: SymbolRegistry;
 }
 /**
- * Union of all service tags available to plugins.
- *
- * Plugins can yield any of these from Effect context:
- * ```typescript
- * const ir = yield* IR
- * const inflection = yield* Inflection
- * ```
- */
-export type PluginServices = IR | Inflection | Emissions | Symbols | TypeHints | ArtifactStore | PluginMeta;
-/**
- * Effect-native Plugin interface
- *
- * Plugins are Effects that yield the services they need from context.
- * The PluginRunner provides all services via layers.
+ * A plugin handles requests for a specific resource kind.
  *
- * @example
- * ```typescript
- * const myPlugin: Plugin<MyConfig> = {
- *   name: "my-plugin",
- *   provides: ["types:row"],
- *   configSchema: MyConfigSchema,
- *   inflection: { ... },
+ * Core calls canProvide() to match requests to plugins, then calls
+ * provide() to generate the resource.
  *
- *   run: (config) => Effect.gen(function* () {
- *     const ir = yield* IR
- *     const emissions = yield* Emissions
- *     const meta = yield* PluginMeta
- *
- *     for (const entity of ir.entities.values()) {
- *       emissions.emit(`types/${entity.name}.ts`, generateType(entity), meta.name)
- *     }
- *   })
- * }
- * ```
+ * @typeParam TParams - The expected params shape (opaque to core)
+ * @typeParam TResult - The result shape (opaque to core)
  */
-export interface Plugin<TConfig = unknown, TEncoded = TConfig> {
-    /** Unique plugin name */
+export interface Plugin<TParams = unknown, TResult = unknown> {
+    /**
+     * Unique plugin name for identification and error messages.
+     */
     readonly name: string;
-    /** Capabilities this plugin requires (must be provided by earlier plugins) */
-    readonly requires?: readonly CapabilityKey[];
-    /** Capabilities this plugin provides */
-    readonly provides: readonly CapabilityKey[];
-    /** Configuration schema (Effect Schema) - Schema<TConfig, Encoded> with TConfig as decoded type */
-    readonly configSchema: S.Schema<TConfig, TEncoded, never>;
-    /** Plugin-specific inflection for file and symbol naming */
-    readonly inflection: PluginInflection;
     /**
-     * Plugin's default inflection transforms.
+     * The resource kind this plugin handles.
+     * Multiple plugins can handle the same kind - first match wins.
+     */
+    readonly kind: string;
+    /**
+     * If true, this plugin runs once automatically without explicit request.
+     * The result is shared by all dependents.
      *
-     * These are applied BEFORE user-configured inflection, allowing composition:
-     * - Plugin sets baseline (e.g., entityName: inflect.pascalCase → "users" → "Users")
-     * - User config refines (e.g., entityName: inflect.singularize → "Users" → "User")
+     * Typical singletons: introspection, semantic-ir
+     */
+    readonly singleton?: boolean;
+    /**
+     * Params to use for singleton execution.
+     * Only meaningful when singleton is true.
+     */
+    readonly singletonParams?: TParams;
+    /**
+     * Check if this plugin can handle a request with the given params.
      *
-     * @example
-     * ```typescript
-     * import { inflect } from "pg-sourcerer"
+     * Called during resolution to match requests to plugins.
+     * First plugin that returns true wins.
      *
-     * inflectionDefaults: {
-     *   entityName: inflect.pascalCase,  // Plugin wants PascalCase class names
-     *   // fieldName not set = plugin preserves field names as-is
-     * }
-     * ```
+     * @param params - The request params (opaque to core)
+     * @returns true if this plugin can handle the request
      */
-    readonly inflectionDefaults?: InflectionConfig;
+    readonly canProvide: (params: TParams) => boolean;
     /**
-     * Plugin execution - returns Effect that yields services from context.
+     * Declare what resources this plugin needs before it can run.
      *
-     * Accepts the encoded/partial config type. The run function decodes through
-     * the schema, applying defaults to produce the full TConfig.
+     * Used to build the dependency DAG. The results are passed to provide().
      *
-     * Services available:
-     * - IR: SemanticIR (read-only)
-     * - Inflection: CoreInflection (composed: plugin defaults + user config)
-     * - Emissions: EmissionBuffer
-     * - Symbols: SymbolRegistry
-     * - TypeHints: TypeHintRegistry
-     * - ArtifactStore: plugin-to-plugin data
-     * - PluginMeta: current plugin name
+     * @param params - The request params
+     * @returns Array of resource requests that must be resolved first
      */
-    readonly run: (config: TEncoded) => Effect.Effect<void, PluginExecutionFailed, IR | Inflection | Emissions | Symbols | TypeHints | ArtifactStore | PluginMeta>;
+    readonly requires?: (params: TParams) => readonly ResourceRequest[];
+    /**
+     * Declare optional dependencies that enhance this plugin if available.
+     *
+     * Unlike `requires`, missing optional dependencies don't cause errors.
+     * If a provider exists, the dependency is resolved and ordering is enforced.
+     * If no provider exists, the dependency is silently skipped.
+     *
+     * Useful for plugins that have fallback behavior when an optional dependency
+     * isn't available (e.g., http-elysia falling back to TypeBox when no schema
+     * plugin is registered).
+     *
+     * @param params - The request params
+     * @returns Array of optional resource requests
+     */
+    readonly optionalRequires?: (params: TParams) => readonly ResourceRequest[];
+    /**
+     * Generate the resource.
+     *
+     * Called during execution phase after all dependencies are resolved.
+     *
+     * @param params - The request params
+     * @param deps - Resolved results from requires() in same order
+     * @param ctx - Plugin context for sub-requests and emission
+     * @returns The resource result (shape is plugin-defined)
+     */
+    readonly provide: (params: TParams, deps: readonly unknown[], ctx: PluginContext) => TResult;
 }
+declare const PluginNotFound_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: "PluginNotFound";
+} & Readonly<A>;
 /**
- * A plugin factory function that creates ConfiguredPlugin instances.
- *
- * The factory also exposes the underlying plugin for inspection:
- * - `factory.plugin` - The Plugin object with name, provides, requires, etc.
+ * No plugin could handle a request.
+ */
+export declare class PluginNotFound extends PluginNotFound_base<{
+    readonly message: string;
+    readonly kind: string;
+    readonly params: unknown;
+    readonly requestedBy?: string;
+}> {
+}
+declare const PluginCycle_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: "PluginCycle";
+} & Readonly<A>;
+/**
+ * A cycle was detected in plugin dependencies.
+ */
+export declare class PluginCycle extends PluginCycle_base<{
+    readonly message: string;
+    readonly cycle: readonly string[];
+}> {
+}
+declare const PluginExecutionFailed_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: "PluginExecutionFailed";
+} & Readonly<A>;
+/**
+ * A plugin failed during execution.
  */
-export interface PluginFactory<TConfig, TEncoded = TConfig> {
-    (config?: TEncoded): ConfiguredPlugin;
-    /** The underlying plugin definition */
-    readonly plugin: Plugin<TConfig, TEncoded>;
+export declare class PluginExecutionFailed extends PluginExecutionFailed_base<{
+    readonly message: string;
+    readonly plugin: string;
+    readonly kind: string;
+    readonly params: unknown;
+    readonly cause: unknown;
+}> {
 }
+declare const ResourceNotResolved_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: "ResourceNotResolved";
+} & Readonly<A>;
 /**
- * A plugin with its validated configuration
+ * Attempted to access a deferred resource before resolution.
  */
-export interface ConfiguredPlugin {
-    readonly plugin: Plugin<unknown>;
-    readonly config: unknown;
+export declare class ResourceNotResolved extends ResourceNotResolved_base<{
+    readonly message: string;
+    readonly kind: string;
+    readonly params: unknown;
+}> {
 }
 /**
- * Logger interface for simple plugins
+ * Union of all plugin-related errors.
  */
-export interface SimplePluginLogger {
-    readonly debug: (message: string) => void;
-    readonly info: (message: string) => void;
-    readonly warn: (message: string) => void;
+export type PluginError = PluginNotFound | PluginCycle | PluginExecutionFailed | ResourceNotResolved;
+/**
+ * A pending request tracked by the registry.
+ * @internal
+ */
+export interface PendingRequest {
+    readonly kind: string;
+    readonly params: unknown;
+    readonly requestedBy: string;
+    readonly deferred: MutableDeferredResource;
 }
 /**
- * Context object provided to simple plugins.
+ * A mutable deferred resource used during resolution.
+ * @internal
+ */
+export interface MutableDeferredResource<T = unknown> {
+    readonly kind: string;
+    readonly params: unknown;
+    resolved: boolean;
+    value: T | undefined;
+}
+/**
+ * Create a mutable deferred resource.
+ * @internal
+ */
+export declare const createDeferredResource: <T = unknown>(kind: string, params: unknown) => MutableDeferredResource<T>;
+/**
+ * Create a read-only deferred resource view.
+ * Throws if accessed before resolution.
+ * @internal
+ */
+export declare const asDeferredResource: <T>(mutable: MutableDeferredResource<T>) => DeferredResource<T>;
+/**
+ * Registry for service handlers.
  *
- * This is a convenience wrapper around the Effect services,
- * providing a plain object API for plugins that don't need
- * full Effect capabilities.
+ * Plugins register handlers during their provide() call.
+ * Other plugins can then invoke these handlers via ctx.request().
  */
-export interface SimplePluginContext {
-    /** Read-only access to the IR */
-    readonly ir: SemanticIR;
-    /** Core inflection service */
-    readonly inflection: CoreInflection;
-    /** Symbol registry for cross-file imports */
-    readonly symbols: SymbolRegistry;
-    /** Type hints registry */
-    readonly typeHints: TypeHintRegistry;
-    /** Emit string content to a file (buffered) */
-    readonly emit: (path: string, content: string) => void;
+export interface ServiceRegistry {
     /**
-     * Emit an AST program to a file (buffered).
-     * The plugin runner handles serialization after all plugins run.
+     * Register a handler for a resource kind.
+     * Multiple handlers can be registered for the same kind - they're tried in order.
      *
-     * @param path - Output file path
-     * @param ast - The AST program node to emit
-     * @param header - Optional header to prepend (e.g., imports that can't be in AST)
+     * @param kind - Resource kind this handler provides
+     * @param handler - Function to handle requests
+     * @param pluginName - Name of the plugin registering (for error messages)
      */
-    readonly emitAst: (path: string, ast: n.Program, header?: string) => void;
-    /** Append to an already-emitted file */
-    readonly appendEmit: (path: string, content: string) => void;
-    /** Get an artifact from a previous plugin */
-    readonly getArtifact: (capability: CapabilityKey) => Artifact | undefined;
-    /** Store an artifact for downstream plugins */
-    readonly setArtifact: (capability: CapabilityKey, data: unknown) => void;
-    /** Logging */
-    readonly log: SimplePluginLogger;
-    /** Current plugin name */
-    readonly pluginName: string;
-    /** Plugin's inflection for file and symbol naming */
-    readonly pluginInflection: PluginInflection;
+    readonly register: (kind: string, handler: ServiceHandler, pluginName: string) => void;
     /**
-     * Create a FileBuilder for structured file emission.
+     * Invoke a handler for the given kind and params.
      *
-     * Use this for AST-based code generation with automatic symbol registration:
-     *
-     * @example
-     * ```typescript
-     * ctx.file("types/User.ts")
-     *   .header("// Auto-generated")
-     *   .import({ kind: "package", names: ["z"], from: "zod" })
-     *   .ast(symbolProgram(...))
-     *   .emit()
-     * ```
+     * @param kind - Resource kind to request
+     * @param params - Opaque params for the handler
+     * @param ctx - Plugin context to pass to handler
+     * @returns The handler result, or undefined if no handler matched
      */
-    readonly file: (path: string) => FileBuilder;
+    readonly invoke: <T = unknown>(kind: string, params: unknown, ctx: PluginContext) => T | undefined;
+    /**
+     * Check if any handler is registered for a kind.
+     */
+    readonly hasHandler: (kind: string) => boolean;
 }
 /**
- * Definition for a simple plugin (no Effect knowledge required)
+ * Create a service registry for handler registration and invocation.
  */
-export interface SimplePluginDef<TConfig = unknown, TEncoded = TConfig> {
-    /** Unique plugin name */
-    readonly name: string;
-    /** Capabilities this plugin requires */
-    readonly requires?: readonly CapabilityKey[];
-    /** Capabilities this plugin provides */
-    readonly provides: readonly CapabilityKey[];
-    /** Configuration schema - Type is the decoded config, Encoded can differ (e.g., with defaults) */
-    readonly configSchema: S.Schema<TConfig, TEncoded, never>;
-    /** Plugin-specific inflection for file and symbol naming */
-    readonly inflection: PluginInflection;
+export declare const createServiceRegistry: () => ServiceRegistry;
+declare const Services_base: Context.TagClass<Services, "Services", ServiceRegistry>;
+/**
+ * Effect service tag for ServiceRegistry.
+ */
+export declare class Services extends Services_base {
+}
+/**
+ * Plugin registry service interface.
+ *
+ * Manages plugin registration and request collection during execution.
+ */
+export interface PluginRegistry {
+    /**
+     * Register a plugin for a resource kind.
+     *
+     * @param plugin - The plugin to register
+     */
+    readonly register: (plugin: Plugin) => void;
     /**
-     * Plugin's default inflection transforms.
+     * Request a resource. Returns a deferred reference.
      *
-     * These are applied BEFORE user-configured inflection, allowing composition:
-     * - Plugin sets baseline (e.g., entityName: inflect.pascalCase → "users" → "Users")
-     * - User config refines (e.g., entityName: inflect.singularize → "Users" → "User")
+     * The deferred is populated after resolution and execution phases.
+     *
+     * @param kind - Resource kind to request
+     * @param params - Opaque params for the plugin
+     * @param requestedBy - Name of the requester (for error messages)
+     * @returns A deferred resource reference
+     */
+    readonly request: <T = unknown>(kind: string, params: unknown, requestedBy: string) => DeferredResource<T>;
+    /**
+     * Get all registered plugins.
+     * @internal Used by resolution phase.
      */
-    readonly inflectionDefaults?: InflectionConfig;
+    readonly getPlugins: () => readonly Plugin[];
     /**
-     * Plugin execution function.
-     * Can be sync or async (return void or Promise<void>).
+     * Get all pending requests.
+     * @internal Used by resolution phase.
      */
-    readonly run: (ctx: SimplePluginContext, config: TConfig) => void | Promise<void>;
+    readonly getPendingRequests: () => readonly PendingRequest[];
+    /**
+     * Get singleton plugins.
+     * @internal Used by resolution phase to create implicit requests.
+     */
+    readonly getSingletons: () => readonly Plugin[];
 }
+declare const Plugins_base: Context.TagClass<Plugins, "Plugins", PluginRegistry>;
 /**
- * Create a plugin factory from a simple function-based definition.
- *
- * Returns a curried function that accepts config and returns a ConfiguredPlugin.
+ * Effect service tag for PluginRegistry.
+ */
+export declare class Plugins extends Plugins_base {
+}
+/**
+ * Schema for ResourceRequest (for artifact serialization if needed).
+ */
+export declare const ResourceRequestSchema: S.Struct<{
+    kind: typeof S.String;
+    params: typeof S.Unknown;
+}>;
+/**
+ * Define a plugin with type inference.
  *
  * @example
  * ```typescript
- * const myPlugin = definePlugin({
- *   name: "my-plugin",
- *   provides: ["types:row"],
- *   configSchema: S.Struct({ outputDir: S.String }),
- *   inflection: { ... },
- *
- *   run: (ctx, config) => {
- *     for (const entity of ctx.ir.entities.values()) {
- *       ctx.emit(`${config.outputDir}/${entity.name}.ts`, generateType(entity))
- *     }
- *   }
+ * const zodSchemas = definePlugin({
+ *   name: "zod-schemas",
+ *   kind: "validation-schema",
+ *   canProvide: (p) => !p.format || p.format === "zod",
+ *   requires: () => [{ kind: "semantic-ir", params: {} }],
+ *   provide: (params, [ir], ctx) => {
+ *     // Generate schema, return symbol ref
+ *   },
  * })
- *
- * // Usage in config:
- * plugins: [
- *   myPlugin({ outputDir: "types" }),
- * ]
  * ```
  */
-export declare function definePlugin<TConfig, TEncoded = TConfig>(def: SimplePluginDef<TConfig, TEncoded>): PluginFactory<TConfig, TEncoded>;
+export declare function definePlugin<TParams = unknown, TResult = unknown>(plugin: Plugin<TParams, TResult>): Plugin<TParams, TResult>;
+/**
+ * Create a plugin registry for collecting plugins and requests.
+ *
+ * Used during generation to:
+ * 1. Collect plugin registrations
+ * 2. Collect requests during plugin execution
+ * 3. Provide data to resolution phase
+ */
+export declare const createPluginRegistry: () => PluginRegistry;
+/**
+ * Layer providing a fresh plugin registry.
+ */
+export declare const PluginsLive: Layer.Layer<Plugins, never, never>;
+export {};
 //# sourceMappingURL=plugin.d.ts.map