@promptbook/node 0.112.0-71 → 0.112.0-72

package/esm/index.es.js

@@ -35,7 +35,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.112.0-71';
+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
@@ -7608,118 +7608,75 @@ async function preparePipeline(pipeline, tools, options) {
  */
 
 /**
- * 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$1(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
      */
@@ -7727,354 +7684,77 @@ const knowledgeCommandParser = {
         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$1((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$1(`
-                    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
@@ -9157,63 +8837,156 @@ const jokerCommandParser = {
 };
 
 /**
- * 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$1((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$1(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$1((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',
                 };
@@ -9690,69 +9463,296 @@ const postprocessCommandParser = {
 };
 
 /**
- * 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$1((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$1(`
+                    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
                     `,
@@ -10143,85 +10143,321 @@ function parseCommandVariant(input) {
 }
 
 /**
- * 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$1((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$1((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$1(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$1((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$1((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
@@ -10403,197 +10639,125 @@ const HIGH_LEVEL_ABSTRACTIONS = [
 // 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$1(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$1(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$1(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$1(pipelineStringLines.join('\n'));
-    let quotedPrompt;
-    if (prompt.split(/\r?\n/).length <= 1) {
-        quotedPrompt = `> ${prompt}`;
-    }
-    else {
-        quotedPrompt = spaceTrim$1((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$1((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$1((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
@@ -10665,213 +10829,24 @@ function splitMarkdownIntoSections(markdown) {
                 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$1(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$1(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$1((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.
  *
@@ -10888,7 +10863,7 @@ function parsePreparedPipelineSections(pipelineString, $pipelineJson) {
 /**
  * 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) {
@@ -10919,148 +10894,270 @@ function assertPipelineSectionsStructure(pipelineHead, pipelineSections, $pipeli
                 `));
     }
 }
+
 /**
- * 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$1(description);
-    if (description === '') {
-        return undefined;
-    }
-    return description;
+function removeMarkdownComments(content) {
+    return spaceTrim$1(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$1((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$1(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$1(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$1(pipelineStringLines.join('\n'));
+    let quotedPrompt;
+    if (prompt.split(/\r?\n/).length <= 1) {
+        quotedPrompt = `> ${prompt}`;
+    }
+    else {
+        quotedPrompt = spaceTrim$1((block) => `
+                \`\`\`
+                ${block(prompt.split('`').join('\\`'))}
+                \`\`\`
+            `);
+    }
+    pipelineString = validatePipelineString(spaceTrim$1((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$1(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$1(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$1((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$1((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$1((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.
  *
@@ -11080,7 +11177,7 @@ function processPipelineSection(pipelineSection, $pipelineJson, getUniqueSection
 /**
  * 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);
@@ -11108,7 +11205,7 @@ function createTaskJsonFromSection(pipelineSection, getUniqueSectionName) {
 /**
  * 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;
@@ -11119,7 +11216,7 @@ function extractResultingParameterName(sectionContent) {
 /**
  * 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) => ({
@@ -11130,7 +11227,7 @@ function parsePipelineTaskCommands(sectionContent) {
 /**
  * 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');
@@ -11142,7 +11239,7 @@ function applyDefaultTaskSectionType($taskJson, commands, $pipelineJson) {
 /**
  * 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;
@@ -11193,7 +11290,7 @@ function applyPipelineTaskCommand(commandItem, $taskJson, $pipelineJson) {
 /**
  * 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';
@@ -11210,7 +11307,6 @@ function applyScriptTaskLanguage($taskJson, language, $pipelineJson) {
     if (!SUPPORTED_SCRIPT_LANGUAGES.includes(language)) {
         throw new ParseError(spaceTrim$1((block) => `
                     Script language ${language} is not supported.
-
                     Supported languages are:
                     ${block(SUPPORTED_SCRIPT_LANGUAGES.join(', '))}
 
@@ -11219,168 +11315,87 @@ function applyScriptTaskLanguage($taskJson, language, $pipelineJson) {
     $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
@@ -18128,7 +18143,9 @@ const octopus3dAvatarVisual = {
         };
         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;
@@ -18214,7 +18231,11 @@ const octopus3dAvatarVisual = {
             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 +
@@ -18223,7 +18244,11 @@ const octopus3dAvatarVisual = {
                     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);
     },
 };
@@ -18384,7 +18409,8 @@ function createOctopusTentacleStrokes(options) {
             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,
         };
@@ -18449,8 +18475,7 @@ function drawTentacleStroke(context, tentacleStroke, palette) {
         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();
@@ -26645,6 +26670,212 @@ const DEFAULT_LIST_TIMEOUTS_LIMIT = 20;
  * @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$1(`
+            ${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.
  *
@@ -26671,22 +26902,14 @@ const parseTimeoutToolArgs = {
      * 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$1(`
-                    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$1(`
-                    Timeout \`timeoutId\` is required unless you pass \`allActive: true\`.
-                `));
-        }
-        return { timeoutId };
+        return { timeoutId: target.timeoutId };
     },
     /**
      * Parses `list_timeouts` input.
@@ -26717,106 +26940,14 @@ const parseTimeoutToolArgs = {
      * 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$1(`
-                    Timeout update must target either one \`timeoutId\` or \`allActive: true\`, not both.
-                `));
-        }
-        if (!timeoutId && !allActive) {
-            throw new PipelineExecutionError(spaceTrim$1(`
-                    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$1(`
-                        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$1(`
-                        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$1(`
-                    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$1(`
-                        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$1(`
-                        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$1(`
-                        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$1(`
-                        Bulk timeout update only supports the \`paused\` field.
-                    `));
-            }
-            return {
-                allActive: true,
-                paused: patch.paused,
-            };
-        }
-        if (!timeoutId) {
-            throw new PipelineExecutionError(spaceTrim$1(`
-                    Timeout \`timeoutId\` is required for single-timeout updates.
-                `));
-        }
-        if (Object.keys(patch).length === 0) {
-            throw new PipelineExecutionError(spaceTrim$1(`
-                    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);
     },
 };