@testsmith/testblocks 0.9.4 → 0.9.7

package/dist/core/blocks/procedures/ProcedureCallWithReturnBlock.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcedureCallWithReturnBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+const procedureRegistry_1 = require("./procedureRegistry");
+/**
+ * Call a procedure and get return value.
+ */
+class ProcedureCallWithReturnBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'procedure_call_with_return';
+        this.category = 'Procedures';
+        this.color = '#9C27B0';
+        this.tooltip = 'Call a procedure and get return value';
+        this.output = { type: ['String', 'Number', 'Boolean', 'Object', 'Array'] };
+    }
+    getInputs() {
+        return [
+            { name: 'NAME', type: 'field', fieldType: 'text', required: true },
+            { name: 'ARGS', type: 'field', fieldType: 'text', default: '' },
+        ];
+    }
+    async execute(params, context) {
+        const name = params.NAME;
+        const argsStr = (0, utils_1.resolveVariables)(params.ARGS, context);
+        const procedure = context.procedures?.get(name) || (0, procedureRegistry_1.getProcedure)(name);
+        if (!procedure) {
+            throw new Error(`Procedure not found: ${name}`);
+        }
+        let args = {};
+        if (argsStr.trim()) {
+            try {
+                args = JSON.parse(argsStr);
+            }
+            catch {
+                const values = argsStr.split(',').map(v => v.trim());
+                if (procedure.params) {
+                    procedure.params.forEach((param, index) => {
+                        if (index < values.length) {
+                            args[param.name] = values[index];
+                        }
+                    });
+                }
+            }
+        }
+        return { procedureCall: true, name, args, procedure, expectReturn: true };
+    }
+}
+exports.ProcedureCallWithReturnBlock = ProcedureCallWithReturnBlock;

package/dist/core/blocks/procedures/ProcedureDefineBlock.d.ts

@@ -0,0 +1,15 @@
+import { Block } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Define a reusable procedure with parameters.
+ */
+export declare class ProcedureDefineBlock extends Block {
+    readonly type = "procedure_define";
+    readonly category = "Procedures";
+    readonly color = "#9C27B0";
+    readonly tooltip = "Define a reusable procedure with parameters";
+    readonly previousStatement = false;
+    readonly nextStatement = false;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/procedures/ProcedureDefineBlock.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcedureDefineBlock = void 0;
+const base_1 = require("../base");
+const procedureRegistry_1 = require("./procedureRegistry");
+/**
+ * Define a reusable procedure with parameters.
+ */
+class ProcedureDefineBlock extends base_1.Block {
+    constructor() {
+        super(...arguments);
+        this.type = 'procedure_define';
+        this.category = 'Procedures';
+        this.color = '#9C27B0';
+        this.tooltip = 'Define a reusable procedure with parameters';
+        this.previousStatement = false;
+        this.nextStatement = false;
+    }
+    getInputs() {
+        return [
+            { name: 'NAME', type: 'field', fieldType: 'text', required: true },
+            { name: 'DESCRIPTION', type: 'field', fieldType: 'text', default: '' },
+            { name: 'PARAMS', type: 'field', fieldType: 'text', default: '' }, // comma-separated: "username, password, timeout"
+            { name: 'DO', type: 'statement' },
+        ];
+    }
+    async execute(params, context) {
+        const name = params.NAME;
+        const description = params.DESCRIPTION;
+        const paramsStr = params.PARAMS;
+        // Parse parameters
+        const procedureParams = paramsStr
+            .split(',')
+            .map(p => p.trim())
+            .filter(p => p)
+            .map(p => {
+            // Support type annotations: "username:string", "count:number"
+            const [paramName, paramType] = p.split(':').map(s => s.trim());
+            return {
+                name: paramName,
+                type: paramType || 'any',
+            };
+        });
+        // Register the procedure
+        const procedure = {
+            name,
+            description,
+            params: procedureParams,
+            steps: [], // Steps will be extracted by the executor
+        };
+        (0, procedureRegistry_1.registerProcedure)(name, procedure);
+        if (context.procedures) {
+            context.procedures.set(name, procedure);
+        }
+        context.logger.debug(`Defined procedure: ${name}(${procedureParams.map(p => p.name).join(', ')})`);
+        return { procedureDefine: true, name, procedure };
+    }
+}
+exports.ProcedureDefineBlock = ProcedureDefineBlock;

package/dist/core/blocks/procedures/ProcedureFillFormBlock.d.ts

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Fill multiple form fields from a data object.
+ */
+export declare class ProcedureFillFormBlock extends StatementBlock {
+    readonly type = "procedure_fill_form";
+    readonly category = "Procedures";
+    readonly color = "#AB47BC";
+    readonly tooltip = "Fill multiple form fields from a data object";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/procedures/ProcedureFillFormBlock.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcedureFillFormBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Fill multiple form fields from a data object.
+ */
+class ProcedureFillFormBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'procedure_fill_form';
+        this.category = 'Procedures';
+        this.color = '#AB47BC';
+        this.tooltip = 'Fill multiple form fields from a data object';
+    }
+    getInputs() {
+        return [
+            { name: 'FIELDS', type: 'value', check: 'Object', required: true },
+        ];
+    }
+    async execute(params, _context) {
+        const fields = params.FIELDS;
+        const steps = Object.entries(fields).map(([selector, value]) => ({
+            type: 'web_fill',
+            params: { SELECTOR: selector, VALUE: value },
+        }));
+        return { compoundAction: 'fillForm', steps };
+    }
+}
+exports.ProcedureFillFormBlock = ProcedureFillFormBlock;

package/dist/core/blocks/procedures/ProcedureGetParamBlock.d.ts

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Get a procedure parameter value.
+ */
+export declare class ProcedureGetParamBlock extends ValueBlock {
+    readonly type = "procedure_get_param";
+    readonly category = "Procedures";
+    readonly color = "#9C27B0";
+    readonly tooltip = "Get a procedure parameter value";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/procedures/ProcedureGetParamBlock.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcedureGetParamBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Get a procedure parameter value.
+ */
+class ProcedureGetParamBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'procedure_get_param';
+        this.category = 'Procedures';
+        this.color = '#9C27B0';
+        this.tooltip = 'Get a procedure parameter value';
+        this.output = { type: ['String', 'Number', 'Boolean', 'Object', 'Array'] };
+    }
+    getInputs() {
+        return [
+            { name: 'NAME', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const name = params.NAME;
+        // Parameters are stored in variables with a prefix
+        const value = context.variables.get(`__param_${name}`);
+        if (value === undefined) {
+            // Check regular variables as fallback
+            return context.variables.get(name);
+        }
+        return value;
+    }
+}
+exports.ProcedureGetParamBlock = ProcedureGetParamBlock;

package/dist/core/blocks/procedures/ProcedureInlineBlock.d.ts

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Define and immediately use an inline procedure.
+ */
+export declare class ProcedureInlineBlock extends ValueBlock {
+    readonly type = "procedure_inline";
+    readonly category = "Procedures";
+    readonly color = "#9C27B0";
+    readonly tooltip = "Define and immediately use an inline procedure";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/procedures/ProcedureInlineBlock.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcedureInlineBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Define and immediately use an inline procedure.
+ */
+class ProcedureInlineBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'procedure_inline';
+        this.category = 'Procedures';
+        this.color = '#9C27B0';
+        this.tooltip = 'Define and immediately use an inline procedure';
+        this.output = { type: 'Procedure' };
+    }
+    getInputs() {
+        return [
+            { name: 'PARAMS', type: 'field', fieldType: 'text', default: '' },
+            { name: 'DO', type: 'statement' },
+        ];
+    }
+    async execute(params, _context) {
+        return {
+            inlineProcedure: true,
+            params: params.PARAMS.split(',').map(p => p.trim()).filter(p => p),
+            statement: 'DO',
+        };
+    }
+}
+exports.ProcedureInlineBlock = ProcedureInlineBlock;

package/dist/core/blocks/procedures/ProcedureLoginBlock.d.ts

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Common login action with username and password.
+ */
+export declare class ProcedureLoginBlock extends StatementBlock {
+    readonly type = "procedure_login";
+    readonly category = "Procedures";
+    readonly color = "#AB47BC";
+    readonly tooltip = "Common login action with username and password";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/procedures/ProcedureLoginBlock.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcedureLoginBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Common login action with username and password.
+ */
+class ProcedureLoginBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'procedure_login';
+        this.category = 'Procedures';
+        this.color = '#AB47BC';
+        this.tooltip = 'Common login action with username and password';
+    }
+    getInputs() {
+        return [
+            { name: 'USERNAME_SELECTOR', type: 'field', fieldType: 'text', default: '#username' },
+            { name: 'PASSWORD_SELECTOR', type: 'field', fieldType: 'text', default: '#password' },
+            { name: 'SUBMIT_SELECTOR', type: 'field', fieldType: 'text', default: 'button[type="submit"]' },
+            { name: 'USERNAME', type: 'value', check: 'String', required: true },
+            { name: 'PASSWORD', type: 'value', check: 'String', required: true },
+        ];
+    }
+    async execute(params, _context) {
+        // This is a compound action that expands to multiple steps
+        return {
+            compoundAction: 'login',
+            steps: [
+                { type: 'web_fill', params: { SELECTOR: params.USERNAME_SELECTOR, VALUE: params.USERNAME } },
+                { type: 'web_fill', params: { SELECTOR: params.PASSWORD_SELECTOR, VALUE: params.PASSWORD } },
+                { type: 'web_click', params: { SELECTOR: params.SUBMIT_SELECTOR } },
+            ],
+        };
+    }
+}
+exports.ProcedureLoginBlock = ProcedureLoginBlock;

package/dist/core/blocks/procedures/ProcedureMapBlock.d.ts

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Apply a procedure to each item in an array.
+ */
+export declare class ProcedureMapBlock extends ValueBlock {
+    readonly type = "procedure_map";
+    readonly category = "Procedures";
+    readonly color = "#9C27B0";
+    readonly tooltip = "Apply a procedure to each item in an array";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/procedures/ProcedureMapBlock.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcedureMapBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Apply a procedure to each item in an array.
+ */
+class ProcedureMapBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'procedure_map';
+        this.category = 'Procedures';
+        this.color = '#9C27B0';
+        this.tooltip = 'Apply a procedure to each item in an array';
+        this.output = { type: 'Array' };
+    }
+    getInputs() {
+        return [
+            { name: 'ARRAY', type: 'value', check: 'Array', required: true },
+            { name: 'PROCEDURE', type: 'field', fieldType: 'text', required: true },
+            { name: 'ITEM_PARAM', type: 'field', fieldType: 'text', default: 'item' },
+        ];
+    }
+    async execute(params, _context) {
+        const array = params.ARRAY;
+        const procedureName = params.PROCEDURE;
+        const itemParam = params.ITEM_PARAM;
+        return {
+            procedureMap: true,
+            array,
+            procedureName,
+            itemParam,
+        };
+    }
+}
+exports.ProcedureMapBlock = ProcedureMapBlock;

package/dist/core/blocks/procedures/ProcedureReturnBlock.d.ts

@@ -0,0 +1,15 @@
+import { Block } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Return a value from a procedure.
+ */
+export declare class ProcedureReturnBlock extends Block {
+    readonly type = "procedure_return";
+    readonly category = "Procedures";
+    readonly color = "#9C27B0";
+    readonly tooltip = "Return a value from a procedure";
+    readonly previousStatement = true;
+    readonly nextStatement = false;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/procedures/ProcedureReturnBlock.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcedureReturnBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Return a value from a procedure.
+ */
+class ProcedureReturnBlock extends base_1.Block {
+    constructor() {
+        super(...arguments);
+        this.type = 'procedure_return';
+        this.category = 'Procedures';
+        this.color = '#9C27B0';
+        this.tooltip = 'Return a value from a procedure';
+        this.previousStatement = true;
+        this.nextStatement = false;
+    }
+    getInputs() {
+        return [
+            { name: 'VALUE', type: 'value' },
+        ];
+    }
+    async execute(params, _context) {
+        const value = params.VALUE;
+        return { procedureReturn: true, value };
+    }
+}
+exports.ProcedureReturnBlock = ProcedureReturnBlock;

package/dist/core/blocks/procedures/ProcedureWaitAndClickBlock.d.ts

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Wait for element to be visible then click.
+ */
+export declare class ProcedureWaitAndClickBlock extends StatementBlock {
+    readonly type = "procedure_wait_and_click";
+    readonly category = "Procedures";
+    readonly color = "#AB47BC";
+    readonly tooltip = "Wait for element to be visible then click";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/procedures/ProcedureWaitAndClickBlock.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcedureWaitAndClickBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Wait for element to be visible then click.
+ */
+class ProcedureWaitAndClickBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'procedure_wait_and_click';
+        this.category = 'Procedures';
+        this.color = '#AB47BC';
+        this.tooltip = 'Wait for element to be visible then click';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'TIMEOUT', type: 'field', fieldType: 'number', default: 30000 },
+        ];
+    }
+    async execute(params, _context) {
+        return {
+            compoundAction: 'waitAndClick',
+            steps: [
+                { type: 'web_wait_for_element', params: { SELECTOR: params.SELECTOR, STATE: 'visible', TIMEOUT: params.TIMEOUT } },
+                { type: 'web_click', params: { SELECTOR: params.SELECTOR } },
+            ],
+        };
+    }
+}
+exports.ProcedureWaitAndClickBlock = ProcedureWaitAndClickBlock;

package/dist/core/blocks/procedures/index.d.ts

@@ -0,0 +1,21 @@
+import { Block } from '../base';
+import { BlockDefinition } from '../../types';
+export { registerProcedure, getProcedure, clearProcedures } from './procedureRegistry';
+export { ProcedureDefineBlock } from './ProcedureDefineBlock';
+export { ProcedureCallBlock } from './ProcedureCallBlock';
+export { ProcedureCallWithReturnBlock } from './ProcedureCallWithReturnBlock';
+export { ProcedureReturnBlock } from './ProcedureReturnBlock';
+export { ProcedureGetParamBlock } from './ProcedureGetParamBlock';
+export { ProcedureInlineBlock } from './ProcedureInlineBlock';
+export { ProcedureMapBlock } from './ProcedureMapBlock';
+export { ProcedureLoginBlock } from './ProcedureLoginBlock';
+export { ProcedureWaitAndClickBlock } from './ProcedureWaitAndClickBlock';
+export { ProcedureFillFormBlock } from './ProcedureFillFormBlock';
+/**
+ * All Procedure block class instances.
+ */
+export declare const procedureBlockClasses: Block[];
+/**
+ * Procedure blocks as BlockDefinition array for backward compatibility.
+ */
+export declare const procedureBlocks: BlockDefinition[];

package/dist/core/blocks/procedures/index.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.procedureBlocks = exports.procedureBlockClasses = exports.ProcedureFillFormBlock = exports.ProcedureWaitAndClickBlock = exports.ProcedureLoginBlock = exports.ProcedureMapBlock = exports.ProcedureInlineBlock = exports.ProcedureGetParamBlock = exports.ProcedureReturnBlock = exports.ProcedureCallWithReturnBlock = exports.ProcedureCallBlock = exports.ProcedureDefineBlock = exports.clearProcedures = exports.getProcedure = exports.registerProcedure = void 0;
+// Registry functions
+var procedureRegistry_1 = require("./procedureRegistry");
+Object.defineProperty(exports, "registerProcedure", { enumerable: true, get: function () { return procedureRegistry_1.registerProcedure; } });
+Object.defineProperty(exports, "getProcedure", { enumerable: true, get: function () { return procedureRegistry_1.getProcedure; } });
+Object.defineProperty(exports, "clearProcedures", { enumerable: true, get: function () { return procedureRegistry_1.clearProcedures; } });
+// Procedure definition and execution blocks
+var ProcedureDefineBlock_1 = require("./ProcedureDefineBlock");
+Object.defineProperty(exports, "ProcedureDefineBlock", { enumerable: true, get: function () { return ProcedureDefineBlock_1.ProcedureDefineBlock; } });
+var ProcedureCallBlock_1 = require("./ProcedureCallBlock");
+Object.defineProperty(exports, "ProcedureCallBlock", { enumerable: true, get: function () { return ProcedureCallBlock_1.ProcedureCallBlock; } });
+var ProcedureCallWithReturnBlock_1 = require("./ProcedureCallWithReturnBlock");
+Object.defineProperty(exports, "ProcedureCallWithReturnBlock", { enumerable: true, get: function () { return ProcedureCallWithReturnBlock_1.ProcedureCallWithReturnBlock; } });
+var ProcedureReturnBlock_1 = require("./ProcedureReturnBlock");
+Object.defineProperty(exports, "ProcedureReturnBlock", { enumerable: true, get: function () { return ProcedureReturnBlock_1.ProcedureReturnBlock; } });
+var ProcedureGetParamBlock_1 = require("./ProcedureGetParamBlock");
+Object.defineProperty(exports, "ProcedureGetParamBlock", { enumerable: true, get: function () { return ProcedureGetParamBlock_1.ProcedureGetParamBlock; } });
+var ProcedureInlineBlock_1 = require("./ProcedureInlineBlock");
+Object.defineProperty(exports, "ProcedureInlineBlock", { enumerable: true, get: function () { return ProcedureInlineBlock_1.ProcedureInlineBlock; } });
+var ProcedureMapBlock_1 = require("./ProcedureMapBlock");
+Object.defineProperty(exports, "ProcedureMapBlock", { enumerable: true, get: function () { return ProcedureMapBlock_1.ProcedureMapBlock; } });
+// Common action blocks
+var ProcedureLoginBlock_1 = require("./ProcedureLoginBlock");
+Object.defineProperty(exports, "ProcedureLoginBlock", { enumerable: true, get: function () { return ProcedureLoginBlock_1.ProcedureLoginBlock; } });
+var ProcedureWaitAndClickBlock_1 = require("./ProcedureWaitAndClickBlock");
+Object.defineProperty(exports, "ProcedureWaitAndClickBlock", { enumerable: true, get: function () { return ProcedureWaitAndClickBlock_1.ProcedureWaitAndClickBlock; } });
+var ProcedureFillFormBlock_1 = require("./ProcedureFillFormBlock");
+Object.defineProperty(exports, "ProcedureFillFormBlock", { enumerable: true, get: function () { return ProcedureFillFormBlock_1.ProcedureFillFormBlock; } });
+// Import all block classes
+const ProcedureDefineBlock_2 = require("./ProcedureDefineBlock");
+const ProcedureCallBlock_2 = require("./ProcedureCallBlock");
+const ProcedureCallWithReturnBlock_2 = require("./ProcedureCallWithReturnBlock");
+const ProcedureReturnBlock_2 = require("./ProcedureReturnBlock");
+const ProcedureGetParamBlock_2 = require("./ProcedureGetParamBlock");
+const ProcedureInlineBlock_2 = require("./ProcedureInlineBlock");
+const ProcedureMapBlock_2 = require("./ProcedureMapBlock");
+const ProcedureLoginBlock_2 = require("./ProcedureLoginBlock");
+const ProcedureWaitAndClickBlock_2 = require("./ProcedureWaitAndClickBlock");
+const ProcedureFillFormBlock_2 = require("./ProcedureFillFormBlock");
+/**
+ * All Procedure block class instances.
+ */
+exports.procedureBlockClasses = [
+    // Core procedure blocks
+    new ProcedureDefineBlock_2.ProcedureDefineBlock(),
+    new ProcedureCallBlock_2.ProcedureCallBlock(),
+    new ProcedureCallWithReturnBlock_2.ProcedureCallWithReturnBlock(),
+    new ProcedureReturnBlock_2.ProcedureReturnBlock(),
+    new ProcedureGetParamBlock_2.ProcedureGetParamBlock(),
+    new ProcedureInlineBlock_2.ProcedureInlineBlock(),
+    new ProcedureMapBlock_2.ProcedureMapBlock(),
+    // Common action blocks
+    new ProcedureLoginBlock_2.ProcedureLoginBlock(),
+    new ProcedureWaitAndClickBlock_2.ProcedureWaitAndClickBlock(),
+    new ProcedureFillFormBlock_2.ProcedureFillFormBlock(),
+];
+/**
+ * Procedure blocks as BlockDefinition array for backward compatibility.
+ */
+exports.procedureBlocks = exports.procedureBlockClasses.map(block => block.toDefinition());

package/dist/core/blocks/{procedures.d.ts → procedures/procedureRegistry.d.ts}

@@ -1,5 +1,13 @@
-import { BlockDefinition, ProcedureDefinition } from '../types';
+import { ProcedureDefinition } from '../../types';
+/**
+ * Register a procedure.
+ */
 export declare function registerProcedure(name: string, procedure: ProcedureDefinition): void;
+/**
+ * Get a procedure by name.
+ */
 export declare function getProcedure(name: string): ProcedureDefinition | undefined;
+/**
+ * Clear all procedures.
+ */
 export declare function clearProcedures(): void;
-export declare const procedureBlocks: BlockDefinition[];

package/dist/core/blocks/procedures/procedureRegistry.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerProcedure = registerProcedure;
+exports.getProcedure = getProcedure;
+exports.clearProcedures = clearProcedures;
+/**
+ * Procedure registry for runtime procedure storage.
+ */
+const procedureRegistry = new Map();
+/**
+ * Register a procedure.
+ */
+function registerProcedure(name, procedure) {
+    procedureRegistry.set(name, procedure);
+}
+/**
+ * Get a procedure by name.
+ */
+function getProcedure(name) {
+    return procedureRegistry.get(name);
+}
+/**
+ * Clear all procedures.
+ */
+function clearProcedures() {
+    procedureRegistry.clear();
+}