@promptbook/node 0.112.0-70 → 0.112.0-72

package/umd/index.umd.js

@@ -48,7 +48,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-70';
+    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-72';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -7621,118 +7621,75 @@
      */
 
     /**
-     * All available task types
-     *
-     * There is is distinction between task types and section types
-     * - Every section in markdown has its SectionType
-     * - Some sections are tasks but other can be non-task sections
-     *
-     * @public exported from `@promptbook/core`
-     */
-    const TaskTypes = [
-        'PROMPT',
-        'SIMPLE',
-        'SCRIPT',
-        'DIALOG',
-        // <- [🅱]
-    ];
-
-    /**
-     * All available sections which are not tasks
-     *
-     * @public exported from `@promptbook/core`
-     */
-    const NonTaskSectionTypes = ['EXAMPLE', 'KNOWLEDGE', 'INSTRUMENT', 'ACTION'];
-    /**
-     * All available section types
-     *
-     * There is is distinction between task types and section types
-     * - Every section in markdown has its SectionType
-     * - Some sections are tasks but other can be non-task sections
+     * Parses the boilerplate command
      *
-     * @public exported from `@promptbook/core`
-     */
-    const SectionTypes = [
-        ...TaskTypes.map((TaskType) => `${TaskType}_TASK`),
-        ...NonTaskSectionTypes,
-    ];
-
-    /**
-     * Parses the knowledge command
+     * Note: @@ This command is used as boilerplate for new commands - it should NOT be used in any `.book` file
      *
      * @see `documentationUrl` for more details
      *
-     * @public exported from `@promptbook/editable`
+     * @private within the commands folder
      */
-    const knowledgeCommandParser = {
+    const boilerplateCommandParser = {
         /**
          * Name of the command
          */
-        name: 'KNOWLEDGE',
+        name: 'BOILERPLATE',
+        /**
+         * Aliases for the BOILERPLATE command
+         */
+        aliasNames: ['BP'],
         /**
          * BOILERPLATE command can be used in:
          */
         isUsedInPipelineHead: true,
-        isUsedInPipelineTask: false,
+        isUsedInPipelineTask: true,
         /**
-         * Description of the KNOWLEDGE command
+         * Description of the BOILERPLATE command
          */
-        description: `Tells promptbook which external knowledge to use`,
+        description: `@@`,
         /**
          * Link to documentation
          */
-        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/41',
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/@@',
         /**
-         * Example usages of the KNOWLEDGE command
+         * Example usages of the BOILERPLATE command
          */
-        examples: [
-            'KNOWLEDGE https://www.pavolhejny.com/',
-            'KNOWLEDGE ./hejny-cv.txt',
-            'KNOWLEDGE ./hejny-cv.md',
-            'KNOWLEDGE ./hejny-cv.pdf',
-            'KNOWLEDGE ./hejny-cv.docx',
-            //          <- TODO: [😿] Allow ONLY files scoped in the (sub)directory NOT ../ and test it
-        ],
+        examples: ['BOILERPLATE foo', 'BOILERPLATE bar', 'BP foo', 'BP bar'],
         /**
-         * Parses the KNOWLEDGE command
+         * Parses the BOILERPLATE command
          */
         parse(input) {
             const { args } = input;
-            const knowledgeSourceContent = _spaceTrim.spaceTrim(args[0] || '');
-            if (knowledgeSourceContent === '') {
-                throw new ParseError(`Source is not defined`);
-            }
-            // TODO: [main] !!4 Following checks should be applied every link in the `sourceContent`
-            if (knowledgeSourceContent.startsWith('http://')) {
-                throw new ParseError(`Source is not secure`);
-            }
-            if (!(isValidFilePath(knowledgeSourceContent) || isValidUrl(knowledgeSourceContent))) {
-                throw new ParseError(`Source not valid`);
+            if (args.length !== 1) {
+                throw new ParseError(`BOILERPLATE command requires exactly one argument`);
             }
-            if (knowledgeSourceContent.startsWith('../') ||
-                knowledgeSourceContent.startsWith('/') ||
-                /^[A-Z]:[\\/]+/i.test(knowledgeSourceContent)) {
-                throw new ParseError(`Source cannot be outside of the .book.md folder`);
+            const value = args[0].toLowerCase();
+            if (value.includes('brr')) {
+                throw new ParseError(`BOILERPLATE value can not contain brr`);
             }
             return {
-                type: 'KNOWLEDGE',
-                knowledgeSourceContent,
+                type: 'BOILERPLATE',
+                value,
             };
         },
         /**
-         * Apply the KNOWLEDGE command to the `pipelineJson`
+         * Apply the BOILERPLATE command to the `pipelineJson`
          *
          * Note: `$` is used to indicate that this function mutates given `pipelineJson`
          */
         $applyToPipelineJson(command, $pipelineJson) {
-            const { knowledgeSourceContent } = command;
-            $pipelineJson.knowledgeSources.push({
-                name: knowledgeSourceContentToName(knowledgeSourceContent),
-                knowledgeSourceContent,
-            });
+            throw new ParseError(`BOILERPLATE command is only for testing purposes and should not be used in the .book.md file`);
         },
         /**
-         * Converts the KNOWLEDGE command back to string
+         * Apply the BOILERPLATE command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `taskJson`
+         */
+        $applyToTaskJson(command, $taskJson, $pipelineJson) {
+            throw new ParseError(`BOILERPLATE command is only for testing purposes and should not be used in the .book.md file`);
+        },
+        /**
+         * Converts the BOILERPLATE command back to string
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
@@ -7740,354 +7697,77 @@
             return `---`; // <- TODO: [🛋] Implement
         },
         /**
-         * Reads the KNOWLEDGE command from the `PipelineJson`
+         * Reads the BOILERPLATE command from the `PipelineJson`
          *
          * Note: This is used in `pipelineJsonToString` utility
          */
         takeFromPipelineJson(pipelineJson) {
-            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
+            throw new ParseError(`BOILERPLATE command is only for testing purposes and should not be used in the .book.md file`);
+        },
+        /**
+         * Reads the BOILERPLATE command from the `TaskJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromTaskJson($taskJson) {
+            throw new ParseError(`BOILERPLATE command is only for testing purposes and should not be used in the .book.md file`);
         },
     };
-    // Note: [⛱] There are two types of KNOWLEDGE commands *...(read more in [⛱])*
 
     /**
-     * Parses the section command
+     * Parses the BOOK_VERSION command
      *
      * @see `documentationUrl` for more details
      *
      * @public exported from `@promptbook/editable`
      */
-    const sectionCommandParser = {
+    const bookVersionCommandParser = {
         /**
          * Name of the command
          */
-        name: 'SECTION',
-        /**
-         * Aliases for the SECTION command
-         */
-        aliasNames: [
-            'PROMPT',
-            'SIMPLE',
-            'SCRIPT',
-            'DIALOG',
-            'SAMPLE',
-            'EXAMPLE',
-            'KNOWLEDGE',
-            'INSTRUMENT',
-            'ACTION', // <- Note: [⛱]
-        ],
-        /**
-         * Aliases for the SECTION command
-         */
-        deprecatedNames: ['TEMPLATE', 'BLOCK', 'EXECUTE'],
+        name: 'BOOK_VERSION',
+        aliasNames: ['PTBK_VERSION', 'PROMPTBOOK_VERSION', 'BOOK'],
         /**
          * BOILERPLATE command can be used in:
          */
-        isUsedInPipelineHead: false,
-        isUsedInPipelineTask: true,
+        isUsedInPipelineHead: true,
+        isUsedInPipelineTask: false,
         /**
-         * Description of the SECTION command
+         * Description of the BOOK_VERSION command
          */
-        description: `Defines the purpose of the markdown section - if its a task and which type or something else`,
+        description: `Which version of the Book language is the .book.md using`,
         /**
          * Link to documentation
          */
-        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/64',
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/69',
         /**
-         * Example usages of the SECTION command
+         * Example usages of the BOOK_VERSION command
          */
-        examples: [
-            // Short form:
-            'PROMPT',
-            'SIMPLE',
-            'SCRIPT',
-            'DIALOG',
-            // <- [🅱]
-            'EXAMPLE',
-            'KNOWLEDGE',
-            'INSTRUMENT',
-            'ACTION',
-            // -----------------
-            // Recommended (reversed) form:
-            'PROMPT SECTION',
-            'SIMPLE SECTION',
-            'SCRIPT SECTION',
-            'DIALOG SECTION',
-            // <- [🅱]
-            'EXAMPLE SECTION',
-            'KNOWLEDGE SECTION',
-            'INSTRUMENT SECTION',
-            'ACTION SECTION',
-            // -----------------
-            // Standard form:
-            'SECTION PROMPT',
-            'SECTION SIMPLE',
-            'SECTION SCRIPT',
-            'SECTION DIALOG',
-            // <- [🅱]
-            'SECTION EXAMPLE',
-            'SECTION KNOWLEDGE',
-            'SECTION INSTRUMENT',
-            'SECTION ACTION',
-        ],
-        // TODO: [♓️] order: -10 /* <- Note: Putting before other commands */
+        examples: [`BOOK VERSION ${BOOK_LANGUAGE_VERSION}`, `BOOK ${BOOK_LANGUAGE_VERSION}`],
         /**
-         * Parses the SECTION command
+         * Parses the BOOK_VERSION command
          */
         parse(input) {
-            let { normalized } = input;
-            normalized = normalized.split('SAMPLE').join('EXAMPLE');
-            normalized = normalized.split('EXECUTE_').join('');
-            normalized = normalized.split('DIALOGUE').join('DIALOG');
-            const taskTypes = SectionTypes.filter((sectionType) => normalized.includes(sectionType.split('_TASK').join('')));
-            if (taskTypes.length !== 1) {
-                throw new ParseError(_spaceTrim.spaceTrim((block) => `
-                        Unknown section type "${normalized}"
-
-                        Supported section types are:
-                        ${block(SectionTypes.join(', '))}
-                    `));
+            const { args } = input;
+            const bookVersion = args.pop();
+            if (bookVersion === undefined) {
+                throw new ParseError(`Version is required`);
+            }
+            if (!isValidPromptbookVersion(bookVersion)) {
+                throw new ParseError(`Invalid Promptbook version "${bookVersion}"`);
+            }
+            if (args.length > 0 && !(((args.length === 1 && args[0]) || '').toUpperCase() === 'VERSION')) {
+                throw new ParseError(`Can not have more than one Promptbook version`);
             }
-            const taskType = taskTypes[0];
             return {
-                type: 'SECTION',
-                taskType,
+                type: 'BOOK_VERSION',
+                bookVersion: bookVersion,
             };
         },
         /**
-         * Apply the SECTION command to the `pipelineJson`
+         * Apply the BOOK_VERSION command to the `pipelineJson`
          *
-         * Note: `$` is used to indicate that this function mutates given `taskJson`
-         */
-        $applyToTaskJson(command, $taskJson, $pipelineJson) {
-            if ($taskJson.isSectionTypeSet === true) {
-                throw new ParseError(_spaceTrim.spaceTrim(`
-                    Section type is already defined in the section.
-                    It can be defined only once.
-                `));
-            }
-            $taskJson.isSectionTypeSet = true;
-            // TODO: [🍧][💩] Rearrange better - but at bottom and unwrap from function
-            const expectResultingParameterName = () => {
-                if ($taskJson.resultingParameterName) {
-                    return;
-                }
-                throw new ParseError(`Task section and example section must end with return statement -> {parameterName}`);
-            };
-            if ($taskJson.content === undefined) {
-                throw new UnexpectedError(`Content is missing in the taskJson - probably commands are applied in wrong order`);
-            }
-            if (command.taskType === 'EXAMPLE') {
-                expectResultingParameterName();
-                const parameter = $pipelineJson.parameters.find((param) => param.name === $taskJson.resultingParameterName);
-                if (parameter === undefined) {
-                    // TODO: !!6 Change to logic error for higher level abstraction of chatbot to work
-                    throw new ParseError(`Parameter \`{${$taskJson.resultingParameterName}}\` is not defined so can not define example value of it`);
-                }
-                parameter.exampleValues = parameter.exampleValues || [];
-                parameter.exampleValues.push($taskJson.content);
-                $taskJson.isTask = false;
-                return;
-            }
-            if (command.taskType === 'KNOWLEDGE') {
-                knowledgeCommandParser.$applyToPipelineJson({
-                    type: 'KNOWLEDGE',
-                    knowledgeSourceContent: $taskJson.content, // <- TODO: [🐝][main] !!3 Work with KNOWLEDGE which not referring to the source file or website, but its content itself
-                }, $pipelineJson);
-                $taskJson.isTask = false;
-                return;
-            }
-            if (command.taskType === 'ACTION') {
-                console.error(new NotYetImplementedError('Actions are not implemented yet'));
-                $taskJson.isTask = false;
-                return;
-            }
-            if (command.taskType === 'INSTRUMENT') {
-                console.error(new NotYetImplementedError('Instruments are not implemented yet'));
-                $taskJson.isTask = false;
-                return;
-            }
-            expectResultingParameterName();
-            $taskJson.taskType = command.taskType;
-            $taskJson.isTask = true;
-        },
-        /**
-         * Converts the SECTION command back to string
-         *
-         * Note: This is used in `pipelineJsonToString` utility
-         */
-        stringify(command) {
-            return `---`; // <- TODO: [🛋] Implement
-        },
-        /**
-         * Reads the SECTION command from the `TaskJson`
-         *
-         * Note: This is used in `pipelineJsonToString` utility
-         */
-        takeFromTaskJson($taskJson) {
-            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
-        },
-    };
-    /**
-     * Note: [⛱] There are two types of KNOWLEDGE, ACTION and INSTRUMENT commands:
-     * 1) There are commands `KNOWLEDGE`, `ACTION` and `INSTRUMENT` used in the pipeline head, they just define the knowledge, action or instrument as single line after the command
-     *    - KNOWLEDGE Look at https://en.wikipedia.org/wiki/Artificial_intelligence
-     * 2) `KNOWLEDGE SECTION` which has short form `KNOWLEDGE` is used in the sectiom, does not refer the line itself, but the content of the section block
-     *   - KNOWLEDGE SECTION
-     *
-     *   ```
-     *   Look at https://en.wikipedia.org/wiki/Artificial_intelligence
-     *   ```
-     */
-
-    /**
-     * Parses the boilerplate command
-     *
-     * Note: @@ This command is used as boilerplate for new commands - it should NOT be used in any `.book` file
-     *
-     * @see `documentationUrl` for more details
-     *
-     * @private within the commands folder
-     */
-    const boilerplateCommandParser = {
-        /**
-         * Name of the command
-         */
-        name: 'BOILERPLATE',
-        /**
-         * Aliases for the BOILERPLATE command
-         */
-        aliasNames: ['BP'],
-        /**
-         * BOILERPLATE command can be used in:
-         */
-        isUsedInPipelineHead: true,
-        isUsedInPipelineTask: true,
-        /**
-         * Description of the BOILERPLATE command
-         */
-        description: `@@`,
-        /**
-         * Link to documentation
-         */
-        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/@@',
-        /**
-         * Example usages of the BOILERPLATE command
-         */
-        examples: ['BOILERPLATE foo', 'BOILERPLATE bar', 'BP foo', 'BP bar'],
-        /**
-         * Parses the BOILERPLATE command
-         */
-        parse(input) {
-            const { args } = input;
-            if (args.length !== 1) {
-                throw new ParseError(`BOILERPLATE command requires exactly one argument`);
-            }
-            const value = args[0].toLowerCase();
-            if (value.includes('brr')) {
-                throw new ParseError(`BOILERPLATE value can not contain brr`);
-            }
-            return {
-                type: 'BOILERPLATE',
-                value,
-            };
-        },
-        /**
-         * Apply the BOILERPLATE command to the `pipelineJson`
-         *
-         * Note: `$` is used to indicate that this function mutates given `pipelineJson`
-         */
-        $applyToPipelineJson(command, $pipelineJson) {
-            throw new ParseError(`BOILERPLATE command is only for testing purposes and should not be used in the .book.md file`);
-        },
-        /**
-         * Apply the BOILERPLATE command to the `pipelineJson`
-         *
-         * Note: `$` is used to indicate that this function mutates given `taskJson`
-         */
-        $applyToTaskJson(command, $taskJson, $pipelineJson) {
-            throw new ParseError(`BOILERPLATE command is only for testing purposes and should not be used in the .book.md file`);
-        },
-        /**
-         * Converts the BOILERPLATE command back to string
-         *
-         * Note: This is used in `pipelineJsonToString` utility
-         */
-        stringify(command) {
-            return `---`; // <- TODO: [🛋] Implement
-        },
-        /**
-         * Reads the BOILERPLATE command from the `PipelineJson`
-         *
-         * Note: This is used in `pipelineJsonToString` utility
-         */
-        takeFromPipelineJson(pipelineJson) {
-            throw new ParseError(`BOILERPLATE command is only for testing purposes and should not be used in the .book.md file`);
-        },
-        /**
-         * Reads the BOILERPLATE command from the `TaskJson`
-         *
-         * Note: This is used in `pipelineJsonToString` utility
-         */
-        takeFromTaskJson($taskJson) {
-            throw new ParseError(`BOILERPLATE command is only for testing purposes and should not be used in the .book.md file`);
-        },
-    };
-
-    /**
-     * Parses the BOOK_VERSION command
-     *
-     * @see `documentationUrl` for more details
-     *
-     * @public exported from `@promptbook/editable`
-     */
-    const bookVersionCommandParser = {
-        /**
-         * Name of the command
-         */
-        name: 'BOOK_VERSION',
-        aliasNames: ['PTBK_VERSION', 'PROMPTBOOK_VERSION', 'BOOK'],
-        /**
-         * BOILERPLATE command can be used in:
-         */
-        isUsedInPipelineHead: true,
-        isUsedInPipelineTask: false,
-        /**
-         * Description of the BOOK_VERSION command
-         */
-        description: `Which version of the Book language is the .book.md using`,
-        /**
-         * Link to documentation
-         */
-        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/69',
-        /**
-         * Example usages of the BOOK_VERSION command
-         */
-        examples: [`BOOK VERSION ${BOOK_LANGUAGE_VERSION}`, `BOOK ${BOOK_LANGUAGE_VERSION}`],
-        /**
-         * Parses the BOOK_VERSION command
-         */
-        parse(input) {
-            const { args } = input;
-            const bookVersion = args.pop();
-            if (bookVersion === undefined) {
-                throw new ParseError(`Version is required`);
-            }
-            if (!isValidPromptbookVersion(bookVersion)) {
-                throw new ParseError(`Invalid Promptbook version "${bookVersion}"`);
-            }
-            if (args.length > 0 && !(((args.length === 1 && args[0]) || '').toUpperCase() === 'VERSION')) {
-                throw new ParseError(`Can not have more than one Promptbook version`);
-            }
-            return {
-                type: 'BOOK_VERSION',
-                bookVersion: bookVersion,
-            };
-        },
-        /**
-         * Apply the BOOK_VERSION command to the `pipelineJson`
-         *
-         * Note: `$` is used to indicate that this function mutates given `pipelineJson`
+         * Note: `$` is used to indicate that this function mutates given `pipelineJson`
          */
         $applyToPipelineJson(command, $pipelineJson) {
             // TODO: Warn if the version is overridden
@@ -9170,63 +8850,156 @@
     };
 
     /**
-     * Constant for model variants.
-     *
-     * @see {@link ModelVariant}
-     *
-     * @public exported from `@promptbook/core`
-     */
-    const MODEL_VARIANTS = [
-        'COMPLETION',
-        'CHAT',
-        'IMAGE_GENERATION',
-        'EMBEDDING' /* <- TODO [🏳] */ /* <- [🤖] */,
-    ];
-
-    /**
-     * Parses the model command
+     * Parses the knowledge command
      *
      * @see `documentationUrl` for more details
-     * @deprecated Option to manually set the model requirements is not recommended to use, use `PERSONA` instead
      *
      * @public exported from `@promptbook/editable`
      */
-    const modelCommandParser = {
+    const knowledgeCommandParser = {
         /**
          * Name of the command
          */
-        name: 'MODEL',
+        name: 'KNOWLEDGE',
         /**
          * BOILERPLATE command can be used in:
          */
         isUsedInPipelineHead: true,
-        isUsedInPipelineTask: true,
+        isUsedInPipelineTask: false,
         /**
-         * Description of the MODEL command
+         * Description of the KNOWLEDGE command
          */
-        description: `Tells which \`modelRequirements\` (for example which model) to use for the prompt task execution`,
+        description: `Tells promptbook which external knowledge to use`,
         /**
          * Link to documentation
          */
-        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/67',
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/41',
         /**
-         * Example usages of the MODEL command
+         * Example usages of the KNOWLEDGE command
          */
-        examples: ['MODEL VARIANT Chat', 'MODEL NAME `gpt-4`'],
+        examples: [
+            'KNOWLEDGE https://www.pavolhejny.com/',
+            'KNOWLEDGE ./hejny-cv.txt',
+            'KNOWLEDGE ./hejny-cv.md',
+            'KNOWLEDGE ./hejny-cv.pdf',
+            'KNOWLEDGE ./hejny-cv.docx',
+            //          <- TODO: [😿] Allow ONLY files scoped in the (sub)directory NOT ../ and test it
+        ],
         /**
-         * Parses the MODEL command
+         * Parses the KNOWLEDGE command
          */
         parse(input) {
-            const { args, normalized } = input;
-            const availableVariantsMessage = _spaceTrim.spaceTrim((block) => `
-              Available variants are:
-              ${block(MODEL_VARIANTS.map((variantName) => `- ${variantName}${variantName !== 'EMBEDDING' ? '' : ' (Not available in pipeline)'}`).join('\n'))}
-          `);
-            // TODO: Make this more elegant and dynamically
-            if (normalized.startsWith('MODEL_VARIANT')) {
-                if (normalized === 'MODEL_VARIANT_CHAT') {
-                    return {
-                        type: 'MODEL',
+            const { args } = input;
+            const knowledgeSourceContent = _spaceTrim.spaceTrim(args[0] || '');
+            if (knowledgeSourceContent === '') {
+                throw new ParseError(`Source is not defined`);
+            }
+            // TODO: [main] !!4 Following checks should be applied every link in the `sourceContent`
+            if (knowledgeSourceContent.startsWith('http://')) {
+                throw new ParseError(`Source is not secure`);
+            }
+            if (!(isValidFilePath(knowledgeSourceContent) || isValidUrl(knowledgeSourceContent))) {
+                throw new ParseError(`Source not valid`);
+            }
+            if (knowledgeSourceContent.startsWith('../') ||
+                knowledgeSourceContent.startsWith('/') ||
+                /^[A-Z]:[\\/]+/i.test(knowledgeSourceContent)) {
+                throw new ParseError(`Source cannot be outside of the .book.md folder`);
+            }
+            return {
+                type: 'KNOWLEDGE',
+                knowledgeSourceContent,
+            };
+        },
+        /**
+         * Apply the KNOWLEDGE command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `pipelineJson`
+         */
+        $applyToPipelineJson(command, $pipelineJson) {
+            const { knowledgeSourceContent } = command;
+            $pipelineJson.knowledgeSources.push({
+                name: knowledgeSourceContentToName(knowledgeSourceContent),
+                knowledgeSourceContent,
+            });
+        },
+        /**
+         * Converts the KNOWLEDGE command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify(command) {
+            return `---`; // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the KNOWLEDGE command from the `PipelineJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromPipelineJson(pipelineJson) {
+            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
+        },
+    };
+    // Note: [⛱] There are two types of KNOWLEDGE commands *...(read more in [⛱])*
+
+    /**
+     * Constant for model variants.
+     *
+     * @see {@link ModelVariant}
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const MODEL_VARIANTS = [
+        'COMPLETION',
+        'CHAT',
+        'IMAGE_GENERATION',
+        'EMBEDDING' /* <- TODO [🏳] */ /* <- [🤖] */,
+    ];
+
+    /**
+     * Parses the model command
+     *
+     * @see `documentationUrl` for more details
+     * @deprecated Option to manually set the model requirements is not recommended to use, use `PERSONA` instead
+     *
+     * @public exported from `@promptbook/editable`
+     */
+    const modelCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'MODEL',
+        /**
+         * BOILERPLATE command can be used in:
+         */
+        isUsedInPipelineHead: true,
+        isUsedInPipelineTask: true,
+        /**
+         * Description of the MODEL command
+         */
+        description: `Tells which \`modelRequirements\` (for example which model) to use for the prompt task execution`,
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/67',
+        /**
+         * Example usages of the MODEL command
+         */
+        examples: ['MODEL VARIANT Chat', 'MODEL NAME `gpt-4`'],
+        /**
+         * Parses the MODEL command
+         */
+        parse(input) {
+            const { args, normalized } = input;
+            const availableVariantsMessage = _spaceTrim.spaceTrim((block) => `
+              Available variants are:
+              ${block(MODEL_VARIANTS.map((variantName) => `- ${variantName}${variantName !== 'EMBEDDING' ? '' : ' (Not available in pipeline)'}`).join('\n'))}
+          `);
+            // TODO: Make this more elegant and dynamically
+            if (normalized.startsWith('MODEL_VARIANT')) {
+                if (normalized === 'MODEL_VARIANT_CHAT') {
+                    return {
+                        type: 'MODEL',
                         key: 'modelVariant',
                         value: 'CHAT',
                     };
@@ -9703,69 +9476,296 @@
     };
 
     /**
-     * Parses the url command
+     * All available task types
+     *
+     * There is is distinction between task types and section types
+     * - Every section in markdown has its SectionType
+     * - Some sections are tasks but other can be non-task sections
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const TaskTypes = [
+        'PROMPT',
+        'SIMPLE',
+        'SCRIPT',
+        'DIALOG',
+        // <- [🅱]
+    ];
+
+    /**
+     * All available sections which are not tasks
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const NonTaskSectionTypes = ['EXAMPLE', 'KNOWLEDGE', 'INSTRUMENT', 'ACTION'];
+    /**
+     * All available section types
+     *
+     * There is is distinction between task types and section types
+     * - Every section in markdown has its SectionType
+     * - Some sections are tasks but other can be non-task sections
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const SectionTypes = [
+        ...TaskTypes.map((TaskType) => `${TaskType}_TASK`),
+        ...NonTaskSectionTypes,
+    ];
+
+    /**
+     * Parses the section command
      *
      * @see `documentationUrl` for more details
      *
      * @public exported from `@promptbook/editable`
      */
-    const urlCommandParser = {
+    const sectionCommandParser = {
         /**
          * Name of the command
          */
-        name: 'URL',
-        aliasNames: ['PIPELINE_URL'],
-        /*
-        Note: [🛵] No need for this alias name because it is already preprocessed
-        aliasNames: ['HTTPS'],
-        */
+        name: 'SECTION',
+        /**
+         * Aliases for the SECTION command
+         */
+        aliasNames: [
+            'PROMPT',
+            'SIMPLE',
+            'SCRIPT',
+            'DIALOG',
+            'SAMPLE',
+            'EXAMPLE',
+            'KNOWLEDGE',
+            'INSTRUMENT',
+            'ACTION', // <- Note: [⛱]
+        ],
+        /**
+         * Aliases for the SECTION command
+         */
+        deprecatedNames: ['TEMPLATE', 'BLOCK', 'EXECUTE'],
         /**
          * BOILERPLATE command can be used in:
          */
-        isUsedInPipelineHead: true,
-        isUsedInPipelineTask: false,
+        isUsedInPipelineHead: false,
+        isUsedInPipelineTask: true,
         /**
-         * Description of the URL command
+         * Description of the SECTION command
          */
-        description: `Declares unique URL for the pipeline`,
+        description: `Defines the purpose of the markdown section - if its a task and which type or something else`,
         /**
          * Link to documentation
          */
-        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/70',
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/64',
         /**
-         * Example usages of the URL command
+         * Example usages of the SECTION command
          */
         examples: [
-            'PIPELINE URL https://promptbook.studio/library/write-cv.book',
-            'URL https://promptbook.studio/library/write-cv.book',
-            'https://promptbook.studio/library/write-cv.book',
+            // Short form:
+            'PROMPT',
+            'SIMPLE',
+            'SCRIPT',
+            'DIALOG',
+            // <- [🅱]
+            'EXAMPLE',
+            'KNOWLEDGE',
+            'INSTRUMENT',
+            'ACTION',
+            // -----------------
+            // Recommended (reversed) form:
+            'PROMPT SECTION',
+            'SIMPLE SECTION',
+            'SCRIPT SECTION',
+            'DIALOG SECTION',
+            // <- [🅱]
+            'EXAMPLE SECTION',
+            'KNOWLEDGE SECTION',
+            'INSTRUMENT SECTION',
+            'ACTION SECTION',
+            // -----------------
+            // Standard form:
+            'SECTION PROMPT',
+            'SECTION SIMPLE',
+            'SECTION SCRIPT',
+            'SECTION DIALOG',
+            // <- [🅱]
+            'SECTION EXAMPLE',
+            'SECTION KNOWLEDGE',
+            'SECTION INSTRUMENT',
+            'SECTION ACTION',
         ],
+        // TODO: [♓️] order: -10 /* <- Note: Putting before other commands */
         /**
-         * Parses the URL command
+         * Parses the SECTION command
          */
         parse(input) {
-            const { args } = input;
-            const pipelineUrl = args.pop();
-            if (pipelineUrl === undefined) {
-                throw new ParseError(`URL is required`);
-            }
-            // TODO: [🧠][🚲] This should be maybe tested as logic not parse
-            if (!isValidPipelineUrl(pipelineUrl)) {
-                throw new ParseError(`Invalid pipeline URL "${pipelineUrl}"`);
-            }
-            if (args.length > 0) {
-                throw new ParseError(`Can not have more than one pipeline URL`);
-            }
-            /*
-            TODO: [🐠 Maybe more info from `isValidPipelineUrl`:
-            if (pipelineUrl.protocol !== 'https:') {
-                throw new ParseError(`Protocol must be HTTPS`);
-            }
+            let { normalized } = input;
+            normalized = normalized.split('SAMPLE').join('EXAMPLE');
+            normalized = normalized.split('EXECUTE_').join('');
+            normalized = normalized.split('DIALOGUE').join('DIALOG');
+            const taskTypes = SectionTypes.filter((sectionType) => normalized.includes(sectionType.split('_TASK').join('')));
+            if (taskTypes.length !== 1) {
+                throw new ParseError(_spaceTrim.spaceTrim((block) => `
+                        Unknown section type "${normalized}"
 
-            if (pipelineUrl.hash !== '') {
-                throw new ParseError(
-                    spaceTrim(
-                        `
+                        Supported section types are:
+                        ${block(SectionTypes.join(', '))}
+                    `));
+            }
+            const taskType = taskTypes[0];
+            return {
+                type: 'SECTION',
+                taskType,
+            };
+        },
+        /**
+         * Apply the SECTION command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `taskJson`
+         */
+        $applyToTaskJson(command, $taskJson, $pipelineJson) {
+            if ($taskJson.isSectionTypeSet === true) {
+                throw new ParseError(_spaceTrim.spaceTrim(`
+                    Section type is already defined in the section.
+                    It can be defined only once.
+                `));
+            }
+            $taskJson.isSectionTypeSet = true;
+            // TODO: [🍧][💩] Rearrange better - but at bottom and unwrap from function
+            const expectResultingParameterName = () => {
+                if ($taskJson.resultingParameterName) {
+                    return;
+                }
+                throw new ParseError(`Task section and example section must end with return statement -> {parameterName}`);
+            };
+            if ($taskJson.content === undefined) {
+                throw new UnexpectedError(`Content is missing in the taskJson - probably commands are applied in wrong order`);
+            }
+            if (command.taskType === 'EXAMPLE') {
+                expectResultingParameterName();
+                const parameter = $pipelineJson.parameters.find((param) => param.name === $taskJson.resultingParameterName);
+                if (parameter === undefined) {
+                    // TODO: !!6 Change to logic error for higher level abstraction of chatbot to work
+                    throw new ParseError(`Parameter \`{${$taskJson.resultingParameterName}}\` is not defined so can not define example value of it`);
+                }
+                parameter.exampleValues = parameter.exampleValues || [];
+                parameter.exampleValues.push($taskJson.content);
+                $taskJson.isTask = false;
+                return;
+            }
+            if (command.taskType === 'KNOWLEDGE') {
+                knowledgeCommandParser.$applyToPipelineJson({
+                    type: 'KNOWLEDGE',
+                    knowledgeSourceContent: $taskJson.content, // <- TODO: [🐝][main] !!3 Work with KNOWLEDGE which not referring to the source file or website, but its content itself
+                }, $pipelineJson);
+                $taskJson.isTask = false;
+                return;
+            }
+            if (command.taskType === 'ACTION') {
+                console.error(new NotYetImplementedError('Actions are not implemented yet'));
+                $taskJson.isTask = false;
+                return;
+            }
+            if (command.taskType === 'INSTRUMENT') {
+                console.error(new NotYetImplementedError('Instruments are not implemented yet'));
+                $taskJson.isTask = false;
+                return;
+            }
+            expectResultingParameterName();
+            $taskJson.taskType = command.taskType;
+            $taskJson.isTask = true;
+        },
+        /**
+         * Converts the SECTION command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify(command) {
+            return `---`; // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the SECTION command from the `TaskJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromTaskJson($taskJson) {
+            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
+        },
+    };
+    /**
+     * Note: [⛱] There are two types of KNOWLEDGE, ACTION and INSTRUMENT commands:
+     * 1) There are commands `KNOWLEDGE`, `ACTION` and `INSTRUMENT` used in the pipeline head, they just define the knowledge, action or instrument as single line after the command
+     *    - KNOWLEDGE Look at https://en.wikipedia.org/wiki/Artificial_intelligence
+     * 2) `KNOWLEDGE SECTION` which has short form `KNOWLEDGE` is used in the sectiom, does not refer the line itself, but the content of the section block
+     *   - KNOWLEDGE SECTION
+     *
+     *   ```
+     *   Look at https://en.wikipedia.org/wiki/Artificial_intelligence
+     *   ```
+     */
+
+    /**
+     * Parses the url command
+     *
+     * @see `documentationUrl` for more details
+     *
+     * @public exported from `@promptbook/editable`
+     */
+    const urlCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'URL',
+        aliasNames: ['PIPELINE_URL'],
+        /*
+        Note: [🛵] No need for this alias name because it is already preprocessed
+        aliasNames: ['HTTPS'],
+        */
+        /**
+         * BOILERPLATE command can be used in:
+         */
+        isUsedInPipelineHead: true,
+        isUsedInPipelineTask: false,
+        /**
+         * Description of the URL command
+         */
+        description: `Declares unique URL for the pipeline`,
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/70',
+        /**
+         * Example usages of the URL command
+         */
+        examples: [
+            'PIPELINE URL https://promptbook.studio/library/write-cv.book',
+            'URL https://promptbook.studio/library/write-cv.book',
+            'https://promptbook.studio/library/write-cv.book',
+        ],
+        /**
+         * Parses the URL command
+         */
+        parse(input) {
+            const { args } = input;
+            const pipelineUrl = args.pop();
+            if (pipelineUrl === undefined) {
+                throw new ParseError(`URL is required`);
+            }
+            // TODO: [🧠][🚲] This should be maybe tested as logic not parse
+            if (!isValidPipelineUrl(pipelineUrl)) {
+                throw new ParseError(`Invalid pipeline URL "${pipelineUrl}"`);
+            }
+            if (args.length > 0) {
+                throw new ParseError(`Can not have more than one pipeline URL`);
+            }
+            /*
+            TODO: [🐠 Maybe more info from `isValidPipelineUrl`:
+            if (pipelineUrl.protocol !== 'https:') {
+                throw new ParseError(`Protocol must be HTTPS`);
+            }
+
+            if (pipelineUrl.hash !== '') {
+                throw new ParseError(
+                    spaceTrim(
+                        `
                             URL must not contain hash
                             Hash is used for identification of the section of the pipeline
                         `,
@@ -10156,85 +10156,321 @@
     }
 
     /**
-     * Extracts the interface (input and output parameters) from a pipeline.
+     * Utility function to extract all list items from markdown
      *
-     * @deprecated https://github.com/webgptorg/promptbook/pull/186
-     * @see https://github.com/webgptorg/promptbook/discussions/171
+     * Note: It works with both ul and ol
+     * Note: It omits list items in code blocks
+     * Note: It flattens nested lists
+     * Note: It can not work with html syntax and comments
      *
-     * @public exported from `@promptbook/core`
+     * @param markdown any valid markdown
+     * @returns An array of strings, each representing an individual list item found in the markdown
+     *
+     * @public exported from `@promptbook/markdown-utils`
      */
-    function getPipelineInterface(pipeline) {
-        const pipelineInterface = {
-            inputParameters: [],
-            outputParameters: [],
-        };
-        for (const parameter of pipeline.parameters) {
-            const { isInput, isOutput } = parameter;
-            if (isInput) {
-                pipelineInterface.inputParameters.push(deepClone(parameter));
+    function extractAllListItemsFromMarkdown(markdown) {
+        const lines = markdown.split(/\r?\n/);
+        const listItems = [];
+        let isInCodeBlock = false;
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            if (trimmedLine.startsWith('```')) {
+                isInCodeBlock = !isInCodeBlock;
             }
-            if (isOutput) {
-                pipelineInterface.outputParameters.push(deepClone(parameter));
+            if (!isInCodeBlock && (trimmedLine.startsWith('-') || trimmedLine.match(/^\d+\./))) {
+                const listItem = trimmedLine.replace(/^-|\d+\./, '').trim();
+                listItems.push(listItem);
             }
         }
-        for (const key of ['inputParameters', 'outputParameters']) {
-            pipelineInterface[key].sort(({ name: name1 }, { name: name2 }) => name1.localeCompare(name2));
-        }
-        return exportJson({
-            name: `pipelineInterface`,
-            message: `Result of \`getPipelineInterface\``,
-            order: ['inputParameters', 'outputParameters'],
-            value: pipelineInterface,
-        });
+        return listItems;
     }
 
     /**
-     * Checks if two pipeline interfaces are structurally identical.
-     *
-     * @deprecated https://github.com/webgptorg/promptbook/pull/186
-     * @see https://github.com/webgptorg/promptbook/discussions/171
+     * Builds a short file/url identification block for parse errors.
      *
-     * @public exported from `@promptbook/core`
+     * @private internal utility of `parsePipeline`
      */
-    function isPipelineInterfacesEqual(pipelineInterface1, pipelineInterface2) {
-        for (const whichParameters of ['inputParameters', 'outputParameters']) {
-            const parameters1 = pipelineInterface1[whichParameters]; // <- Note: `isPipelineInterfacesEqual` is just temporary solution, no need to fix this
-            const parameters2 = pipelineInterface2[whichParameters];
-            if (parameters1.length !== parameters2.length) {
-                return false;
-            }
-            for (const parameter of parameters1) {
-                const matchingParameter = parameters2.find(({ name }) => name === parameter.name);
-                if (!matchingParameter) {
-                    return false;
-                }
-                // Note: Do not compare description, it is not relevant for compatibility
-                if (matchingParameter.isInput !== parameter.isInput) {
-                    return false;
-                }
-                if (matchingParameter.isOutput !== parameter.isOutput) {
-                    return false;
-                }
-            }
+    function getPipelineIdentification($pipelineJson) {
+        // Note: This is a 😐 implementation of [🚞]
+        const pipelineIdentificationParts = [];
+        if ($pipelineJson.sourceFile !== undefined) {
+            pipelineIdentificationParts.push(`File: ${$pipelineJson.sourceFile}`);
         }
-        return true;
+        if ($pipelineJson.pipelineUrl !== undefined) {
+            pipelineIdentificationParts.push(`Url: ${$pipelineJson.pipelineUrl}`);
+        }
+        return pipelineIdentificationParts.join('\n');
     }
 
     /**
-     * Checks if a given pipeline satisfies the requirements of a specified pipeline interface.
-     *
-     * @deprecated https://github.com/webgptorg/promptbook/pull/186
-     * @see https://github.com/webgptorg/promptbook/discussions/171
-     * @returns `true` if the pipeline implements the interface, `false` otherwise.
+     * Merges one parameter declaration into the mutable pipeline parameter list.
      *
-     * @public exported from `@promptbook/core`
+     * @private internal utility of `parsePipeline`
      */
-    function isPipelineImplementingInterface(options) {
-        const { pipeline, pipelineInterface } = options;
-        return isPipelineInterfacesEqual(getPipelineInterface(pipeline), pipelineInterface);
-    }
-
-    /**
+    function defineParameter($pipelineJson, parameterCommand) {
+        const { parameterName, parameterDescription, isInput, isOutput } = parameterCommand;
+        if (RESERVED_PARAMETER_NAMES.includes(parameterName)) {
+            throw new ParseError(_spaceTrim.spaceTrim((block) => `
+                    Parameter name {${parameterName}} is reserved and cannot be used as resulting parameter name
+
+                    ${block(getPipelineIdentification($pipelineJson))}
+                `) /* <- TODO: [🚞] */);
+        }
+        const existingParameter = $pipelineJson.parameters.find((parameter) => parameter.name === parameterName);
+        if (existingParameter &&
+            existingParameter.description &&
+            existingParameter.description !== parameterDescription &&
+            parameterDescription) {
+            throw new ParseError(_spaceTrim.spaceTrim((block) => `
+                    Parameter \`{${parameterName}}\` is defined multiple times with different description:
+
+                    ${block(getPipelineIdentification($pipelineJson))}
+
+                    First definition:
+                    ${block(existingParameter.description || '[undefined]')}
+
+                    Second definition:
+                    ${block(parameterDescription || '[undefined]')}
+                `));
+        }
+        if (existingParameter) {
+            if (parameterDescription) {
+                existingParameter.description = parameterDescription;
+            }
+            existingParameter.isInput = existingParameter.isInput || isInput;
+            existingParameter.isOutput = existingParameter.isOutput || isOutput;
+            return;
+        }
+        $pipelineJson.parameters.push({
+            name: parameterName,
+            description: parameterDescription || undefined,
+            isInput,
+            isOutput,
+        });
+    }
+
+    /**
+     * Removes fenced code blocks when deriving human-readable section descriptions.
+     *
+     * @private internal utility of `extractPipelineDescription`
+     */
+    const DESCRIPTION_CODE_BLOCK_REGEXP = /^```.*^```/gms;
+    /**
+     * Removes blockquote lines when deriving human-readable section descriptions.
+     *
+     * @private internal utility of `extractPipelineDescription`
+     */
+    const DESCRIPTION_BLOCKQUOTE_REGEXP = /^>.*$/gm;
+    /**
+     * Removes list items and return statements when deriving human-readable section descriptions.
+     *
+     * @private internal utility of `extractPipelineDescription`
+     */
+    const DESCRIPTION_LIST_ITEM_REGEXP = /^(?:(?:-)|(?:\d\))|(?:`?->))\s+.*$/gm;
+    /**
+     * Extracts the plain-text description from a head or task section body.
+     *
+     * @private internal utility of `parsePipeline`
+     */
+    function extractPipelineDescription(sectionContent) {
+        let description = sectionContent;
+        description = description.split(DESCRIPTION_CODE_BLOCK_REGEXP).join('');
+        description = description.split(DESCRIPTION_BLOCKQUOTE_REGEXP).join('');
+        description = description.split(DESCRIPTION_LIST_ITEM_REGEXP).join('');
+        description = _spaceTrim.spaceTrim(description);
+        if (description === '') {
+            return undefined;
+        }
+        return description;
+    }
+
+    /**
+     * Applies the pipeline head title, description, and head-level commands.
+     *
+     * @private internal utility of `parsePipeline`
+     */
+    function applyPipelineHead(pipelineHead, $pipelineJson) {
+        $pipelineJson.title = pipelineHead.title;
+        $pipelineJson.description = extractPipelineDescription(pipelineHead.content);
+        for (const listItem of extractAllListItemsFromMarkdown(pipelineHead.content)) {
+            applyPipelineHeadCommand(listItem, $pipelineJson);
+        }
+    }
+    /**
+     * Parses and applies one command declared in the pipeline head.
+     *
+     * @private internal utility of `applyPipelineHead`
+     */
+    function applyPipelineHeadCommand(listItem, $pipelineJson) {
+        const command = parseCommand(listItem, 'PIPELINE_HEAD');
+        const commandParser = getParserForCommand(command);
+        if (commandParser.isUsedInPipelineHead !== true /* <- Note: [🦦][4] */) {
+            throw new ParseError(_spaceTrim.spaceTrim((block) => `
+                    Command \`${command.type}\` is not allowed in the head of the pipeline ONLY at the pipeline task
+
+                    ${block(getPipelineIdentification($pipelineJson))}
+                `)); // <- TODO: [🚞]
+        }
+        try {
+            commandParser.$applyToPipelineJson(command, $pipelineJson);
+            //             <- Note: [🦦] Its strange that this assertion must be here, [🦦][4] should do this assertion implicitly
+        }
+        catch (error) {
+            if (!(error instanceof ParseError)) {
+                throw error;
+            }
+            throw new ParseError(_spaceTrim.spaceTrim((block) => `
+                    Command ${command.type} failed to apply to the pipeline
+
+                    The error:
+                    ${block(error.message)}
+
+                    Raw command:
+                    - ${listItem}
+
+                    Usage of ${command.type}:
+                    ${block(commandParser.examples.map((example) => `- ${example}`).join('\n'))}
+
+                    ${block(getPipelineIdentification($pipelineJson))}
+              `)); // <- TODO: [🚞]
+        }
+        if (command.type === 'PARAMETER') {
+            defineParameter($pipelineJson, command);
+            // <- Note: [🍣]
+        }
+    }
+
+    /**
+     * Creates the mutable pipeline JSON structure used throughout parsing.
+     *
+     * @private internal utility of `parsePipeline`
+     */
+    function createInitialPipelineJson(pipelineString) {
+        return {
+            title: DEFAULT_BOOK_TITLE,
+            parameters: [],
+            tasks: [],
+            knowledgeSources: [],
+            knowledgePieces: [],
+            personas: [],
+            preparations: [],
+            sources: [
+                {
+                    type: 'BOOK',
+                    path: null,
+                    // <- TODO: !!6 Pass here path of the file
+                    content: pipelineString,
+                },
+            ],
+        };
+    }
+
+    /**
+     * Creates stable unique task names for duplicate section titles.
+     *
+     * @private internal utility of `parsePipeline`
+     */
+    function createUniqueSectionNameResolver(pipelineSections) {
+        const sectionCounts = {};
+        for (const pipelineSection of pipelineSections) {
+            const sectionName = titleToName(pipelineSection.title);
+            if (sectionCounts[sectionName] === undefined) {
+                sectionCounts[sectionName] = { count: 0, currentIndex: 0 };
+            }
+            sectionCounts[sectionName].count++;
+        }
+        return (title) => {
+            const sectionName = titleToName(title);
+            const sectionCount = sectionCounts[sectionName];
+            if (sectionCount.count === 1) {
+                return sectionName;
+            }
+            const nameWithSuffix = `${sectionName}-${sectionCount.currentIndex}`;
+            sectionCount.currentIndex++;
+            return nameWithSuffix;
+        };
+    }
+
+    /**
+     * Extracts the interface (input and output parameters) from a pipeline.
+     *
+     * @deprecated https://github.com/webgptorg/promptbook/pull/186
+     * @see https://github.com/webgptorg/promptbook/discussions/171
+     *
+     * @public exported from `@promptbook/core`
+     */
+    function getPipelineInterface(pipeline) {
+        const pipelineInterface = {
+            inputParameters: [],
+            outputParameters: [],
+        };
+        for (const parameter of pipeline.parameters) {
+            const { isInput, isOutput } = parameter;
+            if (isInput) {
+                pipelineInterface.inputParameters.push(deepClone(parameter));
+            }
+            if (isOutput) {
+                pipelineInterface.outputParameters.push(deepClone(parameter));
+            }
+        }
+        for (const key of ['inputParameters', 'outputParameters']) {
+            pipelineInterface[key].sort(({ name: name1 }, { name: name2 }) => name1.localeCompare(name2));
+        }
+        return exportJson({
+            name: `pipelineInterface`,
+            message: `Result of \`getPipelineInterface\``,
+            order: ['inputParameters', 'outputParameters'],
+            value: pipelineInterface,
+        });
+    }
+
+    /**
+     * Checks if two pipeline interfaces are structurally identical.
+     *
+     * @deprecated https://github.com/webgptorg/promptbook/pull/186
+     * @see https://github.com/webgptorg/promptbook/discussions/171
+     *
+     * @public exported from `@promptbook/core`
+     */
+    function isPipelineInterfacesEqual(pipelineInterface1, pipelineInterface2) {
+        for (const whichParameters of ['inputParameters', 'outputParameters']) {
+            const parameters1 = pipelineInterface1[whichParameters]; // <- Note: `isPipelineInterfacesEqual` is just temporary solution, no need to fix this
+            const parameters2 = pipelineInterface2[whichParameters];
+            if (parameters1.length !== parameters2.length) {
+                return false;
+            }
+            for (const parameter of parameters1) {
+                const matchingParameter = parameters2.find(({ name }) => name === parameter.name);
+                if (!matchingParameter) {
+                    return false;
+                }
+                // Note: Do not compare description, it is not relevant for compatibility
+                if (matchingParameter.isInput !== parameter.isInput) {
+                    return false;
+                }
+                if (matchingParameter.isOutput !== parameter.isOutput) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Checks if a given pipeline satisfies the requirements of a specified pipeline interface.
+     *
+     * @deprecated https://github.com/webgptorg/promptbook/pull/186
+     * @see https://github.com/webgptorg/promptbook/discussions/171
+     * @returns `true` if the pipeline implements the interface, `false` otherwise.
+     *
+     * @public exported from `@promptbook/core`
+     */
+    function isPipelineImplementingInterface(options) {
+        const { pipeline, pipelineInterface } = options;
+        return isPipelineInterfacesEqual(getPipelineInterface(pipeline), pipelineInterface);
+    }
+
+    /**
      * Set formfactor based on the pipeline interface e
      *
      * @private
@@ -10416,197 +10652,125 @@
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
     /**
-     * Supported script languages
+     * Applies postprocessing and exports the parsed pipeline JSON.
      *
-     * @private internal base for `ScriptLanguage`
+     * @private internal utility of `parsePipeline`
      */
-    const SUPPORTED_SCRIPT_LANGUAGES = ['javascript', 'typescript', 'python'];
-    //          <- TODO: [🏥] DRY
-
+    function finalizeParsedPipeline($pipelineJson) {
+        applyImplicitParameterDirections($pipelineJson);
+        removeUndefinedValuesFromPipeline($pipelineJson);
+        applySyncHighLevelAbstractions($pipelineJson);
+        ensurePipelineFormfactor($pipelineJson);
+        return exportParsedPipelineJson($pipelineJson);
+    }
     /**
-     * Number of padding lines to add at the end of the book content
+     * Applies default INPUT/OUTPUT flags when the author did not specify them explicitly.
      *
-     * @public exported from `@promptbook/core`
+     * @private internal utility of `finalizeParsedPipeline`
      */
-    const PADDING_LINES = 11;
+    function applyImplicitParameterDirections($pipelineJson) {
+        markImplicitInputParameters($pipelineJson);
+        markImplicitOutputParameters($pipelineJson);
+    }
     /**
-     * A function that adds padding to the book content
-     *
-     * Note: [🔂] This function is idempotent.
+     * Marks non-result parameters as pipeline inputs when no input was declared.
      *
-     * @public exported from `@promptbook/core`
+     * @private internal utility of `finalizeParsedPipeline`
      */
-    function padBook(content) {
-        if (!content) {
-            return '\n'.repeat(PADDING_LINES);
+    function markImplicitInputParameters($pipelineJson) {
+        if ($pipelineJson.parameters.some((parameter) => parameter.isInput)) {
+            return;
         }
-        const lines = content.split(/\r?\n/);
-        let trailingEmptyLines = 0;
-        for (let i = lines.length - 1; i >= 0; i--) {
-            const line = lines[i];
-            if (line === undefined) {
-                // Note: This should not happen in reality, but it's here to satisfy TypeScript's noUncheckedIndexedAccess option
-                continue;
-            }
-            if (line.trim() === '') {
-                trailingEmptyLines++;
-            }
-            else {
-                break;
+        for (const parameter of $pipelineJson.parameters) {
+            const isThisParameterResulting = $pipelineJson.tasks.some((task) => task.resultingParameterName === parameter.name);
+            if (!isThisParameterResulting) {
+                parameter.isInput = true;
+                // <- TODO: [💔] Why this is making typescript error in vscode but not in cli
+                //        > Type 'true' is not assignable to type 'false'.ts(2322)
+                //        > (property) isInput: false
+                //        > The parameter is input of the pipeline The parameter is NOT input of the pipeline
             }
         }
-        if (trailingEmptyLines >= PADDING_LINES) {
-            return content;
-        }
-        const linesToAdd = PADDING_LINES - trailingEmptyLines;
-        return (content + '\n'.repeat(linesToAdd));
     }
-    // TODO: [🧠] Maybe export
-
     /**
-     * Removes Markdown (or HTML) comments
-     *
-     * @param {string} content - The string to remove comments from.
-     * @returns {string} The input string with all comments removed.
-     *
-     * @public exported from `@promptbook/markdown-utils`
-     */
-    function removeMarkdownComments(content) {
-        return _spaceTrim.spaceTrim(content.replace(/<!--(.*?)-->/gs, ''));
-    }
-
-    /**
-     * Utility to determine if a pipeline string is in flat format.
-     * A flat pipeline is a simple text without proper structure (headers, blocks, etc).
-     *
-     * @public exported from `@promptbook/editable`
-     */
-    function isFlatPipeline(pipelineString) {
-        pipelineString = removeMarkdownComments(pipelineString);
-        pipelineString = _spaceTrim.spaceTrim(pipelineString);
-        const isMarkdownBeginningWithHeadline = pipelineString.startsWith('# ');
-        //const isLastLineReturnStatement = pipelineString.split(/\r?\n/).pop()!.split('`').join('').startsWith('->');
-        const isBacktickBlockUsed = pipelineString.includes('```');
-        const isQuoteBlocksUsed = /^>\s+/m.test(pipelineString);
-        const isBlocksUsed = isBacktickBlockUsed || isQuoteBlocksUsed;
-        // TODO: [🧉] Also (double)check
-        // > const usedCommands
-        // > const isBlocksUsed
-        // > const returnStatementCount
-        const isFlat = !isMarkdownBeginningWithHeadline && !isBlocksUsed; /* && isLastLineReturnStatement */
-        return isFlat;
-    }
-
-    /**
-     * Converts a pipeline structure to its string representation.
-     *
-     * Transforms a flat, simple pipeline into a properly formatted pipeline string
-     * with sections for title, prompt, and return statement.
+     * Marks every non-input parameter as output when no output was declared.
      *
-     * @public exported from `@promptbook/editable`
+     * @private internal utility of `finalizeParsedPipeline`
      */
-    function deflatePipeline(pipelineString) {
-        if (!isFlatPipeline(pipelineString)) {
-            return pipelineString;
-        }
-        pipelineString = _spaceTrim.spaceTrim(pipelineString);
-        const pipelineStringLines = pipelineString.split(/\r?\n/);
-        const potentialReturnStatement = pipelineStringLines.pop();
-        let returnStatement;
-        if (/(-|=)>\s*\{.*\}/.test(potentialReturnStatement)) {
-            // Note: Last line is return statement
-            returnStatement = potentialReturnStatement;
-        }
-        else {
-            // Note: Last line is not a return statement
-            returnStatement = `-> {${DEFAULT_BOOK_OUTPUT_PARAMETER_NAME}}`;
-            pipelineStringLines.push(potentialReturnStatement);
-        }
-        const prompt = _spaceTrim.spaceTrim(pipelineStringLines.join('\n'));
-        let quotedPrompt;
-        if (prompt.split(/\r?\n/).length <= 1) {
-            quotedPrompt = `> ${prompt}`;
-        }
-        else {
-            quotedPrompt = _spaceTrim.spaceTrim((block) => `
-                \`\`\`
-                ${block(prompt.split('`').join('\\`'))}
-                \`\`\`
-            `);
+    function markImplicitOutputParameters($pipelineJson) {
+        if ($pipelineJson.parameters.some((parameter) => parameter.isOutput)) {
+            return;
+        }
+        for (const parameter of $pipelineJson.parameters) {
+            if (!parameter.isInput) {
+                parameter.isOutput = true;
+                // <- TODO: [💔]
+            }
         }
-        pipelineString = validatePipelineString(_spaceTrim.spaceTrim((block) => `
-                # ${DEFAULT_BOOK_TITLE}
-
-                ## Prompt
-
-                ${block(quotedPrompt)}
-
-                ${returnStatement}
-            `));
-        // <- TODO: Maybe use book` notation
-        return padBook(pipelineString);
     }
-    // TODO: Unit test
-
     /**
-     * Utility function to extract all list items from markdown
-     *
-     * Note: It works with both ul and ol
-     * Note: It omits list items in code blocks
-     * Note: It flattens nested lists
-     * Note: It can not work with html syntax and comments
+     * Removes `undefined` properties from serialized tasks and parameters.
      *
-     * @param markdown any valid markdown
-     * @returns An array of strings, each representing an individual list item found in the markdown
+     * @private internal utility of `finalizeParsedPipeline`
+     */
+    function removeUndefinedValuesFromPipeline($pipelineJson) {
+        $pipelineJson.tasks.forEach(removeUndefinedProperties);
+        $pipelineJson.parameters.forEach(removeUndefinedProperties);
+    }
+    /**
+     * Deletes all own properties with `undefined` values from a mutable JSON entity.
      *
-     * @public exported from `@promptbook/markdown-utils`
+     * @private internal utility of `finalizeParsedPipeline`
      */
-    function extractAllListItemsFromMarkdown(markdown) {
-        const lines = markdown.split(/\r?\n/);
-        const listItems = [];
-        let isInCodeBlock = false;
-        for (const line of lines) {
-            const trimmedLine = line.trim();
-            if (trimmedLine.startsWith('```')) {
-                isInCodeBlock = !isInCodeBlock;
-            }
-            if (!isInCodeBlock && (trimmedLine.startsWith('-') || trimmedLine.match(/^\d+\./))) {
-                const listItem = trimmedLine.replace(/^-|\d+\./, '').trim();
-                listItems.push(listItem);
+    function removeUndefinedProperties(entity) {
+        for (const [key, value] of Object.entries(entity)) {
+            if (value === undefined) {
+                delete entity[key];
             }
         }
-        return listItems;
     }
-
     /**
-     * Extracts exactly ONE code block from markdown.
-     *
-     * - When there are multiple or no code blocks the function throws a `ParseError`
-     *
-     * Note: There are multiple similar functions:
-     * - `extractBlock` just extracts the content of the code block which is also used as built-in function for postprocessing
-     * - `extractJsonBlock` extracts exactly one valid JSON code block
-     * - `extractOneBlockFromMarkdown` extracts exactly one code block with language of the code block
-     * - `extractAllBlocksFromMarkdown` extracts all code blocks with language of the code block
+     * Applies all sync-only high-level abstractions after parsing.
      *
-     * @param markdown any valid markdown
-     * @returns code block with language and content
-     * @throws {ParseError} if there is not exactly one code block in the markdown
+     * @private internal utility of `finalizeParsedPipeline`
+     */
+    function applySyncHighLevelAbstractions($pipelineJson) {
+        for (const highLevelAbstraction of HIGH_LEVEL_ABSTRACTIONS.filter(({ type }) => type === 'SYNC')) {
+            highLevelAbstraction.$applyToPipelineJson($pipelineJson);
+        }
+    }
+    /**
+     * Ensures parsed pipelines always have the default `GENERIC` formfactor.
      *
-     * @public exported from `@promptbook/markdown-utils`
+     * @private internal utility of `finalizeParsedPipeline`
      */
-    function extractOneBlockFromMarkdown(markdown) {
-        const codeBlocks = extractAllBlocksFromMarkdown(markdown);
-        if (codeBlocks.length !== 1) {
-            throw new ParseError(_spaceTrim.spaceTrim((block) => `
-                    There should be exactly 1 code block in task section, found ${codeBlocks.length} code blocks
-
-                    ${block(codeBlocks.map((block, i) => `Block ${i + 1}:\n${block.content}`).join('\n\n\n'))}
-                `));
+    function ensurePipelineFormfactor($pipelineJson) {
+        // Note: [🔆] If formfactor is still not set, set it to 'GENERIC'
+        if ($pipelineJson.formfactorName === undefined) {
+            $pipelineJson.formfactorName = 'GENERIC';
         }
-        return codeBlocks[0];
     }
-    // TODO: [🍓][🌻] Decide of this is internal utility, external util OR validator/postprocessor
+    /**
+     * Finalizes ordering and exports the parsed pipeline JSON.
+     *
+     * @private internal utility of `finalizeParsedPipeline`
+     */
+    function exportParsedPipelineJson($pipelineJson) {
+        return exportJson({
+            name: 'pipelineJson',
+            message: `Result of \`parsePipeline\``,
+            order: ORDER_OF_PIPELINE_JSON,
+            value: {
+                formfactorName: 'GENERIC',
+                // <- Note: [🔆] Setting `formfactorName` is redundant to satisfy the typescript
+                ...$pipelineJson,
+            },
+        });
+    }
+    // TODO: Use spaceTrim more effectively
+    // TODO: [🧠] Parameter flags - isInput, isOutput, isInternal
+    // TODO: [♈] Probably move expectations from tasks to parameters
+    // TODO: [🍙] Make some standard order of json properties
 
     /**
      * Parses markdown section to title its level and content
@@ -10678,213 +10842,24 @@
                     currentType = 'MARKDOWN';
                 }
             }
-            else if (currentType === 'COMMENT') {
-                buffer.push(line);
-                if (line.includes('-->')) {
-                    currentType = 'MARKDOWN';
-                }
-            }
-        }
-        finishSection();
-        return sections;
-    }
-    /**
-     * TODO: [🏛] This can be part of markdown builder
-     * Note: [🕞] In past (commit 42086e1603cbed506482997c00a8ee979af0a247) there was much more
-     *       sophisticated implementation of this function through parsing markdown into JSON structure
-     *       and flattening the actual structure
-     *       NOW we are working just with markdown string and its good enough
-     */
-
-    /**
-     * Normalizes the markdown by flattening the structure
-     *
-     * - It always have h1 - if there is no h1 in the markdown, it will be added `DEFAULT_BOOK_TITLE`
-     * - All other headings are normalized to h2
-     *
-     * @public exported from `@promptbook/markdown-utils`
-     */
-    function flattenMarkdown(markdown) {
-        const sections = splitMarkdownIntoSections(markdown);
-        if (sections.length === 0) {
-            return `# ${DEFAULT_BOOK_TITLE}`;
-        }
-        let flattenedMarkdown = '';
-        const parsedSections = sections.map(parseMarkdownSection);
-        const firstSection = parsedSections.shift();
-        if (firstSection.level === 1) {
-            flattenedMarkdown += `# ${firstSection.title}` + `\n\n`;
-            flattenedMarkdown += firstSection.content + `\n\n`; // <- [🧠] Maybe 3 new lines?
-        }
-        else {
-            parsedSections.unshift(firstSection);
-            flattenedMarkdown += `# ${DEFAULT_BOOK_TITLE}` + `\n\n`; // <- [🧠] Maybe 3 new lines?
-        }
-        for (const { title, content } of parsedSections) {
-            flattenedMarkdown += `## ${title}` + `\n\n`;
-            flattenedMarkdown += content + `\n\n`; // <- [🧠] Maybe 3 new lines?
-        }
-        return _spaceTrim.spaceTrim(flattenedMarkdown);
-    }
-    /**
-     * TODO: [🏛] This can be part of markdown builder
-     * Note: [🕞] In past (commit 42086e1603cbed506482997c00a8ee979af0a247) there was much more
-     *       sophisticated implementation of this function through parsing markdown into JSON structure
-     *       and flattening the actual structure
-     *       NOW we are working just with markdown string and its good enough
-     */
-
-    /**
-     * Normalizes inline parameter mentions wrapped in code spans before markdown flattening.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    const INLINE_CODE_PARAMETER_REGEXP = /`\{(?<parameterName>[a-z0-9_]+)\}`/gi;
-    /**
-     * Normalizes inline return statements wrapped in code spans before markdown flattening.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    const INLINE_CODE_RETURN_PARAMETER_REGEXP = /`->\s+\{(?<parameterName>[a-z0-9_]+)\}`/gi;
-    /**
-     * Matches the trailing return statement of a task section.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    const RESULTING_PARAMETER_LINE_REGEXP = /^->\s*\{(?<resultingParamName>[a-z0-9_]+)\}/im;
-    /**
-     * Removes fenced code blocks when deriving human-readable section descriptions.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    const DESCRIPTION_CODE_BLOCK_REGEXP = /^```.*^```/gms;
-    /**
-     * Removes blockquote lines when deriving human-readable section descriptions.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    const DESCRIPTION_BLOCKQUOTE_REGEXP = /^>.*$/gm;
-    /**
-     * Removes list items and return statements when deriving human-readable section descriptions.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    const DESCRIPTION_LIST_ITEM_REGEXP = /^(?:(?:-)|(?:\d\))|(?:`?->))\s+.*$/gm;
-    /**
-     * Compile pipeline from string (markdown) format to JSON format synchronously
-     *
-     * Note: There are 3 similar functions:
-     * - `compilePipeline` **(preferred)** - which properly compiles the promptbook and uses embedding for external knowledge
-     * - `parsePipeline` - use only if you need to compile promptbook synchronously and it contains NO external knowledge
-     * - `preparePipeline` - just one step in the compilation process
-     *
-     * Note: This function does not validate logic of the pipeline only the parsing
-     * Note: This function acts as compilation process
-     *
-     * @param pipelineString {Promptbook} in string markdown format (.book.md)
-     * @returns {Promptbook} compiled in JSON format (.bookc)
-     * @throws {ParseError} if the promptbook string is not valid
-     *
-     * @public exported from `@promptbook/core`
-     */
-    function parsePipeline(pipelineString) {
-        const $pipelineJson = createInitialPipelineJson(pipelineString);
-        const preparedPipelineString = preparePipelineString(pipelineString, $pipelineJson);
-        const { pipelineHead, pipelineSections } = parsePreparedPipelineSections(preparedPipelineString, $pipelineJson);
-        const getUniqueSectionName = createUniqueSectionNameResolver(pipelineSections);
-        applyPipelineHead(pipelineHead, $pipelineJson);
-        for (const pipelineSection of pipelineSections) {
-            processPipelineSection(pipelineSection, $pipelineJson, getUniqueSectionName);
-        }
-        applyImplicitParameterDirections($pipelineJson);
-        removeUndefinedValuesFromPipeline($pipelineJson);
-        applySyncHighLevelAbstractions($pipelineJson);
-        ensurePipelineFormfactor($pipelineJson);
-        return exportParsedPipelineJson($pipelineJson);
-    }
-    /**
-     * Creates the mutable pipeline JSON structure used throughout parsing.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    function createInitialPipelineJson(pipelineString) {
-        return {
-            title: DEFAULT_BOOK_TITLE,
-            parameters: [],
-            tasks: [],
-            knowledgeSources: [],
-            knowledgePieces: [],
-            personas: [],
-            preparations: [],
-            sources: [
-                {
-                    type: 'BOOK',
-                    path: null,
-                    // <- TODO: !!6 Pass here path of the file
-                    content: pipelineString,
-                },
-            ],
-        };
-    }
-    /**
-     * Builds a short file/url identification block for parse errors.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    function getPipelineIdentification($pipelineJson) {
-        // Note: This is a 😐 implementation of [🚞]
-        const pipelineIdentificationParts = [];
-        if ($pipelineJson.sourceFile !== undefined) {
-            pipelineIdentificationParts.push(`File: ${$pipelineJson.sourceFile}`);
-        }
-        if ($pipelineJson.pipelineUrl !== undefined) {
-            pipelineIdentificationParts.push(`Url: ${$pipelineJson.pipelineUrl}`);
+            else if (currentType === 'COMMENT') {
+                buffer.push(line);
+                if (line.includes('-->')) {
+                    currentType = 'MARKDOWN';
+                }
+            }
         }
-        return pipelineIdentificationParts.join('\n');
-    }
-    /**
-     * Removes shebang/comments and normalizes markdown into a parseable pipeline form.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    function preparePipelineString(pipelineString, $pipelineJson) {
-        pipelineString = removePipelineShebang(pipelineString, $pipelineJson);
-        pipelineString = removeMarkdownComments(pipelineString);
-        pipelineString = _spaceTrim.spaceTrim(pipelineString);
-        // <- TODO: [😧] `spaceTrim` should preserve discriminated type *(or at lease `PipelineString`)*
-        pipelineString = deflatePipeline(pipelineString);
-        pipelineString = flattenMarkdown(pipelineString);
-        pipelineString = pipelineString.replaceAll(INLINE_CODE_PARAMETER_REGEXP, '{$<parameterName>}');
-        pipelineString = pipelineString.replaceAll(INLINE_CODE_RETURN_PARAMETER_REGEXP, '-> {$<parameterName>}');
-        return pipelineString;
+        finishSection();
+        return sections;
     }
     /**
-     * Validates and removes the optional `#!` shebang line for `.book` files.
-     *
-     * @private internal utility of `parsePipeline`
+     * TODO: [🏛] This can be part of markdown builder
+     * Note: [🕞] In past (commit 42086e1603cbed506482997c00a8ee979af0a247) there was much more
+     *       sophisticated implementation of this function through parsing markdown into JSON structure
+     *       and flattening the actual structure
+     *       NOW we are working just with markdown string and its good enough
      */
-    function removePipelineShebang(pipelineString, $pipelineJson) {
-        if (!pipelineString.startsWith('#!')) {
-            return pipelineString;
-        }
-        const [shebangLine, ...restLines] = pipelineString.split(/\r?\n/);
-        const isBookShebang = (shebangLine || '').includes('ptbk');
-        if (!isBookShebang) {
-            throw new ParseError(_spaceTrim.spaceTrim((block) => `
-                    It seems that you try to parse a book file which has non-standard shebang line for book files:
-                    Shebang line must contain 'ptbk'
-
-                    You have:
-                    ${block(shebangLine || '(empty line)')}
-
-                    It should look like this:
-                    #!/usr/bin/env ptbk
 
-                    ${block(getPipelineIdentification($pipelineJson))}
-                `));
-        }
-        return validatePipelineString(restLines.join('\n'));
-    }
     /**
      * Splits the prepared markdown into the pipeline head and task sections.
      *
@@ -10901,7 +10876,7 @@
     /**
      * Ensures the flattened markdown has exactly one h1 head followed by only h2 sections.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `parsePreparedPipelineSections`
      */
     function assertPipelineSectionsStructure(pipelineHead, pipelineSections, $pipelineJson) {
         if (pipelineHead === undefined) {
@@ -10932,148 +10907,270 @@
                 `));
         }
     }
+
     /**
-     * Applies the pipeline head title, description, and head-level commands.
+     * Number of padding lines to add at the end of the book content
      *
-     * @private internal utility of `parsePipeline`
+     * @public exported from `@promptbook/core`
      */
-    function applyPipelineHead(pipelineHead, $pipelineJson) {
-        $pipelineJson.title = pipelineHead.title;
-        $pipelineJson.description = extractPipelineDescription(pipelineHead.content);
-        for (const listItem of extractAllListItemsFromMarkdown(pipelineHead.content)) {
-            applyPipelineHeadCommand(listItem, $pipelineJson);
+    const PADDING_LINES = 11;
+    /**
+     * A function that adds padding to the book content
+     *
+     * Note: [🔂] This function is idempotent.
+     *
+     * @public exported from `@promptbook/core`
+     */
+    function padBook(content) {
+        if (!content) {
+            return '\n'.repeat(PADDING_LINES);
+        }
+        const lines = content.split(/\r?\n/);
+        let trailingEmptyLines = 0;
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i];
+            if (line === undefined) {
+                // Note: This should not happen in reality, but it's here to satisfy TypeScript's noUncheckedIndexedAccess option
+                continue;
+            }
+            if (line.trim() === '') {
+                trailingEmptyLines++;
+            }
+            else {
+                break;
+            }
+        }
+        if (trailingEmptyLines >= PADDING_LINES) {
+            return content;
         }
+        const linesToAdd = PADDING_LINES - trailingEmptyLines;
+        return (content + '\n'.repeat(linesToAdd));
     }
+    // TODO: [🧠] Maybe export
+
     /**
-     * Extracts the plain-text description from a head or task section body.
+     * Removes Markdown (or HTML) comments
      *
-     * @private internal utility of `parsePipeline`
+     * @param {string} content - The string to remove comments from.
+     * @returns {string} The input string with all comments removed.
+     *
+     * @public exported from `@promptbook/markdown-utils`
      */
-    function extractPipelineDescription(sectionContent) {
-        let description = sectionContent;
-        description = description.split(DESCRIPTION_CODE_BLOCK_REGEXP).join('');
-        description = description.split(DESCRIPTION_BLOCKQUOTE_REGEXP).join('');
-        description = description.split(DESCRIPTION_LIST_ITEM_REGEXP).join('');
-        description = _spaceTrim.spaceTrim(description);
-        if (description === '') {
-            return undefined;
-        }
-        return description;
+    function removeMarkdownComments(content) {
+        return _spaceTrim.spaceTrim(content.replace(/<!--(.*?)-->/gs, ''));
     }
+
     /**
-     * Parses and applies one command declared in the pipeline head.
+     * Utility to determine if a pipeline string is in flat format.
+     * A flat pipeline is a simple text without proper structure (headers, blocks, etc).
      *
-     * @private internal utility of `parsePipeline`
+     * @public exported from `@promptbook/editable`
      */
-    function applyPipelineHeadCommand(listItem, $pipelineJson) {
-        const command = parseCommand(listItem, 'PIPELINE_HEAD');
-        const commandParser = getParserForCommand(command);
-        if (commandParser.isUsedInPipelineHead !== true /* <- Note: [🦦][4] */) {
-            throw new ParseError(_spaceTrim.spaceTrim((block) => `
-                    Command \`${command.type}\` is not allowed in the head of the pipeline ONLY at the pipeline task
+    function isFlatPipeline(pipelineString) {
+        pipelineString = removeMarkdownComments(pipelineString);
+        pipelineString = _spaceTrim.spaceTrim(pipelineString);
+        const isMarkdownBeginningWithHeadline = pipelineString.startsWith('# ');
+        //const isLastLineReturnStatement = pipelineString.split(/\r?\n/).pop()!.split('`').join('').startsWith('->');
+        const isBacktickBlockUsed = pipelineString.includes('```');
+        const isQuoteBlocksUsed = /^>\s+/m.test(pipelineString);
+        const isBlocksUsed = isBacktickBlockUsed || isQuoteBlocksUsed;
+        // TODO: [🧉] Also (double)check
+        // > const usedCommands
+        // > const isBlocksUsed
+        // > const returnStatementCount
+        const isFlat = !isMarkdownBeginningWithHeadline && !isBlocksUsed; /* && isLastLineReturnStatement */
+        return isFlat;
+    }
 
-                    ${block(getPipelineIdentification($pipelineJson))}
-                `)); // <- TODO: [🚞]
+    /**
+     * Converts a pipeline structure to its string representation.
+     *
+     * Transforms a flat, simple pipeline into a properly formatted pipeline string
+     * with sections for title, prompt, and return statement.
+     *
+     * @public exported from `@promptbook/editable`
+     */
+    function deflatePipeline(pipelineString) {
+        if (!isFlatPipeline(pipelineString)) {
+            return pipelineString;
         }
-        try {
-            commandParser.$applyToPipelineJson(command, $pipelineJson);
-            //             <- Note: [🦦] Its strange that this assertion must be here, [🦦][4] should do this assertion implicitly
+        pipelineString = _spaceTrim.spaceTrim(pipelineString);
+        const pipelineStringLines = pipelineString.split(/\r?\n/);
+        const potentialReturnStatement = pipelineStringLines.pop();
+        let returnStatement;
+        if (/(-|=)>\s*\{.*\}/.test(potentialReturnStatement)) {
+            // Note: Last line is return statement
+            returnStatement = potentialReturnStatement;
+        }
+        else {
+            // Note: Last line is not a return statement
+            returnStatement = `-> {${DEFAULT_BOOK_OUTPUT_PARAMETER_NAME}}`;
+            pipelineStringLines.push(potentialReturnStatement);
+        }
+        const prompt = _spaceTrim.spaceTrim(pipelineStringLines.join('\n'));
+        let quotedPrompt;
+        if (prompt.split(/\r?\n/).length <= 1) {
+            quotedPrompt = `> ${prompt}`;
+        }
+        else {
+            quotedPrompt = _spaceTrim.spaceTrim((block) => `
+                \`\`\`
+                ${block(prompt.split('`').join('\\`'))}
+                \`\`\`
+            `);
+        }
+        pipelineString = validatePipelineString(_spaceTrim.spaceTrim((block) => `
+                # ${DEFAULT_BOOK_TITLE}
+
+                ## Prompt
+
+                ${block(quotedPrompt)}
+
+                ${returnStatement}
+            `));
+        // <- TODO: Maybe use book` notation
+        return padBook(pipelineString);
+    }
+    // TODO: Unit test
+
+    /**
+     * Normalizes the markdown by flattening the structure
+     *
+     * - It always have h1 - if there is no h1 in the markdown, it will be added `DEFAULT_BOOK_TITLE`
+     * - All other headings are normalized to h2
+     *
+     * @public exported from `@promptbook/markdown-utils`
+     */
+    function flattenMarkdown(markdown) {
+        const sections = splitMarkdownIntoSections(markdown);
+        if (sections.length === 0) {
+            return `# ${DEFAULT_BOOK_TITLE}`;
+        }
+        let flattenedMarkdown = '';
+        const parsedSections = sections.map(parseMarkdownSection);
+        const firstSection = parsedSections.shift();
+        if (firstSection.level === 1) {
+            flattenedMarkdown += `# ${firstSection.title}` + `\n\n`;
+            flattenedMarkdown += firstSection.content + `\n\n`; // <- [🧠] Maybe 3 new lines?
+        }
+        else {
+            parsedSections.unshift(firstSection);
+            flattenedMarkdown += `# ${DEFAULT_BOOK_TITLE}` + `\n\n`; // <- [🧠] Maybe 3 new lines?
+        }
+        for (const { title, content } of parsedSections) {
+            flattenedMarkdown += `## ${title}` + `\n\n`;
+            flattenedMarkdown += content + `\n\n`; // <- [🧠] Maybe 3 new lines?
+        }
+        return _spaceTrim.spaceTrim(flattenedMarkdown);
+    }
+    /**
+     * TODO: [🏛] This can be part of markdown builder
+     * Note: [🕞] In past (commit 42086e1603cbed506482997c00a8ee979af0a247) there was much more
+     *       sophisticated implementation of this function through parsing markdown into JSON structure
+     *       and flattening the actual structure
+     *       NOW we are working just with markdown string and its good enough
+     */
+
+    /**
+     * Normalizes inline parameter mentions wrapped in code spans before markdown flattening.
+     *
+     * @private internal utility of `preparePipelineString`
+     */
+    const INLINE_CODE_PARAMETER_REGEXP = /`\{(?<parameterName>[a-z0-9_]+)\}`/gi;
+    /**
+     * Normalizes inline return statements wrapped in code spans before markdown flattening.
+     *
+     * @private internal utility of `preparePipelineString`
+     */
+    const INLINE_CODE_RETURN_PARAMETER_REGEXP = /`->\s+\{(?<parameterName>[a-z0-9_]+)\}`/gi;
+    /**
+     * Removes shebang/comments and normalizes markdown into a parseable pipeline form.
+     *
+     * @private internal utility of `parsePipeline`
+     */
+    function preparePipelineString(pipelineString, $pipelineJson) {
+        pipelineString = removePipelineShebang(pipelineString, $pipelineJson);
+        pipelineString = removeMarkdownComments(pipelineString);
+        pipelineString = _spaceTrim.spaceTrim(pipelineString);
+        // <- TODO: [😧] `spaceTrim` should preserve discriminated type *(or at lease `PipelineString`)*
+        pipelineString = deflatePipeline(pipelineString);
+        pipelineString = flattenMarkdown(pipelineString);
+        pipelineString = pipelineString.replaceAll(INLINE_CODE_PARAMETER_REGEXP, '{$<parameterName>}');
+        pipelineString = pipelineString.replaceAll(INLINE_CODE_RETURN_PARAMETER_REGEXP, '-> {$<parameterName>}');
+        return pipelineString;
+    }
+    /**
+     * Validates and removes the optional `#!` shebang line for `.book` files.
+     *
+     * @private internal utility of `preparePipelineString`
+     */
+    function removePipelineShebang(pipelineString, $pipelineJson) {
+        if (!pipelineString.startsWith('#!')) {
+            return pipelineString;
         }
-        catch (error) {
-            if (!(error instanceof ParseError)) {
-                throw error;
-            }
+        const [shebangLine, ...restLines] = pipelineString.split(/\r?\n/);
+        const isBookShebang = (shebangLine || '').includes('ptbk');
+        if (!isBookShebang) {
             throw new ParseError(_spaceTrim.spaceTrim((block) => `
-                    Command ${command.type} failed to apply to the pipeline
-
-                    The error:
-                    ${block(error.message)}
+                    It seems that you try to parse a book file which has non-standard shebang line for book files:
+                    Shebang line must contain 'ptbk'
 
-                    Raw command:
-                    - ${listItem}
+                    You have:
+                    ${block(shebangLine || '(empty line)')}
 
-                    Usage of ${command.type}:
-                    ${block(commandParser.examples.map((example) => `- ${example}`).join('\n'))}
+                    It should look like this:
+                    #!/usr/bin/env ptbk
 
                     ${block(getPipelineIdentification($pipelineJson))}
-              `)); // <- TODO: [🚞]
-        }
-        if (command.type === 'PARAMETER') {
-            defineParameter($pipelineJson, command);
-            // <- Note: [🍣]
+                `));
         }
+        return validatePipelineString(restLines.join('\n'));
     }
+
     /**
-     * Merges one parameter declaration into the mutable pipeline parameter list.
+     * Supported script languages
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal base for `ScriptLanguage`
      */
-    function defineParameter($pipelineJson, parameterCommand) {
-        const { parameterName, parameterDescription, isInput, isOutput } = parameterCommand;
-        if (RESERVED_PARAMETER_NAMES.includes(parameterName)) {
-            throw new ParseError(_spaceTrim.spaceTrim((block) => `
-                    Parameter name {${parameterName}} is reserved and cannot be used as resulting parameter name
+    const SUPPORTED_SCRIPT_LANGUAGES = ['javascript', 'typescript', 'python'];
+    //          <- TODO: [🏥] DRY
 
-                    ${block(getPipelineIdentification($pipelineJson))}
-                `) /* <- TODO: [🚞] */);
-        }
-        const existingParameter = $pipelineJson.parameters.find((parameter) => parameter.name === parameterName);
-        if (existingParameter &&
-            existingParameter.description &&
-            existingParameter.description !== parameterDescription &&
-            parameterDescription) {
+    /**
+     * Extracts exactly ONE code block from markdown.
+     *
+     * - When there are multiple or no code blocks the function throws a `ParseError`
+     *
+     * Note: There are multiple similar functions:
+     * - `extractBlock` just extracts the content of the code block which is also used as built-in function for postprocessing
+     * - `extractJsonBlock` extracts exactly one valid JSON code block
+     * - `extractOneBlockFromMarkdown` extracts exactly one code block with language of the code block
+     * - `extractAllBlocksFromMarkdown` extracts all code blocks with language of the code block
+     *
+     * @param markdown any valid markdown
+     * @returns code block with language and content
+     * @throws {ParseError} if there is not exactly one code block in the markdown
+     *
+     * @public exported from `@promptbook/markdown-utils`
+     */
+    function extractOneBlockFromMarkdown(markdown) {
+        const codeBlocks = extractAllBlocksFromMarkdown(markdown);
+        if (codeBlocks.length !== 1) {
             throw new ParseError(_spaceTrim.spaceTrim((block) => `
-                    Parameter \`{${parameterName}}\` is defined multiple times with different description:
-
-                    ${block(getPipelineIdentification($pipelineJson))}
-
-                    First definition:
-                    ${block(existingParameter.description || '[undefined]')}
+                    There should be exactly 1 code block in task section, found ${codeBlocks.length} code blocks
 
-                    Second definition:
-                    ${block(parameterDescription || '[undefined]')}
+                    ${block(codeBlocks.map((block, i) => `Block ${i + 1}:\n${block.content}`).join('\n\n\n'))}
                 `));
         }
-        if (existingParameter) {
-            if (parameterDescription) {
-                existingParameter.description = parameterDescription;
-            }
-            existingParameter.isInput = existingParameter.isInput || isInput;
-            existingParameter.isOutput = existingParameter.isOutput || isOutput;
-            return;
-        }
-        $pipelineJson.parameters.push({
-            name: parameterName,
-            description: parameterDescription || undefined,
-            isInput,
-            isOutput,
-        });
+        return codeBlocks[0];
     }
+    // TODO: [🍓][🌻] Decide of this is internal utility, external util OR validator/postprocessor
+
     /**
-     * Creates stable unique task names for duplicate section titles.
+     * Matches the trailing return statement of a task section.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
-    function createUniqueSectionNameResolver(pipelineSections) {
-        const sectionCounts = {};
-        for (const pipelineSection of pipelineSections) {
-            const sectionName = titleToName(pipelineSection.title);
-            if (sectionCounts[sectionName] === undefined) {
-                sectionCounts[sectionName] = { count: 0, currentIndex: 0 };
-            }
-            sectionCounts[sectionName].count++;
-        }
-        return (title) => {
-            const sectionName = titleToName(title);
-            const sectionCount = sectionCounts[sectionName];
-            if (sectionCount.count === 1) {
-                return sectionName;
-            }
-            const nameWithSuffix = `${sectionName}-${sectionCount.currentIndex}`;
-            sectionCount.currentIndex++;
-            return nameWithSuffix;
-        };
-    }
+    const RESULTING_PARAMETER_LINE_REGEXP = /^->\s*\{(?<resultingParamName>[a-z0-9_]+)\}/im;
     /**
      * Parses, applies, and persists one h2 task section.
      *
@@ -11093,7 +11190,7 @@
     /**
      * Creates the mutable task JSON shell from one markdown section.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
     function createTaskJsonFromSection(pipelineSection, getUniqueSectionName) {
         const { language, content } = extractOneBlockFromMarkdown(pipelineSection.content);
@@ -11121,7 +11218,7 @@
     /**
      * Extracts the optional trailing `-> {parameter}` statement from a section body.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
     function extractResultingParameterName(sectionContent) {
         var _a;
@@ -11132,7 +11229,7 @@
     /**
      * Parses all list-item commands declared inside one task section.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
     function parsePipelineTaskCommands(sectionContent) {
         return extractAllListItemsFromMarkdown(sectionContent).map((listItem) => ({
@@ -11143,7 +11240,7 @@
     /**
      * Applies the implicit default `PROMPT_TASK` section type when no SECTION command is present.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
     function applyDefaultTaskSectionType($taskJson, commands, $pipelineJson) {
         const isSectionCommandPresent = commands.some(({ command }) => command.type === 'SECTION');
@@ -11155,7 +11252,7 @@
     /**
      * Parses and applies one command declared inside a task section.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
     function applyPipelineTaskCommand(commandItem, $taskJson, $pipelineJson) {
         const { listItem, command } = commandItem;
@@ -11206,7 +11303,7 @@
     /**
      * Validates and stores the language for SCRIPT tasks.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
     function applyScriptTaskLanguage($taskJson, language, $pipelineJson) {
         const isScriptTask = $taskJson.taskType === 'SCRIPT_TASK';
@@ -11223,7 +11320,6 @@
         if (!SUPPORTED_SCRIPT_LANGUAGES.includes(language)) {
             throw new ParseError(_spaceTrim.spaceTrim((block) => `
                     Script language ${language} is not supported.
-
                     Supported languages are:
                     ${block(SUPPORTED_SCRIPT_LANGUAGES.join(', '))}
 
@@ -11232,168 +11328,87 @@
         $taskJson.contentLanguage = language;
     }
     /**
-     * Extracts task dependencies and ensures referenced parameters exist.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    function registerTaskDependentParameters($taskJson, $pipelineJson) {
-        $taskJson.dependentParameterNames = Array.from(extractParameterNamesFromTask($taskJson));
-        for (const parameterName of $taskJson.dependentParameterNames) {
-            // TODO: [🧠] This definition should be made first in the task
-            defineParameter($pipelineJson, {
-                parameterName,
-                parameterDescription: null,
-                isInput: false,
-                isOutput: false,
-                // <- Note: In this case null+false+false means that we do not know yet if it is input or output and we will set it later
-            });
-        }
-    }
-    /**
-     * Removes transient parsing flags and persists real tasks into the pipeline JSON.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    function persistTaskIfNeeded($taskJson, $pipelineJson) {
-        /*
-        // TODO: [🍧] This should be checked in `MODEL` command + better error message
-        if ($taskJson.taskType !== 'PROMPT_TASK' && $taskJson.modelRequirements !== undefined) {
-            throw new UnexpectedError(
-                spaceTrim(
-                    (block) => `
-                        Model requirements are defined for the block type ${
-                            $taskJson.taskType
-                        } which is not a \`PROMPT\` task
-
-                        This should be avoided by the \`modelCommandParser\`
-
-                        ${block(getPipelineIdentification($pipelineJson))}
-                  `,
-                ),
-            );
-        }
-        */
-        if (!$taskJson.isTask) {
-            return;
-        }
-        delete $taskJson.isSectionTypeSet;
-        delete $taskJson.isTask;
-        // TODO: [🍙] Maybe do reorder of `$taskJson` here
-        $pipelineJson.tasks.push($taskJson);
-    }
-    /**
-     * Applies default INPUT/OUTPUT flags when the author did not specify them explicitly.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    function applyImplicitParameterDirections($pipelineJson) {
-        markImplicitInputParameters($pipelineJson);
-        markImplicitOutputParameters($pipelineJson);
-    }
-    /**
-     * Marks non-result parameters as pipeline inputs when no input was declared.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    function markImplicitInputParameters($pipelineJson) {
-        if ($pipelineJson.parameters.some((parameter) => parameter.isInput)) {
-            return;
-        }
-        for (const parameter of $pipelineJson.parameters) {
-            const isThisParameterResulting = $pipelineJson.tasks.some((task) => task.resultingParameterName === parameter.name);
-            if (!isThisParameterResulting) {
-                parameter.isInput = true;
-                // <- TODO: [💔] Why this is making typescript error in vscode but not in cli
-                //        > Type 'true' is not assignable to type 'false'.ts(2322)
-                //        > (property) isInput: false
-                //        > The parameter is input of the pipeline The parameter is NOT input of the pipeline
-            }
-        }
-    }
-    /**
-     * Marks every non-input parameter as output when no output was declared.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    function markImplicitOutputParameters($pipelineJson) {
-        if ($pipelineJson.parameters.some((parameter) => parameter.isOutput)) {
-            return;
-        }
-        for (const parameter of $pipelineJson.parameters) {
-            if (!parameter.isInput) {
-                parameter.isOutput = true;
-                // <- TODO: [💔]
-            }
-        }
-    }
-    /**
-     * Removes `undefined` properties from serialized tasks and parameters.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    function removeUndefinedValuesFromPipeline($pipelineJson) {
-        $pipelineJson.tasks.forEach(removeUndefinedProperties);
-        $pipelineJson.parameters.forEach(removeUndefinedProperties);
-    }
-    /**
-     * Deletes all own properties with `undefined` values from a mutable JSON entity.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    function removeUndefinedProperties(entity) {
-        for (const [key, value] of Object.entries(entity)) {
-            if (value === undefined) {
-                delete entity[key];
-            }
-        }
-    }
-    /**
-     * Applies all sync-only high-level abstractions after parsing.
+     * Extracts task dependencies and ensures referenced parameters exist.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
-    function applySyncHighLevelAbstractions($pipelineJson) {
-        for (const highLevelAbstraction of HIGH_LEVEL_ABSTRACTIONS.filter(({ type }) => type === 'SYNC')) {
-            highLevelAbstraction.$applyToPipelineJson($pipelineJson);
+    function registerTaskDependentParameters($taskJson, $pipelineJson) {
+        $taskJson.dependentParameterNames = Array.from(extractParameterNamesFromTask($taskJson));
+        for (const parameterName of $taskJson.dependentParameterNames) {
+            // TODO: [🧠] This definition should be made first in the task
+            defineParameter($pipelineJson, {
+                parameterName,
+                parameterDescription: null,
+                isInput: false,
+                isOutput: false,
+                // <- Note: In this case null+false+false means that we do not know yet if it is input or output and we will set it later
+            });
         }
     }
     /**
-     * Ensures parsed pipelines always have the default `GENERIC` formfactor.
+     * Removes transient parsing flags and persists real tasks into the pipeline JSON.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
-    function ensurePipelineFormfactor($pipelineJson) {
-        // Note: [🔆] If formfactor is still not set, set it to 'GENERIC'
-        if ($pipelineJson.formfactorName === undefined) {
-            $pipelineJson.formfactorName = 'GENERIC';
+    function persistTaskIfNeeded($taskJson, $pipelineJson) {
+        /*
+        // TODO: [🍧] This should be checked in `MODEL` command + better error message
+        if ($taskJson.taskType !== 'PROMPT_TASK' && $taskJson.modelRequirements !== undefined) {
+            throw new UnexpectedError(
+                spaceTrim(
+                    (block) => `
+                        Model requirements are defined for the block type ${
+                            $taskJson.taskType
+                        } which is not a \`PROMPT\` task
+
+                        This should be avoided by the \`modelCommandParser\`
+
+                        ${block(getPipelineIdentification($pipelineJson))}
+                  `,
+                ),
+            );
+        }
+        */
+        if (!$taskJson.isTask) {
+            return;
         }
+        delete $taskJson.isSectionTypeSet;
+        delete $taskJson.isTask;
+        // TODO: [🍙] Maybe do reorder of `$taskJson` here
+        $pipelineJson.tasks.push($taskJson);
     }
+
     /**
-     * Finalizes ordering and exports the parsed pipeline JSON.
+     * Compile pipeline from string (markdown) format to JSON format synchronously
      *
-     * @private internal utility of `parsePipeline`
+     * Note: There are 3 similar functions:
+     * - `compilePipeline` **(preferred)** - which properly compiles the promptbook and uses embedding for external knowledge
+     * - `parsePipeline` - use only if you need to compile promptbook synchronously and it contains NO external knowledge
+     * - `preparePipeline` - just one step in the compilation process
+     *
+     * Note: This function does not validate logic of the pipeline only the parsing
+     * Note: This function acts as compilation process
+     *
+     * @param pipelineString {Promptbook} in string markdown format (.book.md)
+     * @returns {Promptbook} compiled in JSON format (.bookc)
+     * @throws {ParseError} if the promptbook string is not valid
+     *
+     * @public exported from `@promptbook/core`
      */
-    function exportParsedPipelineJson($pipelineJson) {
-        return exportJson({
-            name: 'pipelineJson',
-            message: `Result of \`parsePipeline\``,
-            order: ORDER_OF_PIPELINE_JSON,
-            value: {
-                formfactorName: 'GENERIC',
-                // <- Note: [🔆] Setting `formfactorName` is redundant to satisfy the typescript
-                ...$pipelineJson,
-            },
-        });
+    function parsePipeline(pipelineString) {
+        const $pipelineJson = createInitialPipelineJson(pipelineString);
+        const preparedPipelineString = preparePipelineString(pipelineString, $pipelineJson);
+        const { pipelineHead, pipelineSections } = parsePreparedPipelineSections(preparedPipelineString, $pipelineJson);
+        const getUniqueSectionName = createUniqueSectionNameResolver(pipelineSections);
+        applyPipelineHead(pipelineHead, $pipelineJson);
+        for (const pipelineSection of pipelineSections) {
+            processPipelineSection(pipelineSection, $pipelineJson, getUniqueSectionName);
+        }
+        return finalizeParsedPipeline($pipelineJson);
     }
     // TODO: [🧠] Maybe more things here can be refactored as high-level abstractions
     // TODO: [main] !!4 Warn if used only sync version
     // TODO: [🚞] Report here line/column of error
-    // TODO: Use spaceTrim more effectively
-    // TODO: [🧠] Parameter flags - isInput, isOutput, isInternal
-    // TODO: [🥞] Not optimal parsing because `splitMarkdownIntoSections` is executed twice with same string, once through `flattenMarkdown` and second directly here
-    // TODO: [♈] Probably move expectations from tasks to parameters
-    // TODO: [🛠] Actions, instruments (and maybe knowledge) => Functions and tools
-    // TODO: [🍙] Make some standard order of json properties
 
     /**
      * Compile pipeline from string (markdown) format to JSON format
@@ -18141,7 +18156,9 @@
             };
             const mantleRadiusX = size * morphologyProfile.body.bodyRadiusRatio * morphologyProfile.body.horizontalStretch;
             const mantleRadiusY = size * morphologyProfile.body.bodyRadiusRatio * morphologyProfile.body.verticalStretch * 1.1;
-            const mantleRadiusZ = size * morphologyProfile.body.bodyRadiusRatio * (0.9 + (morphologyProfile.body.horizontalStretch - 1) * 0.3);
+            const mantleRadiusZ = size *
+                morphologyProfile.body.bodyRadiusRatio *
+                (0.9 + (morphologyProfile.body.horizontalStretch - 1) * 0.3);
             const underbodyRadiusX = mantleRadiusX * (0.9 + (morphologyProfile.tentacles.rootSpreadScale - 1) * 0.08);
             const underbodyRadiusY = mantleRadiusY * (0.44 + morphologyProfile.body.lowerDropRatio * 3.1);
             const underbodyRadiusZ = mantleRadiusZ * 0.78;
@@ -18227,7 +18244,11 @@
                 z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, faceEyeSpacing, faceEyeYOffset),
             }, faceEyeRadiusX, faceEyeRadiusY, mantleCenter, headPitch, headYaw, sceneCenterX, sceneCenterY, size, palette, timeMs, animationPhase + 0.7 + eyeRandom() * 0.6, interaction, morphologyProfile.face.eyeStyle);
             drawProjectedMouth(context, [
-                { x: -mouthHalfWidth, y: mouthY, z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, -mouthHalfWidth, mouthY) },
+                {
+                    x: -mouthHalfWidth,
+                    y: mouthY,
+                    z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, -mouthHalfWidth, mouthY),
+                },
                 {
                     x: size * morphologyProfile.face.mouthCenterOffsetRatio,
                     y: mouthY +
@@ -18236,7 +18257,11 @@
                         interaction.gazeY * size * 0.01,
                     z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, size * morphologyProfile.face.mouthCenterOffsetRatio, mouthY),
                 },
-                { x: mouthHalfWidth, y: mouthY, z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, mouthHalfWidth, mouthY) },
+                {
+                    x: mouthHalfWidth,
+                    y: mouthY,
+                    z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, mouthHalfWidth, mouthY),
+                },
             ], mantleCenter, headPitch, headYaw, sceneCenterX, sceneCenterY, palette, size);
         },
     };
@@ -18397,7 +18422,8 @@
                 z: anchorPoint.z + Math.cos(orbitAngle) * depthReach * 0.3 + sway * size * 0.012,
             };
             const controlPointTwo = {
-                x: anchorPoint.x + Math.sin(orbitAngle) * lateralReach * (0.82 + morphologyProfile.tentacles.swayScale * 0.12),
+                x: anchorPoint.x +
+                    Math.sin(orbitAngle) * lateralReach * (0.82 + morphologyProfile.tentacles.swayScale * 0.12),
                 y: anchorPoint.y + flowLength * 0.66,
                 z: anchorPoint.z + Math.cos(orbitAngle) * depthReach * 0.72 + sway * size * 0.02,
             };
@@ -18462,8 +18488,7 @@
             context.beginPath();
             context.moveTo(startPoint.x, startPoint.y);
             context.lineTo(endPoint.x, endPoint.y);
-            context.strokeStyle =
-                tentacleStroke.colorBias > 0.6 ? `${palette.secondary}f0` : `${palette.primary}f0`;
+            context.strokeStyle = tentacleStroke.colorBias > 0.6 ? `${palette.secondary}f0` : `${palette.primary}f0`;
             context.lineWidth = width;
             context.lineCap = 'round';
             context.stroke();
@@ -26658,6 +26683,212 @@
      * @private internal USE TIMEOUT constant
      */
     const MAX_LIST_TIMEOUTS_LIMIT = 100;
+    /**
+     * Creates one formatted timeout-argument validation error.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function createTimeoutToolArgsError(message) {
+        return new PipelineExecutionError(_spaceTrim.spaceTrim(`
+            ${message}
+        `));
+    }
+    /**
+     * Normalizes one optional timeout id string.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function normalizeOptionalTimeoutId(value) {
+        return typeof value === 'string' ? value.trim() : '';
+    }
+    /**
+     * Parses timeout target selection for tools that accept either `timeoutId` or `allActive: true`.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseTimeoutTargetSelection(args, options) {
+        const timeoutId = normalizeOptionalTimeoutId(args.timeoutId);
+        const allActive = args.allActive === true;
+        if (timeoutId && allActive) {
+            throw createTimeoutToolArgsError(options.bothMessage);
+        }
+        if (allActive) {
+            return { allActive: true };
+        }
+        if (!timeoutId) {
+            throw createTimeoutToolArgsError(options.missingMessage);
+        }
+        return {
+            timeoutId,
+            allActive: false,
+        };
+    }
+    /**
+     * Parses one explicit `dueAt` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutDueAt(value) {
+        if (typeof value !== 'string' || value.trim().length === 0) {
+            return undefined;
+        }
+        const normalizedDueAt = value.trim();
+        const dueAtTimestamp = Date.parse(normalizedDueAt);
+        if (!Number.isFinite(dueAtTimestamp)) {
+            throw createTimeoutToolArgsError('Timeout `dueAt` must be one valid ISO timestamp.');
+        }
+        return new Date(dueAtTimestamp).toISOString();
+    }
+    /**
+     * Parses one explicit `extendByMs` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutExtendByMs(value) {
+        if (typeof value !== 'number') {
+            return undefined;
+        }
+        if (!Number.isFinite(value) || value <= 0) {
+            throw createTimeoutToolArgsError('Timeout `extendByMs` must be a positive number of milliseconds.');
+        }
+        return Math.floor(value);
+    }
+    /**
+     * Parses one explicit `recurrenceIntervalMs` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutRecurrenceInterval(value) {
+        if (value === null) {
+            return null;
+        }
+        if (typeof value !== 'number') {
+            return undefined;
+        }
+        if (!Number.isFinite(value) || value <= 0) {
+            throw createTimeoutToolArgsError('Timeout `recurrenceIntervalMs` must be a positive number of milliseconds or `null`.');
+        }
+        return Math.floor(value);
+    }
+    /**
+     * Parses one explicit `message` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutMessage(value) {
+        if (value === null) {
+            return null;
+        }
+        if (typeof value !== 'string') {
+            return undefined;
+        }
+        const normalizedMessage = value.trim();
+        return normalizedMessage.length > 0 ? normalizedMessage : null;
+    }
+    /**
+     * Parses one explicit `parameters` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutParameters(value) {
+        if (value === undefined) {
+            return undefined;
+        }
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            throw createTimeoutToolArgsError('Timeout `parameters` must be one JSON object.');
+        }
+        return value;
+    }
+    /**
+     * Parses one explicit `paused` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutPaused(value) {
+        return typeof value === 'boolean' ? value : undefined;
+    }
+    /**
+     * Parses patch fields for `update_timeout`.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseTimeoutUpdatePatch(args) {
+        const patch = {};
+        const dueAt = parseOptionalTimeoutDueAt(args.dueAt);
+        const extendByMs = parseOptionalTimeoutExtendByMs(args.extendByMs);
+        const recurrenceIntervalMs = parseOptionalTimeoutRecurrenceInterval(args.recurrenceIntervalMs);
+        const message = parseOptionalTimeoutMessage(args.message);
+        const parameters = parseOptionalTimeoutParameters(args.parameters);
+        const paused = parseOptionalTimeoutPaused(args.paused);
+        if (dueAt !== undefined) {
+            patch.dueAt = dueAt;
+        }
+        if (extendByMs !== undefined) {
+            patch.extendByMs = extendByMs;
+        }
+        if (patch.dueAt !== undefined && patch.extendByMs !== undefined) {
+            throw createTimeoutToolArgsError('Timeout update cannot include both `dueAt` and `extendByMs`.');
+        }
+        if (recurrenceIntervalMs !== undefined) {
+            patch.recurrenceIntervalMs = recurrenceIntervalMs;
+        }
+        if (message !== undefined) {
+            patch.message = message;
+        }
+        if (parameters !== undefined) {
+            patch.parameters = parameters;
+        }
+        if (paused !== undefined) {
+            patch.paused = paused;
+        }
+        return patch;
+    }
+    /**
+     * Determines whether the patch contains fields that are only supported for single-timeout updates.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function hasSingleTimeoutOnlyPatchFields(patch) {
+        return (patch.dueAt !== undefined ||
+            patch.extendByMs !== undefined ||
+            patch.recurrenceIntervalMs !== undefined ||
+            patch.message !== undefined ||
+            patch.parameters !== undefined);
+    }
+    /**
+     * Parses bulk timeout update arguments.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseBulkTimeoutUpdateArgs(patch) {
+        if (patch.paused === undefined) {
+            throw createTimeoutToolArgsError('Bulk timeout update with `allActive: true` requires `paused` to be explicitly set.');
+        }
+        if (hasSingleTimeoutOnlyPatchFields(patch)) {
+            throw createTimeoutToolArgsError('Bulk timeout update only supports the `paused` field.');
+        }
+        return {
+            allActive: true,
+            paused: patch.paused,
+        };
+    }
+    /**
+     * Parses single-timeout update arguments.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseSingleTimeoutUpdateArgs(timeoutId, patch) {
+        if (!timeoutId) {
+            throw createTimeoutToolArgsError('Timeout `timeoutId` is required for single-timeout updates.');
+        }
+        if (Object.keys(patch).length === 0) {
+            throw createTimeoutToolArgsError('Timeout update must include at least one editable field.');
+        }
+        return {
+            timeoutId,
+            patch,
+        };
+    }
     /**
      * Parses and validates `USE TIMEOUT` tool arguments.
      *
@@ -26684,22 +26915,14 @@
          * Parses `cancel_timeout` input.
          */
         cancel(args) {
-            const timeoutId = typeof args.timeoutId === 'string' ? args.timeoutId.trim() : '';
-            const allActive = args.allActive === true;
-            if (timeoutId && allActive) {
-                throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                    Timeout cancellation must target either one \`timeoutId\` or \`allActive: true\`, not both.
-                `));
-            }
-            if (allActive) {
+            const target = parseTimeoutTargetSelection(args, {
+                bothMessage: 'Timeout cancellation must target either one `timeoutId` or `allActive: true`, not both.',
+                missingMessage: 'Timeout `timeoutId` is required unless you pass `allActive: true`.',
+            });
+            if (target.allActive) {
                 return { allActive: true };
             }
-            if (!timeoutId) {
-                throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                    Timeout \`timeoutId\` is required unless you pass \`allActive: true\`.
-                `));
-            }
-            return { timeoutId };
+            return { timeoutId: target.timeoutId };
         },
         /**
          * Parses `list_timeouts` input.
@@ -26730,106 +26953,14 @@
          * Parses `update_timeout` input.
          */
         update(args) {
-            const timeoutId = typeof args.timeoutId === 'string' ? args.timeoutId.trim() : '';
-            const allActive = args.allActive === true;
-            if (timeoutId && allActive) {
-                throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                    Timeout update must target either one \`timeoutId\` or \`allActive: true\`, not both.
-                `));
-            }
-            if (!timeoutId && !allActive) {
-                throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                    Timeout update requires one \`timeoutId\` or \`allActive: true\`.
-                `));
-            }
-            const patch = {};
-            if (typeof args.dueAt === 'string' && args.dueAt.trim().length > 0) {
-                const normalizedDueAt = args.dueAt.trim();
-                const dueAtTimestamp = Date.parse(normalizedDueAt);
-                if (!Number.isFinite(dueAtTimestamp)) {
-                    throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                        Timeout \`dueAt\` must be one valid ISO timestamp.
-                    `));
-                }
-                patch.dueAt = new Date(dueAtTimestamp).toISOString();
-            }
-            if (typeof args.extendByMs === 'number') {
-                if (!Number.isFinite(args.extendByMs) || args.extendByMs <= 0) {
-                    throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                        Timeout \`extendByMs\` must be a positive number of milliseconds.
-                    `));
-                }
-                patch.extendByMs = Math.floor(args.extendByMs);
-            }
-            if (patch.dueAt !== undefined && patch.extendByMs !== undefined) {
-                throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                    Timeout update cannot include both \`dueAt\` and \`extendByMs\`.
-                `));
-            }
-            if (args.recurrenceIntervalMs === null) {
-                patch.recurrenceIntervalMs = null;
-            }
-            else if (typeof args.recurrenceIntervalMs === 'number') {
-                if (!Number.isFinite(args.recurrenceIntervalMs) || args.recurrenceIntervalMs <= 0) {
-                    throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                        Timeout \`recurrenceIntervalMs\` must be a positive number of milliseconds or \`null\`.
-                    `));
-                }
-                patch.recurrenceIntervalMs = Math.floor(args.recurrenceIntervalMs);
-            }
-            if (args.message === null) {
-                patch.message = null;
-            }
-            else if (typeof args.message === 'string') {
-                const normalizedMessage = args.message.trim();
-                patch.message = normalizedMessage.length > 0 ? normalizedMessage : null;
-            }
-            if (args.parameters !== undefined) {
-                if (!args.parameters || typeof args.parameters !== 'object' || Array.isArray(args.parameters)) {
-                    throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                        Timeout \`parameters\` must be one JSON object.
-                    `));
-                }
-                patch.parameters = args.parameters;
-            }
-            if (typeof args.paused === 'boolean') {
-                patch.paused = args.paused;
-            }
-            if (allActive) {
-                if (patch.paused === undefined) {
-                    throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                        Bulk timeout update with \`allActive: true\` requires \`paused\` to be explicitly set.
-                    `));
-                }
-                const hasSingleOnlyPatch = patch.dueAt !== undefined ||
-                    patch.extendByMs !== undefined ||
-                    patch.recurrenceIntervalMs !== undefined ||
-                    patch.message !== undefined ||
-                    patch.parameters !== undefined;
-                if (hasSingleOnlyPatch) {
-                    throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                        Bulk timeout update only supports the \`paused\` field.
-                    `));
-                }
-                return {
-                    allActive: true,
-                    paused: patch.paused,
-                };
-            }
-            if (!timeoutId) {
-                throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                    Timeout \`timeoutId\` is required for single-timeout updates.
-                `));
-            }
-            if (Object.keys(patch).length === 0) {
-                throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                    Timeout update must include at least one editable field.
-                `));
-            }
-            return {
-                timeoutId,
-                patch,
-            };
+            const target = parseTimeoutTargetSelection(args, {
+                bothMessage: 'Timeout update must target either one `timeoutId` or `allActive: true`, not both.',
+                missingMessage: 'Timeout update requires one `timeoutId` or `allActive: true`.',
+            });
+            const patch = parseTimeoutUpdatePatch(args);
+            return target.allActive
+                ? parseBulkTimeoutUpdateArgs(patch)
+                : parseSingleTimeoutUpdateArgs(target.timeoutId, patch);
         },
     };