@promptbook/wizard 0.112.0-70 → 0.112.0-72

package/umd/index.umd.js

@@ -49,7 +49,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-70';
+    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-72';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -22870,7 +22870,9 @@
             };
             const mantleRadiusX = size * morphologyProfile.body.bodyRadiusRatio * morphologyProfile.body.horizontalStretch;
             const mantleRadiusY = size * morphologyProfile.body.bodyRadiusRatio * morphologyProfile.body.verticalStretch * 1.1;
-            const mantleRadiusZ = size * morphologyProfile.body.bodyRadiusRatio * (0.9 + (morphologyProfile.body.horizontalStretch - 1) * 0.3);
+            const mantleRadiusZ = size *
+                morphologyProfile.body.bodyRadiusRatio *
+                (0.9 + (morphologyProfile.body.horizontalStretch - 1) * 0.3);
             const underbodyRadiusX = mantleRadiusX * (0.9 + (morphologyProfile.tentacles.rootSpreadScale - 1) * 0.08);
             const underbodyRadiusY = mantleRadiusY * (0.44 + morphologyProfile.body.lowerDropRatio * 3.1);
             const underbodyRadiusZ = mantleRadiusZ * 0.78;
@@ -22956,7 +22958,11 @@
                 z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, faceEyeSpacing, faceEyeYOffset),
             }, faceEyeRadiusX, faceEyeRadiusY, mantleCenter, headPitch, headYaw, sceneCenterX, sceneCenterY, size, palette, timeMs, animationPhase + 0.7 + eyeRandom() * 0.6, interaction, morphologyProfile.face.eyeStyle);
             drawProjectedMouth(context, [
-                { x: -mouthHalfWidth, y: mouthY, z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, -mouthHalfWidth, mouthY) },
+                {
+                    x: -mouthHalfWidth,
+                    y: mouthY,
+                    z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, -mouthHalfWidth, mouthY),
+                },
                 {
                     x: size * morphologyProfile.face.mouthCenterOffsetRatio,
                     y: mouthY +
@@ -22965,7 +22971,11 @@
                         interaction.gazeY * size * 0.01,
                     z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, size * morphologyProfile.face.mouthCenterOffsetRatio, mouthY),
                 },
-                { x: mouthHalfWidth, y: mouthY, z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, mouthHalfWidth, mouthY) },
+                {
+                    x: mouthHalfWidth,
+                    y: mouthY,
+                    z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, mouthHalfWidth, mouthY),
+                },
             ], mantleCenter, headPitch, headYaw, sceneCenterX, sceneCenterY, palette, size);
         },
     };
@@ -23126,7 +23136,8 @@
                 z: anchorPoint.z + Math.cos(orbitAngle) * depthReach * 0.3 + sway * size * 0.012,
             };
             const controlPointTwo = {
-                x: anchorPoint.x + Math.sin(orbitAngle) * lateralReach * (0.82 + morphologyProfile.tentacles.swayScale * 0.12),
+                x: anchorPoint.x +
+                    Math.sin(orbitAngle) * lateralReach * (0.82 + morphologyProfile.tentacles.swayScale * 0.12),
                 y: anchorPoint.y + flowLength * 0.66,
                 z: anchorPoint.z + Math.cos(orbitAngle) * depthReach * 0.72 + sway * size * 0.02,
             };
@@ -23191,8 +23202,7 @@
             context.beginPath();
             context.moveTo(startPoint.x, startPoint.y);
             context.lineTo(endPoint.x, endPoint.y);
-            context.strokeStyle =
-                tentacleStroke.colorBias > 0.6 ? `${palette.secondary}f0` : `${palette.primary}f0`;
+            context.strokeStyle = tentacleStroke.colorBias > 0.6 ? `${palette.secondary}f0` : `${palette.primary}f0`;
             context.lineWidth = width;
             context.lineCap = 'round';
             context.stroke();
@@ -31177,6 +31187,212 @@
      * @private internal USE TIMEOUT constant
      */
     const MAX_LIST_TIMEOUTS_LIMIT = 100;
+    /**
+     * Creates one formatted timeout-argument validation error.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function createTimeoutToolArgsError(message) {
+        return new PipelineExecutionError(_spaceTrim.spaceTrim(`
+            ${message}
+        `));
+    }
+    /**
+     * Normalizes one optional timeout id string.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function normalizeOptionalTimeoutId(value) {
+        return typeof value === 'string' ? value.trim() : '';
+    }
+    /**
+     * Parses timeout target selection for tools that accept either `timeoutId` or `allActive: true`.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseTimeoutTargetSelection(args, options) {
+        const timeoutId = normalizeOptionalTimeoutId(args.timeoutId);
+        const allActive = args.allActive === true;
+        if (timeoutId && allActive) {
+            throw createTimeoutToolArgsError(options.bothMessage);
+        }
+        if (allActive) {
+            return { allActive: true };
+        }
+        if (!timeoutId) {
+            throw createTimeoutToolArgsError(options.missingMessage);
+        }
+        return {
+            timeoutId,
+            allActive: false,
+        };
+    }
+    /**
+     * Parses one explicit `dueAt` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutDueAt(value) {
+        if (typeof value !== 'string' || value.trim().length === 0) {
+            return undefined;
+        }
+        const normalizedDueAt = value.trim();
+        const dueAtTimestamp = Date.parse(normalizedDueAt);
+        if (!Number.isFinite(dueAtTimestamp)) {
+            throw createTimeoutToolArgsError('Timeout `dueAt` must be one valid ISO timestamp.');
+        }
+        return new Date(dueAtTimestamp).toISOString();
+    }
+    /**
+     * Parses one explicit `extendByMs` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutExtendByMs(value) {
+        if (typeof value !== 'number') {
+            return undefined;
+        }
+        if (!Number.isFinite(value) || value <= 0) {
+            throw createTimeoutToolArgsError('Timeout `extendByMs` must be a positive number of milliseconds.');
+        }
+        return Math.floor(value);
+    }
+    /**
+     * Parses one explicit `recurrenceIntervalMs` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutRecurrenceInterval(value) {
+        if (value === null) {
+            return null;
+        }
+        if (typeof value !== 'number') {
+            return undefined;
+        }
+        if (!Number.isFinite(value) || value <= 0) {
+            throw createTimeoutToolArgsError('Timeout `recurrenceIntervalMs` must be a positive number of milliseconds or `null`.');
+        }
+        return Math.floor(value);
+    }
+    /**
+     * Parses one explicit `message` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutMessage(value) {
+        if (value === null) {
+            return null;
+        }
+        if (typeof value !== 'string') {
+            return undefined;
+        }
+        const normalizedMessage = value.trim();
+        return normalizedMessage.length > 0 ? normalizedMessage : null;
+    }
+    /**
+     * Parses one explicit `parameters` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutParameters(value) {
+        if (value === undefined) {
+            return undefined;
+        }
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            throw createTimeoutToolArgsError('Timeout `parameters` must be one JSON object.');
+        }
+        return value;
+    }
+    /**
+     * Parses one explicit `paused` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutPaused(value) {
+        return typeof value === 'boolean' ? value : undefined;
+    }
+    /**
+     * Parses patch fields for `update_timeout`.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseTimeoutUpdatePatch(args) {
+        const patch = {};
+        const dueAt = parseOptionalTimeoutDueAt(args.dueAt);
+        const extendByMs = parseOptionalTimeoutExtendByMs(args.extendByMs);
+        const recurrenceIntervalMs = parseOptionalTimeoutRecurrenceInterval(args.recurrenceIntervalMs);
+        const message = parseOptionalTimeoutMessage(args.message);
+        const parameters = parseOptionalTimeoutParameters(args.parameters);
+        const paused = parseOptionalTimeoutPaused(args.paused);
+        if (dueAt !== undefined) {
+            patch.dueAt = dueAt;
+        }
+        if (extendByMs !== undefined) {
+            patch.extendByMs = extendByMs;
+        }
+        if (patch.dueAt !== undefined && patch.extendByMs !== undefined) {
+            throw createTimeoutToolArgsError('Timeout update cannot include both `dueAt` and `extendByMs`.');
+        }
+        if (recurrenceIntervalMs !== undefined) {
+            patch.recurrenceIntervalMs = recurrenceIntervalMs;
+        }
+        if (message !== undefined) {
+            patch.message = message;
+        }
+        if (parameters !== undefined) {
+            patch.parameters = parameters;
+        }
+        if (paused !== undefined) {
+            patch.paused = paused;
+        }
+        return patch;
+    }
+    /**
+     * Determines whether the patch contains fields that are only supported for single-timeout updates.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function hasSingleTimeoutOnlyPatchFields(patch) {
+        return (patch.dueAt !== undefined ||
+            patch.extendByMs !== undefined ||
+            patch.recurrenceIntervalMs !== undefined ||
+            patch.message !== undefined ||
+            patch.parameters !== undefined);
+    }
+    /**
+     * Parses bulk timeout update arguments.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseBulkTimeoutUpdateArgs(patch) {
+        if (patch.paused === undefined) {
+            throw createTimeoutToolArgsError('Bulk timeout update with `allActive: true` requires `paused` to be explicitly set.');
+        }
+        if (hasSingleTimeoutOnlyPatchFields(patch)) {
+            throw createTimeoutToolArgsError('Bulk timeout update only supports the `paused` field.');
+        }
+        return {
+            allActive: true,
+            paused: patch.paused,
+        };
+    }
+    /**
+     * Parses single-timeout update arguments.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseSingleTimeoutUpdateArgs(timeoutId, patch) {
+        if (!timeoutId) {
+            throw createTimeoutToolArgsError('Timeout `timeoutId` is required for single-timeout updates.');
+        }
+        if (Object.keys(patch).length === 0) {
+            throw createTimeoutToolArgsError('Timeout update must include at least one editable field.');
+        }
+        return {
+            timeoutId,
+            patch,
+        };
+    }
     /**
      * Parses and validates `USE TIMEOUT` tool arguments.
      *
@@ -31203,22 +31419,14 @@
          * Parses `cancel_timeout` input.
          */
         cancel(args) {
-            const timeoutId = typeof args.timeoutId === 'string' ? args.timeoutId.trim() : '';
-            const allActive = args.allActive === true;
-            if (timeoutId && allActive) {
-                throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                    Timeout cancellation must target either one \`timeoutId\` or \`allActive: true\`, not both.
-                `));
-            }
-            if (allActive) {
+            const target = parseTimeoutTargetSelection(args, {
+                bothMessage: 'Timeout cancellation must target either one `timeoutId` or `allActive: true`, not both.',
+                missingMessage: 'Timeout `timeoutId` is required unless you pass `allActive: true`.',
+            });
+            if (target.allActive) {
                 return { allActive: true };
             }
-            if (!timeoutId) {
-                throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                    Timeout \`timeoutId\` is required unless you pass \`allActive: true\`.
-                `));
-            }
-            return { timeoutId };
+            return { timeoutId: target.timeoutId };
         },
         /**
          * Parses `list_timeouts` input.
@@ -31249,106 +31457,14 @@
          * Parses `update_timeout` input.
          */
         update(args) {
-            const timeoutId = typeof args.timeoutId === 'string' ? args.timeoutId.trim() : '';
-            const allActive = args.allActive === true;
-            if (timeoutId && allActive) {
-                throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                    Timeout update must target either one \`timeoutId\` or \`allActive: true\`, not both.
-                `));
-            }
-            if (!timeoutId && !allActive) {
-                throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                    Timeout update requires one \`timeoutId\` or \`allActive: true\`.
-                `));
-            }
-            const patch = {};
-            if (typeof args.dueAt === 'string' && args.dueAt.trim().length > 0) {
-                const normalizedDueAt = args.dueAt.trim();
-                const dueAtTimestamp = Date.parse(normalizedDueAt);
-                if (!Number.isFinite(dueAtTimestamp)) {
-                    throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                        Timeout \`dueAt\` must be one valid ISO timestamp.
-                    `));
-                }
-                patch.dueAt = new Date(dueAtTimestamp).toISOString();
-            }
-            if (typeof args.extendByMs === 'number') {
-                if (!Number.isFinite(args.extendByMs) || args.extendByMs <= 0) {
-                    throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                        Timeout \`extendByMs\` must be a positive number of milliseconds.
-                    `));
-                }
-                patch.extendByMs = Math.floor(args.extendByMs);
-            }
-            if (patch.dueAt !== undefined && patch.extendByMs !== undefined) {
-                throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                    Timeout update cannot include both \`dueAt\` and \`extendByMs\`.
-                `));
-            }
-            if (args.recurrenceIntervalMs === null) {
-                patch.recurrenceIntervalMs = null;
-            }
-            else if (typeof args.recurrenceIntervalMs === 'number') {
-                if (!Number.isFinite(args.recurrenceIntervalMs) || args.recurrenceIntervalMs <= 0) {
-                    throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                        Timeout \`recurrenceIntervalMs\` must be a positive number of milliseconds or \`null\`.
-                    `));
-                }
-                patch.recurrenceIntervalMs = Math.floor(args.recurrenceIntervalMs);
-            }
-            if (args.message === null) {
-                patch.message = null;
-            }
-            else if (typeof args.message === 'string') {
-                const normalizedMessage = args.message.trim();
-                patch.message = normalizedMessage.length > 0 ? normalizedMessage : null;
-            }
-            if (args.parameters !== undefined) {
-                if (!args.parameters || typeof args.parameters !== 'object' || Array.isArray(args.parameters)) {
-                    throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                        Timeout \`parameters\` must be one JSON object.
-                    `));
-                }
-                patch.parameters = args.parameters;
-            }
-            if (typeof args.paused === 'boolean') {
-                patch.paused = args.paused;
-            }
-            if (allActive) {
-                if (patch.paused === undefined) {
-                    throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                        Bulk timeout update with \`allActive: true\` requires \`paused\` to be explicitly set.
-                    `));
-                }
-                const hasSingleOnlyPatch = patch.dueAt !== undefined ||
-                    patch.extendByMs !== undefined ||
-                    patch.recurrenceIntervalMs !== undefined ||
-                    patch.message !== undefined ||
-                    patch.parameters !== undefined;
-                if (hasSingleOnlyPatch) {
-                    throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                        Bulk timeout update only supports the \`paused\` field.
-                    `));
-                }
-                return {
-                    allActive: true,
-                    paused: patch.paused,
-                };
-            }
-            if (!timeoutId) {
-                throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                    Timeout \`timeoutId\` is required for single-timeout updates.
-                `));
-            }
-            if (Object.keys(patch).length === 0) {
-                throw new PipelineExecutionError(_spaceTrim.spaceTrim(`
-                    Timeout update must include at least one editable field.
-                `));
-            }
-            return {
-                timeoutId,
-                patch,
-            };
+            const target = parseTimeoutTargetSelection(args, {
+                bothMessage: 'Timeout update must target either one `timeoutId` or `allActive: true`, not both.',
+                missingMessage: 'Timeout update requires one `timeoutId` or `allActive: true`.',
+            });
+            const patch = parseTimeoutUpdatePatch(args);
+            return target.allActive
+                ? parseBulkTimeoutUpdateArgs(patch)
+                : parseSingleTimeoutUpdateArgs(target.timeoutId, patch);
         },
     };
 
@@ -41454,326 +41570,6 @@
     }
     // Note: [🟢] Code for Node archive helper [loadArchive](src/conversion/archive/loadArchive.ts) should never be published into packages that could be imported into browser environment
 
-    /**
-     * 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 knowledge command
-     *
-     * @see `documentationUrl` for more details
-     *
-     * @public exported from `@promptbook/editable`
-     */
-    const knowledgeCommandParser = {
-        /**
-         * Name of the command
-         */
-        name: 'KNOWLEDGE',
-        /**
-         * BOILERPLATE command can be used in:
-         */
-        isUsedInPipelineHead: true,
-        isUsedInPipelineTask: false,
-        /**
-         * Description of the KNOWLEDGE command
-         */
-        description: `Tells promptbook which external knowledge to use`,
-        /**
-         * Link to documentation
-         */
-        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/41',
-        /**
-         * Example usages of the KNOWLEDGE 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
-        ],
-        /**
-         * Parses the KNOWLEDGE command
-         */
-        parse(input) {
-            const { args } = input;
-            const knowledgeSourceContent = _spaceTrim.spaceTrim(args[0] || '');
-            if (knowledgeSourceContent === '') {
-                throw new ParseError(`Source is not defined`);
-            }
-            // TODO: [main] !!4 Following checks should be applied every link in the `sourceContent`
-            if (knowledgeSourceContent.startsWith('http://')) {
-                throw new ParseError(`Source is not secure`);
-            }
-            if (!(isValidFilePath(knowledgeSourceContent) || isValidUrl(knowledgeSourceContent))) {
-                throw new ParseError(`Source not valid`);
-            }
-            if (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 [⛱])*
-
-    /**
-     * Parses the section command
-     *
-     * @see `documentationUrl` for more details
-     *
-     * @public exported from `@promptbook/editable`
-     */
-    const sectionCommandParser = {
-        /**
-         * 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'],
-        /**
-         * BOILERPLATE command can be used in:
-         */
-        isUsedInPipelineHead: false,
-        isUsedInPipelineTask: true,
-        /**
-         * Description of the SECTION command
-         */
-        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/64',
-        /**
-         * Example usages of the SECTION 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 */
-        /**
-         * Parses the SECTION command
-         */
-        parse(input) {
-            let { normalized } = input;
-            normalized = normalized.split('SAMPLE').join('EXAMPLE');
-            normalized = normalized.split('EXECUTE_').join('');
-            normalized = normalized.split('DIALOGUE').join('DIALOG');
-            const taskTypes = SectionTypes.filter((sectionType) => normalized.includes(sectionType.split('_TASK').join('')));
-            if (taskTypes.length !== 1) {
-                throw new ParseError(_spaceTrim.spaceTrim((block) => `
-                        Unknown section type "${normalized}"
-
-                        Supported section types are:
-                        ${block(SectionTypes.join(', '))}
-                    `));
-            }
-            const taskType = taskTypes[0];
-            return {
-                type: 'SECTION',
-                taskType,
-            };
-        },
-        /**
-         * Apply the SECTION command to the `pipelineJson`
-         *
-         * Note: `$` is used to indicate that this function mutates given `taskJson`
-         */
-        $applyToTaskJson(command, $taskJson, $pipelineJson) {
-            if ($taskJson.isSectionTypeSet === true) {
-                throw new ParseError(_spaceTrim.spaceTrim(`
-                    Section type is already defined in the section.
-                    It can be defined only once.
-                `));
-            }
-            $taskJson.isSectionTypeSet = true;
-            // TODO: [🍧][💩] Rearrange better - but at bottom and unwrap from function
-            const expectResultingParameterName = () => {
-                if ($taskJson.resultingParameterName) {
-                    return;
-                }
-                throw new ParseError(`Task section and example section must end with return statement -> {parameterName}`);
-            };
-            if ($taskJson.content === undefined) {
-                throw new UnexpectedError(`Content is missing in the taskJson - probably commands are applied in wrong order`);
-            }
-            if (command.taskType === 'EXAMPLE') {
-                expectResultingParameterName();
-                const parameter = $pipelineJson.parameters.find((param) => param.name === $taskJson.resultingParameterName);
-                if (parameter === undefined) {
-                    // TODO: !!6 Change to logic error for higher level abstraction of chatbot to work
-                    throw new ParseError(`Parameter \`{${$taskJson.resultingParameterName}}\` is not defined so can not define example value of it`);
-                }
-                parameter.exampleValues = parameter.exampleValues || [];
-                parameter.exampleValues.push($taskJson.content);
-                $taskJson.isTask = false;
-                return;
-            }
-            if (command.taskType === 'KNOWLEDGE') {
-                knowledgeCommandParser.$applyToPipelineJson({
-                    type: 'KNOWLEDGE',
-                    knowledgeSourceContent: $taskJson.content, // <- TODO: [🐝][main] !!3 Work with KNOWLEDGE which not referring to the source file or website, but its content itself
-                }, $pipelineJson);
-                $taskJson.isTask = false;
-                return;
-            }
-            if (command.taskType === 'ACTION') {
-                console.error(new NotYetImplementedError('Actions are not implemented yet'));
-                $taskJson.isTask = false;
-                return;
-            }
-            if (command.taskType === 'INSTRUMENT') {
-                console.error(new NotYetImplementedError('Instruments are not implemented yet'));
-                $taskJson.isTask = false;
-                return;
-            }
-            expectResultingParameterName();
-            $taskJson.taskType = command.taskType;
-            $taskJson.isTask = true;
-        },
-        /**
-         * Converts the SECTION command back to string
-         *
-         * Note: This is used in `pipelineJsonToString` utility
-         */
-        stringify(command) {
-            return `---`; // <- TODO: [🛋] Implement
-        },
-        /**
-         * Reads the SECTION command from the `TaskJson`
-         *
-         * Note: This is used in `pipelineJsonToString` utility
-         */
-        takeFromTaskJson($taskJson) {
-            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
-        },
-    };
-    /**
-     * Note: [⛱] There are two types of KNOWLEDGE, ACTION and INSTRUMENT commands:
-     * 1) There are commands `KNOWLEDGE`, `ACTION` and `INSTRUMENT` used in the pipeline head, they just define the knowledge, action or instrument as single line after the command
-     *    - KNOWLEDGE Look at https://en.wikipedia.org/wiki/Artificial_intelligence
-     * 2) `KNOWLEDGE SECTION` which has short form `KNOWLEDGE` is used in the sectiom, does not refer the line itself, but the content of the section block
-     *   - KNOWLEDGE SECTION
-     *
-     *   ```
-     *   Look at https://en.wikipedia.org/wiki/Artificial_intelligence
-     *   ```
-     */
-
     /**
      * Parses the boilerplate command
      *
@@ -42855,6 +42651,99 @@
         },
     };
 
+    /**
+     * Parses the knowledge command
+     *
+     * @see `documentationUrl` for more details
+     *
+     * @public exported from `@promptbook/editable`
+     */
+    const knowledgeCommandParser = {
+        /**
+         * Name of the command
+         */
+        name: 'KNOWLEDGE',
+        /**
+         * BOILERPLATE command can be used in:
+         */
+        isUsedInPipelineHead: true,
+        isUsedInPipelineTask: false,
+        /**
+         * Description of the KNOWLEDGE command
+         */
+        description: `Tells promptbook which external knowledge to use`,
+        /**
+         * Link to documentation
+         */
+        documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/41',
+        /**
+         * Example usages of the KNOWLEDGE 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
+        ],
+        /**
+         * Parses the KNOWLEDGE command
+         */
+        parse(input) {
+            const { args } = input;
+            const knowledgeSourceContent = _spaceTrim.spaceTrim(args[0] || '');
+            if (knowledgeSourceContent === '') {
+                throw new ParseError(`Source is not defined`);
+            }
+            // TODO: [main] !!4 Following checks should be applied every link in the `sourceContent`
+            if (knowledgeSourceContent.startsWith('http://')) {
+                throw new ParseError(`Source is not secure`);
+            }
+            if (!(isValidFilePath(knowledgeSourceContent) || isValidUrl(knowledgeSourceContent))) {
+                throw new ParseError(`Source not valid`);
+            }
+            if (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.
      *
@@ -43373,6 +43262,233 @@
         },
     };
 
+    /**
+     * 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 sectionCommandParser = {
+        /**
+         * 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'],
+        /**
+         * BOILERPLATE command can be used in:
+         */
+        isUsedInPipelineHead: false,
+        isUsedInPipelineTask: true,
+        /**
+         * Description of the SECTION command
+         */
+        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/64',
+        /**
+         * Example usages of the SECTION 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 */
+        /**
+         * Parses the SECTION command
+         */
+        parse(input) {
+            let { normalized } = input;
+            normalized = normalized.split('SAMPLE').join('EXAMPLE');
+            normalized = normalized.split('EXECUTE_').join('');
+            normalized = normalized.split('DIALOGUE').join('DIALOG');
+            const taskTypes = SectionTypes.filter((sectionType) => normalized.includes(sectionType.split('_TASK').join('')));
+            if (taskTypes.length !== 1) {
+                throw new ParseError(_spaceTrim.spaceTrim((block) => `
+                        Unknown section type "${normalized}"
+
+                        Supported section types are:
+                        ${block(SectionTypes.join(', '))}
+                    `));
+            }
+            const taskType = taskTypes[0];
+            return {
+                type: 'SECTION',
+                taskType,
+            };
+        },
+        /**
+         * Apply the SECTION command to the `pipelineJson`
+         *
+         * Note: `$` is used to indicate that this function mutates given `taskJson`
+         */
+        $applyToTaskJson(command, $taskJson, $pipelineJson) {
+            if ($taskJson.isSectionTypeSet === true) {
+                throw new ParseError(_spaceTrim.spaceTrim(`
+                    Section type is already defined in the section.
+                    It can be defined only once.
+                `));
+            }
+            $taskJson.isSectionTypeSet = true;
+            // TODO: [🍧][💩] Rearrange better - but at bottom and unwrap from function
+            const expectResultingParameterName = () => {
+                if ($taskJson.resultingParameterName) {
+                    return;
+                }
+                throw new ParseError(`Task section and example section must end with return statement -> {parameterName}`);
+            };
+            if ($taskJson.content === undefined) {
+                throw new UnexpectedError(`Content is missing in the taskJson - probably commands are applied in wrong order`);
+            }
+            if (command.taskType === 'EXAMPLE') {
+                expectResultingParameterName();
+                const parameter = $pipelineJson.parameters.find((param) => param.name === $taskJson.resultingParameterName);
+                if (parameter === undefined) {
+                    // TODO: !!6 Change to logic error for higher level abstraction of chatbot to work
+                    throw new ParseError(`Parameter \`{${$taskJson.resultingParameterName}}\` is not defined so can not define example value of it`);
+                }
+                parameter.exampleValues = parameter.exampleValues || [];
+                parameter.exampleValues.push($taskJson.content);
+                $taskJson.isTask = false;
+                return;
+            }
+            if (command.taskType === 'KNOWLEDGE') {
+                knowledgeCommandParser.$applyToPipelineJson({
+                    type: 'KNOWLEDGE',
+                    knowledgeSourceContent: $taskJson.content, // <- TODO: [🐝][main] !!3 Work with KNOWLEDGE which not referring to the source file or website, but its content itself
+                }, $pipelineJson);
+                $taskJson.isTask = false;
+                return;
+            }
+            if (command.taskType === 'ACTION') {
+                console.error(new NotYetImplementedError('Actions are not implemented yet'));
+                $taskJson.isTask = false;
+                return;
+            }
+            if (command.taskType === 'INSTRUMENT') {
+                console.error(new NotYetImplementedError('Instruments are not implemented yet'));
+                $taskJson.isTask = false;
+                return;
+            }
+            expectResultingParameterName();
+            $taskJson.taskType = command.taskType;
+            $taskJson.isTask = true;
+        },
+        /**
+         * Converts the SECTION command back to string
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        stringify(command) {
+            return `---`; // <- TODO: [🛋] Implement
+        },
+        /**
+         * Reads the SECTION command from the `TaskJson`
+         *
+         * Note: This is used in `pipelineJsonToString` utility
+         */
+        takeFromTaskJson($taskJson) {
+            throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
+        },
+    };
+    /**
+     * Note: [⛱] There are two types of KNOWLEDGE, ACTION and INSTRUMENT commands:
+     * 1) There are commands `KNOWLEDGE`, `ACTION` and `INSTRUMENT` used in the pipeline head, they just define the knowledge, action or instrument as single line after the command
+     *    - KNOWLEDGE Look at https://en.wikipedia.org/wiki/Artificial_intelligence
+     * 2) `KNOWLEDGE SECTION` which has short form `KNOWLEDGE` is used in the sectiom, does not refer the line itself, but the content of the section block
+     *   - KNOWLEDGE SECTION
+     *
+     *   ```
+     *   Look at https://en.wikipedia.org/wiki/Artificial_intelligence
+     *   ```
+     */
+
     /**
      * Parses the url command
      *
@@ -43826,6 +43942,242 @@
         return null;
     }
 
+    /**
+     * 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
+     *
+     * @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 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);
+            }
+        }
+        return listItems;
+    }
+
+    /**
+     * 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}`);
+        }
+        return pipelineIdentificationParts.join('\n');
+    }
+
+    /**
+     * Merges one parameter declaration into the mutable pipeline parameter list.
+     *
+     * @private internal utility of `parsePipeline`
+     */
+    function defineParameter($pipelineJson, parameterCommand) {
+        const { parameterName, parameterDescription, isInput, isOutput } = parameterCommand;
+        if (RESERVED_PARAMETER_NAMES.includes(parameterName)) {
+            throw new ParseError(_spaceTrim.spaceTrim((block) => `
+                    Parameter name {${parameterName}} is reserved and cannot be used as resulting parameter name
+
+                    ${block(getPipelineIdentification($pipelineJson))}
+                `) /* <- TODO: [🚞] */);
+        }
+        const existingParameter = $pipelineJson.parameters.find((parameter) => parameter.name === parameterName);
+        if (existingParameter &&
+            existingParameter.description &&
+            existingParameter.description !== parameterDescription &&
+            parameterDescription) {
+            throw new ParseError(_spaceTrim.spaceTrim((block) => `
+                    Parameter \`{${parameterName}}\` is defined multiple times with different description:
+
+                    ${block(getPipelineIdentification($pipelineJson))}
+
+                    First definition:
+                    ${block(existingParameter.description || '[undefined]')}
+
+                    Second definition:
+                    ${block(parameterDescription || '[undefined]')}
+                `));
+        }
+        if (existingParameter) {
+            if (parameterDescription) {
+                existingParameter.description = parameterDescription;
+            }
+            existingParameter.isInput = existingParameter.isInput || isInput;
+            existingParameter.isOutput = existingParameter.isOutput || isOutput;
+            return;
+        }
+        $pipelineJson.parameters.push({
+            name: parameterName,
+            description: parameterDescription || undefined,
+            isInput,
+            isOutput,
+        });
+    }
+
+    /**
+     * Removes fenced code blocks when deriving human-readable section descriptions.
+     *
+     * @private internal utility of `extractPipelineDescription`
+     */
+    const DESCRIPTION_CODE_BLOCK_REGEXP = /^```.*^```/gms;
+    /**
+     * Removes blockquote lines when deriving human-readable section descriptions.
+     *
+     * @private internal utility of `extractPipelineDescription`
+     */
+    const DESCRIPTION_BLOCKQUOTE_REGEXP = /^>.*$/gm;
+    /**
+     * Removes list items and return statements when deriving human-readable section descriptions.
+     *
+     * @private internal utility of `extractPipelineDescription`
+     */
+    const DESCRIPTION_LIST_ITEM_REGEXP = /^(?:(?:-)|(?:\d\))|(?:`?->))\s+.*$/gm;
+    /**
+     * Extracts the plain-text description from a head or task section body.
+     *
+     * @private internal utility of `parsePipeline`
+     */
+    function extractPipelineDescription(sectionContent) {
+        let description = sectionContent;
+        description = description.split(DESCRIPTION_CODE_BLOCK_REGEXP).join('');
+        description = description.split(DESCRIPTION_BLOCKQUOTE_REGEXP).join('');
+        description = description.split(DESCRIPTION_LIST_ITEM_REGEXP).join('');
+        description = _spaceTrim.spaceTrim(description);
+        if (description === '') {
+            return undefined;
+        }
+        return description;
+    }
+
+    /**
+     * Applies the pipeline head title, description, and head-level commands.
+     *
+     * @private internal utility of `parsePipeline`
+     */
+    function applyPipelineHead(pipelineHead, $pipelineJson) {
+        $pipelineJson.title = pipelineHead.title;
+        $pipelineJson.description = extractPipelineDescription(pipelineHead.content);
+        for (const listItem of extractAllListItemsFromMarkdown(pipelineHead.content)) {
+            applyPipelineHeadCommand(listItem, $pipelineJson);
+        }
+    }
+    /**
+     * Parses and applies one command declared in the pipeline head.
+     *
+     * @private internal utility of `applyPipelineHead`
+     */
+    function applyPipelineHeadCommand(listItem, $pipelineJson) {
+        const command = parseCommand(listItem, 'PIPELINE_HEAD');
+        const commandParser = getParserForCommand(command);
+        if (commandParser.isUsedInPipelineHead !== true /* <- Note: [🦦][4] */) {
+            throw new ParseError(_spaceTrim.spaceTrim((block) => `
+                    Command \`${command.type}\` is not allowed in the head of the pipeline ONLY at the pipeline task
+
+                    ${block(getPipelineIdentification($pipelineJson))}
+                `)); // <- TODO: [🚞]
+        }
+        try {
+            commandParser.$applyToPipelineJson(command, $pipelineJson);
+            //             <- Note: [🦦] Its strange that this assertion must be here, [🦦][4] should do this assertion implicitly
+        }
+        catch (error) {
+            if (!(error instanceof ParseError)) {
+                throw error;
+            }
+            throw new ParseError(_spaceTrim.spaceTrim((block) => `
+                    Command ${command.type} failed to apply to the pipeline
+
+                    The error:
+                    ${block(error.message)}
+
+                    Raw command:
+                    - ${listItem}
+
+                    Usage of ${command.type}:
+                    ${block(commandParser.examples.map((example) => `- ${example}`).join('\n'))}
+
+                    ${block(getPipelineIdentification($pipelineJson))}
+              `)); // <- TODO: [🚞]
+        }
+        if (command.type === 'PARAMETER') {
+            defineParameter($pipelineJson, command);
+            // <- Note: [🍣]
+        }
+    }
+
+    /**
+     * Creates the mutable pipeline JSON structure used throughout parsing.
+     *
+     * @private internal utility of `parsePipeline`
+     */
+    function createInitialPipelineJson(pipelineString) {
+        return {
+            title: DEFAULT_BOOK_TITLE,
+            parameters: [],
+            tasks: [],
+            knowledgeSources: [],
+            knowledgePieces: [],
+            personas: [],
+            preparations: [],
+            sources: [
+                {
+                    type: 'BOOK',
+                    path: null,
+                    // <- TODO: !!6 Pass here path of the file
+                    content: pipelineString,
+                },
+            ],
+        };
+    }
+
+    /**
+     * Creates stable unique task names for duplicate section titles.
+     *
+     * @private internal utility of `parsePipeline`
+     */
+    function createUniqueSectionNameResolver(pipelineSections) {
+        const sectionCounts = {};
+        for (const pipelineSection of pipelineSections) {
+            const sectionName = titleToName(pipelineSection.title);
+            if (sectionCounts[sectionName] === undefined) {
+                sectionCounts[sectionName] = { count: 0, currentIndex: 0 };
+            }
+            sectionCounts[sectionName].count++;
+        }
+        return (title) => {
+            const sectionName = titleToName(title);
+            const sectionCount = sectionCounts[sectionName];
+            if (sectionCount.count === 1) {
+                return sectionName;
+            }
+            const nameWithSuffix = `${sectionName}-${sectionCount.currentIndex}`;
+            sectionCount.currentIndex++;
+            return nameWithSuffix;
+        };
+    }
+
     /**
      * Extracts the interface (input and output parameters) from a pipeline.
      *
@@ -44087,12 +44439,261 @@
     // 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);
+    }
+    /**
+     * Applies default INPUT/OUTPUT flags when the author did not specify them explicitly.
+     *
+     * @private internal utility of `finalizeParsedPipeline`
+     */
+    function applyImplicitParameterDirections($pipelineJson) {
+        markImplicitInputParameters($pipelineJson);
+        markImplicitOutputParameters($pipelineJson);
+    }
+    /**
+     * Marks non-result parameters as pipeline inputs when no input was declared.
+     *
+     * @private internal utility of `finalizeParsedPipeline`
+     */
+    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 `finalizeParsedPipeline`
+     */
+    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 `finalizeParsedPipeline`
+     */
+    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 `finalizeParsedPipeline`
+     */
+    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.
+     *
+     * @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.
+     *
+     * @private internal utility of `finalizeParsedPipeline`
+     */
+    function ensurePipelineFormfactor($pipelineJson) {
+        // Note: [🔆] If formfactor is still not set, set it to 'GENERIC'
+        if ($pipelineJson.formfactorName === undefined) {
+            $pipelineJson.formfactorName = 'GENERIC';
+        }
+    }
+    /**
+     * 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
+     *
+     * @public exported from `@promptbook/markdown-utils`
+     */
+    function parseMarkdownSection(value) {
+        var _a, _b;
+        const lines = value.split(/\r?\n/);
+        if (!lines[0].startsWith('#')) {
+            throw new ParseError('Markdown section must start with heading');
+        }
+        const title = lines[0].replace(/^#+\s*/, '');
+        const level = (_b = (_a = lines[0].match(/^#+/)) === null || _a === void 0 ? void 0 : _a[0].length) !== null && _b !== void 0 ? _b : 0;
+        const content = _spaceTrim.spaceTrim(lines.slice(1).join('\n'));
+        if (level < 1 || level > 6) {
+            throw new ParseError('Markdown section must have heading level between 1 and 6');
+        }
+        return { title, level: level, content };
+    }
+    /**
+     * 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
+     */
+
+    /**
+     * Splits the markdown into sections by headings
+     *
+     * @public exported from `@promptbook/markdown-utils`
+     */
+    function splitMarkdownIntoSections(markdown) {
+        const lines = markdown.split(/\r?\n/);
+        const sections = [];
+        // TODO: [🧽] DRY
+        let currentType = 'MARKDOWN';
+        let buffer = [];
+        const finishSection = () => {
+            if (buffer.length === 0) {
+                return;
+            }
+            let section = _spaceTrim.spaceTrim(buffer.join('\n'));
+            if (section === '') {
+                return;
+            }
+            if (!section.startsWith('#')) {
+                section = `# ${DEFAULT_BOOK_TITLE}\n\n${section}`;
+            }
+            sections.push(section);
+            buffer = [];
+        };
+        for (const line of lines) {
+            if (currentType === 'MARKDOWN') {
+                if (line.startsWith('#')) {
+                    finishSection();
+                }
+                buffer.push(line);
+                if (line.startsWith('```')) {
+                    currentType = 'CODE_BLOCK';
+                }
+                else if (line.includes('<!--')) {
+                    currentType = 'COMMENT';
+                }
+            }
+            else if (currentType === 'CODE_BLOCK') {
+                buffer.push(line);
+                if (line.startsWith('```')) {
+                    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
+     */
+
+    /**
+     * Splits the prepared markdown into the pipeline head and task sections.
+     *
+     * @private internal utility of `parsePipeline`
+     */
+    function parsePreparedPipelineSections(pipelineString, $pipelineJson) {
+        const [pipelineHead, ...pipelineSections] = splitMarkdownIntoSections(pipelineString).map(parseMarkdownSection); /* <- Note: [🥞] */
+        assertPipelineSectionsStructure(pipelineHead, pipelineSections, $pipelineJson);
+        return {
+            pipelineHead,
+            pipelineSections,
+        };
+    }
+    /**
+     * Ensures the flattened markdown has exactly one h1 head followed by only h2 sections.
+     *
+     * @private internal utility of `parsePreparedPipelineSections`
+     */
+    function assertPipelineSectionsStructure(pipelineHead, pipelineSections, $pipelineJson) {
+        if (pipelineHead === undefined) {
+            throw new UnexpectedError(_spaceTrim.spaceTrim((block) => `
+                    Pipeline head is not defined
+
+                    ${block(getPipelineIdentification($pipelineJson))}
+
+                    This should never happen, because the pipeline already flattened
+                `));
+        }
+        if (pipelineHead.level !== 1) {
+            throw new UnexpectedError(_spaceTrim.spaceTrim((block) => `
+                    Pipeline head is not h1
+
+                    ${block(getPipelineIdentification($pipelineJson))}
+
+                    This should never happen, because the pipeline already flattened
+                `));
+        }
+        if (!pipelineSections.every((pipelineSection) => pipelineSection.level === 2)) {
+            throw new UnexpectedError(_spaceTrim.spaceTrim((block) => `
+                    Not every pipeline section is h2
+
+                    ${block(getPipelineIdentification($pipelineJson))}
+
+                    This should never happen, because the pipeline already flattened
+                `));
+        }
+    }
 
     /**
      * Number of padding lines to add at the end of the book content
@@ -44219,124 +44820,6 @@
     }
     // 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
-     *
-     * @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 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);
-            }
-        }
-        return listItems;
-    }
-
-    /**
-     * Parses markdown section to title its level and content
-     *
-     * @public exported from `@promptbook/markdown-utils`
-     */
-    function parseMarkdownSection(value) {
-        var _a, _b;
-        const lines = value.split(/\r?\n/);
-        if (!lines[0].startsWith('#')) {
-            throw new ParseError('Markdown section must start with heading');
-        }
-        const title = lines[0].replace(/^#+\s*/, '');
-        const level = (_b = (_a = lines[0].match(/^#+/)) === null || _a === void 0 ? void 0 : _a[0].length) !== null && _b !== void 0 ? _b : 0;
-        const content = _spaceTrim.spaceTrim(lines.slice(1).join('\n'));
-        if (level < 1 || level > 6) {
-            throw new ParseError('Markdown section must have heading level between 1 and 6');
-        }
-        return { title, level: level, content };
-    }
-    /**
-     * 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
-     */
-
-    /**
-     * Splits the markdown into sections by headings
-     *
-     * @public exported from `@promptbook/markdown-utils`
-     */
-    function splitMarkdownIntoSections(markdown) {
-        const lines = markdown.split(/\r?\n/);
-        const sections = [];
-        // TODO: [🧽] DRY
-        let currentType = 'MARKDOWN';
-        let buffer = [];
-        const finishSection = () => {
-            if (buffer.length === 0) {
-                return;
-            }
-            let section = _spaceTrim.spaceTrim(buffer.join('\n'));
-            if (section === '') {
-                return;
-            }
-            if (!section.startsWith('#')) {
-                section = `# ${DEFAULT_BOOK_TITLE}\n\n${section}`;
-            }
-            sections.push(section);
-            buffer = [];
-        };
-        for (const line of lines) {
-            if (currentType === 'MARKDOWN') {
-                if (line.startsWith('#')) {
-                    finishSection();
-                }
-                buffer.push(line);
-                if (line.startsWith('```')) {
-                    currentType = 'CODE_BLOCK';
-                }
-                else if (line.includes('<!--')) {
-                    currentType = 'COMMENT';
-                }
-            }
-            else if (currentType === 'CODE_BLOCK') {
-                buffer.push(line);
-                if (line.startsWith('```')) {
-                    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
      *
@@ -44378,111 +44861,15 @@
     /**
      * Normalizes inline parameter mentions wrapped in code spans before markdown flattening.
      *
-     * @private internal utility of `parsePipeline`
+     * @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 `parsePipeline`
+     * @private internal utility of `preparePipelineString`
      */
     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}`);
-        }
-        return pipelineIdentificationParts.join('\n');
-    }
     /**
      * Removes shebang/comments and normalizes markdown into a parseable pipeline form.
      *
@@ -44502,7 +44889,7 @@
     /**
      * Validates and removes the optional `#!` shebang line for `.book` files.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `preparePipelineString`
      */
     function removePipelineShebang(pipelineString, $pipelineJson) {
         if (!pipelineString.startsWith('#!')) {
@@ -44526,195 +44913,21 @@
         }
         return validatePipelineString(restLines.join('\n'));
     }
-    /**
-     * Splits the prepared markdown into the pipeline head and task sections.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    function parsePreparedPipelineSections(pipelineString, $pipelineJson) {
-        const [pipelineHead, ...pipelineSections] = splitMarkdownIntoSections(pipelineString).map(parseMarkdownSection); /* <- Note: [🥞] */
-        assertPipelineSectionsStructure(pipelineHead, pipelineSections, $pipelineJson);
-        return {
-            pipelineHead,
-            pipelineSections,
-        };
-    }
-    /**
-     * Ensures the flattened markdown has exactly one h1 head followed by only h2 sections.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    function assertPipelineSectionsStructure(pipelineHead, pipelineSections, $pipelineJson) {
-        if (pipelineHead === undefined) {
-            throw new UnexpectedError(_spaceTrim.spaceTrim((block) => `
-                    Pipeline head is not defined
-
-                    ${block(getPipelineIdentification($pipelineJson))}
-
-                    This should never happen, because the pipeline already flattened
-                `));
-        }
-        if (pipelineHead.level !== 1) {
-            throw new UnexpectedError(_spaceTrim.spaceTrim((block) => `
-                    Pipeline head is not h1
-
-                    ${block(getPipelineIdentification($pipelineJson))}
-
-                    This should never happen, because the pipeline already flattened
-                `));
-        }
-        if (!pipelineSections.every((pipelineSection) => pipelineSection.level === 2)) {
-            throw new UnexpectedError(_spaceTrim.spaceTrim((block) => `
-                    Not every pipeline section is h2
-
-                    ${block(getPipelineIdentification($pipelineJson))}
-
-                    This should never happen, because the pipeline already flattened
-                `));
-        }
-    }
-    /**
-     * 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);
-        }
-    }
-    /**
-     * Extracts the plain-text description from a head or task section body.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    function extractPipelineDescription(sectionContent) {
-        let description = sectionContent;
-        description = description.split(DESCRIPTION_CODE_BLOCK_REGEXP).join('');
-        description = description.split(DESCRIPTION_BLOCKQUOTE_REGEXP).join('');
-        description = description.split(DESCRIPTION_LIST_ITEM_REGEXP).join('');
-        description = _spaceTrim.spaceTrim(description);
-        if (description === '') {
-            return undefined;
-        }
-        return description;
-    }
-    /**
-     * Parses and applies one command declared in the pipeline head.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    function applyPipelineHeadCommand(listItem, $pipelineJson) {
-        const command = parseCommand(listItem, 'PIPELINE_HEAD');
-        const commandParser = getParserForCommand(command);
-        if (commandParser.isUsedInPipelineHead !== true /* <- Note: [🦦][4] */) {
-            throw new ParseError(_spaceTrim.spaceTrim((block) => `
-                    Command \`${command.type}\` is not allowed in the head of the pipeline ONLY at the pipeline task
-
-                    ${block(getPipelineIdentification($pipelineJson))}
-                `)); // <- TODO: [🚞]
-        }
-        try {
-            commandParser.$applyToPipelineJson(command, $pipelineJson);
-            //             <- Note: [🦦] Its strange that this assertion must be here, [🦦][4] should do this assertion implicitly
-        }
-        catch (error) {
-            if (!(error instanceof ParseError)) {
-                throw error;
-            }
-            throw new ParseError(_spaceTrim.spaceTrim((block) => `
-                    Command ${command.type} failed to apply to the pipeline
-
-                    The error:
-                    ${block(error.message)}
-
-                    Raw command:
-                    - ${listItem}
-
-                    Usage of ${command.type}:
-                    ${block(commandParser.examples.map((example) => `- ${example}`).join('\n'))}
 
-                    ${block(getPipelineIdentification($pipelineJson))}
-              `)); // <- TODO: [🚞]
-        }
-        if (command.type === 'PARAMETER') {
-            defineParameter($pipelineJson, command);
-            // <- Note: [🍣]
-        }
-    }
     /**
-     * Merges one parameter declaration into the mutable pipeline parameter list.
+     * Supported script languages
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal base for `ScriptLanguage`
      */
-    function defineParameter($pipelineJson, parameterCommand) {
-        const { parameterName, parameterDescription, isInput, isOutput } = parameterCommand;
-        if (RESERVED_PARAMETER_NAMES.includes(parameterName)) {
-            throw new ParseError(_spaceTrim.spaceTrim((block) => `
-                    Parameter name {${parameterName}} is reserved and cannot be used as resulting parameter name
-
-                    ${block(getPipelineIdentification($pipelineJson))}
-                `) /* <- TODO: [🚞] */);
-        }
-        const existingParameter = $pipelineJson.parameters.find((parameter) => parameter.name === parameterName);
-        if (existingParameter &&
-            existingParameter.description &&
-            existingParameter.description !== parameterDescription &&
-            parameterDescription) {
-            throw new ParseError(_spaceTrim.spaceTrim((block) => `
-                    Parameter \`{${parameterName}}\` is defined multiple times with different description:
-
-                    ${block(getPipelineIdentification($pipelineJson))}
-
-                    First definition:
-                    ${block(existingParameter.description || '[undefined]')}
+    const SUPPORTED_SCRIPT_LANGUAGES = ['javascript', 'typescript', 'python'];
+    //          <- TODO: [🏥] DRY
 
-                    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,
-        });
-    }
     /**
-     * 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.
      *
@@ -44734,7 +44947,7 @@
     /**
      * Creates the mutable task JSON shell from one markdown section.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
     function createTaskJsonFromSection(pipelineSection, getUniqueSectionName) {
         const { language, content } = extractOneBlockFromMarkdown(pipelineSection.content);
@@ -44762,7 +44975,7 @@
     /**
      * Extracts the optional trailing `-> {parameter}` statement from a section body.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
     function extractResultingParameterName(sectionContent) {
         var _a;
@@ -44773,7 +44986,7 @@
     /**
      * Parses all list-item commands declared inside one task section.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
     function parsePipelineTaskCommands(sectionContent) {
         return extractAllListItemsFromMarkdown(sectionContent).map((listItem) => ({
@@ -44784,7 +44997,7 @@
     /**
      * Applies the implicit default `PROMPT_TASK` section type when no SECTION command is present.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
     function applyDefaultTaskSectionType($taskJson, commands, $pipelineJson) {
         const isSectionCommandPresent = commands.some(({ command }) => command.type === 'SECTION');
@@ -44796,7 +45009,7 @@
     /**
      * Parses and applies one command declared inside a task section.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
     function applyPipelineTaskCommand(commandItem, $taskJson, $pipelineJson) {
         const { listItem, command } = commandItem;
@@ -44847,7 +45060,7 @@
     /**
      * Validates and stores the language for SCRIPT tasks.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
     function applyScriptTaskLanguage($taskJson, language, $pipelineJson) {
         const isScriptTask = $taskJson.taskType === 'SCRIPT_TASK';
@@ -44864,7 +45077,6 @@
         if (!SUPPORTED_SCRIPT_LANGUAGES.includes(language)) {
             throw new ParseError(_spaceTrim.spaceTrim((block) => `
                     Script language ${language} is not supported.
-
                     Supported languages are:
                     ${block(SUPPORTED_SCRIPT_LANGUAGES.join(', '))}
 
@@ -44875,7 +45087,7 @@
     /**
      * Extracts task dependencies and ensures referenced parameters exist.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
     function registerTaskDependentParameters($taskJson, $pipelineJson) {
         $taskJson.dependentParameterNames = Array.from(extractParameterNamesFromTask($taskJson));
@@ -44893,7 +45105,7 @@
     /**
      * Removes transient parsing flags and persists real tasks into the pipeline JSON.
      *
-     * @private internal utility of `parsePipeline`
+     * @private internal utility of `processPipelineSection`
      */
     function persistTaskIfNeeded($taskJson, $pipelineJson) {
         /*
@@ -44922,119 +45134,38 @@
         // 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.
+     * Compile pipeline from string (markdown) format to JSON format synchronously
      *
-     * @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.
+     * 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
      *
-     * @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.
+     * Note: This function does not validate logic of the pipeline only the parsing
+     * Note: This function acts as compilation process
      *
-     * @private internal utility of `parsePipeline`
-     */
-    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.
+     * @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
      *
-     * @private internal utility of `parsePipeline`
+     * @public exported from `@promptbook/core`
      */
-    function ensurePipelineFormfactor($pipelineJson) {
-        // Note: [🔆] If formfactor is still not set, set it to 'GENERIC'
-        if ($pipelineJson.formfactorName === undefined) {
-            $pipelineJson.formfactorName = 'GENERIC';
+    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);
         }
-    }
-    /**
-     * Finalizes ordering and exports the parsed pipeline JSON.
-     *
-     * @private internal utility of `parsePipeline`
-     */
-    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,
-            },
-        });
+        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