@bubblelab/bubble-core 0.1.0

package/dist/bubbles/tool-bubble/bubbleflow-validation-tool.d.ts

@@ -0,0 +1,308 @@
+/**
+ * BUBBLEFLOW VALIDATION TOOL
+ *
+ * A tool bubble that validates BubbleFlow TypeScript code for syntax, type errors,
+ * and bubble structure. Takes TypeScript bubbleflow code as input and outputs
+ * validation results including any errors and information about detected bubbles.
+ *
+ * Features:
+ * - TypeScript syntax validation
+ * - BubbleFlow class structure validation
+ * - Bubble instantiation parsing and analysis
+ * - Detailed error reporting with line numbers
+ * - Bubble count and type information
+ */
+import { z } from 'zod';
+import { ToolBubble } from '../../types/tool-bubble-class.js';
+import type { BubbleContext } from '../../types/bubble.js';
+/**
+ * Define the parameters schema using Zod
+ * This schema validates and types the input parameters for the validation tool
+ */
+declare const BubbleFlowValidationToolParamsSchema: z.ZodObject<{
+    code: z.ZodString;
+    options: z.ZodOptional<z.ZodObject<{
+        includeDetails: z.ZodDefault<z.ZodBoolean>;
+        strictMode: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        includeDetails: boolean;
+        strictMode: boolean;
+    }, {
+        includeDetails?: boolean | undefined;
+        strictMode?: boolean | undefined;
+    }>>;
+    credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    options?: {
+        includeDetails: boolean;
+        strictMode: boolean;
+    } | undefined;
+    credentials?: Record<string, string> | undefined;
+    config?: Record<string, unknown> | undefined;
+}, {
+    code: string;
+    options?: {
+        includeDetails?: boolean | undefined;
+        strictMode?: boolean | undefined;
+    } | undefined;
+    credentials?: Record<string, string> | undefined;
+    config?: Record<string, unknown> | undefined;
+}>;
+/**
+ * Type definitions derived from schemas
+ */
+type BubbleFlowValidationToolParamsInput = z.input<typeof BubbleFlowValidationToolParamsSchema>;
+type BubbleFlowValidationToolParams = z.output<typeof BubbleFlowValidationToolParamsSchema>;
+type BubbleFlowValidationToolResult = z.output<typeof BubbleFlowValidationToolResultSchema>;
+/**
+ * Define the result schema
+ * This schema defines what the validation tool returns
+ */
+declare const BubbleFlowValidationToolResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    bubbleCount: z.ZodOptional<z.ZodNumber>;
+    bubbles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        variableName: z.ZodString;
+        bubbleName: z.ZodString;
+        className: z.ZodString;
+        hasAwait: z.ZodBoolean;
+        hasActionCall: z.ZodBoolean;
+        parameterCount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        bubbleName: string;
+        variableName: string;
+        className: string;
+        hasAwait: boolean;
+        hasActionCall: boolean;
+        parameterCount: number;
+    }, {
+        bubbleName: string;
+        variableName: string;
+        className: string;
+        hasAwait: boolean;
+        hasActionCall: boolean;
+        parameterCount: number;
+    }>, "many">>;
+    metadata: z.ZodObject<{
+        validatedAt: z.ZodString;
+        codeLength: z.ZodNumber;
+        strictMode: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        strictMode: boolean;
+        validatedAt: string;
+        codeLength: number;
+    }, {
+        strictMode: boolean;
+        validatedAt: string;
+        codeLength: number;
+    }>;
+    success: z.ZodBoolean;
+    error: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    valid: boolean;
+    success: boolean;
+    error: string;
+    metadata: {
+        strictMode: boolean;
+        validatedAt: string;
+        codeLength: number;
+    };
+    bubbles?: {
+        bubbleName: string;
+        variableName: string;
+        className: string;
+        hasAwait: boolean;
+        hasActionCall: boolean;
+        parameterCount: number;
+    }[] | undefined;
+    errors?: string[] | undefined;
+    bubbleCount?: number | undefined;
+}, {
+    valid: boolean;
+    success: boolean;
+    error: string;
+    metadata: {
+        strictMode: boolean;
+        validatedAt: string;
+        codeLength: number;
+    };
+    bubbles?: {
+        bubbleName: string;
+        variableName: string;
+        className: string;
+        hasAwait: boolean;
+        hasActionCall: boolean;
+        parameterCount: number;
+    }[] | undefined;
+    errors?: string[] | undefined;
+    bubbleCount?: number | undefined;
+}>;
+/**
+ * BubbleFlow Validation Tool
+ * Validates TypeScript BubbleFlow code and provides detailed analysis
+ */
+export declare class BubbleFlowValidationTool extends ToolBubble<BubbleFlowValidationToolParams, BubbleFlowValidationToolResult> {
+    /**
+     * REQUIRED STATIC METADATA
+     */
+    static readonly type: "tool";
+    static readonly bubbleName = "bubbleflow-validation-tool";
+    static readonly schema: z.ZodObject<{
+        code: z.ZodString;
+        options: z.ZodOptional<z.ZodObject<{
+            includeDetails: z.ZodDefault<z.ZodBoolean>;
+            strictMode: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            includeDetails: boolean;
+            strictMode: boolean;
+        }, {
+            includeDetails?: boolean | undefined;
+            strictMode?: boolean | undefined;
+        }>>;
+        credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        options?: {
+            includeDetails: boolean;
+            strictMode: boolean;
+        } | undefined;
+        credentials?: Record<string, string> | undefined;
+        config?: Record<string, unknown> | undefined;
+    }, {
+        code: string;
+        options?: {
+            includeDetails?: boolean | undefined;
+            strictMode?: boolean | undefined;
+        } | undefined;
+        credentials?: Record<string, string> | undefined;
+        config?: Record<string, unknown> | undefined;
+    }>;
+    static readonly resultSchema: z.ZodObject<{
+        valid: z.ZodBoolean;
+        errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        bubbleCount: z.ZodOptional<z.ZodNumber>;
+        bubbles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            variableName: z.ZodString;
+            bubbleName: z.ZodString;
+            className: z.ZodString;
+            hasAwait: z.ZodBoolean;
+            hasActionCall: z.ZodBoolean;
+            parameterCount: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            bubbleName: string;
+            variableName: string;
+            className: string;
+            hasAwait: boolean;
+            hasActionCall: boolean;
+            parameterCount: number;
+        }, {
+            bubbleName: string;
+            variableName: string;
+            className: string;
+            hasAwait: boolean;
+            hasActionCall: boolean;
+            parameterCount: number;
+        }>, "many">>;
+        metadata: z.ZodObject<{
+            validatedAt: z.ZodString;
+            codeLength: z.ZodNumber;
+            strictMode: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            strictMode: boolean;
+            validatedAt: string;
+            codeLength: number;
+        }, {
+            strictMode: boolean;
+            validatedAt: string;
+            codeLength: number;
+        }>;
+        success: z.ZodBoolean;
+        error: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        valid: boolean;
+        success: boolean;
+        error: string;
+        metadata: {
+            strictMode: boolean;
+            validatedAt: string;
+            codeLength: number;
+        };
+        bubbles?: {
+            bubbleName: string;
+            variableName: string;
+            className: string;
+            hasAwait: boolean;
+            hasActionCall: boolean;
+            parameterCount: number;
+        }[] | undefined;
+        errors?: string[] | undefined;
+        bubbleCount?: number | undefined;
+    }, {
+        valid: boolean;
+        success: boolean;
+        error: string;
+        metadata: {
+            strictMode: boolean;
+            validatedAt: string;
+            codeLength: number;
+        };
+        bubbles?: {
+            bubbleName: string;
+            variableName: string;
+            className: string;
+            hasAwait: boolean;
+            hasActionCall: boolean;
+            parameterCount: number;
+        }[] | undefined;
+        errors?: string[] | undefined;
+        bubbleCount?: number | undefined;
+    }>;
+    static readonly shortDescription = "Validates BubbleFlow TypeScript code for syntax and structure";
+    static readonly longDescription = "\n    A comprehensive validation tool for BubbleFlow TypeScript code.\n    \n    What it does:\n    - Validates TypeScript syntax and compilation\n    - Checks BubbleFlow class structure and requirements\n    - Parses and analyzes bubble instantiations\n    - Provides detailed error reporting with line numbers\n    - Returns metadata about detected bubbles\n    \n    How it works:\n    - Uses TypeScript compiler API for syntax validation\n    - Validates that code extends BubbleFlow and has handle method\n    - Parses bubble instantiations using AST analysis\n    - Maps bubble class names to registered bubble types\n    \n    Use cases:\n    - When an AI agent needs to validate user-provided BubbleFlow code\n    - When checking code before execution or deployment\n    - When providing feedback on BubbleFlow implementation\n    - When analyzing bubble usage patterns in code\n  ";
+    static readonly alias = "validate-bubbleflow";
+    private bubbleFactory;
+    /**
+     * Constructor
+     */
+    constructor(params: BubbleFlowValidationToolParamsInput, context?: BubbleContext);
+    private initializeBubbleFactory;
+    /**
+     * Main action method - performs BubbleFlow validation
+     */
+    performAction(context?: BubbleContext): Promise<BubbleFlowValidationToolResult>;
+}
+export {};
+/**
+ * REGISTRATION AND USAGE
+ *
+ * 1. Register the tool in the BubbleFactory:
+ * ```typescript
+ * import { BubbleFlowValidationTool } from './services/bubbleflow-validation-tool.js';
+ *
+ * // In registerDefaults() method:
+ * this.register('bubbleflow-validation', BubbleFlowValidationTool as BubbleClassWithMetadata);
+ * ```
+ *
+ * 2. Direct usage:
+ * ```typescript
+ * const tool = new BubbleFlowValidationTool({
+ *   code: 'export class TestFlow extends BubbleFlow<"webhook/http"> { ... }',
+ *   options: { includeDetails: true }
+ * });
+ * const result = await tool.action();
+ * ```
+ *
+ * 3. AI Agent usage:
+ * ```typescript
+ * // AI agent calls with:
+ * {
+ *   "code": "export class TestFlow extends BubbleFlow<'webhook/http'> { ... }",
+ *   "options": { "includeDetails": true, "strictMode": true }
+ * }
+ * ```
+ */
+//# sourceMappingURL=bubbleflow-validation-tool.d.ts.map

package/dist/bubbles/tool-bubble/bubbleflow-validation-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bubbleflow-validation-tool.d.ts","sourceRoot":"","sources":["../../../src/bubbles/tool-bubble/bubbleflow-validation-tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAQ3D;;;GAGG;AACH,QAAA,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCxC,CAAC;AAEH;;GAEG;AACH,KAAK,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,oCAAoC,CAC5C,CAAC;AACF,KAAK,8BAA8B,GAAG,CAAC,CAAC,MAAM,CAC5C,OAAO,oCAAoC,CAC5C,CAAC;AACF,KAAK,8BAA8B,GAAG,CAAC,CAAC,MAAM,CAC5C,OAAO,oCAAoC,CAC5C,CAAC;AAEF;;;GAGG;AACH,QAAA,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+CxC,CAAC;AAEH;;;GAGG;AACH,qBAAa,wBAAyB,SAAQ,UAAU,CACtD,8BAA8B,EAC9B,8BAA8B,CAC/B;IACC;;OAEG;IAGH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAU;IAGvC,MAAM,CAAC,QAAQ,CAAC,UAAU,gCAAgC;IAG1D,MAAM,CAAC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAAwC;IAC9D,MAAM,CAAC,QAAQ,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAAwC;IAGpE,MAAM,CAAC,QAAQ,CAAC,gBAAgB,mEACkC;IAGlE,MAAM,CAAC,QAAQ,CAAC,eAAe,+3BAqB7B;IAGF,MAAM,CAAC,QAAQ,CAAC,KAAK,yBAAyB;IAE9C,OAAO,CAAC,aAAa,CAAgB;IAErC;;OAEG;gBAED,MAAM,EAAE,mCAAmC,EAC3C,OAAO,CAAC,EAAE,aAAa;YAQX,uBAAuB;IAIrC;;OAEG;IACG,aAAa,CACjB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,8BAA8B,CAAC;CAgH3C;;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG"}

package/dist/bubbles/tool-bubble/bubbleflow-validation-tool.js

@@ -0,0 +1,285 @@
+/**
+ * BUBBLEFLOW VALIDATION TOOL
+ *
+ * A tool bubble that validates BubbleFlow TypeScript code for syntax, type errors,
+ * and bubble structure. Takes TypeScript bubbleflow code as input and outputs
+ * validation results including any errors and information about detected bubbles.
+ *
+ * Features:
+ * - TypeScript syntax validation
+ * - BubbleFlow class structure validation
+ * - Bubble instantiation parsing and analysis
+ * - Detailed error reporting with line numbers
+ * - Bubble count and type information
+ */
+import { z } from 'zod';
+import { ToolBubble } from '../../types/tool-bubble-class.js';
+import { BubbleFactory } from '../../bubble-factory.js';
+import { validateBubbleFlow, } from '../../utils/bubbleflow-validation.js';
+import { parseBubbleFlow } from '../../utils/bubbleflow-parser.js';
+/**
+ * Define the parameters schema using Zod
+ * This schema validates and types the input parameters for the validation tool
+ */
+const BubbleFlowValidationToolParamsSchema = z.object({
+    // The TypeScript code to validate
+    code: z.string().describe('TypeScript code to validate'),
+    // Optional validation options
+    options: z
+        .object({
+        includeDetails: z
+            .boolean()
+            .default(true)
+            .describe('Include detailed bubble analysis'),
+        strictMode: z
+            .boolean()
+            .default(true)
+            .describe('Enable strict TypeScript validation'),
+    })
+        .optional()
+        .describe('Validation configuration options'),
+    // Credentials (not needed for this tool but following template)
+    credentials: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('Credentials (HIDDEN from AI - injected at runtime)'),
+    // Optional configuration
+    config: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe('Configuration for the validation tool (HIDDEN from AI - injected at runtime)'),
+});
+/**
+ * Define the result schema
+ * This schema defines what the validation tool returns
+ */
+const BubbleFlowValidationToolResultSchema = z.object({
+    // Validation results
+    valid: z.boolean().describe('Whether the code is valid'),
+    errors: z
+        .array(z.string())
+        .optional()
+        .describe('List of validation errors if any'),
+    // Bubble analysis (when validation succeeds)
+    bubbleCount: z
+        .number()
+        .optional()
+        .describe('Number of bubbles found in the code'),
+    bubbles: z
+        .array(z.object({
+        variableName: z
+            .string()
+            .describe('Variable name assigned to the bubble'),
+        bubbleName: z
+            .string()
+            .describe('Type of bubble (e.g., postgresql, slack)'),
+        className: z
+            .string()
+            .describe('Bubble class name (e.g., PostgreSQLBubble)'),
+        hasAwait: z.boolean().describe('Whether the bubble call is awaited'),
+        hasActionCall: z.boolean().describe('Whether .action() is called'),
+        parameterCount: z
+            .number()
+            .describe('Number of parameters passed to the bubble'),
+    }))
+        .optional()
+        .describe('Details about each bubble found'),
+    // Metadata
+    metadata: z.object({
+        validatedAt: z.string().describe('Timestamp when validation was performed'),
+        codeLength: z.number().describe('Length of the code in characters'),
+        strictMode: z.boolean().describe('Whether strict mode was used'),
+    }),
+    // Standard result fields
+    success: z
+        .boolean()
+        .describe('Whether the validation operation was successful'),
+    error: z.string().describe('Error message if validation failed'),
+});
+/**
+ * BubbleFlow Validation Tool
+ * Validates TypeScript BubbleFlow code and provides detailed analysis
+ */
+export class BubbleFlowValidationTool extends ToolBubble {
+    /**
+     * REQUIRED STATIC METADATA
+     */
+    // Bubble type - always 'tool' for tool bubbles
+    static type = 'tool';
+    // Unique identifier for the tool
+    static bubbleName = 'bubbleflow-validation-tool';
+    // Schemas for validation
+    static schema = BubbleFlowValidationToolParamsSchema;
+    static resultSchema = BubbleFlowValidationToolResultSchema;
+    // Short description
+    static shortDescription = 'Validates BubbleFlow TypeScript code for syntax and structure';
+    // Long description with detailed information
+    static longDescription = `
+    A comprehensive validation tool for BubbleFlow TypeScript code.
+    
+    What it does:
+    - Validates TypeScript syntax and compilation
+    - Checks BubbleFlow class structure and requirements
+    - Parses and analyzes bubble instantiations
+    - Provides detailed error reporting with line numbers
+    - Returns metadata about detected bubbles
+    
+    How it works:
+    - Uses TypeScript compiler API for syntax validation
+    - Validates that code extends BubbleFlow and has handle method
+    - Parses bubble instantiations using AST analysis
+    - Maps bubble class names to registered bubble types
+    
+    Use cases:
+    - When an AI agent needs to validate user-provided BubbleFlow code
+    - When checking code before execution or deployment
+    - When providing feedback on BubbleFlow implementation
+    - When analyzing bubble usage patterns in code
+  `;
+    // Short alias for the tool
+    static alias = 'validate-bubbleflow';
+    bubbleFactory;
+    /**
+     * Constructor
+     */
+    constructor(params, context) {
+        super(params, context);
+        this.bubbleFactory = new BubbleFactory();
+        // Initialize with defaults for bubble class registry - this is async but we need to handle it
+        this.initializeBubbleFactory();
+    }
+    async initializeBubbleFactory() {
+        await this.bubbleFactory.registerDefaults();
+    }
+    /**
+     * Main action method - performs BubbleFlow validation
+     */
+    async performAction(context) {
+        // Context is available but not used in this tool
+        void context;
+        try {
+            // Ensure BubbleFactory is initialized before validation
+            await this.bubbleFactory.registerDefaults();
+            // Extract parameters
+            const { code, options } = this.params;
+            const includeDetails = options?.includeDetails ?? true;
+            const strictMode = options?.strictMode ?? true;
+            if (!code || code.trim().length === 0) {
+                return {
+                    valid: false,
+                    errors: ['Code cannot be empty'],
+                    metadata: {
+                        validatedAt: new Date().toISOString(),
+                        codeLength: 0,
+                        strictMode,
+                    },
+                    success: false,
+                    error: 'Code cannot be empty',
+                };
+            }
+            // Perform TypeScript validation
+            const validationResult = await validateBubbleFlow(code, this.bubbleFactory);
+            if (!validationResult.valid) {
+                return {
+                    valid: false,
+                    errors: validationResult.errors || ['Unknown validation error'],
+                    metadata: {
+                        validatedAt: new Date().toISOString(),
+                        codeLength: code.length,
+                        strictMode,
+                    },
+                    success: false,
+                    error: `Validation failed: ${validationResult.errors?.[0] || 'Unknown error'}`,
+                };
+            }
+            // If validation passes and details are requested, parse bubbles
+            let bubbleDetails;
+            let bubbleCount = 0;
+            if (includeDetails) {
+                const parseResult = parseBubbleFlow(code, this.bubbleFactory);
+                if (!parseResult.success) {
+                    return {
+                        valid: false,
+                        errors: parseResult.errors || ['Failed to parse bubble details'],
+                        metadata: {
+                            validatedAt: new Date().toISOString(),
+                            codeLength: code.length,
+                            strictMode,
+                        },
+                        success: false,
+                        error: `Bubble parsing failed: ${parseResult.errors?.[0] || 'Unknown error'}`,
+                    };
+                }
+                bubbleCount = Object.keys(parseResult.bubbles).length;
+                // Transform parsed bubbles to result format
+                bubbleDetails = Object.values(parseResult.bubbles).map((bubble) => ({
+                    variableName: bubble.variableName,
+                    bubbleName: bubble.bubbleName,
+                    className: bubble.className,
+                    hasAwait: bubble.hasAwait,
+                    hasActionCall: bubble.hasActionCall,
+                    parameterCount: bubble.parameters.length,
+                }));
+            }
+            // Return successful result
+            return {
+                valid: true,
+                bubbleCount,
+                bubbles: bubbleDetails,
+                metadata: {
+                    validatedAt: new Date().toISOString(),
+                    codeLength: code.length,
+                    strictMode,
+                },
+                success: true,
+                error: '',
+            };
+        }
+        catch (error) {
+            // Handle unexpected errors gracefully
+            return {
+                valid: false,
+                errors: [
+                    error instanceof Error ? error.message : 'Unknown validation error',
+                ],
+                metadata: {
+                    validatedAt: new Date().toISOString(),
+                    codeLength: this.params.code?.length || 0,
+                    strictMode: this.params.options?.strictMode ?? true,
+                },
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown validation error',
+            };
+        }
+    }
+}
+/**
+ * REGISTRATION AND USAGE
+ *
+ * 1. Register the tool in the BubbleFactory:
+ * ```typescript
+ * import { BubbleFlowValidationTool } from './services/bubbleflow-validation-tool.js';
+ *
+ * // In registerDefaults() method:
+ * this.register('bubbleflow-validation', BubbleFlowValidationTool as BubbleClassWithMetadata);
+ * ```
+ *
+ * 2. Direct usage:
+ * ```typescript
+ * const tool = new BubbleFlowValidationTool({
+ *   code: 'export class TestFlow extends BubbleFlow<"webhook/http"> { ... }',
+ *   options: { includeDetails: true }
+ * });
+ * const result = await tool.action();
+ * ```
+ *
+ * 3. AI Agent usage:
+ * ```typescript
+ * // AI agent calls with:
+ * {
+ *   "code": "export class TestFlow extends BubbleFlow<'webhook/http'> { ... }",
+ *   "options": { "includeDetails": true, "strictMode": true }
+ * }
+ * ```
+ */
+//# sourceMappingURL=bubbleflow-validation-tool.js.map

package/dist/bubbles/tool-bubble/bubbleflow-validation-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bubbleflow-validation-tool.js","sourceRoot":"","sources":["../../../src/bubbles/tool-bubble/bubbleflow-validation-tool.ts"],"names":[],"mappings":"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"}