@bsb/registry 1.0.1

package/lib/plugins/service-bsb-registry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/service-bsb-registry/index.ts"],"names":[],"mappings":"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"}

package/lib/plugins/service-bsb-registry/index.js

@@ -0,0 +1,661 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plugin = exports.Config = exports.EventSchemas = exports.RegistryConfigSchema = void 0;
+const zod_1 = require("zod");
+const base_1 = require("@bsb/base");
+const db_1 = require("./db");
+const auth_1 = require("./auth");
+const Types = __importStar(require("./types"));
+// ============================================================================
+// Configuration
+// ============================================================================
+/**
+ * Configuration schema for BSB Registry (Core - Event-Driven).
+ */
+exports.RegistryConfigSchema = zod_1.z.object({
+    database: zod_1.z.object({
+        type: zod_1.z.enum(['file', 'postgres']).default('file'),
+        path: zod_1.z.string().default('./.temp/data'),
+    }),
+    auth: zod_1.z.object({
+        requireAuth: zod_1.z.boolean().default(true),
+    }),
+});
+/**
+ * Event schemas for BSB Registry Core.
+ * All operations are event-driven for maximum flexibility.
+ */
+exports.EventSchemas = (0, base_1.createEventSchemas)({
+    onReturnableEvents: {
+        // Plugin Operations
+        'registry.plugin.publish': (0, base_1.createReturnableEvent)(Types.PublishRequestSchema, Types.PublishResponseSchema, 'Publish a new plugin or version'),
+        'registry.plugin.get': (0, base_1.createReturnableEvent)(base_1.bsb.object({
+            org: base_1.bsb.string({ description: 'Organization name' }),
+            name: base_1.bsb.string({ description: 'Plugin name' }),
+            version: (0, base_1.optional)(base_1.bsb.string({ description: 'Version (defaults to latest)' })),
+        }), Types.RegistryEntrySchema, 'Get plugin details by org/name'),
+        'registry.plugin.list': (0, base_1.createReturnableEvent)(Types.ListQuerySchema, Types.ListResultsSchema, 'List plugins with filtering'),
+        'registry.plugin.search': (0, base_1.createReturnableEvent)(Types.SearchQuerySchema, Types.SearchResultsSchema, 'Search plugins by query'),
+        'registry.plugin.delete': (0, base_1.createReturnableEvent)(base_1.bsb.object({
+            org: base_1.bsb.string({ description: 'Organization name' }),
+            name: base_1.bsb.string({ description: 'Plugin name' }),
+            version: (0, base_1.optional)(base_1.bsb.string({ description: 'Version (or all if not provided)' })),
+        }), base_1.bsb.object({
+            success: base_1.bsb.boolean('Success status'),
+            deleted: base_1.bsb.int32({ min: 0, description: 'Number of versions deleted' }),
+        }), 'Delete a plugin or specific version'),
+        'registry.plugin.versions': (0, base_1.createReturnableEvent)(base_1.bsb.object({
+            org: base_1.bsb.string({ description: 'Organization name' }),
+            name: base_1.bsb.string({ description: 'Plugin name' }),
+            majorMinor: (0, base_1.optional)(base_1.bsb.string({ description: 'Filter by major.minor' })),
+        }), Types.VersionListSchema, 'Get all versions of a plugin'),
+        // Stats
+        'registry.stats.get': (0, base_1.createReturnableEvent)(base_1.bsb.object({}), Types.RegistryStatsSchema, 'Get registry statistics'),
+        // Auth Operations
+        'registry.auth.login': (0, base_1.createReturnableEvent)(base_1.bsb.object({
+            username: base_1.bsb.string({ description: 'Username' }),
+            password: base_1.bsb.string({ description: 'Encrypted password' }),
+        }), base_1.bsb.object({
+            success: base_1.bsb.boolean('Login success'),
+            token: (0, base_1.optional)(base_1.bsb.string({ description: 'Auth token' })),
+            expiresAt: (0, base_1.optional)(base_1.bsb.datetime('Expiration')),
+            message: (0, base_1.optional)(base_1.bsb.string({ description: 'Error message' })),
+        }), 'Authenticate user and get token'),
+        'registry.auth.verify': (0, base_1.createReturnableEvent)(base_1.bsb.object({
+            token: base_1.bsb.string({ description: 'Token to verify' }),
+        }), base_1.bsb.object({
+            valid: base_1.bsb.boolean('Token validity'),
+            userId: (0, base_1.optional)(base_1.bsb.string({ description: 'User ID' })),
+            permissions: (0, base_1.optional)(base_1.bsb.array(base_1.bsb.string())),
+        }), 'Verify authentication token'),
+    },
+});
+/**
+ * Config for BSB Registry Core.
+ */
+exports.Config = (0, base_1.createConfigSchema)({
+    name: 'BSB Registry Core',
+    description: 'Event-driven plugin registry core for multi-language BSB plugin storage and discovery',
+    image: '../../../docs/public/assets/images/bsb-logo.png',
+    tags: ['registry', 'plugin', 'marketplace', 'discovery', 'publishing', 'events', 'storage'],
+    documentation: ['./docs/service-bsb-registry.md', './docs/bsb-registry-db-file.md'],
+}, exports.RegistryConfigSchema);
+// ============================================================================
+// Plugin
+// ============================================================================
+/**
+ * BSB Registry Core Plugin (Event-Driven)
+ *
+ * A language-agnostic plugin registry for the BSB framework, similar to npm registry
+ * but supporting plugins from multiple languages (Node.js, C#, Go, Java, Python).
+ *
+ * This is the CORE registry - it only handles events. For HTTP access, use:
+ * - service-bsb-registry-api (HTTP REST API gateway)
+ * - service-bsb-registry-ui (Web interface)
+ *
+ * Features:
+ * - Event-driven architecture (works locally or distributed)
+ * - SQLite/PostgreSQL storage
+ * - Organization-based naming (org/plugin-name)
+ * - Version matching (major.minor with patch interchangeability)
+ * - Authentication with encrypted passwords
+ * - Full-text search
+ * - Documentation storage
+ *
+ * Events:
+ * - registry.plugin.publish - Publish a plugin
+ * - registry.plugin.get - Get plugin details
+ * - registry.plugin.list - List plugins
+ * - registry.plugin.search - Search plugins
+ * - registry.plugin.delete - Delete plugin
+ * - registry.plugin.versions - Get versions
+ * - registry.stats.get - Get statistics
+ * - registry.auth.login - Login
+ * - registry.auth.verify - Verify token
+ */
+class Plugin extends base_1.BSBService {
+    // v9: Required static properties
+    static Config = exports.Config;
+    static EventSchemas = exports.EventSchemas;
+    initBeforePlugins;
+    initAfterPlugins;
+    runBeforePlugins;
+    runAfterPlugins;
+    storage;
+    authManager;
+    constructor(config) {
+        super({
+            ...config,
+            eventSchemas: exports.EventSchemas,
+        });
+        // Create storage backend via factory
+        this.storage = (0, db_1.createStorage)({
+            type: this.config.database.type,
+            path: this.config.database.path,
+        });
+        // Create auth manager -- delegates all storage to the same RegistryDB
+        this.authManager = new auth_1.AuthManager({ requireAuth: this.config.auth.requireAuth }, this.storage);
+    }
+    /**
+     * Initialize resources and register event handlers.
+     */
+    async init(obs) {
+        obs.log.info('Initializing BSB Registry Core');
+        // Initialize storage (database migrations, etc.)
+        await this.storage.init(obs);
+        // Initialize authentication
+        await this.authManager.init(obs);
+        // Register event handlers
+        await this.registerEventHandlers(obs);
+        obs.log.info('BSB Registry Core initialized - event handlers registered');
+    }
+    /**
+     * Run phase - nothing to start (event-driven).
+     */
+    async run(obs) {
+        obs.log.info('BSB Registry Core ready - listening for events');
+    }
+    /**
+     * Cleanup resources.
+     */
+    dispose() {
+        if (this.storage) {
+            this.storage.dispose();
+        }
+    }
+    /**
+     * Register all event handlers.
+     */
+    async registerEventHandlers(obs) {
+        // Plugin Operations
+        await this.events.onReturnableEvent('registry.plugin.publish', obs, async (trace, data) => {
+            return await this.handlePluginPublish(trace, data);
+        });
+        await this.events.onReturnableEvent('registry.plugin.get', obs, async (trace, data) => {
+            return await this.handlePluginGet(trace, data);
+        });
+        await this.events.onReturnableEvent('registry.plugin.list', obs, async (trace, data) => {
+            return await this.handlePluginList(trace, data);
+        });
+        await this.events.onReturnableEvent('registry.plugin.search', obs, async (trace, data) => {
+            return await this.handlePluginSearch(trace, data);
+        });
+        await this.events.onReturnableEvent('registry.plugin.delete', obs, async (trace, data) => {
+            return await this.handlePluginDelete(trace, data);
+        });
+        await this.events.onReturnableEvent('registry.plugin.versions', obs, async (trace, data) => {
+            return await this.handlePluginVersions(trace, data);
+        });
+        // Stats
+        await this.events.onReturnableEvent('registry.stats.get', obs, async (trace, data) => {
+            return await this.handleStatsGet(trace);
+        });
+        // Auth
+        await this.events.onReturnableEvent('registry.auth.login', obs, async (trace, data) => {
+            return await this.handleAuthLogin(trace, data);
+        });
+        await this.events.onReturnableEvent('registry.auth.verify', obs, async (trace, data) => {
+            return await this.handleAuthVerify(trace, data);
+        });
+        obs.log.debug('Registered {count} event handlers', { count: 9 });
+    }
+    // ============================================================================
+    // Event Handlers (Business Logic with Full Tracing)
+    // ============================================================================
+    /**
+     * Handle plugin publish request
+     */
+    async handlePluginPublish(trace, data) {
+        const span = trace.startSpan('registry.plugin.publish', {
+            org: data.org,
+            name: data.name,
+            version: data.version,
+            language: data.language,
+        });
+        try {
+            trace.log.debug('Publishing plugin {org}/{name} v{version}', {
+                org: data.org,
+                name: data.name,
+                version: data.version,
+            });
+            // Auth is enforced at the HTTP layer (UI server authenticates
+            // the request and resolves the token to a userId before calling
+            // this event). The core plugin trusts the caller.
+            // Check if version already exists (immutable versions)
+            const pluginId = `${data.org}/${data.name}`;
+            const existsSpan = trace.startSpan('storage.versionExists');
+            const exists = await this.storage.versionExists(trace, data.org, data.name, data.version);
+            existsSpan.end();
+            if (exists) {
+                trace.log.warn('Version already exists: {id}@{version}', {
+                    id: pluginId,
+                    version: data.version,
+                });
+                return {
+                    success: false,
+                    pluginId,
+                    version: data.version,
+                    message: `Version ${data.version} already exists. Published versions are immutable - publish a new version instead.`,
+                };
+            }
+            // Build registry entry
+            const buildSpan = trace.startSpan('build.entry');
+            const majorMinor = data.version.split('.').slice(0, 2).join('.');
+            // eventSchema arrives as a parsed object (validated at the HTTP boundary).
+            // It's the full EventSchemaExport: { pluginName, version, events, dependencies? }
+            const parsedExport = (data.eventSchema && typeof data.eventSchema === 'object')
+                ? data.eventSchema
+                : {};
+            // Store only the events map -- pluginName and version are already
+            // at the root level of the registry entry; no need to duplicate them.
+            const eventsMap = parsedExport.events ?? {};
+            // Compute event counts from the events map
+            const counts = this.countEvents(eventsMap);
+            // configSchema arrives as a parsed JSON Schema object (validated at HTTP boundary).
+            // If present, it must have type: "object" and properties -- the HTTP layer enforces this.
+            const configSchema = (data.configSchema && typeof data.configSchema === 'object')
+                ? data.configSchema
+                : undefined;
+            const capabilities = (data.capabilities && typeof data.capabilities === 'object')
+                ? data.capabilities
+                : (parsedExport.capabilities && typeof parsedExport.capabilities === 'object')
+                    ? parsedExport.capabilities
+                    : undefined;
+            // Extract dependencies from the full export if not provided at top level
+            const dependencies = (data.dependencies && data.dependencies.length > 0)
+                ? data.dependencies
+                : parsedExport.dependencies ?? [];
+            const entry = {
+                id: pluginId,
+                org: data.org,
+                name: data.name,
+                displayName: data.metadata.displayName,
+                description: data.metadata.description,
+                version: data.version,
+                majorMinor: majorMinor,
+                language: data.language,
+                category: data.metadata.category,
+                tags: data.metadata.tags,
+                author: data.metadata.author,
+                license: data.metadata.license,
+                homepage: data.metadata.homepage,
+                repository: data.metadata.repository,
+                visibility: data.visibility || 'public',
+                eventSchema: eventsMap,
+                capabilities,
+                configSchema,
+                typeDefinitions: data.typeDefinitions,
+                documentation: data.documentation,
+                dependencies,
+                package: data.package,
+                runtime: data.runtime,
+                eventCount: counts.total,
+                emitEventCount: counts.emit,
+                onEventCount: counts.on,
+                returnableEventCount: counts.returnable,
+                broadcastEventCount: counts.broadcast,
+                publishedBy: data.publishedBy || 'system',
+                publishedAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                downloads: 0,
+            };
+            buildSpan.end();
+            // Store in database (will reject if version exists - double check)
+            const insertSpan = trace.startSpan('storage.insert');
+            await this.storage.insert(trace, entry);
+            insertSpan.end();
+            trace.log.info('Plugin published successfully: {id}@{version}', {
+                id: pluginId,
+                version: data.version,
+            });
+            return {
+                success: true,
+                pluginId,
+                version: data.version,
+                message: 'Plugin published successfully',
+            };
+        }
+        catch (error) {
+            trace.log.error('Failed to publish plugin: {error}', { error: error.message });
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Handle get plugin request
+     */
+    async handlePluginGet(trace, data) {
+        const span = trace.startSpan('registry.plugin.get', { org: data.org, name: data.name });
+        try {
+            trace.log.debug('Getting plugin {org}/{name}', { org: data.org, name: data.name });
+            const getSpan = trace.startSpan('storage.get');
+            const plugin = await this.storage.get(trace, data.org, data.name, data.version);
+            getSpan.end();
+            if (!plugin) {
+                trace.log.warn('Plugin not found: {org}/{name}', { org: data.org, name: data.name });
+                throw new Error(`Plugin not found: ${data.org}/${data.name}`);
+            }
+            // Add plugin metadata to span for dashboarding
+            span.setAttributes({
+                version: plugin.version,
+                category: plugin.category,
+                language: plugin.language,
+            });
+            trace.log.debug('Plugin retrieved: {id}@{version}', { id: plugin.id, version: plugin.version });
+            return plugin;
+        }
+        catch (error) {
+            trace.log.error('Failed to get plugin: {error}', { error: error.message });
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Handle list plugins request
+     */
+    async handlePluginList(trace, data) {
+        const span = trace.startSpan('registry.plugin.list', {
+            ...(data.org && { org: data.org }),
+            ...(data.language && { language: data.language }),
+            ...(data.category && { category: data.category }),
+            ...(data.limit && { limit: data.limit }),
+            ...(data.offset && { offset: data.offset }),
+        });
+        try {
+            trace.log.debug('Listing plugins');
+            const listSpan = trace.startSpan('storage.list');
+            const result = await this.storage.list(trace, data);
+            listSpan.end();
+            const page = Math.floor((data.offset || 0) / (data.limit || 50)) + 1;
+            // Add result metrics to span for dashboarding
+            span.setAttributes({
+                resultCount: result.total,
+                returnedCount: result.results.length,
+            });
+            trace.log.debug('Listed {count} plugins (total: {total})', {
+                count: result.results.length,
+                total: result.total,
+            });
+            return {
+                results: result.results,
+                total: result.total,
+                page,
+            };
+        }
+        catch (error) {
+            trace.log.error('Failed to list plugins: {error}', { error: error.message });
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Handle search plugins request
+     */
+    async handlePluginSearch(trace, data) {
+        const span = trace.startSpan('registry.plugin.search', {
+            query: data.query,
+            ...(data.category && { category: data.category }),
+            ...(data.language && { language: data.language }),
+            limit: data.limit || 20,
+            ...(data.offset && { offset: data.offset }),
+        });
+        try {
+            trace.log.debug('Searching plugins: {query}', { query: data.query });
+            const searchSpan = trace.startSpan('storage.search');
+            const result = await this.storage.search(trace, data);
+            searchSpan.end();
+            // Add result count to span for dashboarding
+            span.setAttributes({
+                resultCount: result.total,
+            });
+            trace.log.info('Found {count} plugins matching "{query}"', {
+                count: result.total,
+                query: data.query,
+            });
+            return {
+                results: result.results,
+                total: result.total,
+                query: data.query,
+            };
+        }
+        catch (error) {
+            trace.log.error('Failed to search plugins: {error}', { error: error.message });
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Handle delete plugin request
+     */
+    async handlePluginDelete(trace, data) {
+        const span = trace.startSpan('registry.plugin.delete', { org: data.org, name: data.name });
+        try {
+            trace.log.debug('Deleting plugin {org}/{name}', { org: data.org, name: data.name });
+            // Auth is enforced at the HTTP layer.
+            // Get current versions count
+            const countSpan = trace.startSpan('storage.getVersions');
+            const versions = await this.storage.getVersions(trace, data.org, data.name);
+            const versionCount = data.version
+                ? versions.filter(v => v.version === data.version).length
+                : versions.length;
+            countSpan.end();
+            // Perform deletion
+            const deleteSpan = trace.startSpan('storage.delete');
+            await this.storage.delete(trace, data.org, data.name, data.version);
+            deleteSpan.end();
+            trace.log.info('Deleted {count} version(s) of {org}/{name}', {
+                count: versionCount,
+                org: data.org,
+                name: data.name,
+            });
+            return {
+                success: true,
+                deleted: versionCount,
+            };
+        }
+        catch (error) {
+            trace.log.error('Failed to delete plugin: {error}', { error: error.message });
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Handle get plugin versions request
+     */
+    async handlePluginVersions(trace, data) {
+        const span = trace.startSpan('registry.plugin.versions', { org: data.org, name: data.name });
+        try {
+            trace.log.debug('Getting versions for {org}/{name}', { org: data.org, name: data.name });
+            const versionsSpan = trace.startSpan('storage.getVersions');
+            const versions = await this.storage.getVersions(trace, data.org, data.name, data.majorMinor);
+            versionsSpan.end();
+            const latest = versions.length > 0 ? versions[0].version : '0.0.0';
+            // Build major.minor -> latest patch map
+            const latestMap = {};
+            for (const v of versions) {
+                if (!latestMap[v.majorMinor] || v.version > latestMap[v.majorMinor]) {
+                    latestMap[v.majorMinor] = v.version;
+                }
+            }
+            trace.log.debug('Found {count} versions for {org}/{name}', {
+                count: versions.length,
+                org: data.org,
+                name: data.name,
+            });
+            return {
+                versions,
+                latest,
+                latestForMajorMinor: JSON.stringify(latestMap),
+            };
+        }
+        catch (error) {
+            trace.log.error('Failed to get versions: {error}', { error: error.message });
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Handle get stats request
+     */
+    async handleStatsGet(trace) {
+        const span = trace.startSpan('registry.stats.get');
+        try {
+            trace.log.debug('Getting registry statistics');
+            const statsSpan = trace.startSpan('storage.getStats');
+            const stats = await this.storage.getStats(trace);
+            statsSpan.end();
+            trace.log.debug('Registry stats: {totalPlugins} plugins', { totalPlugins: stats.totalPlugins });
+            return stats;
+        }
+        catch (error) {
+            trace.log.error('Failed to get stats: {error}', { error: error.message });
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Handle login request
+     */
+    async handleAuthLogin(trace, data) {
+        const span = trace.startSpan('registry.auth.login', { username: data.username });
+        try {
+            trace.log.info('Auth login attempt for user {username}', { username: data.username });
+            // TODO: Implement proper user/password authentication with encrypted password storage
+            // For now, login is not implemented - use API tokens instead
+            trace.log.warn('Login not implemented - use API tokens for authentication');
+            return {
+                success: false,
+                message: 'User/password authentication not implemented. Use API tokens instead.',
+            };
+        }
+        catch (error) {
+            trace.log.error('Login error: {error}', { error: error.message });
+            return {
+                success: false,
+                message: 'Authentication error',
+            };
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Handle verify token request
+     */
+    async handleAuthVerify(trace, data) {
+        const span = trace.startSpan('registry.auth.verify');
+        try {
+            trace.log.debug('Verifying auth token');
+            const verifySpan = trace.startSpan('auth.manager.verify');
+            const resolved = await this.authManager.resolveToken(trace, data.token);
+            verifySpan.end();
+            if (resolved) {
+                trace.log.debug('Token is valid for user {userId}', { userId: resolved.userId });
+                return {
+                    valid: true,
+                    userId: resolved.userId,
+                    permissions: resolved.effectivePermissions,
+                };
+            }
+            else {
+                trace.log.warn('Token verification failed');
+                return {
+                    valid: false,
+                };
+            }
+        }
+        catch (error) {
+            trace.log.error('Token verification error: {error}', { error: error.message });
+            return {
+                valid: false,
+            };
+        }
+        finally {
+            span.end();
+        }
+    }
+    // ============================================================================
+    // Helpers
+    // ============================================================================
+    /**
+     * Count events by type from an events map (Record<string, EventExportEntry>).
+     * The events map is the flat map of event name to definition with `category`.
+     * Gracefully returns zeros if the map is invalid.
+     */
+    countEvents(eventsMap) {
+        const counts = { total: 0, emit: 0, on: 0, returnable: 0, broadcast: 0 };
+        if (!eventsMap || typeof eventsMap !== 'object')
+            return counts;
+        for (const def of Object.values(eventsMap)) {
+            switch (def.category) {
+                case 'emitEvents':
+                    counts.emit++;
+                    break;
+                case 'onEvents':
+                    counts.on++;
+                    break;
+                case 'emitReturnableEvents':
+                case 'onReturnableEvents':
+                    counts.returnable++;
+                    break;
+                case 'emitBroadcast':
+                case 'onBroadcast':
+                    counts.broadcast++;
+                    break;
+            }
+        }
+        counts.total = counts.emit + counts.on + counts.returnable + counts.broadcast;
+        return counts;
+    }
+}
+exports.Plugin = Plugin;
+// Export plugin factory
+exports.default = Plugin;
+//# sourceMappingURL=index.js.map