@promptbook/wizard 0.112.0-71 → 0.112.0-72

package/esm/index.es.js

@@ -38,7 +38,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.112.0-71';
+const PROMPTBOOK_ENGINE_VERSION = '0.112.0-72';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -22859,7 +22859,9 @@ const octopus3dAvatarVisual = {
         };
         const mantleRadiusX = size * morphologyProfile.body.bodyRadiusRatio * morphologyProfile.body.horizontalStretch;
         const mantleRadiusY = size * morphologyProfile.body.bodyRadiusRatio * morphologyProfile.body.verticalStretch * 1.1;
-        const mantleRadiusZ = size * morphologyProfile.body.bodyRadiusRatio * (0.9 + (morphologyProfile.body.horizontalStretch - 1) * 0.3);
+        const mantleRadiusZ = size *
+            morphologyProfile.body.bodyRadiusRatio *
+            (0.9 + (morphologyProfile.body.horizontalStretch - 1) * 0.3);
         const underbodyRadiusX = mantleRadiusX * (0.9 + (morphologyProfile.tentacles.rootSpreadScale - 1) * 0.08);
         const underbodyRadiusY = mantleRadiusY * (0.44 + morphologyProfile.body.lowerDropRatio * 3.1);
         const underbodyRadiusZ = mantleRadiusZ * 0.78;
@@ -22945,7 +22947,11 @@ const octopus3dAvatarVisual = {
             z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, faceEyeSpacing, faceEyeYOffset),
         }, faceEyeRadiusX, faceEyeRadiusY, mantleCenter, headPitch, headYaw, sceneCenterX, sceneCenterY, size, palette, timeMs, animationPhase + 0.7 + eyeRandom() * 0.6, interaction, morphologyProfile.face.eyeStyle);
         drawProjectedMouth(context, [
-            { x: -mouthHalfWidth, y: mouthY, z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, -mouthHalfWidth, mouthY) },
+            {
+                x: -mouthHalfWidth,
+                y: mouthY,
+                z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, -mouthHalfWidth, mouthY),
+            },
             {
                 x: size * morphologyProfile.face.mouthCenterOffsetRatio,
                 y: mouthY +
@@ -22954,7 +22960,11 @@ const octopus3dAvatarVisual = {
                     interaction.gazeY * size * 0.01,
                 z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, size * morphologyProfile.face.mouthCenterOffsetRatio, mouthY),
             },
-            { x: mouthHalfWidth, y: mouthY, z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, mouthHalfWidth, mouthY) },
+            {
+                x: mouthHalfWidth,
+                y: mouthY,
+                z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, mouthHalfWidth, mouthY),
+            },
         ], mantleCenter, headPitch, headYaw, sceneCenterX, sceneCenterY, palette, size);
     },
 };
@@ -23115,7 +23125,8 @@ function createOctopusTentacleStrokes(options) {
             z: anchorPoint.z + Math.cos(orbitAngle) * depthReach * 0.3 + sway * size * 0.012,
         };
         const controlPointTwo = {
-            x: anchorPoint.x + Math.sin(orbitAngle) * lateralReach * (0.82 + morphologyProfile.tentacles.swayScale * 0.12),
+            x: anchorPoint.x +
+                Math.sin(orbitAngle) * lateralReach * (0.82 + morphologyProfile.tentacles.swayScale * 0.12),
             y: anchorPoint.y + flowLength * 0.66,
             z: anchorPoint.z + Math.cos(orbitAngle) * depthReach * 0.72 + sway * size * 0.02,
         };
@@ -23180,8 +23191,7 @@ function drawTentacleStroke(context, tentacleStroke, palette) {
         context.beginPath();
         context.moveTo(startPoint.x, startPoint.y);
         context.lineTo(endPoint.x, endPoint.y);
-        context.strokeStyle =
-            tentacleStroke.colorBias > 0.6 ? `${palette.secondary}f0` : `${palette.primary}f0`;
+        context.strokeStyle = tentacleStroke.colorBias > 0.6 ? `${palette.secondary}f0` : `${palette.primary}f0`;
         context.lineWidth = width;
         context.lineCap = 'round';
         context.stroke();
@@ -31166,6 +31176,212 @@ const DEFAULT_LIST_TIMEOUTS_LIMIT = 20;
  * @private internal USE TIMEOUT constant
  */
 const MAX_LIST_TIMEOUTS_LIMIT = 100;
+/**
+ * Creates one formatted timeout-argument validation error.
+ *
+ * @private internal utility of USE TIMEOUT
+ */
+function createTimeoutToolArgsError(message) {
+    return new PipelineExecutionError(spaceTrim$1(`
+            ${message}
+        `));
+}
+/**
+ * Normalizes one optional timeout id string.
+ *
+ * @private internal utility of USE TIMEOUT
+ */
+function normalizeOptionalTimeoutId(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+/**
+ * Parses timeout target selection for tools that accept either `timeoutId` or `allActive: true`.
+ *
+ * @private internal utility of USE TIMEOUT
+ */
+function parseTimeoutTargetSelection(args, options) {
+    const timeoutId = normalizeOptionalTimeoutId(args.timeoutId);
+    const allActive = args.allActive === true;
+    if (timeoutId && allActive) {
+        throw createTimeoutToolArgsError(options.bothMessage);
+    }
+    if (allActive) {
+        return { allActive: true };
+    }
+    if (!timeoutId) {
+        throw createTimeoutToolArgsError(options.missingMessage);
+    }
+    return {
+        timeoutId,
+        allActive: false,
+    };
+}
+/**
+ * Parses one explicit `dueAt` update value.
+ *
+ * @private internal utility of USE TIMEOUT
+ */
+function parseOptionalTimeoutDueAt(value) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        return undefined;
+    }
+    const normalizedDueAt = value.trim();
+    const dueAtTimestamp = Date.parse(normalizedDueAt);
+    if (!Number.isFinite(dueAtTimestamp)) {
+        throw createTimeoutToolArgsError('Timeout `dueAt` must be one valid ISO timestamp.');
+    }
+    return new Date(dueAtTimestamp).toISOString();
+}
+/**
+ * Parses one explicit `extendByMs` update value.
+ *
+ * @private internal utility of USE TIMEOUT
+ */
+function parseOptionalTimeoutExtendByMs(value) {
+    if (typeof value !== 'number') {
+        return undefined;
+    }
+    if (!Number.isFinite(value) || value <= 0) {
+        throw createTimeoutToolArgsError('Timeout `extendByMs` must be a positive number of milliseconds.');
+    }
+    return Math.floor(value);
+}
+/**
+ * Parses one explicit `recurrenceIntervalMs` update value.
+ *
+ * @private internal utility of USE TIMEOUT
+ */
+function parseOptionalTimeoutRecurrenceInterval(value) {
+    if (value === null) {
+        return null;
+    }
+    if (typeof value !== 'number') {
+        return undefined;
+    }
+    if (!Number.isFinite(value) || value <= 0) {
+        throw createTimeoutToolArgsError('Timeout `recurrenceIntervalMs` must be a positive number of milliseconds or `null`.');
+    }
+    return Math.floor(value);
+}
+/**
+ * Parses one explicit `message` update value.
+ *
+ * @private internal utility of USE TIMEOUT
+ */
+function parseOptionalTimeoutMessage(value) {
+    if (value === null) {
+        return null;
+    }
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalizedMessage = value.trim();
+    return normalizedMessage.length > 0 ? normalizedMessage : null;
+}
+/**
+ * Parses one explicit `parameters` update value.
+ *
+ * @private internal utility of USE TIMEOUT
+ */
+function parseOptionalTimeoutParameters(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw createTimeoutToolArgsError('Timeout `parameters` must be one JSON object.');
+    }
+    return value;
+}
+/**
+ * Parses one explicit `paused` update value.
+ *
+ * @private internal utility of USE TIMEOUT
+ */
+function parseOptionalTimeoutPaused(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+/**
+ * Parses patch fields for `update_timeout`.
+ *
+ * @private internal utility of USE TIMEOUT
+ */
+function parseTimeoutUpdatePatch(args) {
+    const patch = {};
+    const dueAt = parseOptionalTimeoutDueAt(args.dueAt);
+    const extendByMs = parseOptionalTimeoutExtendByMs(args.extendByMs);
+    const recurrenceIntervalMs = parseOptionalTimeoutRecurrenceInterval(args.recurrenceIntervalMs);
+    const message = parseOptionalTimeoutMessage(args.message);
+    const parameters = parseOptionalTimeoutParameters(args.parameters);
+    const paused = parseOptionalTimeoutPaused(args.paused);
+    if (dueAt !== undefined) {
+        patch.dueAt = dueAt;
+    }
+    if (extendByMs !== undefined) {
+        patch.extendByMs = extendByMs;
+    }
+    if (patch.dueAt !== undefined && patch.extendByMs !== undefined) {
+        throw createTimeoutToolArgsError('Timeout update cannot include both `dueAt` and `extendByMs`.');
+    }
+    if (recurrenceIntervalMs !== undefined) {
+        patch.recurrenceIntervalMs = recurrenceIntervalMs;
+    }
+    if (message !== undefined) {
+        patch.message = message;
+    }
+    if (parameters !== undefined) {
+        patch.parameters = parameters;
+    }
+    if (paused !== undefined) {
+        patch.paused = paused;
+    }
+    return patch;
+}
+/**
+ * Determines whether the patch contains fields that are only supported for single-timeout updates.
+ *
+ * @private internal utility of USE TIMEOUT
+ */
+function hasSingleTimeoutOnlyPatchFields(patch) {
+    return (patch.dueAt !== undefined ||
+        patch.extendByMs !== undefined ||
+        patch.recurrenceIntervalMs !== undefined ||
+        patch.message !== undefined ||
+        patch.parameters !== undefined);
+}
+/**
+ * Parses bulk timeout update arguments.
+ *
+ * @private internal utility of USE TIMEOUT
+ */
+function parseBulkTimeoutUpdateArgs(patch) {
+    if (patch.paused === undefined) {
+        throw createTimeoutToolArgsError('Bulk timeout update with `allActive: true` requires `paused` to be explicitly set.');
+    }
+    if (hasSingleTimeoutOnlyPatchFields(patch)) {
+        throw createTimeoutToolArgsError('Bulk timeout update only supports the `paused` field.');
+    }
+    return {
+        allActive: true,
+        paused: patch.paused,
+    };
+}
+/**
+ * Parses single-timeout update arguments.
+ *
+ * @private internal utility of USE TIMEOUT
+ */
+function parseSingleTimeoutUpdateArgs(timeoutId, patch) {
+    if (!timeoutId) {
+        throw createTimeoutToolArgsError('Timeout `timeoutId` is required for single-timeout updates.');
+    }
+    if (Object.keys(patch).length === 0) {
+        throw createTimeoutToolArgsError('Timeout update must include at least one editable field.');
+    }
+    return {
+        timeoutId,
+        patch,
+    };
+}
 /**
  * Parses and validates `USE TIMEOUT` tool arguments.
  *
@@ -31192,22 +31408,14 @@ const parseTimeoutToolArgs = {
      * Parses `cancel_timeout` input.
      */
     cancel(args) {
-        const timeoutId = typeof args.timeoutId === 'string' ? args.timeoutId.trim() : '';
-        const allActive = args.allActive === true;
-        if (timeoutId && allActive) {
-            throw new PipelineExecutionError(spaceTrim$1(`
-                    Timeout cancellation must target either one \`timeoutId\` or \`allActive: true\`, not both.
-                `));
-        }
-        if (allActive) {
+        const target = parseTimeoutTargetSelection(args, {
+            bothMessage: 'Timeout cancellation must target either one `timeoutId` or `allActive: true`, not both.',
+            missingMessage: 'Timeout `timeoutId` is required unless you pass `allActive: true`.',
+        });
+        if (target.allActive) {
             return { allActive: true };
         }
-        if (!timeoutId) {
-            throw new PipelineExecutionError(spaceTrim$1(`
-                    Timeout \`timeoutId\` is required unless you pass \`allActive: true\`.
-                `));
-        }
-        return { timeoutId };
+        return { timeoutId: target.timeoutId };
     },
     /**
      * Parses `list_timeouts` input.
@@ -31238,106 +31446,14 @@ const parseTimeoutToolArgs = {
      * Parses `update_timeout` input.
      */
     update(args) {
-        const timeoutId = typeof args.timeoutId === 'string' ? args.timeoutId.trim() : '';
-        const allActive = args.allActive === true;
-        if (timeoutId && allActive) {
-            throw new PipelineExecutionError(spaceTrim$1(`
-                    Timeout update must target either one \`timeoutId\` or \`allActive: true\`, not both.
-                `));
-        }
-        if (!timeoutId && !allActive) {
-            throw new PipelineExecutionError(spaceTrim$1(`
-                    Timeout update requires one \`timeoutId\` or \`allActive: true\`.
-                `));
-        }
-        const patch = {};
-        if (typeof args.dueAt === 'string' && args.dueAt.trim().length > 0) {
-            const normalizedDueAt = args.dueAt.trim();
-            const dueAtTimestamp = Date.parse(normalizedDueAt);
-            if (!Number.isFinite(dueAtTimestamp)) {
-                throw new PipelineExecutionError(spaceTrim$1(`
-                        Timeout \`dueAt\` must be one valid ISO timestamp.
-                    `));
-            }
-            patch.dueAt = new Date(dueAtTimestamp).toISOString();
-        }
-        if (typeof args.extendByMs === 'number') {
-            if (!Number.isFinite(args.extendByMs) || args.extendByMs <= 0) {
-                throw new PipelineExecutionError(spaceTrim$1(`
-                        Timeout \`extendByMs\` must be a positive number of milliseconds.
-                    `));
-            }
-            patch.extendByMs = Math.floor(args.extendByMs);
-        }
-        if (patch.dueAt !== undefined && patch.extendByMs !== undefined) {
-            throw new PipelineExecutionError(spaceTrim$1(`
-                    Timeout update cannot include both \`dueAt\` and \`extendByMs\`.
-                `));
-        }
-        if (args.recurrenceIntervalMs === null) {
-            patch.recurrenceIntervalMs = null;
-        }
-        else if (typeof args.recurrenceIntervalMs === 'number') {
-            if (!Number.isFinite(args.recurrenceIntervalMs) || args.recurrenceIntervalMs <= 0) {
-                throw new PipelineExecutionError(spaceTrim$1(`
-                        Timeout \`recurrenceIntervalMs\` must be a positive number of milliseconds or \`null\`.
-                    `));
-            }
-            patch.recurrenceIntervalMs = Math.floor(args.recurrenceIntervalMs);
-        }
-        if (args.message === null) {
-            patch.message = null;
-        }
-        else if (typeof args.message === 'string') {
-            const normalizedMessage = args.message.trim();
-            patch.message = normalizedMessage.length > 0 ? normalizedMessage : null;
-        }
-        if (args.parameters !== undefined) {
-            if (!args.parameters || typeof args.parameters !== 'object' || Array.isArray(args.parameters)) {
-                throw new PipelineExecutionError(spaceTrim$1(`
-                        Timeout \`parameters\` must be one JSON object.
-                    `));
-            }
-            patch.parameters = args.parameters;
-        }
-        if (typeof args.paused === 'boolean') {
-            patch.paused = args.paused;
-        }
-        if (allActive) {
-            if (patch.paused === undefined) {
-                throw new PipelineExecutionError(spaceTrim$1(`
-                        Bulk timeout update with \`allActive: true\` requires \`paused\` to be explicitly set.
-                    `));
-            }
-            const hasSingleOnlyPatch = patch.dueAt !== undefined ||
-                patch.extendByMs !== undefined ||
-                patch.recurrenceIntervalMs !== undefined ||
-                patch.message !== undefined ||
-                patch.parameters !== undefined;
-            if (hasSingleOnlyPatch) {
-                throw new PipelineExecutionError(spaceTrim$1(`
-                        Bulk timeout update only supports the \`paused\` field.
-                    `));
-            }
-            return {
-                allActive: true,
-                paused: patch.paused,
-            };
-        }
-        if (!timeoutId) {
-            throw new PipelineExecutionError(spaceTrim$1(`
-                    Timeout \`timeoutId\` is required for single-timeout updates.
-                `));
-        }
-        if (Object.keys(patch).length === 0) {
-            throw new PipelineExecutionError(spaceTrim$1(`
-                    Timeout update must include at least one editable field.
-                `));
-        }
-        return {
-            timeoutId,
-            patch,
-        };
+        const target = parseTimeoutTargetSelection(args, {
+            bothMessage: 'Timeout update must target either one `timeoutId` or `allActive: true`, not both.',
+            missingMessage: 'Timeout update requires one `timeoutId` or `allActive: true`.',
+        });
+        const patch = parseTimeoutUpdatePatch(args);
+        return target.allActive
+            ? parseBulkTimeoutUpdateArgs(patch)
+            : parseSingleTimeoutUpdateArgs(target.timeoutId, patch);
     },
 };
 
@@ -41443,326 +41559,6 @@ async function loadArchive(filePath, fs) {
 }
 // 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$1(args[0] || '');
-        if (knowledgeSourceContent === '') {
-            throw new ParseError(`Source is not defined`);
-        }
-        // TODO: [main] !!4 Following checks should be applied every link in the `sourceContent`
-        if (knowledgeSourceContent.startsWith('http://')) {
-            throw new ParseError(`Source is not secure`);
-        }
-        if (!(isValidFilePath(knowledgeSourceContent) || isValidUrl(knowledgeSourceContent))) {
-            throw new ParseError(`Source not valid`);
-        }
-        if (knowledgeSourceContent.startsWith('../') ||
-            knowledgeSourceContent.startsWith('/') ||
-            /^[A-Z]:[\\/]+/i.test(knowledgeSourceContent)) {
-            throw new ParseError(`Source cannot be outside of the .book.md folder`);
-        }
-        return {
-            type: 'KNOWLEDGE',
-            knowledgeSourceContent,
-        };
-    },
-    /**
-     * Apply the KNOWLEDGE command to the `pipelineJson`
-     *
-     * Note: `$` is used to indicate that this function mutates given `pipelineJson`
-     */
-    $applyToPipelineJson(command, $pipelineJson) {
-        const { knowledgeSourceContent } = command;
-        $pipelineJson.knowledgeSources.push({
-            name: knowledgeSourceContentToName(knowledgeSourceContent),
-            knowledgeSourceContent,
-        });
-    },
-    /**
-     * Converts the KNOWLEDGE command back to string
-     *
-     * Note: This is used in `pipelineJsonToString` utility
-     */
-    stringify(command) {
-        return `---`; // <- TODO: [🛋] Implement
-    },
-    /**
-     * Reads the KNOWLEDGE command from the `PipelineJson`
-     *
-     * Note: This is used in `pipelineJsonToString` utility
-     */
-    takeFromPipelineJson(pipelineJson) {
-        throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
-    },
-};
-// Note: [⛱] There are two types of KNOWLEDGE commands *...(read more in [⛱])*
-
-/**
- * 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$1((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$1(`
-                    Section type is already defined in the section.
-                    It can be defined only once.
-                `));
-        }
-        $taskJson.isSectionTypeSet = true;
-        // TODO: [🍧][💩] Rearrange better - but at bottom and unwrap from function
-        const expectResultingParameterName = () => {
-            if ($taskJson.resultingParameterName) {
-                return;
-            }
-            throw new ParseError(`Task section and example section must end with return statement -> {parameterName}`);
-        };
-        if ($taskJson.content === undefined) {
-            throw new UnexpectedError(`Content is missing in the taskJson - probably commands are applied in wrong order`);
-        }
-        if (command.taskType === 'EXAMPLE') {
-            expectResultingParameterName();
-            const parameter = $pipelineJson.parameters.find((param) => param.name === $taskJson.resultingParameterName);
-            if (parameter === undefined) {
-                // TODO: !!6 Change to logic error for higher level abstraction of chatbot to work
-                throw new ParseError(`Parameter \`{${$taskJson.resultingParameterName}}\` is not defined so can not define example value of it`);
-            }
-            parameter.exampleValues = parameter.exampleValues || [];
-            parameter.exampleValues.push($taskJson.content);
-            $taskJson.isTask = false;
-            return;
-        }
-        if (command.taskType === 'KNOWLEDGE') {
-            knowledgeCommandParser.$applyToPipelineJson({
-                type: 'KNOWLEDGE',
-                knowledgeSourceContent: $taskJson.content, // <- TODO: [🐝][main] !!3 Work with KNOWLEDGE which not referring to the source file or website, but its content itself
-            }, $pipelineJson);
-            $taskJson.isTask = false;
-            return;
-        }
-        if (command.taskType === 'ACTION') {
-            console.error(new NotYetImplementedError('Actions are not implemented yet'));
-            $taskJson.isTask = false;
-            return;
-        }
-        if (command.taskType === 'INSTRUMENT') {
-            console.error(new NotYetImplementedError('Instruments are not implemented yet'));
-            $taskJson.isTask = false;
-            return;
-        }
-        expectResultingParameterName();
-        $taskJson.taskType = command.taskType;
-        $taskJson.isTask = true;
-    },
-    /**
-     * Converts the SECTION command back to string
-     *
-     * Note: This is used in `pipelineJsonToString` utility
-     */
-    stringify(command) {
-        return `---`; // <- TODO: [🛋] Implement
-    },
-    /**
-     * Reads the SECTION command from the `TaskJson`
-     *
-     * Note: This is used in `pipelineJsonToString` utility
-     */
-    takeFromTaskJson($taskJson) {
-        throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
-    },
-};
-/**
- * Note: [⛱] There are two types of KNOWLEDGE, ACTION and INSTRUMENT commands:
- * 1) There are commands `KNOWLEDGE`, `ACTION` and `INSTRUMENT` used in the pipeline head, they just define the knowledge, action or instrument as single line after the command
- *    - KNOWLEDGE Look at https://en.wikipedia.org/wiki/Artificial_intelligence
- * 2) `KNOWLEDGE SECTION` which has short form `KNOWLEDGE` is used in the sectiom, does not refer the line itself, but the content of the section block
- *   - KNOWLEDGE SECTION
- *
- *   ```
- *   Look at https://en.wikipedia.org/wiki/Artificial_intelligence
- *   ```
- */
-
 /**
  * Parses the boilerplate command
  *
@@ -42844,6 +42640,99 @@ const jokerCommandParser = {
     },
 };
 
+/**
+ * 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$1(args[0] || '');
+        if (knowledgeSourceContent === '') {
+            throw new ParseError(`Source is not defined`);
+        }
+        // TODO: [main] !!4 Following checks should be applied every link in the `sourceContent`
+        if (knowledgeSourceContent.startsWith('http://')) {
+            throw new ParseError(`Source is not secure`);
+        }
+        if (!(isValidFilePath(knowledgeSourceContent) || isValidUrl(knowledgeSourceContent))) {
+            throw new ParseError(`Source not valid`);
+        }
+        if (knowledgeSourceContent.startsWith('../') ||
+            knowledgeSourceContent.startsWith('/') ||
+            /^[A-Z]:[\\/]+/i.test(knowledgeSourceContent)) {
+            throw new ParseError(`Source cannot be outside of the .book.md folder`);
+        }
+        return {
+            type: 'KNOWLEDGE',
+            knowledgeSourceContent,
+        };
+    },
+    /**
+     * Apply the KNOWLEDGE command to the `pipelineJson`
+     *
+     * Note: `$` is used to indicate that this function mutates given `pipelineJson`
+     */
+    $applyToPipelineJson(command, $pipelineJson) {
+        const { knowledgeSourceContent } = command;
+        $pipelineJson.knowledgeSources.push({
+            name: knowledgeSourceContentToName(knowledgeSourceContent),
+            knowledgeSourceContent,
+        });
+    },
+    /**
+     * Converts the KNOWLEDGE command back to string
+     *
+     * Note: This is used in `pipelineJsonToString` utility
+     */
+    stringify(command) {
+        return `---`; // <- TODO: [🛋] Implement
+    },
+    /**
+     * Reads the KNOWLEDGE command from the `PipelineJson`
+     *
+     * Note: This is used in `pipelineJsonToString` utility
+     */
+    takeFromPipelineJson(pipelineJson) {
+        throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
+    },
+};
+// Note: [⛱] There are two types of KNOWLEDGE commands *...(read more in [⛱])*
+
 /**
  * Constant for model variants.
  *
@@ -43362,6 +43251,233 @@ const postprocessCommandParser = {
     },
 };
 
+/**
+ * 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$1((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$1(`
+                    Section type is already defined in the section.
+                    It can be defined only once.
+                `));
+        }
+        $taskJson.isSectionTypeSet = true;
+        // TODO: [🍧][💩] Rearrange better - but at bottom and unwrap from function
+        const expectResultingParameterName = () => {
+            if ($taskJson.resultingParameterName) {
+                return;
+            }
+            throw new ParseError(`Task section and example section must end with return statement -> {parameterName}`);
+        };
+        if ($taskJson.content === undefined) {
+            throw new UnexpectedError(`Content is missing in the taskJson - probably commands are applied in wrong order`);
+        }
+        if (command.taskType === 'EXAMPLE') {
+            expectResultingParameterName();
+            const parameter = $pipelineJson.parameters.find((param) => param.name === $taskJson.resultingParameterName);
+            if (parameter === undefined) {
+                // TODO: !!6 Change to logic error for higher level abstraction of chatbot to work
+                throw new ParseError(`Parameter \`{${$taskJson.resultingParameterName}}\` is not defined so can not define example value of it`);
+            }
+            parameter.exampleValues = parameter.exampleValues || [];
+            parameter.exampleValues.push($taskJson.content);
+            $taskJson.isTask = false;
+            return;
+        }
+        if (command.taskType === 'KNOWLEDGE') {
+            knowledgeCommandParser.$applyToPipelineJson({
+                type: 'KNOWLEDGE',
+                knowledgeSourceContent: $taskJson.content, // <- TODO: [🐝][main] !!3 Work with KNOWLEDGE which not referring to the source file or website, but its content itself
+            }, $pipelineJson);
+            $taskJson.isTask = false;
+            return;
+        }
+        if (command.taskType === 'ACTION') {
+            console.error(new NotYetImplementedError('Actions are not implemented yet'));
+            $taskJson.isTask = false;
+            return;
+        }
+        if (command.taskType === 'INSTRUMENT') {
+            console.error(new NotYetImplementedError('Instruments are not implemented yet'));
+            $taskJson.isTask = false;
+            return;
+        }
+        expectResultingParameterName();
+        $taskJson.taskType = command.taskType;
+        $taskJson.isTask = true;
+    },
+    /**
+     * Converts the SECTION command back to string
+     *
+     * Note: This is used in `pipelineJsonToString` utility
+     */
+    stringify(command) {
+        return `---`; // <- TODO: [🛋] Implement
+    },
+    /**
+     * Reads the SECTION command from the `TaskJson`
+     *
+     * Note: This is used in `pipelineJsonToString` utility
+     */
+    takeFromTaskJson($taskJson) {
+        throw new NotYetImplementedError(`[🛋] Not implemented yet`); // <- TODO: [🛋] Implement
+    },
+};
+/**
+ * Note: [⛱] There are two types of KNOWLEDGE, ACTION and INSTRUMENT commands:
+ * 1) There are commands `KNOWLEDGE`, `ACTION` and `INSTRUMENT` used in the pipeline head, they just define the knowledge, action or instrument as single line after the command
+ *    - KNOWLEDGE Look at https://en.wikipedia.org/wiki/Artificial_intelligence
+ * 2) `KNOWLEDGE SECTION` which has short form `KNOWLEDGE` is used in the sectiom, does not refer the line itself, but the content of the section block
+ *   - KNOWLEDGE SECTION
+ *
+ *   ```
+ *   Look at https://en.wikipedia.org/wiki/Artificial_intelligence
+ *   ```
+ */
+
 /**
  * Parses the url command
  *
@@ -43815,6 +43931,242 @@ function parseCommandVariant(input) {
     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$1((block) => `
+                    Parameter name {${parameterName}} is reserved and cannot be used as resulting parameter name
+
+                    ${block(getPipelineIdentification($pipelineJson))}
+                `) /* <- TODO: [🚞] */);
+    }
+    const existingParameter = $pipelineJson.parameters.find((parameter) => parameter.name === parameterName);
+    if (existingParameter &&
+        existingParameter.description &&
+        existingParameter.description !== parameterDescription &&
+        parameterDescription) {
+        throw new ParseError(spaceTrim$1((block) => `
+                    Parameter \`{${parameterName}}\` is defined multiple times with different description:
+
+                    ${block(getPipelineIdentification($pipelineJson))}
+
+                    First definition:
+                    ${block(existingParameter.description || '[undefined]')}
+
+                    Second definition:
+                    ${block(parameterDescription || '[undefined]')}
+                `));
+    }
+    if (existingParameter) {
+        if (parameterDescription) {
+            existingParameter.description = parameterDescription;
+        }
+        existingParameter.isInput = existingParameter.isInput || isInput;
+        existingParameter.isOutput = existingParameter.isOutput || isOutput;
+        return;
+    }
+    $pipelineJson.parameters.push({
+        name: parameterName,
+        description: parameterDescription || undefined,
+        isInput,
+        isOutput,
+    });
+}
+
+/**
+ * Removes fenced code blocks when deriving human-readable section descriptions.
+ *
+ * @private internal utility of `extractPipelineDescription`
+ */
+const DESCRIPTION_CODE_BLOCK_REGEXP = /^```.*^```/gms;
+/**
+ * Removes blockquote lines when deriving human-readable section descriptions.
+ *
+ * @private internal utility of `extractPipelineDescription`
+ */
+const DESCRIPTION_BLOCKQUOTE_REGEXP = /^>.*$/gm;
+/**
+ * Removes list items and return statements when deriving human-readable section descriptions.
+ *
+ * @private internal utility of `extractPipelineDescription`
+ */
+const DESCRIPTION_LIST_ITEM_REGEXP = /^(?:(?:-)|(?:\d\))|(?:`?->))\s+.*$/gm;
+/**
+ * Extracts the plain-text description from a head or task section body.
+ *
+ * @private internal utility of `parsePipeline`
+ */
+function extractPipelineDescription(sectionContent) {
+    let description = sectionContent;
+    description = description.split(DESCRIPTION_CODE_BLOCK_REGEXP).join('');
+    description = description.split(DESCRIPTION_BLOCKQUOTE_REGEXP).join('');
+    description = description.split(DESCRIPTION_LIST_ITEM_REGEXP).join('');
+    description = spaceTrim$1(description);
+    if (description === '') {
+        return undefined;
+    }
+    return description;
+}
+
+/**
+ * Applies the pipeline head title, description, and head-level commands.
+ *
+ * @private internal utility of `parsePipeline`
+ */
+function applyPipelineHead(pipelineHead, $pipelineJson) {
+    $pipelineJson.title = pipelineHead.title;
+    $pipelineJson.description = extractPipelineDescription(pipelineHead.content);
+    for (const listItem of extractAllListItemsFromMarkdown(pipelineHead.content)) {
+        applyPipelineHeadCommand(listItem, $pipelineJson);
+    }
+}
+/**
+ * Parses and applies one command declared in the pipeline head.
+ *
+ * @private internal utility of `applyPipelineHead`
+ */
+function applyPipelineHeadCommand(listItem, $pipelineJson) {
+    const command = parseCommand(listItem, 'PIPELINE_HEAD');
+    const commandParser = getParserForCommand(command);
+    if (commandParser.isUsedInPipelineHead !== true /* <- Note: [🦦][4] */) {
+        throw new ParseError(spaceTrim$1((block) => `
+                    Command \`${command.type}\` is not allowed in the head of the pipeline ONLY at the pipeline task
+
+                    ${block(getPipelineIdentification($pipelineJson))}
+                `)); // <- TODO: [🚞]
+    }
+    try {
+        commandParser.$applyToPipelineJson(command, $pipelineJson);
+        //             <- Note: [🦦] Its strange that this assertion must be here, [🦦][4] should do this assertion implicitly
+    }
+    catch (error) {
+        if (!(error instanceof ParseError)) {
+            throw error;
+        }
+        throw new ParseError(spaceTrim$1((block) => `
+                    Command ${command.type} failed to apply to the pipeline
+
+                    The error:
+                    ${block(error.message)}
+
+                    Raw command:
+                    - ${listItem}
+
+                    Usage of ${command.type}:
+                    ${block(commandParser.examples.map((example) => `- ${example}`).join('\n'))}
+
+                    ${block(getPipelineIdentification($pipelineJson))}
+              `)); // <- TODO: [🚞]
+    }
+    if (command.type === 'PARAMETER') {
+        defineParameter($pipelineJson, command);
+        // <- Note: [🍣]
+    }
+}
+
+/**
+ * Creates the mutable pipeline JSON structure used throughout parsing.
+ *
+ * @private internal utility of `parsePipeline`
+ */
+function createInitialPipelineJson(pipelineString) {
+    return {
+        title: DEFAULT_BOOK_TITLE,
+        parameters: [],
+        tasks: [],
+        knowledgeSources: [],
+        knowledgePieces: [],
+        personas: [],
+        preparations: [],
+        sources: [
+            {
+                type: 'BOOK',
+                path: null,
+                // <- TODO: !!6 Pass here path of the file
+                content: pipelineString,
+            },
+        ],
+    };
+}
+
+/**
+ * Creates stable unique task names for duplicate section titles.
+ *
+ * @private internal utility of `parsePipeline`
+ */
+function createUniqueSectionNameResolver(pipelineSections) {
+    const sectionCounts = {};
+    for (const pipelineSection of pipelineSections) {
+        const sectionName = titleToName(pipelineSection.title);
+        if (sectionCounts[sectionName] === undefined) {
+            sectionCounts[sectionName] = { count: 0, currentIndex: 0 };
+        }
+        sectionCounts[sectionName].count++;
+    }
+    return (title) => {
+        const sectionName = titleToName(title);
+        const sectionCount = sectionCounts[sectionName];
+        if (sectionCount.count === 1) {
+            return sectionName;
+        }
+        const nameWithSuffix = `${sectionName}-${sectionCount.currentIndex}`;
+        sectionCount.currentIndex++;
+        return nameWithSuffix;
+    };
+}
+
 /**
  * Extracts the interface (input and output parameters) from a pipeline.
  *
@@ -44076,12 +44428,261 @@ const HIGH_LEVEL_ABSTRACTIONS = [
 // Note: [💞] Ignore a discrepancy between file name and entity name
 
 /**
- * Supported script languages
+ * Applies postprocessing and exports the parsed pipeline JSON.
  *
- * @private internal base for `ScriptLanguage`
+ * @private internal utility of `parsePipeline`
  */
-const SUPPORTED_SCRIPT_LANGUAGES = ['javascript', 'typescript', 'python'];
-//          <- TODO: [🏥] DRY
+function finalizeParsedPipeline($pipelineJson) {
+    applyImplicitParameterDirections($pipelineJson);
+    removeUndefinedValuesFromPipeline($pipelineJson);
+    applySyncHighLevelAbstractions($pipelineJson);
+    ensurePipelineFormfactor($pipelineJson);
+    return exportParsedPipelineJson($pipelineJson);
+}
+/**
+ * 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$1(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$1(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$1((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$1((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$1((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
@@ -44208,124 +44809,6 @@ function deflatePipeline(pipelineString) {
 }
 // TODO: Unit test
 
-/**
- * Utility function to extract all list items from markdown
- *
- * Note: It works with both ul and ol
- * Note: It omits list items in code blocks
- * Note: It flattens nested lists
- * Note: It can not work with html syntax and comments
- *
- * @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$1(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$1(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
  *
@@ -44367,111 +44850,15 @@ function flattenMarkdown(markdown) {
 /**
  * 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.
  *
@@ -44491,7 +44878,7 @@ function preparePipelineString(pipelineString, $pipelineJson) {
 /**
  * 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('#!')) {
@@ -44515,195 +44902,21 @@ function removePipelineShebang(pipelineString, $pipelineJson) {
     }
     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$1((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$1((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$1((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$1(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$1((block) => `
-                    Command \`${command.type}\` is not allowed in the head of the pipeline ONLY at the pipeline task
-
-                    ${block(getPipelineIdentification($pipelineJson))}
-                `)); // <- TODO: [🚞]
-    }
-    try {
-        commandParser.$applyToPipelineJson(command, $pipelineJson);
-        //             <- Note: [🦦] Its strange that this assertion must be here, [🦦][4] should do this assertion implicitly
-    }
-    catch (error) {
-        if (!(error instanceof ParseError)) {
-            throw error;
-        }
-        throw new ParseError(spaceTrim$1((block) => `
-                    Command ${command.type} failed to apply to the pipeline
-
-                    The error:
-                    ${block(error.message)}
-
-                    Raw command:
-                    - ${listItem}
-
-                    Usage of ${command.type}:
-                    ${block(commandParser.examples.map((example) => `- ${example}`).join('\n'))}
 
-                    ${block(getPipelineIdentification($pipelineJson))}
-              `)); // <- TODO: [🚞]
-    }
-    if (command.type === 'PARAMETER') {
-        defineParameter($pipelineJson, command);
-        // <- Note: [🍣]
-    }
-}
 /**
- * Merges one parameter declaration into the mutable pipeline parameter list.
+ * Supported script languages
  *
- * @private internal utility of `parsePipeline`
+ * @private internal base for `ScriptLanguage`
  */
-function defineParameter($pipelineJson, parameterCommand) {
-    const { parameterName, parameterDescription, isInput, isOutput } = parameterCommand;
-    if (RESERVED_PARAMETER_NAMES.includes(parameterName)) {
-        throw new ParseError(spaceTrim$1((block) => `
-                    Parameter name {${parameterName}} is reserved and cannot be used as resulting parameter name
-
-                    ${block(getPipelineIdentification($pipelineJson))}
-                `) /* <- TODO: [🚞] */);
-    }
-    const existingParameter = $pipelineJson.parameters.find((parameter) => parameter.name === parameterName);
-    if (existingParameter &&
-        existingParameter.description &&
-        existingParameter.description !== parameterDescription &&
-        parameterDescription) {
-        throw new ParseError(spaceTrim$1((block) => `
-                    Parameter \`{${parameterName}}\` is defined multiple times with different description:
-
-                    ${block(getPipelineIdentification($pipelineJson))}
-
-                    First definition:
-                    ${block(existingParameter.description || '[undefined]')}
+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.
  *
@@ -44723,7 +44936,7 @@ function processPipelineSection(pipelineSection, $pipelineJson, getUniqueSection
 /**
  * Creates the mutable task JSON shell from one markdown section.
  *
- * @private internal utility of `parsePipeline`
+ * @private internal utility of `processPipelineSection`
  */
 function createTaskJsonFromSection(pipelineSection, getUniqueSectionName) {
     const { language, content } = extractOneBlockFromMarkdown(pipelineSection.content);
@@ -44751,7 +44964,7 @@ function createTaskJsonFromSection(pipelineSection, getUniqueSectionName) {
 /**
  * Extracts the optional trailing `-> {parameter}` statement from a section body.
  *
- * @private internal utility of `parsePipeline`
+ * @private internal utility of `processPipelineSection`
  */
 function extractResultingParameterName(sectionContent) {
     var _a;
@@ -44762,7 +44975,7 @@ function extractResultingParameterName(sectionContent) {
 /**
  * Parses all list-item commands declared inside one task section.
  *
- * @private internal utility of `parsePipeline`
+ * @private internal utility of `processPipelineSection`
  */
 function parsePipelineTaskCommands(sectionContent) {
     return extractAllListItemsFromMarkdown(sectionContent).map((listItem) => ({
@@ -44773,7 +44986,7 @@ function parsePipelineTaskCommands(sectionContent) {
 /**
  * Applies the implicit default `PROMPT_TASK` section type when no SECTION command is present.
  *
- * @private internal utility of `parsePipeline`
+ * @private internal utility of `processPipelineSection`
  */
 function applyDefaultTaskSectionType($taskJson, commands, $pipelineJson) {
     const isSectionCommandPresent = commands.some(({ command }) => command.type === 'SECTION');
@@ -44785,7 +44998,7 @@ function applyDefaultTaskSectionType($taskJson, commands, $pipelineJson) {
 /**
  * Parses and applies one command declared inside a task section.
  *
- * @private internal utility of `parsePipeline`
+ * @private internal utility of `processPipelineSection`
  */
 function applyPipelineTaskCommand(commandItem, $taskJson, $pipelineJson) {
     const { listItem, command } = commandItem;
@@ -44836,7 +45049,7 @@ function applyPipelineTaskCommand(commandItem, $taskJson, $pipelineJson) {
 /**
  * Validates and stores the language for SCRIPT tasks.
  *
- * @private internal utility of `parsePipeline`
+ * @private internal utility of `processPipelineSection`
  */
 function applyScriptTaskLanguage($taskJson, language, $pipelineJson) {
     const isScriptTask = $taskJson.taskType === 'SCRIPT_TASK';
@@ -44853,7 +45066,6 @@ function applyScriptTaskLanguage($taskJson, language, $pipelineJson) {
     if (!SUPPORTED_SCRIPT_LANGUAGES.includes(language)) {
         throw new ParseError(spaceTrim$1((block) => `
                     Script language ${language} is not supported.
-
                     Supported languages are:
                     ${block(SUPPORTED_SCRIPT_LANGUAGES.join(', '))}
 
@@ -44864,7 +45076,7 @@ function applyScriptTaskLanguage($taskJson, language, $pipelineJson) {
 /**
  * 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));
@@ -44882,7 +45094,7 @@ function registerTaskDependentParameters($taskJson, $pipelineJson) {
 /**
  * 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) {
     /*
@@ -44911,119 +45123,38 @@ function persistTaskIfNeeded($taskJson, $pipelineJson) {
     // 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