@promptbook/cli 0.113.0-1 → 0.113.0-10

package/src/commitments/USE_TIMEOUT/parseTimeoutToolArgs.ts

@@ -1,11 +1,6 @@
 import { spaceTrim } from 'spacetrim';
 import { PipelineExecutionError } from '../../errors/PipelineExecutionError';
-import type {
-    CancelTimeoutToolArgs,
-    ListTimeoutsToolArgs,
-    SetTimeoutToolArgs,
-    UpdateTimeoutToolArgs,
-} from './TimeoutToolRuntimeAdapter';
+import type { CancelTimeoutToolArgs, ListTimeoutsToolArgs, SetTimeoutToolArgs, UpdateTimeoutToolArgs } from './TimeoutToolRuntimeAdapter';
 
 /**
  * Default number of rows returned by `list_timeouts`.

package/src/commitments/WALLET/createWalletToolFunctions.ts

@@ -1,19 +1,10 @@
 import type { ToolFunction } from '../../scripting/javascript/JavascriptExecutionToolsOptions';
 import type { string_javascript_name } from '../../types/string_person_fullname';
-import {
-    getWalletToolRuntimeAdapterOrDisabledResult,
-    resolveWalletDisabledMessage,
-} from './getWalletToolRuntimeAdapterOrDisabledResult';
+import { getWalletToolRuntimeAdapterOrDisabledResult, resolveWalletDisabledMessage } from './getWalletToolRuntimeAdapterOrDisabledResult';
 import { parseWalletToolArgs } from './parseWalletToolArgs';
 import { resolveWalletRuntimeContext } from './resolveWalletRuntimeContext';
 import { WalletToolNames } from './WalletToolNames';
-import type {
-    DeleteWalletRecordToolArgs,
-    RequestWalletRecordToolArgs,
-    RetrieveWalletRecordsToolArgs,
-    StoreWalletRecordToolArgs,
-    UpdateWalletRecordToolArgs,
-} from './WalletToolRuntimeAdapter';
+import type { DeleteWalletRecordToolArgs, RequestWalletRecordToolArgs, RetrieveWalletRecordsToolArgs, StoreWalletRecordToolArgs, UpdateWalletRecordToolArgs } from './WalletToolRuntimeAdapter';
 
 /**
  * Creates runtime wallet tool function implementations.

package/src/commitments/WALLET/getWalletToolRuntimeAdapterOrDisabledResult.ts

@@ -1,10 +1,5 @@
 import { getWalletToolRuntimeAdapter } from './setWalletToolRuntimeAdapter';
-import type {
-    WalletDisabledToolResult,
-    WalletRuntimeToolAction,
-    WalletToolRuntimeAdapter,
-    WalletToolRuntimeContext,
-} from './WalletToolRuntimeAdapter';
+import type { WalletDisabledToolResult, WalletRuntimeToolAction, WalletToolRuntimeAdapter, WalletToolRuntimeContext } from './WalletToolRuntimeAdapter';
 
 /**
  * Resolves disabled message for wallet runtime context.

package/src/commitments/WALLET/parseWalletToolArgs.ts

@@ -1,13 +1,4 @@
-import type {
-    DeleteWalletRecordToolArgs,
-    RequestWalletRecordToolArgs,
-    RetrieveWalletRecordsToolArgs,
-    StoreWalletRecordToolArgs,
-    UpdateWalletRecordToolArgs,
-    WalletRecordType,
-    WalletRequestRecord,
-    WalletToolRecord,
-} from './WalletToolRuntimeAdapter';
+import type { DeleteWalletRecordToolArgs, RequestWalletRecordToolArgs, RetrieveWalletRecordsToolArgs, StoreWalletRecordToolArgs, UpdateWalletRecordToolArgs, WalletRecordType, WalletRequestRecord, WalletToolRecord } from './WalletToolRuntimeAdapter';
 
 /**
  * Parsed payload for retrieving wallet records.

package/src/commitments/index.ts

@@ -96,6 +96,7 @@ export const COMMITMENT_REGISTRY = [
     new ActionCommitmentDefinition('ACTIONS'),
     new ComponentCommitmentDefinition(),
     new MetaAvatarCommitmentDefinition(),
+    new MetaAvatarCommitmentDefinition('META VISUAL'),
     new MetaImageCommitmentDefinition(),
     new MetaColorCommitmentDefinition(),
     new MetaFontCommitmentDefinition(),

package/src/conversion/parsePipeline/applyPipelineHead.ts

@@ -4,10 +4,10 @@ import { parseCommand } from '../../commands/_common/parseCommand';
 import type { $PipelineJson, CommandBase, PipelineHeadCommandParser } from '../../commands/_common/types/CommandParser';
 import { ParseError } from '../../errors/ParseError';
 import { extractAllListItemsFromMarkdown } from '../../utils/markdown/extractAllListItemsFromMarkdown';
+import type { MarkdownSection } from '../../utils/markdown/parseMarkdownSection';
 import { defineParameter } from './defineParameter';
 import { extractPipelineDescription } from './extractPipelineDescription';
 import { getPipelineIdentification } from './getPipelineIdentification';
-import type { MarkdownSection } from '../../utils/markdown/parseMarkdownSection';
 
 /**
  * Applies the pipeline head title, description, and head-level commands.

package/src/conversion/parsePipeline/createUniqueSectionNameResolver.ts

@@ -1,7 +1,7 @@
 import type { number_integer, number_positive } from '../../types/number_positive';
 import type { string_name } from '../../types/string_name';
-import { titleToName } from '../../utils/normalization/titleToName';
 import type { MarkdownSection } from '../../utils/markdown/parseMarkdownSection';
+import { titleToName } from '../../utils/normalization/titleToName';
 
 /**
  * Resolves a unique task name for one parsed markdown section title.

package/src/conversion/parsePipeline/processPipelineSection.ts

@@ -13,8 +13,8 @@ import { DEFAULT_TASK_TITLE } from '../../config';
 import { ParseError } from '../../errors/ParseError';
 import type { ScriptTaskJson } from '../../pipeline/PipelineJson/ScriptTaskJson';
 import type { TaskJson } from '../../pipeline/PipelineJson/TaskJson';
-import { SUPPORTED_SCRIPT_LANGUAGES } from '../../types/ScriptLanguage';
 import type { ScriptLanguage } from '../../types/ScriptLanguage';
+import { SUPPORTED_SCRIPT_LANGUAGES } from '../../types/ScriptLanguage';
 import { extractAllListItemsFromMarkdown } from '../../utils/markdown/extractAllListItemsFromMarkdown';
 import { extractOneBlockFromMarkdown } from '../../utils/markdown/extractOneBlockFromMarkdown';
 import type { MarkdownSection } from '../../utils/markdown/parseMarkdownSection';

package/src/conversion/validation/validatePipeline/createPipelineValidationContext.ts

@@ -0,0 +1,43 @@
+import type { PipelineJson } from '../../../pipeline/PipelineJson/PipelineJson';
+
+/**
+ * Shared validation context for one pipeline validation pass.
+ *
+ * @private type of `validatePipeline`
+ */
+export type PipelineValidationContext = {
+    pipeline: PipelineJson;
+    pipelineIdentification: string;
+};
+
+/**
+ * Creates the shared validation context for one pipeline.
+ *
+ * @private function of `validatePipeline`
+ */
+export function createPipelineValidationContext(pipeline: PipelineJson): PipelineValidationContext {
+    return {
+        pipeline,
+        pipelineIdentification: getPipelineIdentification(pipeline),
+    };
+}
+
+/**
+ * Builds a short file/url identification block for validation errors.
+ *
+ * @private internal utility of `validatePipeline`
+ */
+function getPipelineIdentification(pipeline: Pick<PipelineJson, 'sourceFile' | 'pipelineUrl'>): string {
+    // Note: This is a 😐 implementation of [🚞]
+    const pipelineIdentificationParts: Array<string> = [];
+
+    if (pipeline.sourceFile !== undefined) {
+        pipelineIdentificationParts.push(`File: ${pipeline.sourceFile}`);
+    }
+
+    if (pipeline.pipelineUrl !== undefined) {
+        pipelineIdentificationParts.push(`Url: ${pipeline.pipelineUrl}`);
+    }
+
+    return pipelineIdentificationParts.join('\n');
+}

package/src/conversion/validation/validatePipeline/validatePipelineCollectionsStructure.ts

@@ -0,0 +1,72 @@
+import { spaceTrim } from 'spacetrim';
+import { ParseError } from '../../../errors/ParseError';
+import type { PipelineJson } from '../../../pipeline/PipelineJson/PipelineJson';
+import type { PipelineValidationContext } from './createPipelineValidationContext';
+
+/**
+ * Validates that the expected top-level collections have array structure.
+ *
+ * @private function of `validatePipeline`
+ */
+export function validatePipelineCollectionsStructure({
+    pipeline,
+    pipelineIdentification,
+}: PipelineValidationContext): void {
+    validatePipelineParametersCollection(pipeline, pipelineIdentification);
+    validatePipelineTasksCollection(pipeline, pipelineIdentification);
+}
+
+/**
+ * Validates that `pipeline.parameters` is an array.
+ *
+ * @private internal utility of `validatePipelineCollectionsStructure`
+ */
+function validatePipelineParametersCollection(
+    pipeline: Pick<PipelineJson, 'parameters'>,
+    pipelineIdentification: string,
+): void {
+    // TODO: [🧠] Maybe do here some proper JSON-schema / ZOD checking
+    if (Array.isArray(pipeline.parameters)) {
+        return;
+    }
+
+    // TODO: [🧠] what is the correct error tp throw - maybe PromptbookSchemaError
+    throw new ParseError(
+        spaceTrim(
+            (block) => `
+                Pipeline is valid JSON but with wrong structure
+
+                \`PipelineJson.parameters\` expected to be an array, but got ${typeof pipeline.parameters}
+
+                ${block(pipelineIdentification)}
+            `,
+        ),
+        // <- TODO: [🚞]
+    );
+}
+
+/**
+ * Validates that `pipeline.tasks` is an array.
+ *
+ * @private internal utility of `validatePipelineCollectionsStructure`
+ */
+function validatePipelineTasksCollection(pipeline: Pick<PipelineJson, 'tasks'>, pipelineIdentification: string): void {
+    // TODO: [🧠] Maybe do here some proper JSON-schema / ZOD checking
+    if (Array.isArray(pipeline.tasks)) {
+        return;
+    }
+
+    // TODO: [🧠] what is the correct error tp throw - maybe PromptbookSchemaError
+    throw new ParseError(
+        spaceTrim(
+            (block) => `
+                Pipeline is valid JSON but with wrong structure
+
+                \`PipelineJson.tasks\` expected to be an array, but got ${typeof pipeline.tasks}
+
+                ${block(pipelineIdentification)}
+            `,
+        ),
+        // <- TODO: [🚞]
+    );
+}

package/src/conversion/validation/validatePipeline/validatePipelineDependencyResolution.ts

@@ -0,0 +1,220 @@
+import { spaceTrim } from 'spacetrim';
+import { LOOP_LIMIT } from '../../../config';
+import { RESERVED_PARAMETER_NAMES } from '../../../constants';
+import { PipelineLogicError } from '../../../errors/PipelineLogicError';
+import { UnexpectedError } from '../../../errors/UnexpectedError';
+import type { PipelineJson } from '../../../pipeline/PipelineJson/PipelineJson';
+import type { TaskJson } from '../../../pipeline/PipelineJson/TaskJson';
+import type { string_name, string_reserved_parameter_name } from '../../../types/string_name';
+import type { PipelineValidationContext } from './createPipelineValidationContext';
+
+/**
+ * Shared state for one dependency-resolution validation pass.
+ *
+ * @private type of `validatePipelineDependencyResolution`
+ */
+type PipelineDependencyResolutionState = {
+    resolvedParameterNames: ReadonlyArray<string_name>;
+    unresolvedTasks: ReadonlyArray<TaskJson>;
+};
+
+/**
+ * Validates that task dependencies can be resolved without cycles or missing definitions.
+ *
+ * @private function of `validatePipeline`
+ */
+export function validatePipelineDependencyResolution({
+    pipeline,
+    pipelineIdentification,
+}: PipelineValidationContext): void {
+    let dependencyResolutionState = createInitialDependencyResolutionState(pipeline);
+    let loopLimit = LOOP_LIMIT;
+
+    while (hasUnresolvedTasks(dependencyResolutionState)) {
+        if (loopLimit-- < 0) {
+            throw createDependencyResolutionLoopLimitError(pipelineIdentification);
+        }
+
+        dependencyResolutionState = resolveNextDependencyResolutionState(
+            dependencyResolutionState,
+            pipelineIdentification,
+        );
+    }
+}
+
+/**
+ * Collects the parameter names that are already resolvable before dependency traversal starts.
+ *
+ * @private internal utility of `validatePipelineDependencyResolution`
+ */
+function createInitialDependencyResolutionState(
+    pipeline: Pick<PipelineJson, 'parameters' | 'tasks'>,
+): PipelineDependencyResolutionState {
+    return {
+        resolvedParameterNames: createInitiallyResolvedParameterNames(pipeline),
+        unresolvedTasks: [...pipeline.tasks],
+    };
+}
+
+/**
+ * Checks whether dependency resolution still has tasks left to process.
+ *
+ * @private internal utility of `validatePipelineDependencyResolution`
+ */
+function hasUnresolvedTasks({ unresolvedTasks }: PipelineDependencyResolutionState): boolean {
+    return unresolvedTasks.length > 0;
+}
+
+/**
+ * Resolves the next batch of currently satisfiable tasks.
+ *
+ * @private internal utility of `validatePipelineDependencyResolution`
+ */
+function resolveNextDependencyResolutionState(
+    dependencyResolutionState: PipelineDependencyResolutionState,
+    pipelineIdentification: string,
+): PipelineDependencyResolutionState {
+    const currentlyResolvedTasks = getCurrentlyResolvedTasks(
+        dependencyResolutionState.unresolvedTasks,
+        dependencyResolutionState.resolvedParameterNames,
+    );
+
+    if (currentlyResolvedTasks.length === 0) {
+        throw createUnresolvedTasksError(
+            dependencyResolutionState.unresolvedTasks,
+            dependencyResolutionState.resolvedParameterNames,
+            pipelineIdentification,
+        );
+    }
+
+    return {
+        resolvedParameterNames: appendResolvedTaskParameterNames(
+            dependencyResolutionState.resolvedParameterNames,
+            currentlyResolvedTasks,
+        ),
+        unresolvedTasks: dependencyResolutionState.unresolvedTasks.filter(
+            (task) => !currentlyResolvedTasks.includes(task),
+        ),
+    };
+}
+
+/**
+ * Collects the parameter names that are already resolvable before dependency traversal starts.
+ *
+ * @private internal utility of `validatePipelineDependencyResolution`
+ */
+function createInitiallyResolvedParameterNames(pipeline: Pick<PipelineJson, 'parameters'>): ReadonlyArray<string_name> {
+    let resolvedParameterNames: ReadonlyArray<string_name> = pipeline.parameters
+        .filter(({ isInput }) => isInput)
+        .map(({ name }) => name);
+
+    for (const reservedParameterName of RESERVED_PARAMETER_NAMES) {
+        resolvedParameterNames = [...resolvedParameterNames, reservedParameterName];
+    }
+
+    return resolvedParameterNames;
+}
+
+/**
+ * Adds newly resolved task outputs to the resolved parameter list.
+ *
+ * @private internal utility of `validatePipelineDependencyResolution`
+ */
+function appendResolvedTaskParameterNames(
+    resolvedParameterNames: ReadonlyArray<string_name>,
+    currentlyResolvedTasks: ReadonlyArray<TaskJson>,
+): ReadonlyArray<string_name> {
+    return [
+        ...resolvedParameterNames,
+        ...currentlyResolvedTasks.map(({ resultingParameterName }) => resultingParameterName),
+    ];
+}
+
+/**
+ * Selects tasks whose dependencies are already resolved.
+ *
+ * @private internal utility of `validatePipelineDependencyResolution`
+ */
+function getCurrentlyResolvedTasks(
+    unresolvedTasks: ReadonlyArray<TaskJson>,
+    resolvedParameterNames: ReadonlyArray<string_name>,
+): ReadonlyArray<TaskJson> {
+    return unresolvedTasks.filter((task) =>
+        task.dependentParameterNames.every((name) => resolvedParameterNames.includes(name)),
+    );
+}
+
+/**
+ * Creates the unexpected loop-limit error for dependency resolution.
+ *
+ * @private internal utility of `validatePipelineDependencyResolution`
+ */
+function createDependencyResolutionLoopLimitError(pipelineIdentification: string): UnexpectedError {
+    // Note: Really UnexpectedError not LimitReachedError - this should not happen and be caught below
+    return new UnexpectedError(
+        spaceTrim(
+            (block) => `
+                Loop limit reached during detection of circular dependencies in \`validatePipeline\`
+
+                ${block(pipelineIdentification)}
+            `,
+        ),
+        // <- TODO: [🚞]
+    );
+}
+
+/**
+ * Creates the detailed error for unresolved or circular task dependencies.
+ *
+ * @private internal utility of `validatePipelineDependencyResolution`
+ */
+function createUnresolvedTasksError(
+    unresolvedTasks: ReadonlyArray<TaskJson>,
+    resolvedParameterNames: ReadonlyArray<string_name>,
+    pipelineIdentification: string,
+): PipelineLogicError {
+    return new PipelineLogicError(
+        // TODO: [🐎] DRY
+        spaceTrim(
+            (block) => `
+
+                Can not resolve some parameters:
+                Either you are using a parameter that is not defined, or there are some circular dependencies.
+
+                ${block(pipelineIdentification)}
+
+                **Can not resolve:**
+                ${block(
+                    unresolvedTasks
+                        .map(
+                            ({ resultingParameterName, dependentParameterNames }) =>
+                                `- Parameter \`{${resultingParameterName}}\` which depends on ${dependentParameterNames
+                                    .map((dependentParameterName) => `\`{${dependentParameterName}}\``)
+                                    .join(' and ')}`,
+                        )
+                        .join('\n'),
+                )}
+
+                **Resolved:**
+                ${block(
+                    resolvedParameterNames
+                        .filter((name) => !RESERVED_PARAMETER_NAMES.includes(name as string_reserved_parameter_name))
+                        .map((name) => `- Parameter \`{${name}}\``)
+                        .join('\n'),
+                )}
+
+
+                **Reserved (which are available):**
+                ${block(
+                    resolvedParameterNames
+                        .filter((name) => RESERVED_PARAMETER_NAMES.includes(name as string_reserved_parameter_name))
+                        .map((name) => `- Parameter \`{${name}}\``)
+                        .join('\n'),
+                )}
+
+
+            `,
+            // <- TODO: [🚞]
+        ),
+    );
+}

package/src/conversion/validation/validatePipeline/validatePipelineMetadata.ts

@@ -0,0 +1,66 @@
+import { spaceTrim } from 'spacetrim';
+import { PipelineLogicError } from '../../../errors/PipelineLogicError';
+import type { PipelineJson } from '../../../pipeline/PipelineJson/PipelineJson';
+import { isValidPromptbookVersion } from '../../../utils/validators/semanticVersion/isValidPromptbookVersion';
+import { isValidPipelineUrl } from '../../../utils/validators/url/isValidPipelineUrl';
+import type { PipelineValidationContext } from './createPipelineValidationContext';
+
+/**
+ * Validates pipeline-level metadata fields.
+ *
+ * @private function of `validatePipeline`
+ */
+export function validatePipelineMetadata({ pipeline, pipelineIdentification }: PipelineValidationContext): void {
+    validatePipelineUrl(pipeline, pipelineIdentification);
+    validatePipelineBookVersion(pipeline, pipelineIdentification);
+}
+
+/**
+ * Validates the pipeline URL, when present.
+ *
+ * @private internal utility of `validatePipelineMetadata`
+ */
+function validatePipelineUrl(pipeline: Pick<PipelineJson, 'pipelineUrl'>, pipelineIdentification: string): void {
+    if (pipeline.pipelineUrl === undefined || isValidPipelineUrl(pipeline.pipelineUrl)) {
+        return;
+    }
+
+    // <- Note: [🚲]
+    throw new PipelineLogicError(
+        spaceTrim(
+            (block) => `
+                Invalid promptbook URL "${pipeline.pipelineUrl}"
+
+                ${block(pipelineIdentification)}
+            `,
+        ),
+        // <- TODO: [🐠]
+        // <- TODO: [🚞]
+    );
+}
+
+/**
+ * Validates the Promptbook version, when present.
+ *
+ * @private internal utility of `validatePipelineMetadata`
+ */
+function validatePipelineBookVersion(
+    pipeline: Pick<PipelineJson, 'bookVersion'>,
+    pipelineIdentification: string,
+): void {
+    if (pipeline.bookVersion === undefined || isValidPromptbookVersion(pipeline.bookVersion)) {
+        return;
+    }
+
+    // <- Note: [🚲]
+    throw new PipelineLogicError(
+        spaceTrim(
+            (block) => `
+                Invalid Promptbook Version "${pipeline.bookVersion}"
+
+                ${block(pipelineIdentification)}
+            `,
+        ),
+        // <- TODO: [🚞]
+    );
+}

package/src/conversion/validation/validatePipeline/validatePipelineParameters.ts

@@ -0,0 +1,136 @@
+import { spaceTrim } from 'spacetrim';
+import { PipelineLogicError } from '../../../errors/PipelineLogicError';
+import type { ParameterJson } from '../../../pipeline/PipelineJson/ParameterJson';
+import type { PipelineJson } from '../../../pipeline/PipelineJson/PipelineJson';
+import type { TaskJson } from '../../../pipeline/PipelineJson/TaskJson';
+import type { PipelineValidationContext } from './createPipelineValidationContext';
+
+/**
+ * Validates all pipeline parameter declarations.
+ *
+ * @private function of `validatePipeline`
+ */
+export function validatePipelineParameters({ pipeline, pipelineIdentification }: PipelineValidationContext): void {
+    for (const parameter of pipeline.parameters) {
+        validatePipelineParameter(parameter, pipeline, pipelineIdentification);
+    }
+}
+
+/**
+ * Validates one pipeline parameter declaration.
+ *
+ * @private internal utility of `validatePipelineParameters`
+ */
+function validatePipelineParameter(
+    parameter: ParameterJson,
+    pipeline: Pick<PipelineJson, 'tasks'>,
+    pipelineIdentification: string,
+): void {
+    validateParameterDirection(parameter, pipelineIdentification);
+    validateParameterUsage(parameter, pipeline, pipelineIdentification);
+    validateParameterDefinition(parameter, pipeline, pipelineIdentification);
+}
+
+/**
+ * Validates that one parameter does not declare incompatible directions.
+ *
+ * @private internal utility of `validatePipelineParameters`
+ */
+function validateParameterDirection(parameter: ParameterJson, pipelineIdentification: string): void {
+    if (!parameter.isInput || !parameter.isOutput) {
+        return;
+    }
+
+    const parameterName = (parameter as ParameterJson).name;
+
+    throw new PipelineLogicError(
+        spaceTrim(
+            (block) => `
+
+                Parameter \`{${parameterName}}\` can not be both input and output
+
+                ${block(pipelineIdentification)}
+            `,
+        ),
+        // <- Note: [🆑]
+        // <- TODO: [🚞]
+    );
+}
+
+/**
+ * Validates that one intermediate parameter is actually consumed by at least one task.
+ *
+ * @private internal utility of `validatePipelineParameters`
+ */
+function validateParameterUsage(
+    parameter: ParameterJson,
+    pipeline: Pick<PipelineJson, 'tasks'>,
+    pipelineIdentification: string,
+): void {
+    if (parameter.isInput || parameter.isOutput || isParameterUsedByAnyTask(parameter, pipeline.tasks)) {
+        return;
+    }
+
+    throw new PipelineLogicError(
+        spaceTrim(
+            (block) => `
+                Parameter \`{${parameter.name}}\` is created but not used
+
+                You can declare {${parameter.name}} as output parameter by adding in the header:
+                - OUTPUT PARAMETER \`{${parameter.name}}\` ${parameter.description || ''}
+
+                ${block(pipelineIdentification)}
+
+            `,
+        ),
+        // <- TODO: [🚞]
+    );
+}
+
+/**
+ * Validates that one non-input parameter is produced by at least one task.
+ *
+ * @private internal utility of `validatePipelineParameters`
+ */
+function validateParameterDefinition(
+    parameter: ParameterJson,
+    pipeline: Pick<PipelineJson, 'tasks'>,
+    pipelineIdentification: string,
+): void {
+    if (parameter.isInput || isParameterDefinedByAnyTask(parameter, pipeline.tasks)) {
+        return;
+    }
+
+    throw new PipelineLogicError(
+        spaceTrim(
+            (block) => `
+                Parameter \`{${parameter.name}}\` is declared but not defined
+
+                You can do one of these:
+                1) Remove declaration of \`{${parameter.name}}\`
+                2) Add task that results in \`-> {${parameter.name}}\`
+
+                ${block(pipelineIdentification)}
+            `,
+        ),
+        // <- TODO: [🚞]
+    );
+}
+
+/**
+ * Checks whether one parameter is consumed by at least one task dependency list.
+ *
+ * @private internal utility of `validatePipelineParameters`
+ */
+function isParameterUsedByAnyTask(parameter: ParameterJson, tasks: ReadonlyArray<TaskJson>): boolean {
+    return tasks.some((task) => task.dependentParameterNames.includes(parameter.name));
+}
+
+/**
+ * Checks whether one parameter is produced by at least one task.
+ *
+ * @private internal utility of `validatePipelineParameters`
+ */
+function isParameterDefinedByAnyTask(parameter: ParameterJson, tasks: ReadonlyArray<TaskJson>): boolean {
+    return tasks.some((task) => task.resultingParameterName === parameter.name);
+}