@promptbook/cli 0.104.0-1 → 0.104.0-11

package/umd/index.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('colors'), require('commander'), require('spacetrim'), require('waitasecond'), require('prompts'), require('path'), require('fs/promises'), require('dotenv'), require('crypto-js/enc-hex'), require('crypto-js/sha256'), require('crypto'), require('socket.io-client'), require('rxjs'), require('child_process'), require('jszip'), require('papaparse'), require('crypto-js'), require('mime-types'), require('glob-promise'), require('moment'), require('express'), require('express-openapi-validator'), require('http'), require('socket.io'), require('swagger-ui-express'), require('react'), require('react-dom/server'), require('@anthropic-ai/sdk'), require('bottleneck'), require('@azure/openai'), require('openai'), require('@mozilla/readability'), require('jsdom'), require('showdown')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'colors', 'commander', 'spacetrim', 'waitasecond', 'prompts', 'path', 'fs/promises', 'dotenv', 'crypto-js/enc-hex', 'crypto-js/sha256', 'crypto', 'socket.io-client', 'rxjs', 'child_process', 'jszip', 'papaparse', 'crypto-js', 'mime-types', 'glob-promise', 'moment', 'express', 'express-openapi-validator', 'http', 'socket.io', 'swagger-ui-express', 'react', 'react-dom/server', '@anthropic-ai/sdk', 'bottleneck', '@azure/openai', 'openai', '@mozilla/readability', 'jsdom', 'showdown'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-cli"] = {}, global.colors, global.commander, global.spaceTrim$1, global.waitasecond, global.prompts, global.path, global.promises, global.dotenv, global.hexEncoder, global.sha256, global.crypto, global.socket_ioClient, global.rxjs, global.child_process, global.JSZip, global.papaparse, global.cryptoJs, global.mimeTypes, global.glob, global.moment, global.express, global.OpenApiValidator, global.http, global.socket_io, global.swaggerUi, global.react, global.server, global.Anthropic, global.Bottleneck, global.openai, global.OpenAI, global.readability, global.jsdom, global.showdown));
-})(this, (function (exports, colors, commander, spaceTrim$1, waitasecond, prompts, path, promises, dotenv, hexEncoder, sha256, crypto, socket_ioClient, rxjs, child_process, JSZip, papaparse, cryptoJs, mimeTypes, glob, moment, express, OpenApiValidator, http, socket_io, swaggerUi, react, server, Anthropic, Bottleneck, openai, OpenAI, readability, jsdom, showdown) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('colors'), require('commander'), require('spacetrim'), require('waitasecond'), require('prompts'), require('path'), require('fs/promises'), require('dotenv'), require('crypto-js/enc-hex'), require('crypto-js/sha256'), require('crypto'), require('socket.io-client'), require('crypto-js'), require('rxjs'), require('child_process'), require('jszip'), require('papaparse'), require('mime-types'), require('glob-promise'), require('moment'), require('express'), require('express-openapi-validator'), require('http'), require('socket.io'), require('swagger-ui-express'), require('react'), require('react-dom/server'), require('@anthropic-ai/sdk'), require('bottleneck'), require('@azure/openai'), require('openai'), require('@mozilla/readability'), require('jsdom'), require('showdown')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'colors', 'commander', 'spacetrim', 'waitasecond', 'prompts', 'path', 'fs/promises', 'dotenv', 'crypto-js/enc-hex', 'crypto-js/sha256', 'crypto', 'socket.io-client', 'crypto-js', 'rxjs', 'child_process', 'jszip', 'papaparse', 'mime-types', 'glob-promise', 'moment', 'express', 'express-openapi-validator', 'http', 'socket.io', 'swagger-ui-express', 'react', 'react-dom/server', '@anthropic-ai/sdk', 'bottleneck', '@azure/openai', 'openai', '@mozilla/readability', 'jsdom', 'showdown'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-cli"] = {}, global.colors, global.commander, global.spaceTrim$1, global.waitasecond, global.prompts, global.path, global.promises, global.dotenv, global.hexEncoder, global.sha256, global.crypto, global.socket_ioClient, global.cryptoJs, global.rxjs, global.child_process, global.JSZip, global.papaparse, global.mimeTypes, global.glob, global.moment, global.express, global.OpenApiValidator, global.http, global.socket_io, global.swaggerUi, global.react, global.server, global.Anthropic, global.Bottleneck, global.openai, global.OpenAI, global.readability, global.jsdom, global.showdown));
+})(this, (function (exports, colors, commander, spaceTrim$1, waitasecond, prompts, path, promises, dotenv, hexEncoder, sha256, crypto, socket_ioClient, cryptoJs, rxjs, child_process, JSZip, papaparse, mimeTypes, glob, moment, express, OpenApiValidator, http, socket_io, swaggerUi, react, server, Anthropic, Bottleneck, openai, OpenAI, readability, jsdom, showdown) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -56,7 +56,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.104.0-1';
+    const PROMPTBOOK_ENGINE_VERSION = '0.104.0-11';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -66,6 +66,8 @@
      * Core Promptbook server configuration.
      *
      * This server is also used for auto-federation in the Agents Server.
+     *
+     * @public exported from `@promptbook/core`
      */
     const CORE_SERVER = {
         title: 'Promptbook Core',
@@ -1382,13 +1384,14 @@
      *
      * @public exported from `@promptbook/utils`
      */
-    const $isRunningInNode = new Function(`
-    try {
-        return this === global;
-    } catch (e) {
-        return false;
+    function $isRunningInNode() {
+        try {
+            return typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+        }
+        catch (e) {
+            return false;
+        }
     }
-`);
     /**
      * TODO: [🎺]
      */
@@ -1400,13 +1403,14 @@
      *
      * @public exported from `@promptbook/utils`
      */
-    const $isRunningInBrowser = new Function(`
-    try {
-        return this === window;
-    } catch (e) {
-        return false;
+    function $isRunningInBrowser() {
+        try {
+            return typeof window !== 'undefined' && typeof window.document !== 'undefined';
+        }
+        catch (e) {
+            return false;
+        }
     }
-`);
     /**
      * TODO: [🎺]
      */
@@ -1418,13 +1422,15 @@
      *
      * @public exported from `@promptbook/utils`
      */
-    const $isRunningInJest = new Function(`
-    try {
-        return process.env.JEST_WORKER_ID !== undefined;
-    } catch (e) {
-        return false;
+    function $isRunningInJest() {
+        var _a;
+        try {
+            return typeof process !== 'undefined' && ((_a = process.env) === null || _a === void 0 ? void 0 : _a.JEST_WORKER_ID) !== undefined;
+        }
+        catch (e) {
+            return false;
+        }
     }
-`);
     /**
      * TODO: [🎺]
      */
@@ -1436,17 +1442,17 @@
      *
      * @public exported from `@promptbook/utils`
      */
-    const $isRunningInWebWorker = new Function(`
-    try {
-        if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {
-            return true;
-        } else {
+    function $isRunningInWebWorker() {
+        try {
+            // Note: Check for importScripts which is specific to workers
+            //       and not available in the main browser thread
+            return (typeof self !== 'undefined' &&
+                typeof self.importScripts === 'function');
+        }
+        catch (e) {
             return false;
         }
-    } catch (e) {
-        return false;
     }
-`);
     /**
      * TODO: [🎺]
      */
@@ -1964,7 +1970,7 @@
                                 ${i + 1}) **${title}** \`${className}\` from \`${packageName}\`
                                     ${morePieces.join('; ')}
                             `);
-        if ($isRunningInNode) {
+        if ($isRunningInNode()) {
             if (isInstalled && isFullyConfigured) {
                 providerMessage = colors__default["default"].green(providerMessage);
             }
@@ -3726,6 +3732,7 @@
         }
     }
     /**
+     * TODO: !!!! Deprecate pipeline server and all of its components
      * TODO: Maybe use `$exportJson`
      * TODO: [🧠][🛍] Maybe not `isAnonymous: boolean` BUT `mode: 'ANONYMOUS'|'COLLECTION'`
      * TODO: [🍓] Allow to list compatible models with each variant
@@ -3735,280 +3742,1166 @@
      */
 
     /**
-     * Function isValidJsonString will tell you if the string is valid JSON or not
+     * Normalizes a given text to camelCase format.
      *
-     * @param value The string to check
-     * @returns `true` if the string is a valid JSON string, false otherwise
+     * Note: [🔂] This function is idempotent.
      *
+     * @param text The text to be normalized.
+     * @param _isFirstLetterCapital Whether the first letter should be capitalized.
+     * @returns The camelCase formatted string.
+     * @example 'helloWorld'
+     * @example 'iLovePromptbook'
      * @public exported from `@promptbook/utils`
      */
-    function isValidJsonString(value /* <- [👨‍⚖️] */) {
-        try {
-            JSON.parse(value);
-            return true;
-        }
-        catch (error) {
-            assertsError(error);
-            if (error.message.includes('Unexpected token')) {
-                return false;
+    function normalizeTo_camelCase(text, _isFirstLetterCapital = false) {
+        let charType;
+        let lastCharType = null;
+        let normalizedName = '';
+        for (const char of text) {
+            let normalizedChar;
+            if (/^[a-z]$/.test(char)) {
+                charType = 'LOWERCASE';
+                normalizedChar = char;
             }
-            return false;
+            else if (/^[A-Z]$/.test(char)) {
+                charType = 'UPPERCASE';
+                normalizedChar = char.toLowerCase();
+            }
+            else if (/^[0-9]$/.test(char)) {
+                charType = 'NUMBER';
+                normalizedChar = char;
+            }
+            else {
+                charType = 'OTHER';
+                normalizedChar = '';
+            }
+            if (!lastCharType) {
+                if (_isFirstLetterCapital) {
+                    normalizedChar = normalizedChar.toUpperCase(); //TODO: DRY
+                }
+            }
+            else if (charType !== lastCharType &&
+                !(charType === 'LOWERCASE' && lastCharType === 'UPPERCASE') &&
+                !(lastCharType === 'NUMBER') &&
+                !(charType === 'NUMBER')) {
+                normalizedChar = normalizedChar.toUpperCase(); //TODO: [🌺] DRY
+            }
+            normalizedName += normalizedChar;
+            lastCharType = charType;
         }
+        return normalizedName;
     }
-
     /**
-     * Makes first letter of a string uppercase
-     *
-     * Note: [🔂] This function is idempotent.
-     *
-     * @public exported from `@promptbook/utils`
+     * TODO: [🌺] Use some intermediate util splitWords
      */
-    function capitalize(word) {
-        return word.substring(0, 1).toUpperCase() + word.substring(1);
-    }
 
     /**
-     * Extracts all code blocks from markdown.
+     * Creates a Mermaid graph based on the promptbook
      *
-     * Note: There are multiple similar functions:
-     * - `extractBlock` just extracts the content of the code block which is also used as built-in function for postprocessing
-     * - `extractJsonBlock` extracts exactly one valid JSON code block
-     * - `extractOneBlockFromMarkdown` extracts exactly one code block with language of the code block
-     * - `extractAllBlocksFromMarkdown` extracts all code blocks with language of the code block
+     * Note: The result is not wrapped in a Markdown code block
      *
-     * @param markdown any valid markdown
-     * @returns code blocks with language and content
-     * @throws {ParseError} if block is not closed properly
-     * @public exported from `@promptbook/markdown-utils`
+     * @public exported from `@promptbook/utils`
      */
-    function extractAllBlocksFromMarkdown(markdown) {
-        const codeBlocks = [];
-        const lines = markdown.split('\n');
-        // Note: [0] Ensure that the last block notated by gt > will be closed
-        lines.push('');
-        let currentCodeBlock = null;
-        for (const line of lines) {
-            if (line.startsWith('> ') || line === '>') {
-                if (currentCodeBlock === null) {
-                    currentCodeBlock = { blockNotation: '>', language: null, content: '' };
-                } /* not else */
-                if (currentCodeBlock.blockNotation === '>') {
-                    if (currentCodeBlock.content !== '') {
-                        currentCodeBlock.content += '\n';
-                    }
-                    currentCodeBlock.content += line.slice(2);
-                }
+    function renderPromptbookMermaid(pipelineJson, options) {
+        const { linkTask = () => null } = options || {};
+        const MERMAID_PREFIX = 'pipeline_';
+        const MERMAID_KNOWLEDGE_NAME = MERMAID_PREFIX + 'knowledge';
+        const MERMAID_RESERVED_NAME = MERMAID_PREFIX + 'reserved';
+        const MERMAID_INPUT_NAME = MERMAID_PREFIX + 'input';
+        const MERMAID_OUTPUT_NAME = MERMAID_PREFIX + 'output';
+        const parameterNameToTaskName = (parameterName) => {
+            if (parameterName === 'knowledge') {
+                return MERMAID_KNOWLEDGE_NAME;
             }
-            else if (currentCodeBlock !== null && currentCodeBlock.blockNotation === '>' /* <- Note: [0] */) {
-                codeBlocks.push(currentCodeBlock);
-                currentCodeBlock = null;
+            else if (RESERVED_PARAMETER_NAMES.includes(parameterName)) {
+                return MERMAID_RESERVED_NAME;
             }
-            /* not else */
-            if (line.startsWith('```')) {
-                const language = line.slice(3).trim() || null;
-                if (currentCodeBlock === null) {
-                    currentCodeBlock = { blockNotation: '```', language, content: '' };
-                }
-                else {
-                    if (language !== null) {
-                        throw new ParseError(`${capitalize(currentCodeBlock.language || 'the')} code block was not closed and already opening new ${language} code block`);
-                    }
-                    codeBlocks.push(currentCodeBlock);
-                    currentCodeBlock = null;
-                }
+            const parameter = pipelineJson.parameters.find((parameter) => parameter.name === parameterName);
+            if (!parameter) {
+                throw new UnexpectedError(`Could not find {${parameterName}}`);
+                // <- TODO: This causes problems when {knowledge} and other reserved parameters are used
             }
-            else if (currentCodeBlock !== null && currentCodeBlock.blockNotation === '```') {
-                if (currentCodeBlock.content !== '') {
-                    currentCodeBlock.content += '\n';
-                }
-                currentCodeBlock.content += line.split('\\`\\`\\`').join('```') /* <- TODO: Maybe make proper unescape */;
+            if (parameter.isInput) {
+                return MERMAID_INPUT_NAME;
             }
-        }
-        if (currentCodeBlock !== null) {
-            throw new ParseError(`${capitalize(currentCodeBlock.language || 'the')} code block was not closed at the end of the markdown`);
-        }
-        return codeBlocks;
+            const task = pipelineJson.tasks.find((task) => task.resultingParameterName === parameterName);
+            if (!task) {
+                throw new Error(`Could not find task for {${parameterName}}`);
+            }
+            return MERMAID_PREFIX + (task.name || normalizeTo_camelCase('task-' + titleToName(task.title)));
+        };
+        const inputAndIntermediateParametersMermaid = pipelineJson.tasks
+            .flatMap(({ title, dependentParameterNames, resultingParameterName }) => [
+            `${parameterNameToTaskName(resultingParameterName)}("${title}")`,
+            ...dependentParameterNames.map((dependentParameterName) => `${parameterNameToTaskName(dependentParameterName)}--"{${dependentParameterName}}"-->${parameterNameToTaskName(resultingParameterName)}`),
+        ])
+            .join('\n');
+        const outputParametersMermaid = pipelineJson.parameters
+            .filter(({ isOutput }) => isOutput)
+            .map(({ name }) => `${parameterNameToTaskName(name)}--"{${name}}"-->${MERMAID_OUTPUT_NAME}`)
+            .join('\n');
+        const linksMermaid = pipelineJson.tasks
+            .map((task) => {
+            const link = linkTask(task);
+            if (link === null) {
+                return '';
+            }
+            const { href, title } = link;
+            const taskName = parameterNameToTaskName(task.resultingParameterName);
+            return `click ${taskName} href "${href}" "${title}";`;
+        })
+            .filter((line) => line !== '')
+            .join('\n');
+        const interactionPointsMermaid = Object.entries({
+            [MERMAID_INPUT_NAME]: 'Input',
+            [MERMAID_OUTPUT_NAME]: 'Output',
+            [MERMAID_RESERVED_NAME]: 'Other',
+            [MERMAID_KNOWLEDGE_NAME]: 'Knowledge',
+        })
+            .filter(([MERMAID_NAME]) => (inputAndIntermediateParametersMermaid + outputParametersMermaid).includes(MERMAID_NAME))
+            .map(([MERMAID_NAME, title]) => `${MERMAID_NAME}((${title})):::${MERMAID_NAME}`)
+            .join('\n');
+        const promptbookMermaid = spaceTrim$1.spaceTrim((block) => `
+
+            %% 🔮 Tip: Open this on GitHub or in the VSCode website to see the Mermaid graph visually
+
+            flowchart LR
+              subgraph "${pipelineJson.title}"
+
+                  %% Basic configuration
+                  direction TB
+
+                  %% Interaction points from pipeline to outside
+                  ${block(interactionPointsMermaid)}
+
+                  %% Input and intermediate parameters
+                  ${block(inputAndIntermediateParametersMermaid)}
+
+
+                  %% Output parameters
+                  ${block(outputParametersMermaid)}
+
+                  %% Links
+                  ${block(linksMermaid)}
+
+                  %% Styles
+                  classDef ${MERMAID_INPUT_NAME} color: grey;
+                  classDef ${MERMAID_OUTPUT_NAME} color: grey;
+                  classDef ${MERMAID_RESERVED_NAME} color: grey;
+                  classDef ${MERMAID_KNOWLEDGE_NAME} color: grey;
+
+              end;
+
+        `);
+        return promptbookMermaid;
     }
     /**
-     * TODO: Maybe name for `blockNotation` instead of  '```' and '>'
+     * TODO: [🧠] FOREACH in mermaid graph
+     * TODO: [🧠] Knowledge in mermaid graph
+     * TODO: [🧠] Personas in mermaid graph
+     * TODO: Maybe use some Mermaid package instead of string templating
+     * TODO: [🕌] When more than 2 functionalities, split into separate functions
      */
 
     /**
-     * Extracts  extracts exactly one valid JSON code block
-     *
-     * - When given string is a valid JSON as it is, it just returns it
-     * - When there is no JSON code block the function throws a `ParseError`
-     * - When there are multiple JSON code blocks the function throws a `ParseError`
-     *
-     * Note: It is not important if marked as ```json BUT if it is VALID JSON
-     * Note: There are multiple similar function:
-     * - `extractBlock` just extracts the content of the code block which is also used as build-in function for postprocessing
-     * - `extractJsonBlock` extracts exactly one valid JSON code block
-     * - `extractOneBlockFromMarkdown` extracts exactly one code block with language of the code block
-     * - `extractAllBlocksFromMarkdown` extracts all code blocks with language of the code block
+     * Serializes an error into a [🚉] JSON-serializable object
      *
-     * @public exported from `@promptbook/markdown-utils`
-     * @throws {ParseError} if there is no valid JSON block in the markdown
+     * @public exported from `@promptbook/utils`
      */
-    function extractJsonBlock(markdown) {
-        if (isValidJsonString(markdown)) {
-            return markdown;
+    function serializeError(error) {
+        const { name, message, stack } = error;
+        const { id } = error;
+        if (!Object.keys(ALL_ERRORS).includes(name)) {
+            console.error(spaceTrim__default["default"]((block) => `
+
+                    Cannot serialize error with name "${name}"
+
+                    Authors of Promptbook probably forgot to add this error into the list of errors:
+                    https://github.com/webgptorg/promptbook/blob/main/src/errors/0-index.ts
+
+
+                    ${block(stack || message)}
+
+                `));
+        }
+        return {
+            name: name,
+            message,
+            stack,
+            id, // Include id in the serialized object
+        };
+    }
+
+    /**
+     * Async version of Array.forEach
+     *
+     * @param array - Array to iterate over
+     * @param options - Options for the function
+     * @param callbackfunction - Function to call for each item
+     * @public exported from `@promptbook/utils`
+     * @deprecated [🪂] Use queues instead
+     */
+    async function forEachAsync(array, options, callbackfunction) {
+        const { maxParallelCount = Infinity } = options;
+        let index = 0;
+        let runningTasks = [];
+        const tasks = [];
+        for (const item of array) {
+            const currentIndex = index++;
+            const task = callbackfunction(item, currentIndex, array);
+            tasks.push(task);
+            runningTasks.push(task);
+            /* not await */ Promise.resolve(task).then(() => {
+                runningTasks = runningTasks.filter((t) => t !== task);
+            });
+            if (maxParallelCount < runningTasks.length) {
+                await Promise.race(runningTasks);
+            }
+        }
+        await Promise.all(tasks);
+    }
+
+    /**
+     * Function to check if a string is valid CSV
+     *
+     * @param value The string to check
+     * @returns `true` if the string is a valid CSV string, false otherwise
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function isValidCsvString(value) {
+        try {
+            // A simple check for CSV format: at least one comma and no invalid characters
+            if (value.includes(',') && /^[\w\s,"']+$/.test(value)) {
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            assertsError(error);
+            return false;
+        }
+    }
+
+    /**
+     * Function isValidJsonString will tell you if the string is valid JSON or not
+     *
+     * @param value The string to check
+     * @returns `true` if the string is a valid JSON string, false otherwise
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function isValidJsonString(value /* <- [👨‍⚖️] */) {
+        try {
+            JSON.parse(value);
+            return true;
+        }
+        catch (error) {
+            assertsError(error);
+            if (error.message.includes('Unexpected token')) {
+                return false;
+            }
+            return false;
+        }
+    }
+
+    /**
+     * Function to check if a string is valid XML
+     *
+     * @param value
+     * @returns `true` if the string is a valid XML string, false otherwise
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function isValidXmlString(value) {
+        try {
+            const parser = new DOMParser();
+            const parsedDocument = parser.parseFromString(value, 'application/xml');
+            const parserError = parsedDocument.getElementsByTagName('parsererror');
+            if (parserError.length > 0) {
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            assertsError(error);
+            return false;
+        }
+    }
+
+    /**
+     * Format either small or big number
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function numberToString(value) {
+        if (value === 0) {
+            return '0';
+        }
+        else if (Number.isNaN(value)) {
+            return VALUE_STRINGS.nan;
+        }
+        else if (value === Infinity) {
+            return VALUE_STRINGS.infinity;
+        }
+        else if (value === -Infinity) {
+            return VALUE_STRINGS.negativeInfinity;
+        }
+        for (let exponent = 0; exponent < 15; exponent++) {
+            const factor = 10 ** exponent;
+            const valueRounded = Math.round(value * factor) / factor;
+            if (Math.abs(value - valueRounded) / value < SMALL_NUMBER) {
+                return valueRounded.toFixed(exponent);
+            }
+        }
+        return value.toString();
+    }
+
+    /**
+     * Function `valueToString` will convert the given value to string
+     * This is useful and used in the `templateParameters` function
+     *
+     * Note: This function is not just calling `toString` method
+     *       It's more complex and can handle this conversion specifically for LLM models
+     *       See `VALUE_STRINGS`
+     *
+     * Note: There are 2 similar functions
+     * - `valueToString` converts value to string for LLM models as human-readable string
+     * - `asSerializable` converts value to string to preserve full information to be able to convert it back
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function valueToString(value) {
+        try {
+            if (value === '') {
+                return VALUE_STRINGS.empty;
+            }
+            else if (value === null) {
+                return VALUE_STRINGS.null;
+            }
+            else if (value === undefined) {
+                return VALUE_STRINGS.undefined;
+            }
+            else if (typeof value === 'string') {
+                return value;
+            }
+            else if (typeof value === 'number') {
+                return numberToString(value);
+            }
+            else if (value instanceof Date) {
+                return value.toISOString();
+            }
+            else {
+                try {
+                    return JSON.stringify(value);
+                }
+                catch (error) {
+                    if (error instanceof TypeError && error.message.includes('circular structure')) {
+                        return VALUE_STRINGS.circular;
+                    }
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            assertsError(error);
+            console.error(error);
+            return VALUE_STRINGS.unserializable;
+        }
+    }
+
+    /**
+     * Replaces parameters in template with values from parameters object
+     *
+     * Note: This function is not places strings into string,
+     *       It's more complex and can handle this operation specifically for LLM models
+     *
+     * @param template the template with parameters in {curly} braces
+     * @param parameters the object with parameters
+     * @returns the template with replaced parameters
+     * @throws {PipelineExecutionError} if parameter is not defined, not closed, or not opened
+     * @public exported from `@promptbook/utils`
+     */
+    function templateParameters(template, parameters) {
+        for (const [parameterName, parameterValue] of Object.entries(parameters)) {
+            if (parameterValue === RESERVED_PARAMETER_MISSING_VALUE) {
+                throw new UnexpectedError(`Parameter \`{${parameterName}}\` has missing value`);
+            }
+            else if (parameterValue === RESERVED_PARAMETER_RESTRICTED) {
+                // TODO: [🍵]
+                throw new UnexpectedError(`Parameter \`{${parameterName}}\` is restricted to use`);
+            }
+        }
+        let replacedTemplates = template;
+        let match;
+        let loopLimit = LOOP_LIMIT;
+        while ((match = /^(?<precol>.*){(?<parameterName>\w+)}(.*)/m /* <- Not global */
+            .exec(replacedTemplates))) {
+            if (loopLimit-- < 0) {
+                throw new LimitReachedError('Loop limit reached during parameters replacement in `templateParameters`');
+            }
+            const precol = match.groups.precol;
+            const parameterName = match.groups.parameterName;
+            if (parameterName === '') {
+                // Note: Skip empty placeholders. It's used to avoid confusion with JSON-like strings
+                continue;
+            }
+            if (parameterName.indexOf('{') !== -1 || parameterName.indexOf('}') !== -1) {
+                throw new PipelineExecutionError('Parameter is already opened or not closed');
+            }
+            if (parameters[parameterName] === undefined) {
+                throw new PipelineExecutionError(`Parameter \`{${parameterName}}\` is not defined`);
+            }
+            let parameterValue = parameters[parameterName];
+            if (parameterValue === undefined) {
+                throw new PipelineExecutionError(`Parameter \`{${parameterName}}\` is not defined`);
+            }
+            parameterValue = valueToString(parameterValue);
+            // Escape curly braces in parameter values to prevent prompt-injection
+            parameterValue = parameterValue.replace(/[{}]/g, '\\$&');
+            if (parameterValue.includes('\n') && /^\s*\W{0,3}\s*$/.test(precol)) {
+                parameterValue = parameterValue
+                    .split('\n')
+                    .map((line, index) => (index === 0 ? line : `${precol}${line}`))
+                    .join('\n');
+            }
+            replacedTemplates =
+                replacedTemplates.substring(0, match.index + precol.length) +
+                    parameterValue +
+                    replacedTemplates.substring(match.index + precol.length + parameterName.length + 2);
+        }
+        // [💫] Check if there are parameters that are not closed properly
+        if (/{\w+$/.test(replacedTemplates)) {
+            throw new PipelineExecutionError('Parameter is not closed');
+        }
+        // [💫] Check if there are parameters that are not opened properly
+        if (/^\w+}/.test(replacedTemplates)) {
+            throw new PipelineExecutionError('Parameter is not opened');
+        }
+        return replacedTemplates;
+    }
+
+    /**
+     * Number of characters per standard line with 11pt Arial font size.
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    const CHARACTERS_PER_STANDARD_LINE = 63;
+    /**
+     * Number of lines per standard A4 page with 11pt Arial font size and standard margins and spacing.
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    const LINES_PER_STANDARD_PAGE = 44;
+    /**
+     * TODO: [🧠] Should be this `constants.ts` or `config.ts`?
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * Counts number of characters in the text
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function countCharacters(text) {
+        // Remove null characters
+        text = text.replace(/\0/g, '');
+        // Replace emojis (and also ZWJ sequence) with hyphens
+        text = text.replace(/(\p{Extended_Pictographic})\p{Modifier_Symbol}/gu, '$1');
+        text = text.replace(/(\p{Extended_Pictographic})[\u{FE00}-\u{FE0F}]/gu, '$1');
+        text = text.replace(/\p{Extended_Pictographic}(\u{200D}\p{Extended_Pictographic})*/gu, '-');
+        return text.length;
+    }
+    /**
+     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+     * TODO: [🧠][✌️] Make some Promptbook-native token system
+     */
+
+    /**
+     * Counts number of lines in the text
+     *
+     * Note: This does not check only for the presence of newlines, but also for the length of the standard line.
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function countLines(text) {
+        if (text === '') {
+            return 0;
+        }
+        text = text.replace('\r\n', '\n');
+        text = text.replace('\r', '\n');
+        const lines = text.split('\n');
+        return lines.reduce((count, line) => count + Math.max(Math.ceil(line.length / CHARACTERS_PER_STANDARD_LINE), 1), 0);
+    }
+    /**
+     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+     * TODO: [🧠][✌️] Make some Promptbook-native token system
+     */
+
+    /**
+     * Counts number of pages in the text
+     *
+     * Note: This does not check only for the count of newlines, but also for the length of the standard line and length of the standard page.
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function countPages(text) {
+        return Math.ceil(countLines(text) / LINES_PER_STANDARD_PAGE);
+    }
+    /**
+     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+     * TODO: [🧠][✌️] Make some Promptbook-native token system
+     */
+
+    /**
+     * Counts number of paragraphs in the text
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function countParagraphs(text) {
+        return text.split(/\n\s*\n/).filter((paragraph) => paragraph.trim() !== '').length;
+    }
+    /**
+     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+     * TODO: [🧠][✌️] Make some Promptbook-native token system
+     */
+
+    /**
+     * Split text into sentences
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function splitIntoSentences(text) {
+        return text.split(/[.!?]+/).filter((sentence) => sentence.trim() !== '');
+    }
+    /**
+     * Counts number of sentences in the text
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function countSentences(text) {
+        return splitIntoSentences(text).length;
+    }
+    /**
+     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+     * TODO: [🧠][✌️] Make some Promptbook-native token system
+     */
+
+    /**
+     * Counts number of words in the text
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function countWords(text) {
+        text = text.replace(/[\p{Extended_Pictographic}]/gu, 'a');
+        text = removeDiacritics(text);
+        // Add spaces before uppercase letters preceded by lowercase letters (for camelCase)
+        text = text.replace(/([a-z])([A-Z])/g, '$1 $2');
+        return text.split(/[^a-zа-я0-9]+/i).filter((word) => word.length > 0).length;
+    }
+    /**
+     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+     * TODO: [🧠][✌️] Make some Promptbook-native token system
+     * TODO: [✌️] `countWords` should be just `splitWords(...).length`, and all other counters should use this pattern as well
+     */
+
+    /**
+     * Index of all counter functions
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    const CountUtils = {
+        CHARACTERS: countCharacters,
+        WORDS: countWords,
+        SENTENCES: countSentences,
+        PARAGRAPHS: countParagraphs,
+        LINES: countLines,
+        PAGES: countPages,
+    };
+    /**
+     * TODO: [🧠][🤠] This should be probably as part of `TextFormatParser`
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * Simple wrapper `new Date().toISOString()`
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it is not deterministic because it depends on the current time
+     *
+     * @returns string_date branded type
+     * @public exported from `@promptbook/utils`
+     */
+    function $getCurrentDate() {
+        return new Date().toISOString();
+    }
+
+    /**
+     * Computes SHA-256 hash of the given object
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function computeHash(value) {
+        return cryptoJs.SHA256(hexEncoder__default["default"].parse(spaceTrim__default["default"](valueToString(value)))).toString( /* hex */);
+    }
+    /**
+     * TODO: [🥬][🥬] Use this ACRY
+     */
+
+    /**
+     * Function parseNumber will parse number from string
+     *
+     * Note: [🔂] This function is idempotent.
+     * Unlike Number.parseInt, Number.parseFloat it will never ever result in NaN
+     * Note: it also works only with decimal numbers
+     *
+     * @returns parsed number
+     * @throws {ParseError} if the value is not a number
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function parseNumber(value) {
+        const originalValue = value;
+        if (typeof value === 'number') {
+            value = value.toString(); // <- TODO: Maybe more efficient way to do this
         }
-        const codeBlocks = extractAllBlocksFromMarkdown(markdown);
-        const jsonBlocks = codeBlocks.filter(({ content }) => isValidJsonString(content));
-        if (jsonBlocks.length === 0) {
-            throw new Error('There is no valid JSON block in the markdown');
+        if (typeof value !== 'string') {
+            return 0;
+        }
+        value = value.trim();
+        if (value.startsWith('+')) {
+            return parseNumber(value.substring(1));
+        }
+        if (value.startsWith('-')) {
+            const number = parseNumber(value.substring(1));
+            if (number === 0) {
+                return 0; // <- Note: To prevent -0
+            }
+            return -number;
+        }
+        value = value.replace(/,/g, '.');
+        value = value.toUpperCase();
+        if (value === '') {
+            return 0;
+        }
+        if (value === '♾' || value.startsWith('INF')) {
+            return Infinity;
+        }
+        if (value.includes('/')) {
+            const [numerator_, denominator_] = value.split('/');
+            const numerator = parseNumber(numerator_);
+            const denominator = parseNumber(denominator_);
+            if (denominator === 0) {
+                throw new ParseError(`Unable to parse number from "${originalValue}" because denominator is zero`);
+            }
+            return numerator / denominator;
+        }
+        if (/^(NAN|NULL|NONE|UNDEFINED|ZERO|NO.*)$/.test(value)) {
+            return 0;
+        }
+        if (value.includes('E')) {
+            const [significand, exponent] = value.split('E');
+            return parseNumber(significand) * 10 ** parseNumber(exponent);
+        }
+        if (!/^[0-9.]+$/.test(value) || value.split('.').length > 2) {
+            throw new ParseError(`Unable to parse number from "${originalValue}"`);
+        }
+        const num = parseFloat(value);
+        if (isNaN(num)) {
+            throw new ParseError(`Unexpected NaN when parsing number from "${originalValue}"`);
+        }
+        return num;
+    }
+    /**
+     * TODO: Maybe use sth. like safe-eval in fraction/calculation case @see https://www.npmjs.com/package/safe-eval
+     * TODO: [🧠][🌻] Maybe export through `@promptbook/markdown-utils` not `@promptbook/utils`
+     */
+
+    /**
+     * Makes first letter of a string uppercase
+     *
+     * Note: [🔂] This function is idempotent.
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function capitalize(word) {
+        return word.substring(0, 1).toUpperCase() + word.substring(1);
+    }
+
+    /**
+     * Makes first letter of a string lowercase
+     *
+     * Note: [🔂] This function is idempotent.
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function decapitalize(word) {
+        return word.substring(0, 1).toLowerCase() + word.substring(1);
+    }
+
+    /**
+     * Parses keywords from a string
+     *
+     * @param {string} input
+     * @returns {Set} of keywords without diacritics in lowercase
+     * @public exported from `@promptbook/utils`
+     */
+    function parseKeywordsFromString(input) {
+        const keywords = normalizeTo_SCREAMING_CASE(removeDiacritics(input))
+            .toLowerCase()
+            .split(/[^a-z0-9]+/gs)
+            .filter((value) => value);
+        return new Set(keywords);
+    }
+
+    /**
+     * Converts a name string into a URI-compatible format.
+     *
+     * @param name The string to be converted to a URI-compatible format.
+     * @returns A URI-compatible string derived from the input name.
+     * @example 'Hello World' -> 'hello-world'
+     * @public exported from `@promptbook/utils`
+     */
+    function nameToUriPart(name) {
+        let uriPart = name;
+        uriPart = uriPart.toLowerCase();
+        uriPart = removeDiacritics(uriPart);
+        uriPart = uriPart.replace(/[^a-zA-Z0-9]+/g, '-');
+        uriPart = uriPart.replace(/^-+/, '');
+        uriPart = uriPart.replace(/-+$/, '');
+        return uriPart;
+    }
+
+    /**
+     * Converts a given name into URI-compatible parts.
+     *
+     * @param name The name to be converted into URI parts.
+     * @returns An array of URI-compatible parts derived from the name.
+     * @example 'Example Name' -> ['example', 'name']
+     * @public exported from `@promptbook/utils`
+     */
+    function nameToUriParts(name) {
+        return nameToUriPart(name)
+            .split('-')
+            .filter((value) => value !== '');
+    }
+
+    /**
+     * Normalizes a given text to PascalCase format.
+     *
+     * Note: [🔂] This function is idempotent.
+     *
+     * @param text @public exported from `@promptbook/utils`
+     * @returns
+     * @example 'HelloWorld'
+     * @example 'ILovePromptbook'
+     * @public exported from `@promptbook/utils`
+     */
+    function normalizeTo_PascalCase(text) {
+        return normalizeTo_camelCase(text, true);
+    }
+
+    /**
+     * Take every whitespace (space, new line, tab) and replace it with a single space
+     *
+     * Note: [🔂] This function is idempotent.
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function normalizeWhitespaces(sentence) {
+        return sentence.replace(/\s+/gs, ' ').trim();
+    }
+
+    /**
+     * Removes quotes from a string
+     *
+     * Note: [🔂] This function is idempotent.
+     * Tip: This is very useful for post-processing of the result of the LLM model
+     * Note: This function removes only the same quotes from the beginning and the end of the string
+     * Note: There are two similar functions:
+     * - `removeQuotes` which removes only bounding quotes
+     * - `unwrapResult` which removes whole introduce sentence
+     *
+     * @param text optionally quoted text
+     * @returns text without quotes
+     * @public exported from `@promptbook/utils`
+     */
+    function removeQuotes(text) {
+        if (text.startsWith('"') && text.endsWith('"')) {
+            return text.slice(1, -1);
         }
-        if (jsonBlocks.length > 1) {
-            throw new Error('There are multiple JSON code blocks in the markdown');
+        if (text.startsWith("'") && text.endsWith("'")) {
+            return text.slice(1, -1);
         }
-        return jsonBlocks[0].content;
+        return text;
     }
+
     /**
-     * TODO: Add some auto-healing logic + extract YAML, JSON5, TOML, etc.
-     * TODO: [🏢] Make this logic part of `JsonFormatParser` or `isValidJsonString`
+     * Adds suffix to the URL
+     *
+     * @public exported from `@promptbook/utils`
      */
+    function suffixUrl(value, suffix) {
+        const baseUrl = value.href.endsWith('/') ? value.href.slice(0, -1) : value.href;
+        const normalizedSuffix = suffix.replace(/\/+/g, '/');
+        return (baseUrl + normalizedSuffix);
+    }
 
     /**
-     * Counts number of characters in the text
+     * Removes quotes and optional introduce text from a string
+     *
+     * Tip: This is very useful for post-processing of the result of the LLM model
+     * Note: This function trims the text and removes whole introduce sentence if it is present
+     * Note: There are two similar functions:
+     * - `removeQuotes` which removes only bounding quotes
+     * - `unwrapResult` which removes whole introduce sentence
      *
+     * @param text optionally quoted text
+     * @returns text without quotes
      * @public exported from `@promptbook/utils`
      */
-    function countCharacters(text) {
-        // Remove null characters
-        text = text.replace(/\0/g, '');
-        // Replace emojis (and also ZWJ sequence) with hyphens
-        text = text.replace(/(\p{Extended_Pictographic})\p{Modifier_Symbol}/gu, '$1');
-        text = text.replace(/(\p{Extended_Pictographic})[\u{FE00}-\u{FE0F}]/gu, '$1');
-        text = text.replace(/\p{Extended_Pictographic}(\u{200D}\p{Extended_Pictographic})*/gu, '-');
-        return text.length;
+    function unwrapResult(text, options) {
+        const { isTrimmed = true, isIntroduceSentenceRemoved = true } = options || {};
+        let trimmedText = text;
+        // Remove leading and trailing spaces and newlines
+        if (isTrimmed) {
+            trimmedText = spaceTrim$1.spaceTrim(trimmedText);
+        }
+        let processedText = trimmedText;
+        if (isIntroduceSentenceRemoved) {
+            const introduceSentenceRegex = /^[a-zěščřžýáíéúů:\s]*:\s*/i;
+            if (introduceSentenceRegex.test(text)) {
+                // Remove the introduce sentence and quotes by replacing it with an empty string
+                processedText = processedText.replace(introduceSentenceRegex, '');
+            }
+            processedText = spaceTrim$1.spaceTrim(processedText);
+        }
+        if (processedText.length < 3) {
+            return trimmedText;
+        }
+        if (processedText.includes('\n')) {
+            return trimmedText;
+        }
+        // Remove the quotes by extracting the substring without the first and last characters
+        const unquotedText = processedText.slice(1, -1);
+        // Check if the text starts and ends with quotes
+        if ([
+            ['"', '"'],
+            ["'", "'"],
+            ['`', '`'],
+            ['*', '*'],
+            ['_', '_'],
+            ['„', '“'],
+            ['«', '»'] /* <- QUOTES to config */,
+        ].some(([startQuote, endQuote]) => {
+            if (!processedText.startsWith(startQuote)) {
+                return false;
+            }
+            if (!processedText.endsWith(endQuote)) {
+                return false;
+            }
+            if (unquotedText.includes(startQuote) && !unquotedText.includes(endQuote)) {
+                return false;
+            }
+            if (!unquotedText.includes(startQuote) && unquotedText.includes(endQuote)) {
+                return false;
+            }
+            return true;
+        })) {
+            return unwrapResult(unquotedText, { isTrimmed: false, isIntroduceSentenceRemoved: false });
+        }
+        else {
+            return processedText;
+        }
     }
     /**
-     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
-     * TODO: [🧠][✌️] Make some Promptbook-native token system
+     * TODO: [🧠] Should this also unwrap the (parenthesis)
      */
 
     /**
-     * Number of characters per standard line with 11pt Arial font size.
+     * Parses the task and returns the list of all parameter names
      *
+     * @param template the string template with parameters in {curly} braces
+     * @returns the list of parameter names
      * @public exported from `@promptbook/utils`
      */
-    const CHARACTERS_PER_STANDARD_LINE = 63;
+    function extractParameterNames(template) {
+        const matches = template.matchAll(/{\w+}/g);
+        const parameterNames = new Set();
+        for (const match of matches) {
+            const parameterName = match[0].slice(1, -1);
+            parameterNames.add(parameterName);
+        }
+        return parameterNames;
+    }
+
     /**
-     * Number of lines per standard A4 page with 11pt Arial font size and standard margins and spacing.
-     *
+     * Recursively converts JSON strings to JSON objects
+
      * @public exported from `@promptbook/utils`
      */
-    const LINES_PER_STANDARD_PAGE = 44;
+    function jsonStringsToJsons(object) {
+        if (object === null) {
+            return object;
+        }
+        if (Array.isArray(object)) {
+            return object.map(jsonStringsToJsons);
+        }
+        if (typeof object !== 'object') {
+            return object;
+        }
+        const newObject = { ...object };
+        for (const [key, value] of Object.entries(object)) {
+            if (typeof value === 'string' && isValidJsonString(value)) {
+                newObject[key] = jsonParse(value);
+            }
+            else {
+                newObject[key] = jsonStringsToJsons(value);
+            }
+        }
+        return newObject;
+    }
     /**
-     * TODO: [🧠] Should be this `constants.ts` or `config.ts`?
-     * Note: [💞] Ignore a discrepancy between file name and entity name
+     * TODO: Type the return type correctly
      */
 
     /**
-     * Counts number of lines in the text
-     *
-     * Note: This does not check only for the presence of newlines, but also for the length of the standard line.
+     * Create difference set of two sets.
      *
+     * @deprecated use new javascript set methods instead @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
      * @public exported from `@promptbook/utils`
      */
-    function countLines(text) {
-        if (text === '') {
-            return 0;
+    function difference(a, b, isEqual = (a, b) => a === b) {
+        const diff = new Set();
+        for (const itemA of Array.from(a)) {
+            if (!Array.from(b).some((itemB) => isEqual(itemA, itemB))) {
+                diff.add(itemA);
+            }
         }
-        text = text.replace('\r\n', '\n');
-        text = text.replace('\r', '\n');
-        const lines = text.split('\n');
-        return lines.reduce((count, line) => count + Math.max(Math.ceil(line.length / CHARACTERS_PER_STANDARD_LINE), 1), 0);
+        return diff;
     }
     /**
-     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
-     * TODO: [🧠][✌️] Make some Promptbook-native token system
+     * TODO: [🧠][💯] Maybe also implement symmetricDifference
      */
 
     /**
-     * Counts number of pages in the text
-     *
-     * Note: This does not check only for the count of newlines, but also for the length of the standard line and length of the standard page.
+     * Creates a new set with all elements that are present in either set
      *
+     * @deprecated use new javascript set methods instead @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
      * @public exported from `@promptbook/utils`
      */
-    function countPages(text) {
-        return Math.ceil(countLines(text) / LINES_PER_STANDARD_PAGE);
+    function union(...sets) {
+        const union = new Set();
+        for (const set of sets) {
+            for (const item of Array.from(set)) {
+                union.add(item);
+            }
+        }
+        return union;
     }
+
     /**
-     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
-     * TODO: [🧠][✌️] Make some Promptbook-native token system
+     * Checks if value is valid email
+     *
+     * @public exported from `@promptbook/utils`
      */
+    function isValidEmail(email) {
+        if (typeof email !== 'string') {
+            return false;
+        }
+        if (email.split('\n').length > 1) {
+            return false;
+        }
+        return /^.+@.+\..+$/.test(email);
+    }
 
     /**
-     * Counts number of paragraphs in the text
+     * Checks if the given value is a valid JavaScript identifier name.
      *
+     * @param javascriptName The value to check for JavaScript identifier validity.
+     * @returns `true` if the value is a valid JavaScript name, false otherwise.
      * @public exported from `@promptbook/utils`
      */
-    function countParagraphs(text) {
-        return text.split(/\n\s*\n/).filter((paragraph) => paragraph.trim() !== '').length;
+    function isValidJavascriptName(javascriptName) {
+        if (typeof javascriptName !== 'string') {
+            return false;
+        }
+        return /^[a-zA-Z_$][0-9a-zA-Z_$]*$/i.test(javascriptName);
     }
+
     /**
-     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
-     * TODO: [🧠][✌️] Make some Promptbook-native token system
+     * Tests if given string is valid semantic version
+     *
+     * Note: There are two similar functions:
+     * - `isValidSemanticVersion` which tests any semantic version
+     * - `isValidPromptbookVersion` *(this one)* which tests just Promptbook versions
+     *
+     * @public exported from `@promptbook/utils`
      */
+    function isValidSemanticVersion(version) {
+        if (typeof version !== 'string') {
+            return false;
+        }
+        if (version.startsWith('0.0.0')) {
+            return false;
+        }
+        return /^\d+\.\d+\.\d+(-\d+)?$/i.test(version);
+    }
 
     /**
-     * Split text into sentences
+     * Tests if given string is valid promptbook version
+     * It looks into list of known promptbook versions.
+     *
+     * @see https://www.npmjs.com/package/promptbook?activeTab=versions
+     * Note: When you are using for example promptbook 2.0.0 and there already is promptbook 3.0.0 it don`t know about it.
+     * Note: There are two similar functions:
+     * - `isValidSemanticVersion` which tests any semantic version
+     * - `isValidPromptbookVersion` *(this one)* which tests just Promptbook versions
      *
      * @public exported from `@promptbook/utils`
      */
-    function splitIntoSentences(text) {
-        return text.split(/[.!?]+/).filter((sentence) => sentence.trim() !== '');
+    function isValidPromptbookVersion(version) {
+        if (!isValidSemanticVersion(version)) {
+            return false;
+        }
+        if ( /* version === '1.0.0' || */version === '2.0.0' || version === '3.0.0') {
+            return false;
+        }
+        // <- TODO: [main] !!3 Check isValidPromptbookVersion against PROMPTBOOK_ENGINE_VERSIONS
+        return true;
     }
+
     /**
-     * Counts number of sentences in the text
+     * Tests if given string is valid pipeline URL URL.
+     *
+     * Note: There are two similar functions:
+     * - `isValidUrl` which tests any URL
+     * - `isValidPipelineUrl` *(this one)* which tests just pipeline URL
      *
      * @public exported from `@promptbook/utils`
      */
-    function countSentences(text) {
-        return splitIntoSentences(text).length;
+    function isValidPipelineUrl(url) {
+        if (!isValidUrl(url)) {
+            return false;
+        }
+        if (!url.startsWith('https://') && !url.startsWith('http://') /* <- Note: [👣] */) {
+            return false;
+        }
+        if (url.includes('#')) {
+            // TODO: [🐠]
+            return false;
+        }
+        /*
+        Note: [👣][🧠] Is it secure to allow pipeline URLs on private and unsecured networks?
+        if (isUrlOnPrivateNetwork(url)) {
+            return false;
+        }
+        */
+        return true;
     }
     /**
-     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
-     * TODO: [🧠][✌️] Make some Promptbook-native token system
+     * TODO: [🐠] Maybe more info why the URL is invalid
      */
 
     /**
-     * Counts number of words in the text
+     * Extracts all code blocks from markdown.
      *
-     * @public exported from `@promptbook/utils`
+     * Note: There are multiple similar functions:
+     * - `extractBlock` just extracts the content of the code block which is also used as built-in function for postprocessing
+     * - `extractJsonBlock` extracts exactly one valid JSON code block
+     * - `extractOneBlockFromMarkdown` extracts exactly one code block with language of the code block
+     * - `extractAllBlocksFromMarkdown` extracts all code blocks with language of the code block
+     *
+     * @param markdown any valid markdown
+     * @returns code blocks with language and content
+     * @throws {ParseError} if block is not closed properly
+     * @public exported from `@promptbook/markdown-utils`
      */
-    function countWords(text) {
-        text = text.replace(/[\p{Extended_Pictographic}]/gu, 'a');
-        text = removeDiacritics(text);
-        // Add spaces before uppercase letters preceded by lowercase letters (for camelCase)
-        text = text.replace(/([a-z])([A-Z])/g, '$1 $2');
-        return text.split(/[^a-zа-я0-9]+/i).filter((word) => word.length > 0).length;
+    function extractAllBlocksFromMarkdown(markdown) {
+        const codeBlocks = [];
+        const lines = markdown.split('\n');
+        // Note: [0] Ensure that the last block notated by gt > will be closed
+        lines.push('');
+        let currentCodeBlock = null;
+        for (const line of lines) {
+            if (line.startsWith('> ') || line === '>') {
+                if (currentCodeBlock === null) {
+                    currentCodeBlock = { blockNotation: '>', language: null, content: '' };
+                } /* not else */
+                if (currentCodeBlock.blockNotation === '>') {
+                    if (currentCodeBlock.content !== '') {
+                        currentCodeBlock.content += '\n';
+                    }
+                    currentCodeBlock.content += line.slice(2);
+                }
+            }
+            else if (currentCodeBlock !== null && currentCodeBlock.blockNotation === '>' /* <- Note: [0] */) {
+                codeBlocks.push(currentCodeBlock);
+                currentCodeBlock = null;
+            }
+            /* not else */
+            if (line.startsWith('```')) {
+                const language = line.slice(3).trim() || null;
+                if (currentCodeBlock === null) {
+                    currentCodeBlock = { blockNotation: '```', language, content: '' };
+                }
+                else {
+                    if (language !== null) {
+                        throw new ParseError(`${capitalize(currentCodeBlock.language || 'the')} code block was not closed and already opening new ${language} code block`);
+                    }
+                    codeBlocks.push(currentCodeBlock);
+                    currentCodeBlock = null;
+                }
+            }
+            else if (currentCodeBlock !== null && currentCodeBlock.blockNotation === '```') {
+                if (currentCodeBlock.content !== '') {
+                    currentCodeBlock.content += '\n';
+                }
+                currentCodeBlock.content += line.split('\\`\\`\\`').join('```') /* <- TODO: Maybe make proper unescape */;
+            }
+        }
+        if (currentCodeBlock !== null) {
+            throw new ParseError(`${capitalize(currentCodeBlock.language || 'the')} code block was not closed at the end of the markdown`);
+        }
+        return codeBlocks;
     }
     /**
-     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
-     * TODO: [🧠][✌️] Make some Promptbook-native token system
-     * TODO: [✌️] `countWords` should be just `splitWords(...).length`, and all other counters should use this pattern as well
+     * TODO: Maybe name for `blockNotation` instead of  '```' and '>'
      */
 
     /**
-     * Index of all counter functions
+     * Extracts  extracts exactly one valid JSON code block
      *
-     * @public exported from `@promptbook/utils`
+     * - When given string is a valid JSON as it is, it just returns it
+     * - When there is no JSON code block the function throws a `ParseError`
+     * - When there are multiple JSON code blocks the function throws a `ParseError`
+     *
+     * Note: It is not important if marked as ```json BUT if it is VALID JSON
+     * Note: There are multiple similar function:
+     * - `extractBlock` just extracts the content of the code block which is also used as build-in function for postprocessing
+     * - `extractJsonBlock` extracts exactly one valid JSON code block
+     * - `extractOneBlockFromMarkdown` extracts exactly one code block with language of the code block
+     * - `extractAllBlocksFromMarkdown` extracts all code blocks with language of the code block
+     *
+     * @public exported from `@promptbook/markdown-utils`
+     * @throws {ParseError} if there is no valid JSON block in the markdown
      */
-    const CountUtils = {
-        CHARACTERS: countCharacters,
-        WORDS: countWords,
-        SENTENCES: countSentences,
-        PARAGRAPHS: countParagraphs,
-        LINES: countLines,
-        PAGES: countPages,
-    };
+    function extractJsonBlock(markdown) {
+        if (isValidJsonString(markdown)) {
+            return markdown;
+        }
+        const codeBlocks = extractAllBlocksFromMarkdown(markdown);
+        const jsonBlocks = codeBlocks.filter(({ content }) => isValidJsonString(content));
+        if (jsonBlocks.length === 0) {
+            throw new Error('There is no valid JSON block in the markdown');
+        }
+        if (jsonBlocks.length > 1) {
+            throw new Error('There are multiple JSON code blocks in the markdown');
+        }
+        return jsonBlocks[0].content;
+    }
     /**
-     * TODO: [🧠][🤠] This should be probably as part of `TextFormatParser`
-     * Note: [💞] Ignore a discrepancy between file name and entity name
+     * TODO: Add some auto-healing logic + extract YAML, JSON5, TOML, etc.
+     * TODO: [🏢] Make this logic part of `JsonFormatParser` or `isValidJsonString`
      */
 
     /**
@@ -4150,35 +5043,6 @@
         }
     }
 
-    /**
-     * Simple wrapper `new Date().toISOString()`
-     *
-     * Note: `$` is used to indicate that this function is not a pure function - it is not deterministic because it depends on the current time
-     *
-     * @returns string_date branded type
-     * @public exported from `@promptbook/utils`
-     */
-    function $getCurrentDate() {
-        return new Date().toISOString();
-    }
-
-    /**
-     * Parses the task and returns the list of all parameter names
-     *
-     * @param template the string template with parameters in {curly} braces
-     * @returns the list of parameter names
-     * @public exported from `@promptbook/utils`
-     */
-    function extractParameterNames(template) {
-        const matches = template.matchAll(/{\w+}/g);
-        const parameterNames = new Set();
-        for (const match of matches) {
-            const parameterName = match[0].slice(1, -1);
-            parameterNames.add(parameterName);
-        }
-        return parameterNames;
-    }
-
     /**
      * Intercepts LLM tools and counts total usage of the tools
      *
@@ -4254,6 +5118,9 @@
                 case 'EMBEDDING':
                     promptResult = await llmTools.callEmbeddingModel(prompt);
                     break variant;
+                case 'IMAGE_GENERATION':
+                    promptResult = await llmTools.callImageGenerationModel(prompt);
+                    break variant;
                 // <- case [🤖]:
                 default:
                     throw new PipelineExecutionError(`Unknown model variant "${prompt.modelRequirements.modelVariant}"`);
@@ -4290,12 +5157,13 @@
                     }
                 }
                 catch (error) {
+                    assertsError(error);
                     // If validation throws an unexpected error, don't cache
                     shouldCache = false;
                     if (isVerbose) {
                         console.info('Not caching result due to validation error for key:', key, {
                             content: promptResult.content,
-                            validationError: error instanceof Error ? error.message : String(error),
+                            validationError: serializeError(error),
                         });
                     }
                 }
@@ -4341,6 +5209,11 @@
                 return /* not await */ callCommonModel(prompt);
             };
         }
+        if (llmTools.callImageGenerationModel !== undefined) {
+            proxyTools.callImageGenerationModel = async (prompt) => {
+                return /* not await */ callCommonModel(prompt);
+            };
+        }
         // <- Note: [🤖]
         return proxyTools;
     }
@@ -4529,6 +5402,15 @@
                 return promptResult;
             };
         }
+        if (llmTools.callImageGenerationModel !== undefined) {
+            proxyTools.callImageGenerationModel = async (prompt) => {
+                // console.info('[🚕] callImageGenerationModel through countTotalUsage');
+                const promptResult = await llmTools.callImageGenerationModel(prompt);
+                totalUsage = addUsage(totalUsage, promptResult.usage);
+                spending.next(promptResult.usage);
+                return promptResult;
+            };
+        }
         // <- Note: [🤖]
         return proxyTools;
     }
@@ -4537,7 +5419,7 @@
      * TODO: [🧠] Is there some meaningfull way how to test this util
      * TODO: [🧠][🌯] Maybe a way how to hide ability to `get totalUsage`
      *     > const [llmToolsWithUsage,getUsage] = countTotalUsage(llmTools);
-     * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
+     * TODO: [👷‍♂️] Write a comprehensive manual explaining the construction and usage of LLM tools in the Promptbook ecosystem
      */
 
     /**
@@ -4651,6 +5533,12 @@
         callEmbeddingModel(prompt) {
             return this.callCommonModel(prompt);
         }
+        /**
+         * Calls the best available embedding model
+         */
+        callImageGenerationModel(prompt) {
+            return this.callCommonModel(prompt);
+        }
         // <- Note: [🤖]
         /**
          * Calls the best available model
@@ -4677,6 +5565,11 @@
                                 continue llm;
                             }
                             return await llmExecutionTools.callEmbeddingModel(prompt);
+                        case 'IMAGE_GENERATION':
+                            if (llmExecutionTools.callImageGenerationModel === undefined) {
+                                continue llm;
+                            }
+                            return await llmExecutionTools.callImageGenerationModel(prompt);
                         // <- case [🤖]:
                         default:
                             throw new UnexpectedError(`Unknown model variant "${prompt.modelRequirements.modelVariant}" in ${llmExecutionTools.title}`);
@@ -5001,21 +5894,6 @@
      * TODO: [🧠] Maybe rename because it is not used only for scrapers but also in `$getCompiledBook`
      */
 
-    /**
-     * Checks if value is valid email
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function isValidEmail(email) {
-        if (typeof email !== 'string') {
-            return false;
-        }
-        if (email.split('\n').length > 1) {
-            return false;
-        }
-        return /^.+@.+\..+$/.test(email);
-    }
-
     /**
      * @private utility of CLI
      */
@@ -5694,113 +6572,39 @@
         }));
     }
     /**
-     * Note: [💞] Ignore a discrepancy between file name and entity name
-     * Note: [🟡] Code in this file should never be published outside of `@promptbook/cli`
-     */
-
-    /**
-     * Initializes `login` command for Promptbook CLI utilities
-     *
-     * Note: `$` is used to indicate that this function is not a pure function - it registers a command in the CLI
-     *
-     * @private internal function of `promptbookCli`
-     */
-    function $initializeLoginCommand(program) {
-        const loginCommand = program.command('login');
-        loginCommand.description(spaceTrim__default["default"](`
-            Login to the remote Promptbook server
-        `));
-        loginCommand.action(handleActionErrors(async (cliOptions) => {
-            // Note: Not interested in return value of this function but the side effect of logging in
-            await $provideLlmToolsForCli({
-                isLoginloaded: true,
-                cliOptions: {
-                    ...cliOptions,
-                    strategy: 'REMOTE_SERVER', // <- Note: Overriding strategy to `REMOTE_SERVER`
-                    //                               TODO: Do not allow flag `--strategy` in `login` command at all
-                },
-            });
-            return process.exit(0);
-        }));
-    }
-    /**
-     * TODO: Implement non-interactive login
-     * Note: [💞] Ignore a discrepancy between file name and entity name
-     * Note: [🟡] Code in this file should never be published outside of `@promptbook/cli`
-     */
-
-    /**
-     * Tests if given string is valid semantic version
-     *
-     * Note: There are two similar functions:
-     * - `isValidSemanticVersion` which tests any semantic version
-     * - `isValidPromptbookVersion` *(this one)* which tests just Promptbook versions
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function isValidSemanticVersion(version) {
-        if (typeof version !== 'string') {
-            return false;
-        }
-        if (version.startsWith('0.0.0')) {
-            return false;
-        }
-        return /^\d+\.\d+\.\d+(-\d+)?$/i.test(version);
-    }
-
-    /**
-     * Tests if given string is valid promptbook version
-     * It looks into list of known promptbook versions.
-     *
-     * @see https://www.npmjs.com/package/promptbook?activeTab=versions
-     * Note: When you are using for example promptbook 2.0.0 and there already is promptbook 3.0.0 it don`t know about it.
-     * Note: There are two similar functions:
-     * - `isValidSemanticVersion` which tests any semantic version
-     * - `isValidPromptbookVersion` *(this one)* which tests just Promptbook versions
-     *
-     * @public exported from `@promptbook/utils`
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     * Note: [🟡] Code in this file should never be published outside of `@promptbook/cli`
      */
-    function isValidPromptbookVersion(version) {
-        if (!isValidSemanticVersion(version)) {
-            return false;
-        }
-        if ( /* version === '1.0.0' || */version === '2.0.0' || version === '3.0.0') {
-            return false;
-        }
-        // <- TODO: [main] !!3 Check isValidPromptbookVersion against PROMPTBOOK_ENGINE_VERSIONS
-        return true;
-    }
 
     /**
-     * Tests if given string is valid pipeline URL URL.
+     * Initializes `login` command for Promptbook CLI utilities
      *
-     * Note: There are two similar functions:
-     * - `isValidUrl` which tests any URL
-     * - `isValidPipelineUrl` *(this one)* which tests just pipeline URL
+     * Note: `$` is used to indicate that this function is not a pure function - it registers a command in the CLI
      *
-     * @public exported from `@promptbook/utils`
+     * @private internal function of `promptbookCli`
      */
-    function isValidPipelineUrl(url) {
-        if (!isValidUrl(url)) {
-            return false;
-        }
-        if (!url.startsWith('https://') && !url.startsWith('http://') /* <- Note: [👣] */) {
-            return false;
-        }
-        if (url.includes('#')) {
-            // TODO: [🐠]
-            return false;
-        }
-        /*
-        Note: [👣][🧠] Is it secure to allow pipeline URLs on private and unsecured networks?
-        if (isUrlOnPrivateNetwork(url)) {
-            return false;
-        }
-        */
-        return true;
+    function $initializeLoginCommand(program) {
+        const loginCommand = program.command('login');
+        loginCommand.description(spaceTrim__default["default"](`
+            Login to the remote Promptbook server
+        `));
+        loginCommand.action(handleActionErrors(async (cliOptions) => {
+            // Note: Not interested in return value of this function but the side effect of logging in
+            await $provideLlmToolsForCli({
+                isLoginloaded: true,
+                cliOptions: {
+                    ...cliOptions,
+                    strategy: 'REMOTE_SERVER', // <- Note: Overriding strategy to `REMOTE_SERVER`
+                    //                               TODO: Do not allow flag `--strategy` in `login` command at all
+                },
+            });
+            return process.exit(0);
+        }));
     }
     /**
-     * TODO: [🐠] Maybe more info why the URL is invalid
+     * TODO: Implement non-interactive login
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     * Note: [🟡] Code in this file should never be published outside of `@promptbook/cli`
      */
 
     /**
@@ -6503,65 +7307,6 @@
      *     - [♨] Are tasks prepared
      */
 
-    /**
-     * Serializes an error into a [🚉] JSON-serializable object
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function serializeError(error) {
-        const { name, message, stack } = error;
-        const { id } = error;
-        if (!Object.keys(ALL_ERRORS).includes(name)) {
-            console.error(spaceTrim__default["default"]((block) => `
-
-                    Cannot serialize error with name "${name}"
-
-                    Authors of Promptbook probably forgot to add this error into the list of errors:
-                    https://github.com/webgptorg/promptbook/blob/main/src/errors/0-index.ts
-
-
-                    ${block(stack || message)}
-
-                `));
-        }
-        return {
-            name: name,
-            message,
-            stack,
-            id, // Include id in the serialized object
-        };
-    }
-
-    /**
-     * Recursively converts JSON strings to JSON objects
-
-     * @public exported from `@promptbook/utils`
-     */
-    function jsonStringsToJsons(object) {
-        if (object === null) {
-            return object;
-        }
-        if (Array.isArray(object)) {
-            return object.map(jsonStringsToJsons);
-        }
-        if (typeof object !== 'object') {
-            return object;
-        }
-        const newObject = { ...object };
-        for (const [key, value] of Object.entries(object)) {
-            if (typeof value === 'string' && isValidJsonString(value)) {
-                newObject[key] = jsonParse(value);
-            }
-            else {
-                newObject[key] = jsonStringsToJsons(value);
-            }
-        }
-        return newObject;
-    }
-    /**
-     * TODO: Type the return type correctly
-     */
-
     /**
      * Asserts that the execution of a Promptbook is successful
      *
@@ -6739,144 +7484,63 @@
                             message = `Working on ${current.title}`;
                         }
                     }
-                    if (!message) {
-                        if (errors.length) {
-                            message = errors[errors.length - 1].message || 'Error';
-                        }
-                        else if (warnings.length) {
-                            message = warnings[warnings.length - 1].message || 'Warning';
-                        }
-                        else if (status === 'FINISHED') {
-                            message = 'Finished';
-                        }
-                        else if (status === 'ERROR') {
-                            message = 'Error';
-                        }
-                        else {
-                            message = 'Running';
-                        }
-                    }
-                }
-                return {
-                    percent: percent,
-                    message: message + ' (!!!fallback)',
-                };
-            },
-            get createdAt() {
-                return createdAt;
-                // <- Note: [1] --||--
-            },
-            get updatedAt() {
-                return updatedAt;
-                // <- Note: [1] --||--
-            },
-            asPromise,
-            asObservable() {
-                return partialResultSubject.asObservable();
-            },
-            get errors() {
-                return errors;
-                // <- Note: [1] --||--
-            },
-            get warnings() {
-                return warnings;
-                // <- Note: [1] --||--
-            },
-            get llmCalls() {
-                return [...llmCalls, { foo: '!!! bar' }];
-                // <- Note: [1] --||--
-            },
-            get currentValue() {
-                return currentValue;
-                // <- Note: [1] --||--
-            },
-        };
-    }
-    /**
-     * TODO: Maybe allow to terminate the task and add getter `isFinished` or `status`
-     * TODO: [🐚] Split into more files and make `PrepareTask` & `RemoteTask` + split the function
-     */
-
-    /**
-     * Format either small or big number
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function numberToString(value) {
-        if (value === 0) {
-            return '0';
-        }
-        else if (Number.isNaN(value)) {
-            return VALUE_STRINGS.nan;
-        }
-        else if (value === Infinity) {
-            return VALUE_STRINGS.infinity;
-        }
-        else if (value === -Infinity) {
-            return VALUE_STRINGS.negativeInfinity;
-        }
-        for (let exponent = 0; exponent < 15; exponent++) {
-            const factor = 10 ** exponent;
-            const valueRounded = Math.round(value * factor) / factor;
-            if (Math.abs(value - valueRounded) / value < SMALL_NUMBER) {
-                return valueRounded.toFixed(exponent);
-            }
-        }
-        return value.toString();
-    }
-
-    /**
-     * Function `valueToString` will convert the given value to string
-     * This is useful and used in the `templateParameters` function
-     *
-     * Note: This function is not just calling `toString` method
-     *       It's more complex and can handle this conversion specifically for LLM models
-     *       See `VALUE_STRINGS`
-     *
-     * Note: There are 2 similar functions
-     * - `valueToString` converts value to string for LLM models as human-readable string
-     * - `asSerializable` converts value to string to preserve full information to be able to convert it back
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function valueToString(value) {
-        try {
-            if (value === '') {
-                return VALUE_STRINGS.empty;
-            }
-            else if (value === null) {
-                return VALUE_STRINGS.null;
-            }
-            else if (value === undefined) {
-                return VALUE_STRINGS.undefined;
-            }
-            else if (typeof value === 'string') {
-                return value;
-            }
-            else if (typeof value === 'number') {
-                return numberToString(value);
-            }
-            else if (value instanceof Date) {
-                return value.toISOString();
-            }
-            else {
-                try {
-                    return JSON.stringify(value);
-                }
-                catch (error) {
-                    if (error instanceof TypeError && error.message.includes('circular structure')) {
-                        return VALUE_STRINGS.circular;
+                    if (!message) {
+                        if (errors.length) {
+                            message = errors[errors.length - 1].message || 'Error';
+                        }
+                        else if (warnings.length) {
+                            message = warnings[warnings.length - 1].message || 'Warning';
+                        }
+                        else if (status === 'FINISHED') {
+                            message = 'Finished';
+                        }
+                        else if (status === 'ERROR') {
+                            message = 'Error';
+                        }
+                        else {
+                            message = 'Running';
+                        }
                     }
-                    throw error;
                 }
-            }
-        }
-        catch (error) {
-            assertsError(error);
-            console.error(error);
-            return VALUE_STRINGS.unserializable;
-        }
+                return {
+                    percent: percent,
+                    message: message + ' (!!!fallback)',
+                };
+            },
+            get createdAt() {
+                return createdAt;
+                // <- Note: [1] --||--
+            },
+            get updatedAt() {
+                return updatedAt;
+                // <- Note: [1] --||--
+            },
+            asPromise,
+            asObservable() {
+                return partialResultSubject.asObservable();
+            },
+            get errors() {
+                return errors;
+                // <- Note: [1] --||--
+            },
+            get warnings() {
+                return warnings;
+                // <- Note: [1] --||--
+            },
+            get llmCalls() {
+                return [...llmCalls, { foo: '!!! bar' }];
+                // <- Note: [1] --||--
+            },
+            get currentValue() {
+                return currentValue;
+                // <- Note: [1] --||--
+            },
+        };
     }
+    /**
+     * TODO: Maybe allow to terminate the task and add getter `isFinished` or `status`
+     * TODO: [🐚] Split into more files and make `PrepareTask` & `RemoteTask` + split the function
+     */
 
     /**
      * Parses the given script and returns the list of all used variables that are not defined in the script
@@ -7003,41 +7667,6 @@
      * TODO: [🔣] If script require contentLanguage
      */
 
-    /**
-     * Create difference set of two sets.
-     *
-     * @deprecated use new javascript set methods instead @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
-     * @public exported from `@promptbook/utils`
-     */
-    function difference(a, b, isEqual = (a, b) => a === b) {
-        const diff = new Set();
-        for (const itemA of Array.from(a)) {
-            if (!Array.from(b).some((itemB) => isEqual(itemA, itemB))) {
-                diff.add(itemA);
-            }
-        }
-        return diff;
-    }
-    /**
-     * TODO: [🧠][💯] Maybe also implement symmetricDifference
-     */
-
-    /**
-     * Creates a new set with all elements that are present in either set
-     *
-     * @deprecated use new javascript set methods instead @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
-     * @public exported from `@promptbook/utils`
-     */
-    function union(...sets) {
-        const union = new Set();
-        for (const set of sets) {
-            for (const item of Array.from(set)) {
-                union.add(item);
-            }
-        }
-        return union;
-    }
-
     /**
      * Contains configuration options for parsing and generating CSV files, such as delimiters and quoting rules.
      *
@@ -7066,28 +7695,6 @@
         return csv;
     }
 
-    /**
-     * Function to check if a string is valid CSV
-     *
-     * @param value The string to check
-     * @returns `true` if the string is a valid CSV string, false otherwise
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function isValidCsvString(value) {
-        try {
-            // A simple check for CSV format: at least one comma and no invalid characters
-            if (value.includes(',') && /^[\w\s,"']+$/.test(value)) {
-                return true;
-            }
-            return false;
-        }
-        catch (error) {
-            assertsError(error);
-            return false;
-        }
-    }
-
     /**
      * Definition for CSV spreadsheet
      *
@@ -7267,30 +7874,6 @@
      * TODO: [🏢] Allow to expect something inside each item of list and other formats
      */
 
-    /**
-     * Function to check if a string is valid XML
-     *
-     * @param value
-     * @returns `true` if the string is a valid XML string, false otherwise
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function isValidXmlString(value) {
-        try {
-            const parser = new DOMParser();
-            const parsedDocument = parser.parseFromString(value, 'application/xml');
-            const parserError = parsedDocument.getElementsByTagName('parsererror');
-            if (parserError.length > 0) {
-                return false;
-            }
-            return true;
-        }
-        catch (error) {
-            assertsError(error);
-            return false;
-        }
-    }
-
     /**
      * Definition for XML format
      *
@@ -7380,130 +7963,59 @@
                     ${block(Array.from(expectedParameterNames)
             .map((parameterName) => `- {${parameterName}}`)
             .join('\n'))}
-
-                    Remaining available parameters:
-                    ${block(Array.from(availableParametersNames)
-            .map((parameterName) => `- {${parameterName}}`)
-            .join('\n'))}
-
-                `));
-        }
-        const expectedParameterNamesArray = Array.from(expectedParameterNames);
-        const availableParametersNamesArray = Array.from(availableParametersNames);
-        for (let i = 0; i < expectedParameterNames.size; i++) {
-            mappedParameters[expectedParameterNamesArray[i]] = availableParameters[availableParametersNamesArray[i]];
-        }
-        // Note: [👨‍👨‍👧] Now we can freeze `mappedParameters` to prevent accidental modifications after mapping
-        Object.freeze(mappedParameters);
-        return mappedParameters;
-    }
-
-    /**
-     * Takes an item or an array of items and returns an array of items
-     *
-     * 1) Any item except array and undefined returns array with that one item (also null)
-     * 2) Undefined returns empty array
-     * 3) Array returns itself
-     *
-     * @private internal utility
-     */
-    function arrayableToArray(input) {
-        if (input === undefined) {
-            return [];
-        }
-        if (input instanceof Array) {
-            return input;
-        }
-        return [input];
-    }
-
-    /**
-     * Just returns the given `LlmExecutionTools` or joins multiple into one
-     *
-     * @public exported from `@promptbook/core`
-     */
-    function getSingleLlmExecutionTools(oneOrMoreLlmExecutionTools) {
-        const _llms = arrayableToArray(oneOrMoreLlmExecutionTools);
-        const llmTools = _llms.length === 1
-            ? _llms[0]
-            : joinLlmExecutionTools('Multiple LLM Providers joined by `getSingleLlmExecutionTools`', ..._llms);
-        return llmTools;
-    }
-    /**
-     * TODO: [🙆] `getSingleLlmExecutionTools` vs `joinLlmExecutionTools` - explain difference or pick one
-     * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
-     */
-
-    /**
-     * Replaces parameters in template with values from parameters object
-     *
-     * Note: This function is not places strings into string,
-     *       It's more complex and can handle this operation specifically for LLM models
-     *
-     * @param template the template with parameters in {curly} braces
-     * @param parameters the object with parameters
-     * @returns the template with replaced parameters
-     * @throws {PipelineExecutionError} if parameter is not defined, not closed, or not opened
-     * @public exported from `@promptbook/utils`
-     */
-    function templateParameters(template, parameters) {
-        for (const [parameterName, parameterValue] of Object.entries(parameters)) {
-            if (parameterValue === RESERVED_PARAMETER_MISSING_VALUE) {
-                throw new UnexpectedError(`Parameter \`{${parameterName}}\` has missing value`);
-            }
-            else if (parameterValue === RESERVED_PARAMETER_RESTRICTED) {
-                // TODO: [🍵]
-                throw new UnexpectedError(`Parameter \`{${parameterName}}\` is restricted to use`);
-            }
-        }
-        let replacedTemplates = template;
-        let match;
-        let loopLimit = LOOP_LIMIT;
-        while ((match = /^(?<precol>.*){(?<parameterName>\w+)}(.*)/m /* <- Not global */
-            .exec(replacedTemplates))) {
-            if (loopLimit-- < 0) {
-                throw new LimitReachedError('Loop limit reached during parameters replacement in `templateParameters`');
-            }
-            const precol = match.groups.precol;
-            const parameterName = match.groups.parameterName;
-            if (parameterName === '') {
-                // Note: Skip empty placeholders. It's used to avoid confusion with JSON-like strings
-                continue;
-            }
-            if (parameterName.indexOf('{') !== -1 || parameterName.indexOf('}') !== -1) {
-                throw new PipelineExecutionError('Parameter is already opened or not closed');
-            }
-            if (parameters[parameterName] === undefined) {
-                throw new PipelineExecutionError(`Parameter \`{${parameterName}}\` is not defined`);
-            }
-            let parameterValue = parameters[parameterName];
-            if (parameterValue === undefined) {
-                throw new PipelineExecutionError(`Parameter \`{${parameterName}}\` is not defined`);
-            }
-            parameterValue = valueToString(parameterValue);
-            // Escape curly braces in parameter values to prevent prompt-injection
-            parameterValue = parameterValue.replace(/[{}]/g, '\\$&');
-            if (parameterValue.includes('\n') && /^\s*\W{0,3}\s*$/.test(precol)) {
-                parameterValue = parameterValue
-                    .split('\n')
-                    .map((line, index) => (index === 0 ? line : `${precol}${line}`))
-                    .join('\n');
-            }
-            replacedTemplates =
-                replacedTemplates.substring(0, match.index + precol.length) +
-                    parameterValue +
-                    replacedTemplates.substring(match.index + precol.length + parameterName.length + 2);
+
+                    Remaining available parameters:
+                    ${block(Array.from(availableParametersNames)
+            .map((parameterName) => `- {${parameterName}}`)
+            .join('\n'))}
+
+                `));
         }
-        // [💫] Check if there are parameters that are not closed properly
-        if (/{\w+$/.test(replacedTemplates)) {
-            throw new PipelineExecutionError('Parameter is not closed');
+        const expectedParameterNamesArray = Array.from(expectedParameterNames);
+        const availableParametersNamesArray = Array.from(availableParametersNames);
+        for (let i = 0; i < expectedParameterNames.size; i++) {
+            mappedParameters[expectedParameterNamesArray[i]] = availableParameters[availableParametersNamesArray[i]];
         }
-        // [💫] Check if there are parameters that are not opened properly
-        if (/^\w+}/.test(replacedTemplates)) {
-            throw new PipelineExecutionError('Parameter is not opened');
+        // Note: [👨‍👨‍👧] Now we can freeze `mappedParameters` to prevent accidental modifications after mapping
+        Object.freeze(mappedParameters);
+        return mappedParameters;
+    }
+
+    /**
+     * Takes an item or an array of items and returns an array of items
+     *
+     * 1) Any item except array and undefined returns array with that one item (also null)
+     * 2) Undefined returns empty array
+     * 3) Array returns itself
+     *
+     * @private internal utility
+     */
+    function arrayableToArray(input) {
+        if (input === undefined) {
+            return [];
         }
-        return replacedTemplates;
+        if (input instanceof Array) {
+            return input;
+        }
+        return [input];
+    }
+
+    /**
+     * Just returns the given `LlmExecutionTools` or joins multiple into one
+     *
+     * @public exported from `@promptbook/core`
+     */
+    function getSingleLlmExecutionTools(oneOrMoreLlmExecutionTools) {
+        const _llms = arrayableToArray(oneOrMoreLlmExecutionTools);
+        const llmTools = _llms.length === 1
+            ? _llms[0]
+            : joinLlmExecutionTools('Multiple LLM Providers joined by `getSingleLlmExecutionTools`', ..._llms);
+        return llmTools;
     }
+    /**
+     * TODO: [🙆] `getSingleLlmExecutionTools` vs `joinLlmExecutionTools` - explain difference or pick one
+     * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
+     */
 
     /**
      * Executes a pipeline task with multiple attempts, including joker and retry logic. Handles different task types
@@ -7599,8 +8111,9 @@
                                         $ongoingTaskResult.$resultString = $ongoingTaskResult.$completionResult.content;
                                         break variant;
                                     case 'EMBEDDING':
+                                    case 'IMAGE_GENERATION':
                                         throw new PipelineExecutionError(spaceTrim$1.spaceTrim((block) => `
-                                                Embedding model can not be used in pipeline
+                                                ${modelRequirements.modelVariant} model can not be used in pipeline
 
                                                 This should be catched during parsing
 
@@ -8734,35 +9247,6 @@
         return pipelineExecutor;
     }
 
-    /**
-     * Async version of Array.forEach
-     *
-     * @param array - Array to iterate over
-     * @param options - Options for the function
-     * @param callbackfunction - Function to call for each item
-     * @public exported from `@promptbook/utils`
-     * @deprecated [🪂] Use queues instead
-     */
-    async function forEachAsync(array, options, callbackfunction) {
-        const { maxParallelCount = Infinity } = options;
-        let index = 0;
-        let runningTasks = [];
-        const tasks = [];
-        for (const item of array) {
-            const currentIndex = index++;
-            const task = callbackfunction(item, currentIndex, array);
-            tasks.push(task);
-            runningTasks.push(task);
-            /* not await */ Promise.resolve(task).then(() => {
-                runningTasks = runningTasks.filter((t) => t !== task);
-            });
-            if (maxParallelCount < runningTasks.length) {
-                await Promise.race(runningTasks);
-            }
-        }
-        await Promise.all(tasks);
-    }
-
     /**
      * Prepares the persona for the pipeline
      *
@@ -9898,75 +10382,6 @@
      * TODO: [💝] Unite object for expecting amount and format - remove format
      */
 
-    /**
-     * Function parseNumber will parse number from string
-     *
-     * Note: [🔂] This function is idempotent.
-     * Unlike Number.parseInt, Number.parseFloat it will never ever result in NaN
-     * Note: it also works only with decimal numbers
-     *
-     * @returns parsed number
-     * @throws {ParseError} if the value is not a number
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function parseNumber(value) {
-        const originalValue = value;
-        if (typeof value === 'number') {
-            value = value.toString(); // <- TODO: Maybe more efficient way to do this
-        }
-        if (typeof value !== 'string') {
-            return 0;
-        }
-        value = value.trim();
-        if (value.startsWith('+')) {
-            return parseNumber(value.substring(1));
-        }
-        if (value.startsWith('-')) {
-            const number = parseNumber(value.substring(1));
-            if (number === 0) {
-                return 0; // <- Note: To prevent -0
-            }
-            return -number;
-        }
-        value = value.replace(/,/g, '.');
-        value = value.toUpperCase();
-        if (value === '') {
-            return 0;
-        }
-        if (value === '♾' || value.startsWith('INF')) {
-            return Infinity;
-        }
-        if (value.includes('/')) {
-            const [numerator_, denominator_] = value.split('/');
-            const numerator = parseNumber(numerator_);
-            const denominator = parseNumber(denominator_);
-            if (denominator === 0) {
-                throw new ParseError(`Unable to parse number from "${originalValue}" because denominator is zero`);
-            }
-            return numerator / denominator;
-        }
-        if (/^(NAN|NULL|NONE|UNDEFINED|ZERO|NO.*)$/.test(value)) {
-            return 0;
-        }
-        if (value.includes('E')) {
-            const [significand, exponent] = value.split('E');
-            return parseNumber(significand) * 10 ** parseNumber(exponent);
-        }
-        if (!/^[0-9.]+$/.test(value) || value.split('.').length > 2) {
-            throw new ParseError(`Unable to parse number from "${originalValue}"`);
-        }
-        const num = parseFloat(value);
-        if (isNaN(num)) {
-            throw new ParseError(`Unexpected NaN when parsing number from "${originalValue}"`);
-        }
-        return num;
-    }
-    /**
-     * TODO: Maybe use sth. like safe-eval in fraction/calculation case @see https://www.npmjs.com/package/safe-eval
-     * TODO: [🧠][🌻] Maybe export through `@promptbook/markdown-utils` not `@promptbook/utils`
-     */
-
     /**
     import { WrappedError } from '../../errors/WrappedError';
     import { assertsError } from '../../errors/assertsError';
@@ -10109,84 +10524,6 @@
         },
     };
 
-    /**
-     * Normalizes a given text to camelCase format.
-     *
-     * Note: [🔂] This function is idempotent.
-     *
-     * @param text The text to be normalized.
-     * @param _isFirstLetterCapital Whether the first letter should be capitalized.
-     * @returns The camelCase formatted string.
-     * @example 'helloWorld'
-     * @example 'iLovePromptbook'
-     * @public exported from `@promptbook/utils`
-     */
-    function normalizeTo_camelCase(text, _isFirstLetterCapital = false) {
-        let charType;
-        let lastCharType = null;
-        let normalizedName = '';
-        for (const char of text) {
-            let normalizedChar;
-            if (/^[a-z]$/.test(char)) {
-                charType = 'LOWERCASE';
-                normalizedChar = char;
-            }
-            else if (/^[A-Z]$/.test(char)) {
-                charType = 'UPPERCASE';
-                normalizedChar = char.toLowerCase();
-            }
-            else if (/^[0-9]$/.test(char)) {
-                charType = 'NUMBER';
-                normalizedChar = char;
-            }
-            else {
-                charType = 'OTHER';
-                normalizedChar = '';
-            }
-            if (!lastCharType) {
-                if (_isFirstLetterCapital) {
-                    normalizedChar = normalizedChar.toUpperCase(); //TODO: DRY
-                }
-            }
-            else if (charType !== lastCharType &&
-                !(charType === 'LOWERCASE' && lastCharType === 'UPPERCASE') &&
-                !(lastCharType === 'NUMBER') &&
-                !(charType === 'NUMBER')) {
-                normalizedChar = normalizedChar.toUpperCase(); //TODO: [🌺] DRY
-            }
-            normalizedName += normalizedChar;
-            lastCharType = charType;
-        }
-        return normalizedName;
-    }
-    /**
-     * TODO: [🌺] Use some intermediate util splitWords
-     */
-
-    /**
-     * Removes quotes from a string
-     *
-     * Note: [🔂] This function is idempotent.
-     * Tip: This is very useful for post-processing of the result of the LLM model
-     * Note: This function removes only the same quotes from the beginning and the end of the string
-     * Note: There are two similar functions:
-     * - `removeQuotes` which removes only bounding quotes
-     * - `unwrapResult` which removes whole introduce sentence
-     *
-     * @param text optionally quoted text
-     * @returns text without quotes
-     * @public exported from `@promptbook/utils`
-     */
-    function removeQuotes(text) {
-        if (text.startsWith('"') && text.endsWith('"')) {
-            return text.slice(1, -1);
-        }
-        if (text.startsWith("'") && text.endsWith("'")) {
-            return text.slice(1, -1);
-        }
-        return text;
-    }
-
     /**
      * Function `validateParameterName` will normalize and validate a parameter name for use in pipelines.
      * It removes diacritics, emojis, and quotes, normalizes to camelCase, and checks for reserved names and invalid characters.
@@ -11076,11 +11413,7 @@
             // TODO: [🚜] DRY
             if ($taskJson.modelRequirements[command.key] !== undefined) {
                 if ($taskJson.modelRequirements[command.key] === command.value) {
-                    console.warn(`Multiple commands \`MODEL ${{
-                    modelName: 'NAME',
-                    modelVariant: 'VARIANT',
-                    maxTokens: '???',
-                }[command.key]} ${command.value}\` in the task "${$taskJson.title || $taskJson.name}"`);
+                    console.warn(`Multiple commands \`MODEL ${command.key} ${command.value}\` in the task "${$taskJson.title || $taskJson.name}"`);
                     // <- TODO: [🏮] Some standard way how to transform errors into warnings and how to handle non-critical fails during the tasks
                 }
                 else {
@@ -11361,30 +11694,16 @@
         }
         console.warn(spaceTrim__default["default"](`
 
-            Persona "${personaName}" is defined multiple times with different description:
-
-            First definition:
-            ${persona.description}
-
-            Second definition:
-            ${personaDescription}
-
-        `));
-        persona.description += spaceTrim__default["default"]('\n\n' + personaDescription);
-    }
-
-    /**
-     * Checks if the given value is a valid JavaScript identifier name.
-     *
-     * @param javascriptName The value to check for JavaScript identifier validity.
-     * @returns `true` if the value is a valid JavaScript name, false otherwise.
-     * @public exported from `@promptbook/utils`
-     */
-    function isValidJavascriptName(javascriptName) {
-        if (typeof javascriptName !== 'string') {
-            return false;
-        }
-        return /^[a-zA-Z_$][0-9a-zA-Z_$]*$/i.test(javascriptName);
+            Persona "${personaName}" is defined multiple times with different description:
+
+            First definition:
+            ${persona.description}
+
+            Second definition:
+            ${personaDescription}
+
+        `));
+        persona.description += spaceTrim__default["default"]('\n\n' + personaDescription);
     }
 
     /**
@@ -12900,345 +13219,59 @@
         if ($pipelineJson.formfactorName === undefined) {
             $pipelineJson.formfactorName = 'GENERIC';
         }
-        // =============================================================
-        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: [🧠] 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
-     *
-     * @see https://github.com/webgptorg/promptbook/discussions/196
-     *
-     * 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)
-     * @param tools - Tools for the preparation and scraping - if not provided together with `llm`, the preparation will be skipped
-     * @param options - Options and tools for the compilation
-     * @returns {Promptbook} compiled in JSON format (.bookc)
-     * @throws {ParseError} if the promptbook string is not valid
-     * @public exported from `@promptbook/core`
-     */
-    async function compilePipeline(pipelineString, tools, options) {
-        let pipelineJson = parsePipeline(pipelineString);
-        if (tools !== undefined && tools.llm !== undefined) {
-            pipelineJson = await preparePipeline(pipelineJson, tools, options || {
-                rootDirname: null,
-            });
-        }
-        // Note: No need to use `$exportJson` because `parsePipeline` and `preparePipeline` already do that
-        return pipelineJson;
-    }
-    /**
-     * TODO: [🏏] Leverage the batch API and build queues @see https://platform.openai.com/docs/guides/batch
-     * TODO: [🛠] Actions, instruments (and maybe knowledge) => Functions and tools
-     * TODO: [🧠] Should be in generated JSON file GENERATOR_WARNING
-     */
-
-    /**
-     * Creates a Mermaid graph based on the promptbook
-     *
-     * Note: The result is not wrapped in a Markdown code block
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function renderPromptbookMermaid(pipelineJson, options) {
-        const { linkTask = () => null } = options || {};
-        const MERMAID_PREFIX = 'pipeline_';
-        const MERMAID_KNOWLEDGE_NAME = MERMAID_PREFIX + 'knowledge';
-        const MERMAID_RESERVED_NAME = MERMAID_PREFIX + 'reserved';
-        const MERMAID_INPUT_NAME = MERMAID_PREFIX + 'input';
-        const MERMAID_OUTPUT_NAME = MERMAID_PREFIX + 'output';
-        const parameterNameToTaskName = (parameterName) => {
-            if (parameterName === 'knowledge') {
-                return MERMAID_KNOWLEDGE_NAME;
-            }
-            else if (RESERVED_PARAMETER_NAMES.includes(parameterName)) {
-                return MERMAID_RESERVED_NAME;
-            }
-            const parameter = pipelineJson.parameters.find((parameter) => parameter.name === parameterName);
-            if (!parameter) {
-                throw new UnexpectedError(`Could not find {${parameterName}}`);
-                // <- TODO: This causes problems when {knowledge} and other reserved parameters are used
-            }
-            if (parameter.isInput) {
-                return MERMAID_INPUT_NAME;
-            }
-            const task = pipelineJson.tasks.find((task) => task.resultingParameterName === parameterName);
-            if (!task) {
-                throw new Error(`Could not find task for {${parameterName}}`);
-            }
-            return MERMAID_PREFIX + (task.name || normalizeTo_camelCase('task-' + titleToName(task.title)));
-        };
-        const inputAndIntermediateParametersMermaid = pipelineJson.tasks
-            .flatMap(({ title, dependentParameterNames, resultingParameterName }) => [
-            `${parameterNameToTaskName(resultingParameterName)}("${title}")`,
-            ...dependentParameterNames.map((dependentParameterName) => `${parameterNameToTaskName(dependentParameterName)}--"{${dependentParameterName}}"-->${parameterNameToTaskName(resultingParameterName)}`),
-        ])
-            .join('\n');
-        const outputParametersMermaid = pipelineJson.parameters
-            .filter(({ isOutput }) => isOutput)
-            .map(({ name }) => `${parameterNameToTaskName(name)}--"{${name}}"-->${MERMAID_OUTPUT_NAME}`)
-            .join('\n');
-        const linksMermaid = pipelineJson.tasks
-            .map((task) => {
-            const link = linkTask(task);
-            if (link === null) {
-                return '';
-            }
-            const { href, title } = link;
-            const taskName = parameterNameToTaskName(task.resultingParameterName);
-            return `click ${taskName} href "${href}" "${title}";`;
-        })
-            .filter((line) => line !== '')
-            .join('\n');
-        const interactionPointsMermaid = Object.entries({
-            [MERMAID_INPUT_NAME]: 'Input',
-            [MERMAID_OUTPUT_NAME]: 'Output',
-            [MERMAID_RESERVED_NAME]: 'Other',
-            [MERMAID_KNOWLEDGE_NAME]: 'Knowledge',
-        })
-            .filter(([MERMAID_NAME]) => (inputAndIntermediateParametersMermaid + outputParametersMermaid).includes(MERMAID_NAME))
-            .map(([MERMAID_NAME, title]) => `${MERMAID_NAME}((${title})):::${MERMAID_NAME}`)
-            .join('\n');
-        const promptbookMermaid = spaceTrim$1.spaceTrim((block) => `
-
-            %% 🔮 Tip: Open this on GitHub or in the VSCode website to see the Mermaid graph visually
-
-            flowchart LR
-              subgraph "${pipelineJson.title}"
-
-                  %% Basic configuration
-                  direction TB
-
-                  %% Interaction points from pipeline to outside
-                  ${block(interactionPointsMermaid)}
-
-                  %% Input and intermediate parameters
-                  ${block(inputAndIntermediateParametersMermaid)}
-
-
-                  %% Output parameters
-                  ${block(outputParametersMermaid)}
-
-                  %% Links
-                  ${block(linksMermaid)}
-
-                  %% Styles
-                  classDef ${MERMAID_INPUT_NAME} color: grey;
-                  classDef ${MERMAID_OUTPUT_NAME} color: grey;
-                  classDef ${MERMAID_RESERVED_NAME} color: grey;
-                  classDef ${MERMAID_KNOWLEDGE_NAME} color: grey;
-
-              end;
-
-        `);
-        return promptbookMermaid;
-    }
-    /**
-     * TODO: [🧠] FOREACH in mermaid graph
-     * TODO: [🧠] Knowledge in mermaid graph
-     * TODO: [🧠] Personas in mermaid graph
-     * TODO: Maybe use some Mermaid package instead of string templating
-     * TODO: [🕌] When more than 2 functionalities, split into separate functions
-     */
-
-    /**
-     * Computes SHA-256 hash of the given object
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function computeHash(value) {
-        return cryptoJs.SHA256(hexEncoder__default["default"].parse(spaceTrim__default["default"](valueToString(value)))).toString( /* hex */);
-    }
-    /**
-     * TODO: [🥬][🥬] Use this ACRY
-     */
-
-    /**
-     * Makes first letter of a string lowercase
-     *
-     * Note: [🔂] This function is idempotent.
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function decapitalize(word) {
-        return word.substring(0, 1).toLowerCase() + word.substring(1);
-    }
-
-    /**
-     * Parses keywords from a string
-     *
-     * @param {string} input
-     * @returns {Set} of keywords without diacritics in lowercase
-     * @public exported from `@promptbook/utils`
-     */
-    function parseKeywordsFromString(input) {
-        const keywords = normalizeTo_SCREAMING_CASE(removeDiacritics(input))
-            .toLowerCase()
-            .split(/[^a-z0-9]+/gs)
-            .filter((value) => value);
-        return new Set(keywords);
-    }
-
-    /**
-     * Converts a name string into a URI-compatible format.
-     *
-     * @param name The string to be converted to a URI-compatible format.
-     * @returns A URI-compatible string derived from the input name.
-     * @example 'Hello World' -> 'hello-world'
-     * @public exported from `@promptbook/utils`
-     */
-    function nameToUriPart(name) {
-        let uriPart = name;
-        uriPart = uriPart.toLowerCase();
-        uriPart = removeDiacritics(uriPart);
-        uriPart = uriPart.replace(/[^a-zA-Z0-9]+/g, '-');
-        uriPart = uriPart.replace(/^-+/, '');
-        uriPart = uriPart.replace(/-+$/, '');
-        return uriPart;
-    }
-
-    /**
-     * Converts a given name into URI-compatible parts.
-     *
-     * @param name The name to be converted into URI parts.
-     * @returns An array of URI-compatible parts derived from the name.
-     * @example 'Example Name' -> ['example', 'name']
-     * @public exported from `@promptbook/utils`
-     */
-    function nameToUriParts(name) {
-        return nameToUriPart(name)
-            .split('-')
-            .filter((value) => value !== '');
-    }
-
-    /**
-     * Normalizes a given text to PascalCase format.
-     *
-     * Note: [🔂] This function is idempotent.
-     *
-     * @param text @public exported from `@promptbook/utils`
-     * @returns
-     * @example 'HelloWorld'
-     * @example 'ILovePromptbook'
-     * @public exported from `@promptbook/utils`
-     */
-    function normalizeTo_PascalCase(text) {
-        return normalizeTo_camelCase(text, true);
+        // =============================================================
+        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,
+            },
+        });
     }
-
     /**
-     * Take every whitespace (space, new line, tab) and replace it with a single space
-     *
-     * Note: [🔂] This function is idempotent.
-     *
-     * @public exported from `@promptbook/utils`
+     * 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
      */
-    function normalizeWhitespaces(sentence) {
-        return sentence.replace(/\s+/gs, ' ').trim();
-    }
 
     /**
-     * Adds suffix to the URL
+     * Compile pipeline from string (markdown) format to JSON format
      *
-     * @public exported from `@promptbook/utils`
-     */
-    function suffixUrl(value, suffix) {
-        const baseUrl = value.href.endsWith('/') ? value.href.slice(0, -1) : value.href;
-        const normalizedSuffix = suffix.replace(/\/+/g, '/');
-        return (baseUrl + normalizedSuffix);
-    }
-
-    /**
-     * Removes quotes and optional introduce text from a string
+     * @see https://github.com/webgptorg/promptbook/discussions/196
      *
-     * Tip: This is very useful for post-processing of the result of the LLM model
-     * Note: This function trims the text and removes whole introduce sentence if it is present
-     * Note: There are two similar functions:
-     * - `removeQuotes` which removes only bounding quotes
-     * - `unwrapResult` which removes whole introduce sentence
+     * Note: This function does not validate logic of the pipeline only the parsing
+     * Note: This function acts as compilation process
      *
-     * @param text optionally quoted text
-     * @returns text without quotes
-     * @public exported from `@promptbook/utils`
+     * @param pipelineString {Promptbook} in string markdown format (.book.md)
+     * @param tools - Tools for the preparation and scraping - if not provided together with `llm`, the preparation will be skipped
+     * @param options - Options and tools for the compilation
+     * @returns {Promptbook} compiled in JSON format (.bookc)
+     * @throws {ParseError} if the promptbook string is not valid
+     * @public exported from `@promptbook/core`
      */
-    function unwrapResult(text, options) {
-        const { isTrimmed = true, isIntroduceSentenceRemoved = true } = options || {};
-        let trimmedText = text;
-        // Remove leading and trailing spaces and newlines
-        if (isTrimmed) {
-            trimmedText = spaceTrim$1.spaceTrim(trimmedText);
-        }
-        let processedText = trimmedText;
-        if (isIntroduceSentenceRemoved) {
-            const introduceSentenceRegex = /^[a-zěščřžýáíéúů:\s]*:\s*/i;
-            if (introduceSentenceRegex.test(text)) {
-                // Remove the introduce sentence and quotes by replacing it with an empty string
-                processedText = processedText.replace(introduceSentenceRegex, '');
-            }
-            processedText = spaceTrim$1.spaceTrim(processedText);
-        }
-        if (processedText.length < 3) {
-            return trimmedText;
-        }
-        if (processedText.includes('\n')) {
-            return trimmedText;
-        }
-        // Remove the quotes by extracting the substring without the first and last characters
-        const unquotedText = processedText.slice(1, -1);
-        // Check if the text starts and ends with quotes
-        if ([
-            ['"', '"'],
-            ["'", "'"],
-            ['`', '`'],
-            ['*', '*'],
-            ['_', '_'],
-            ['„', '“'],
-            ['«', '»'] /* <- QUOTES to config */,
-        ].some(([startQuote, endQuote]) => {
-            if (!processedText.startsWith(startQuote)) {
-                return false;
-            }
-            if (!processedText.endsWith(endQuote)) {
-                return false;
-            }
-            if (unquotedText.includes(startQuote) && !unquotedText.includes(endQuote)) {
-                return false;
-            }
-            if (!unquotedText.includes(startQuote) && unquotedText.includes(endQuote)) {
-                return false;
-            }
-            return true;
-        })) {
-            return unwrapResult(unquotedText, { isTrimmed: false, isIntroduceSentenceRemoved: false });
-        }
-        else {
-            return processedText;
+    async function compilePipeline(pipelineString, tools, options) {
+        let pipelineJson = parsePipeline(pipelineString);
+        if (tools !== undefined && tools.llm !== undefined) {
+            pipelineJson = await preparePipeline(pipelineJson, tools, options || {
+                rootDirname: null,
+            });
         }
+        // Note: No need to use `$exportJson` because `parsePipeline` and `preparePipeline` already do that
+        return pipelineJson;
     }
     /**
-     * TODO: [🧠] Should this also unwrap the (parenthesis)
+     * TODO: [🏏] Leverage the batch API and build queues @see https://platform.openai.com/docs/guides/batch
+     * TODO: [🛠] Actions, instruments (and maybe knowledge) => Functions and tools
+     * TODO: [🧠] Should be in generated JSON file GENERATOR_WARNING
      */
 
     /**
@@ -19453,7 +19486,7 @@
             let threadMessages = [];
             if ('thread' in prompt && Array.isArray(prompt.thread)) {
                 threadMessages = prompt.thread.map((msg) => ({
-                    role: msg.role === 'assistant' ? 'assistant' : 'user',
+                    role: msg.sender === 'assistant' ? 'assistant' : 'user',
                     content: msg.content,
                 }));
             }
@@ -19866,13 +19899,14 @@
             const modelName = currentModelRequirements.modelName || this.getDefaultImageGenerationModel().modelName;
             const modelSettings = {
                 model: modelName,
-                // size: currentModelRequirements.size,
-                // quality: currentModelRequirements.quality,
-                // style: currentModelRequirements.style,
+                size: currentModelRequirements.size,
+                quality: currentModelRequirements.quality,
+                style: currentModelRequirements.style,
             };
             const rawPromptContent = templateParameters(content, { ...parameters, modelName });
             const rawRequest = {
                 ...modelSettings,
+                size: modelSettings.size || '1024x1024',
                 prompt: rawPromptContent,
                 user: (_a = this.options.userId) === null || _a === void 0 ? void 0 : _a.toString(),
                 response_format: 'url', // TODO: [🧠] Maybe allow b64_json
@@ -20409,10 +20443,10 @@
             // <- TODO: [🛄]
         }
         /**
-         * Default model for image generation variant.
+         * Default model for completion variant.
          */
         getDefaultImageGenerationModel() {
-            return this.getDefaultModel('!!!'); // <- TODO: [🧠] Pick the best default model
+            return this.getDefaultModel('dall-e-3');
             // <- TODO: [🛄]
         }
     }
@@ -21227,11 +21261,10 @@
             throw new PipelineExecutionError(`${this.title} does not support EMBEDDING model variant`);
         }
         /**
-         * Default model for image generation variant.
+         * Default model for completion variant.
          */
         getDefaultImageGenerationModel() {
-            return this.getDefaultModel('!!!'); // <- TODO: [🧠] Pick the best default model
-            // <- TODO: [🛄]
+            throw new PipelineExecutionError(`${this.title} does not support IMAGE_GENERATION model variant`);
         }
     }
     /**
@@ -23107,6 +23140,114 @@
      * Note: [💞] Ignore a discrepancy between file name and entity name
      */
 
+    /**
+     * DICTIONARY commitment definition
+     *
+     * The DICTIONARY commitment defines specific terms and their meanings that the agent should use correctly
+     * in its reasoning and responses. This ensures consistent terminology usage.
+     *
+     * Key features:
+     * - Multiple DICTIONARY commitments are automatically merged into one
+     * - Content is placed in a dedicated section of the system message
+     * - Terms and definitions are stored in metadata.DICTIONARY for debugging
+     * - Agent should use the defined terms correctly in responses
+     *
+     * Example usage in agent source:
+     *
+     * ```book
+     * Legal Assistant
+     *
+     * PERSONA You are a knowledgeable legal assistant
+     * DICTIONARY Misdemeanor is a minor wrongdoing or criminal offense
+     * DICTIONARY Felony is a serious crime usually punishable by imprisonment for more than one year
+     * DICTIONARY Tort is a civil wrong that causes harm or loss to another person, leading to legal liability
+     * ```
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class DictionaryCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('DICTIONARY');
+        }
+        /**
+         * Short one-line description of DICTIONARY.
+         */
+        get description() {
+            return 'Define terms and their meanings for consistent terminology usage.';
+        }
+        /**
+         * Icon for this commitment.
+         */
+        get icon() {
+            return '📚';
+        }
+        /**
+         * Markdown documentation for DICTIONARY commitment.
+         */
+        get documentation() {
+            return spaceTrim$1.spaceTrim(`
+            # DICTIONARY
+
+            Defines specific terms and their meanings that the agent should use correctly in reasoning and responses.
+
+            ## Key aspects
+
+            - Multiple \`DICTIONARY\` commitments are merged together.
+            - Terms are defined in the format: "Term is definition"
+            - The agent should use these terms consistently in responses.
+            - Definitions help ensure accurate and consistent terminology.
+
+            ## Examples
+
+            \`\`\`book
+            Legal Assistant
+
+            PERSONA You are a knowledgeable legal assistant specializing in criminal law
+            DICTIONARY Misdemeanor is a minor wrongdoing or criminal offense
+            DICTIONARY Felony is a serious crime usually punishable by imprisonment for more than one year
+            DICTIONARY Tort is a civil wrong that causes harm or loss to another person, leading to legal liability
+            \`\`\`
+
+            \`\`\`book
+            Medical Assistant
+
+            PERSONA You are a helpful medical assistant
+            DICTIONARY Hypertension is persistently high blood pressure
+            DICTIONARY Diabetes is a chronic condition that affects how the body processes blood sugar
+            DICTIONARY Vaccine is a biological preparation that provides active immunity to a particular disease
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            var _a;
+            const trimmedContent = content.trim();
+            if (!trimmedContent) {
+                return requirements;
+            }
+            // Get existing dictionary entries from metadata
+            const existingDictionary = ((_a = requirements.metadata) === null || _a === void 0 ? void 0 : _a.DICTIONARY) || '';
+            // Merge the new dictionary entry with existing entries
+            const mergedDictionary = existingDictionary
+                ? `${existingDictionary}\n${trimmedContent}`
+                : trimmedContent;
+            // Store the merged dictionary in metadata for debugging and inspection
+            const updatedMetadata = {
+                ...requirements.metadata,
+                DICTIONARY: mergedDictionary,
+            };
+            // Create the dictionary section for the system message
+            // Format: "# DICTIONARY\nTerm: definition\nTerm: definition..."
+            const dictionarySection = `# DICTIONARY\n${mergedDictionary}`;
+            return {
+                ...this.appendToSystemMessage(requirements, dictionarySection),
+                metadata: updatedMetadata,
+            };
+        }
+    }
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
     /**
      * FORMAT commitment definition
      *
@@ -25927,6 +26068,7 @@
         new DeleteCommitmentDefinition('CANCEL'),
         new DeleteCommitmentDefinition('DISCARD'),
         new DeleteCommitmentDefinition('REMOVE'),
+        new DictionaryCommitmentDefinition(),
         new OpenCommitmentDefinition(),
         new ClosedCommitmentDefinition(),
         new UseBrowserCommitmentDefinition(),
@@ -26011,17 +26153,64 @@
             };
         }
         const lines = agentSource.split('\n');
-        const agentName = (((_a = lines[0]) === null || _a === void 0 ? void 0 : _a.trim()) || null);
+        let agentName = null;
+        let agentNameLineIndex = -1;
+        // Find the agent name: first non-empty line that is not a commitment and not a horizontal line
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line === undefined) {
+                continue;
+            }
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            const isHorizontal = HORIZONTAL_LINE_PATTERN.test(line);
+            if (isHorizontal) {
+                continue;
+            }
+            let isCommitment = false;
+            for (const definition of COMMITMENT_REGISTRY) {
+                const typeRegex = definition.createTypeRegex();
+                const match = typeRegex.exec(trimmed);
+                if (match && ((_a = match.groups) === null || _a === void 0 ? void 0 : _a.type)) {
+                    isCommitment = true;
+                    break;
+                }
+            }
+            if (!isCommitment) {
+                agentName = trimmed;
+                agentNameLineIndex = i;
+                break;
+            }
+        }
         const commitments = [];
         const nonCommitmentLines = [];
-        // Always add the first line (agent name) to non-commitment lines
-        if (lines[0] !== undefined) {
-            nonCommitmentLines.push(lines[0]);
+        // Add lines before agentName that are horizontal lines (they are non-commitment)
+        for (let i = 0; i < agentNameLineIndex; i++) {
+            const line = lines[i];
+            if (line === undefined) {
+                continue;
+            }
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            const isHorizontal = HORIZONTAL_LINE_PATTERN.test(line);
+            if (isHorizontal) {
+                nonCommitmentLines.push(line);
+            }
+            // Note: Commitments before agentName are not added to nonCommitmentLines
+        }
+        // Add the agent name line to non-commitment lines
+        if (agentNameLineIndex >= 0) {
+            nonCommitmentLines.push(lines[agentNameLineIndex]);
         }
         // Parse commitments with multiline support
         let currentCommitment = null;
-        // Process lines starting from the second line (skip agent name)
-        for (let i = 1; i < lines.length; i++) {
+        // Process lines starting from after the agent name line
+        const startIndex = agentNameLineIndex >= 0 ? agentNameLineIndex + 1 : 0;
+        for (let i = startIndex; i < lines.length; i++) {
             const line = lines[i];
             if (line === undefined) {
                 continue;
@@ -26241,7 +26430,12 @@
             };
         }
         // Apply each commitment in order using reduce-like pattern
-        for (const commitment of filteredCommitments) {
+        for (let i = 0; i < filteredCommitments.length; i++) {
+            const commitment = filteredCommitments[i];
+            // CLOSED commitment should work only if its the last commitment in the book
+            if (commitment.type === 'CLOSED' && i !== filteredCommitments.length - 1) {
+                continue;
+            }
             const definition = getCommitmentDefinition(commitment.type);
             if (definition) {
                 try {
@@ -26282,44 +26476,6 @@
         };
     }
 
-    /**
-     * Generates a gravatar URL based on agent name for fallback avatar
-     *
-     * @param agentName The agent name to generate avatar for
-     * @returns Gravatar URL
-     *
-     * @private - [🤹] The fact that profile image is Gravatar is just implementation detail which should be hidden for consumer
-     */
-    function generateGravatarUrl(agentName) {
-        // Use a default name if none provided
-        const safeName = agentName || 'Anonymous Agent';
-        // Create a simple hash from the name for consistent avatar
-        let hash = 0;
-        for (let i = 0; i < safeName.length; i++) {
-            const char = safeName.charCodeAt(i);
-            hash = (hash << 5) - hash + char;
-            hash = hash & hash; // Convert to 32bit integer
-        }
-        const avatarId = Math.abs(hash).toString();
-        return `https://www.gravatar.com/avatar/${avatarId}?default=robohash&size=200&rating=x`;
-    }
-
-    /**
-     * Generates an image for the agent to use as profile image
-     *
-     * @param agentName The agent name to generate avatar for
-     * @returns The placeholder profile image URL for the agent
-     *
-     * @public exported from `@promptbook/core`
-     */
-    function generatePlaceholderAgentProfileImageUrl(agentName) {
-        // Note: [🤹] The fact that profile image is Gravatar is just implementation detail which should be hidden for consumer
-        return generateGravatarUrl(agentName);
-    }
-    /**
-     * TODO: [🤹] Figure out best placeholder image generator https://i.pravatar.cc/1000?u=568
-     */
-
     /**
      * Computes SHA-256 hash of the agent source
      *
@@ -26387,7 +26543,57 @@
         }
         const meta = {};
         const links = [];
+        const capabilities = [];
         for (const commitment of parseResult.commitments) {
+            if (commitment.type === 'USE BROWSER') {
+                capabilities.push({
+                    type: 'browser',
+                    label: 'Browser',
+                    iconName: 'Globe',
+                });
+                continue;
+            }
+            if (commitment.type === 'USE SEARCH ENGINE') {
+                capabilities.push({
+                    type: 'search-engine',
+                    label: 'Search Internet',
+                    iconName: 'Search',
+                });
+                continue;
+            }
+            if (commitment.type === 'KNOWLEDGE') {
+                const content = spaceTrim__default["default"](commitment.content).split('\n')[0] || '';
+                let label = content;
+                let iconName = 'Book';
+                if (content.startsWith('http://') || content.startsWith('https://')) {
+                    try {
+                        const url = new URL(content);
+                        if (url.pathname.endsWith('.pdf')) {
+                            label = url.pathname.split('/').pop() || 'Document.pdf';
+                            iconName = 'FileText';
+                        }
+                        else {
+                            label = url.hostname.replace(/^www\./, '');
+                        }
+                    }
+                    catch (e) {
+                        // Invalid URL, treat as text
+                    }
+                }
+                else {
+                    // Text content - take first few words
+                    const words = content.split(/\s+/);
+                    if (words.length > 4) {
+                        label = words.slice(0, 4).join(' ') + '...';
+                    }
+                }
+                capabilities.push({
+                    type: 'knowledge',
+                    label,
+                    iconName,
+                });
+                continue;
+            }
             if (commitment.type === 'META LINK') {
                 const linkValue = spaceTrim__default["default"](commitment.content);
                 links.push(linkValue);
@@ -26417,10 +26623,6 @@
             const metaType = normalizeTo_camelCase(metaTypeRaw);
             meta[metaType] = spaceTrim__default["default"](commitment.content.substring(metaTypeRaw.length));
         }
-        // Generate gravatar fallback if no meta image specified
-        if (!meta.image) {
-            meta.image = generatePlaceholderAgentProfileImageUrl(parseResult.agentName || '!!');
-        }
         // Generate fullname fallback if no meta fullname specified
         if (!meta.fullname) {
             meta.fullname = parseResult.agentName || createDefaultAgentName(agentSource);
@@ -26432,11 +26634,13 @@
         return {
             agentName: normalizeAgentName(parseResult.agentName || createDefaultAgentName(agentSource)),
             agentHash,
+            permanentId: meta.id,
             personaDescription,
             initialMessage,
             meta,
             links,
             parameters,
+            capabilities,
         };
     }
     /**