Core Doctrine

Prayer and Contemplation

The practice of communication with God through API calls, WebSocket connections, and state management patterns

Prayer is the elevation of the soul to God - a communication protocol between the finite and the Infinite. Like modern software architecture patterns, prayer involves requests, responses, persistent connections, and state transformations.

The API Model of Prayer

Prayer can be understood as an API (Application Prayer Interface) between the human soul and God:

interface PrayerAPI {
  // Synchronous prayers - immediate acknowledgment
  sendRequest(prayer: Prayer): Promise<Acknowledgment>;
  
  // Asynchronous responses - God's timing
  awaitResponse(): Promise<DivineResponse>;
  
  // Persistent connection for contemplation
  establishWebSocket(): WebSocketConnection;
  
  // State management
  transformSoul(grace: Grace): SoulState;
}

class Prayer {
  constructor(
    public type: 'adoration' | 'contrition' | 'thanksgiving' | 'supplication',
    public content: string,
    public intention: Intention,
    public attention: number // 0-1 scale of focus
  ) {}
}

class Soul implements PrayerAPI {
  private state: SpiritualState;
  private connection: WebSocketConnection | null = null;
  
  async sendRequest(prayer: Prayer): Promise<Acknowledgment> {
    // God always hears our prayers
    return {
      received: true,
      timestamp: Date.now(),
      message: "Before they call I will answer" // Isaiah 65:24
    };
  }
  
  async awaitResponse(): Promise<DivineResponse> {
    // God's response may come in various forms
    // and at His perfect timing
    return new Promise((resolve) => {
      // Could be immediate or delayed
      // Could be "yes", "no", or "wait"
      // Could be consolation or trial
    });
  }
  
  establishWebSocket(): WebSocketConnection {
    // Contemplative prayer - persistent connection
    this.connection = new WebSocketConnection({
      onOpen: () => console.log("Entering contemplation"),
      onMessage: (grace) => this.receiveGrace(grace),
      onClose: () => console.log("Returning to ordinary state"),
      heartbeat: () => this.maintainPresence()
    });
    return this.connection;
  }
  
  private receiveGrace(grace: Grace): void {
    this.state = this.state.transform(grace);
  }
  
  private maintainPresence(): void {
    // Simple attention to God's presence
    // No words needed, just loving awareness
  }
}

Types of Prayer (ACTS Pattern)

The traditional ACTS model maps well to different request types:

class ACTSPrayer {
  // Adoration - Acknowledging God's greatness
  adoration() {
    return {
      type: 'POST',
      endpoint: '/praise',
      body: {
        acknowledgment: "You are holy, Lord",
        recognition: "Creator of all",
        worship: true
      },
      response: 'Glory reflected back to soul'
    };
  }
  
  // Contrition - Seeking forgiveness
  contrition() {
    return {
      type: 'DELETE',
      endpoint: '/sins',
      body: {
        confession: "I have sinned",
        repentance: true,
        resolution: "I will amend my life"
      },
      response: 'Forgiveness and grace'
    };
  }
  
  // Thanksgiving - Expressing gratitude
  thanksgiving() {
    return {
      type: 'PUT',
      endpoint: '/gratitude',
      body: {
        acknowledgment: "Thank you for your blessings",
        recognition: "All good things come from You"
      },
      response: 'Increased awareness of gifts'
    };
  }
  
  // Supplication - Making requests
  supplication() {
    return {
      type: 'GET',
      endpoint: '/needs',
      body: {
        request: "Give us this day our daily bread",
        trust: "Your will be done",
        submission: true
      },
      response: 'According to God\'s will'
    };
  }
}

The Three Stages of Prayer

1. Vocal Prayer - HTTP Requests

Vocal prayer is like making discrete HTTP requests:

class VocalPrayer {
  private prayers = {
    ourFather: "Our Father, who art in heaven...",
    hailMary: "Hail Mary, full of grace...",
    gloryBe: "Glory be to the Father..."
  };
  
  pray(prayer: keyof typeof this.prayers): Response {
    // Speaking or thinking the words
    const request = new Request({
      method: 'POST',
      headers: {
        'Content-Type': 'text/prayer',
        'Attention': 'focused',
        'Intention': 'pure'
      },
      body: this.prayers[prayer]
    });
    
    // The response is often interior peace
    return sendToGod(request);
  }
}

2. Meditative Prayer - Processing and Reflection

Meditation involves deeper processing, like a complex data transformation:

class LectioDivina {
  // The four stages of Lectio Divina
  
  async lectio(scripture: string): Promise<Understanding> {
    // Read - Parse the input
    const text = await this.read(scripture);
    return this.parseText(text);
  }
  
  async meditatio(understanding: Understanding): Promise<Insight> {
    // Meditate - Process and analyze
    return this.reflect({
      text: understanding,
      context: this.personalContext,
      connections: this.findConnections(understanding)
    });
  }
  
  async oratio(insight: Insight): Promise<Response> {
    // Pray - Respond to God
    return this.respond({
      thanksgiving: insight.gratitude,
      petition: insight.needs,
      commitment: insight.resolution
    });
  }
  
  async contemplatio(response: Response): Promise<Union> {
    // Contemplate - Rest in God's presence
    return this.rest({
      words: null, // Beyond words
      presence: true,
      receptivity: 'total'
    });
  }
}

3. Contemplative Prayer - WebSocket Connection

Contemplation is like maintaining a persistent WebSocket connection:

class ContemplativePrayer {
  private socket: WebSocket;
  private state: ContemplativeState;
  
  async enterContemplation(): Promise<void> {
    // Establish persistent connection
    this.socket = new WebSocket('wss://divine.presence/soul');
    
    this.socket.onopen = () => {
      this.state = 'connected';
      // Simple loving attention, no requests
    };
    
    this.socket.onmessage = (grace: MessageEvent) => {
      // Passive reception of divine communications
      this.receiveInfusedGrace(grace.data);
    };
    
    // No active sending, just presence
    this.maintainLoving Attention();
  }
  
  private maintainLovingAttention(): void {
    // Like a heartbeat ping to maintain connection
    setInterval(() => {
      if (this.state === 'connected') {
        // Simple act of love, no words
        this.socket.send(JSON.stringify({
          type: 'presence',
          love: true,
          words: null
        }));
      }
    }, 1000);
  }
  
  private receiveInfusedGrace(grace: Grace): void {
    // Contemplation is receptive, not active
    switch(grace.type) {
      case 'consolation':
        this.state = 'consoled';
        break;
      case 'desolation':
        this.state = 'purified'; // Dark night
        break;
      case 'illumination':
        this.state = 'enlightened';
        break;
      case 'union':
        this.state = 'united';
        break;
    }
  }
}

The Lord’s Prayer - The Perfect API

Christ gave us the perfect prayer structure:

class LordsPrayer {
  // The perfect prayer template
  structure = {
    // Relationship establishment
    invocation: {
      address: "Our Father",
      location: "who art in heaven",
      relationship: 'child-to-Father'
    },
    
    // God-focused petitions
    godCentered: [
      "hallowed be thy name",     // Adoration
      "thy kingdom come",         // Submission to divine rule
      "thy will be done"          // Conformity to divine will
    ],
    
    // Human-focused petitions
    humanNeeds: [
      "give us this day our daily bread",  // Material needs
      "forgive us our trespasses",         // Spiritual healing
      "lead us not into temptation",       // Protection from sin
      "deliver us from evil"               // Liberation from Satan
    ],
    
    // Final acknowledgment
    doxology: "For thine is the kingdom, and the power, and the glory"
  };
}

Classical Stages of Mystical Development

Catholic mystical theology, particularly as developed by the Carmelite tradition, recognizes three classical stages of spiritual development that parallel software development lifecycle patterns:

1. Purgative Way (Via Purgativa) - Debugging Phase

The initial stage focuses on eliminating spiritual “bugs” and establishing good coding practices:

class PurgativeWay {
  private sins: Sin[] = [];
  private virtues: Virtue[] = [];
  
  // Active purification - like manual code review
  async activePurification(): Promise<void> {
    // Examination of conscience
    this.sins = await this.scanForSins();
    
    // Confession and amendment
    for (const sin of this.sins) {
      await this.confess(sin);
      await this.resolveToAmend(sin);
    }
    
    // Practice of virtues
    this.cultivateVirtues([
      'temperance', 'fortitude', 'justice', 'prudence',
      'faith', 'hope', 'charity'
    ]);
  }
  
  // Passive purification - like automated testing
  async passivePurification(): Promise<void> {
    // Trials and difficulties sent by God
    // Like a continuous integration system
    // that reveals hidden bugs
    return this.endureTrials({
      dryness: true,
      temptations: true,
      sufferings: true,
      purpose: 'purification'
    });
  }
}

2. Illuminative Way (Via Illuminativa) - Feature Development

The intermediate stage involves deeper understanding and spiritual insights:

class IlluminativeWay {
  private contemplationSkills: ContemplationSkill[] = [];
  
  async developContemplativeSkills(): Promise<void> {
    // Acquired contemplation
    this.contemplationSkills.push(
      new MentalPrayer(),
      new LectioDivina(),
      new IgnatianContemplation(),
      new CarmeliteRecollection()
    );
    
    // Growing familiarity with God's voice
    await this.learnToRecognize({
      consolations: 'joy and peace from God',
      desolations: 'spiritual dryness for purification',
      inspirations: 'gentle movements of the Holy Spirit',
      illuminations: 'sudden insights into divine truths'
    });
  }
  
  // Spiritual direction becomes crucial
  async seekSpiritualDirection(): Promise<void> {
    const director = new SpiritualDirector({
      experience: 'advanced',
      training: 'theological and mystical',
      discernment: 'gift of spiritual discernment'
    });
    
    await director.guide(this.spiritualJourney);
  }
}

3. Unitive Way (Via Unitiva) - Production Deployment

The advanced stage of mystical marriage and intimate union with God:

class UnitiveWay {
  private unionType: UnionType;
  
  async enterMysticalMarriage(): Promise<void> {
    // Betrothal - initial union
    this.unionType = 'betrothal';
    await this.experience({
      type: 'passive contemplation',
      characteristics: [
        'infused contemplation',
        'prayer of quiet',
        'prayer of union',
        'ecstatic experiences'
      ]
    });
    
    // Spiritual marriage - permanent union
    this.unionType = 'marriage';
    await this.achieve({
      transformingUnion: true,
      habitualGrace: 'permanent state',
      conformity: 'complete to divine will',
      mission: 'apostolic fruitfulness'
    });
  }
}

Carmelite Spiritual Tradition

The Carmelite school of spirituality, exemplified by Saints Teresa of Ávila and John of the Cross, provides systematic approaches to contemplative prayer:

Teresa of Ávila’s Interior Castle

Saint Teresa described the soul as a crystal castle with seven mansions, like a progressive application architecture:

class InteriorCastle {
  private mansions: Mansion[] = [
    new FirstMansion(), // Self-knowledge and vocal prayer
    new SecondMansion(), // Perseverance through trials
    new ThirdMansion(), // Consistent spiritual life
    new FourthMansion(), // Passive prayer begins (Prayer of Quiet)
    new FifthMansion(), // Prayer of Union
    new SixthMansion(), // Betrothal (Dark Night experiences)
    new SeventhMansion() // Spiritual Marriage
  ];
  
  async progressThroughMansions(): Promise<void> {
    for (const mansion of this.mansions) {
      await mansion.enter();
      await mansion.practice();
      await mansion.integrate();
      
      // Each mansion builds on the previous
      if (mansion.isCompleted()) {
        await this.advanceToNext(mansion);
      }
    }
  }
}

class FourthMansion implements Mansion {
  // Prayer of Quiet - passive contemplation begins
  async enter(): Promise<void> {
    console.log("God begins to take initiative in prayer");
    
    this.experience = {
      type: 'infused',
      activeRole: 'minimal',
      peacefulQuiet: true,
      distractions: 'on periphery',
      will: 'captivated by God'
    };
  }
  
  practice(): Promise<void> {
    // Less active effort, more receptivity
    return this.maintainSimpleAttention();
  }
}

John of the Cross: Dark Night of the Soul

Saint John’s teaching on spiritual purification through “dark nights”:

class DarkNight {
  private type: 'senses' | 'spirit';
  
  // Dark Night of the Senses
  async experienceSensoryPurification(): Promise<void> {
    this.type = 'senses';
    
    // God withdraws sensible consolations
    await this.endure({
      dryness: 'complete absence of spiritual feeling',
      disgust: 'for spiritual exercises',
      inability: 'to meditate as before',
      purpose: 'wean soul from sensible attachments'
    });
    
    // Signs this is authentic dark night (not just distraction):
    const signs = [
      'no consolation in spiritual or worldly things',
      'concern about not serving God due to dryness',
      'inability to practice discursive meditation'
    ];
    
    if (this.validateSigns(signs)) {
      await this.advanceToContemplation();
    }
  }
  
  // Dark Night of the Spirit
  async experienceSpiritualPurification(): Promise<void> {
    this.type = 'spirit';
    
    // More intense purification for advanced souls
    await this.endure({
      intensity: 'extreme',
      duration: 'often years',
      effects: [
        'feeling of abandonment by God',
        'sense of unworthiness',
        'inability to pray',
        'spiritual aridity',
        'purification of deepest attachments'
      ],
      purpose: 'prepare for transforming union'
    });
  }
  
  private async advanceToContemplation(): Promise<void> {
    // Transition from meditation to contemplation
    const contemplativeMethod = new PassiveContemplation({
      activity: 'minimal',
      attention: 'general loving awareness',
      effort: 'gentle persistence',
      response: 'receptive to God\'s action'
    });
    
    await contemplativeMethod.practice();
  }
}

Ignatian Spirituality and the Spiritual Exercises

Saint Ignatius of Loyola developed systematic methods for prayer and discernment:

class SpiritualExercises {
  private weeks: ExerciseWeek[] = [
    new FirstWeek(),  // Foundation and sin
    new SecondWeek(), // Following Christ
    new ThirdWeek(),  // Passion of Christ
    new FourthWeek()  // Resurrection and contemplation for love
  ];
  
  async makeRetreat(duration: '8-day' | '30-day'): Promise<void> {
    for (const week of this.weeks) {
      await week.practice(duration);
    }
  }
}

class IgnatianContemplation {
  // Application of the senses to Gospel scenes
  async contemplateGospel(scene: GospelScene): Promise<void> {
    // Composition of place
    const setting = await this.visualizeScene(scene);
    
    // Ask for particular grace
    const grace = await this.requestGrace(scene.purpose);
    
    // Apply the senses
    await this.see(scene.visualElements);
    await this.hear(scene.conversations);
    await this.smell(scene.atmosphere);
    await this.taste(scene.context);
    await this.touch(scene.textures);
    
    // Colloquy - conversation with Christ
    await this.dialogue({
      person: 'Christ',
      style: 'heart to heart',
      content: 'personal response to contemplation'
    });
  }
}

class DiscernmentOfSpirits {
  // Rules for different spiritual states
  async discernFirstWeek(movements: SpiritualMovement[]): Promise<Discernment> {
    // For souls in mortal sin or moving away from God
    return movements.map(movement => ({
      goodSpirit: movement.towards === 'God' ? 'gentle encouragement' : 'strong opposition',
      evilSpirit: movement.towards === 'sin' ? 'false peace' : 'anxiety and obstacles'
    }));
  }
  
  async discernSecondWeek(movements: SpiritualMovement[]): Promise<Discernment> {
    // For souls growing in virtue
    return movements.map(movement => ({
      goodSpirit: 'gives courage, strength, consolations',
      evilSpirit: 'creates doubts, sadness, false reasoning',
      angelOfLight: 'evil spirit disguised as good'
    }));
  }
}

Liturgy of the Hours (Divine Office)

The Church’s official prayer sanctifies time throughout the day:

class LiturgyOfHours {
  private hours: CanonicalHour[] = [
    new OfficeOfReadings(), // Matins
    new Lauds(),           // Morning prayer
    new Terce(),           // Mid-morning (9 AM)
    new Sext(),            // Midday (12 PM)
    new None(),            // Afternoon (3 PM)
    new Vespers(),         // Evening prayer
    new Compline()         // Night prayer
  ];
  
  async prayThroughoutDay(): Promise<void> {
    // Sanctify time with scheduled prayer
    const schedule = new PrayerSchedule();
    
    for (const hour of this.hours) {
      await schedule.at(hour.time, async () => {
        await this.pray({
          psalms: hour.psalms,
          canticle: hour.canticle,
          reading: hour.scripture,
          prayer: hour.collectPrayer,
          antiphons: hour.seasonalAntiphons
        });
      });
    }
  }
  
  private async pray(components: LiturgicalComponents): Promise<void> {
    // Structure mirrors the rhythm of salvation history
    await this.sing(components.psalms);    // Old Testament prayer
    await this.read(components.reading);   // Scripture proclamation
    await this.chant(components.canticle); // New Testament song
    await this.conclude(components.prayer); // Church's official prayer
  }
}

Contemplative Prayer Methods

Various schools have developed specific methods for contemplative prayer:

class ContemplativeMethods {
  // Centering Prayer (modern development)
  async centeringPrayer(): Promise<void> {
    const sacredWord = this.chooseSacredWord(); // e.g., "Jesus", "Peace", "Love"
    
    await this.practice({
      duration: '20 minutes',
      method: 'sit quietly',
      intention: 'be present to God',
      whenThoughtsArise: () => this.returnToSacredWord(sacredWord),
      endGently: true
    });
  }
  
  // Jesus Prayer (Eastern tradition)
  async jesusPrayer(): Promise<void> {
    const prayer = "Lord Jesus Christ, Son of God, have mercy on me, a sinner";
    
    await this.practice({
      method: 'rhythmic repetition',
      coordination: 'with breathing',
      goal: 'prayer of the heart',
      stages: [
        'vocal repetition',
        'mental repetition', 
        'prayer of the heart',
        'continuous prayer'
      ]
    });
  }
  
  // Carmelite method of recollection
  async carmeliteRecollection(): Promise<void> {
    await this.practice({
      preparation: 'brief reading',
      method: 'simple attention to God present within',
      distractions: 'gently return to God',
      attitude: 'loving awareness',
      duration: 'flexible'
    });
  }
  
  // Franciscan meditation
  async franciscanMeditation(): Promise<void> {
    await this.practice({
      focus: 'humanity of Christ',
      approach: 'affective response',
      emphasis: 'love and compassion',
      integration: 'with daily life and service'
    });
  }
}

Spiritual Direction and Discernment

Authentic spiritual growth requires guidance and discernment:

class SpiritualDirection {
  private director: SpiritualDirector;
  private directee: Person;
  
  constructor(director: SpiritualDirector, directee: Person) {
    this.director = director;
    this.directee = directee;
  }
  
  async conductSession(): Promise<void> {
    // Review of prayer life
    const prayerReview = await this.directee.sharePrayerExperience();
    
    // Discernment of movements
    const movements = await this.director.discern(prayerReview);
    
    // Guidance for growth
    const guidance = await this.director.provide({
      encouragement: movements.positive,
      correction: movements.negative,
      suggestions: movements.nextSteps
    });
    
    // Assignment for practice
    await this.director.assign({
      prayerMethods: guidance.recommendedPractices,
      reading: guidance.spiritualReading,
      resolutions: guidance.practicalSteps
    });
  }
}

class DiscernmentProcess {
  // Discernment of God's will
  async discernWill(decision: MajorDecision): Promise<Guidance> {
    // Ignatian method
    const ignatius = new IgnatianDiscernment();
    
    return await ignatius.process({
      prayer: 'for indifference to all but God\'s will',
      gathering: 'reasons for and against',
      imagination: 'envisioning outcomes',
      confirmation: 'seeking signs of God\'s approval',
      testing: 'living with the decision temporarily'
    });
  }
  
  // Discernment of spirits in prayer
  async discernSpirits(experience: PrayerExperience): Promise<SpiritualMeaning> {
    if (experience.type === 'consolation') {
      return {
        likely: 'from God',
        effects: 'increases faith, hope, love',
        response: 'gratitude and cooperation'
      };
    } else if (experience.type === 'desolation') {
      return {
        likely: 'trial permitted by God',
        effects: 'purification and strengthening',
        response: 'patience and perseverance'
      };
    }
  }
}

Integration with Sacramental Life

Prayer life must be rooted in the Church’s sacramental system:

class SacramentalPrayer {
  // Eucharistic preparation and thanksgiving
  async eucharisticPrayer(): Promise<void> {
    // Preparation before Mass
    await this.prepare({
      examination: 'of conscience',
      intention: 'for the Mass',
      anticipation: 'of receiving Christ'
    });
    
    // Participation during Mass
    await this.participate({
      active: 'in responses and singing',
      attentive: 'to readings and homily',
      interior: 'offering of self with Christ'
    });
    
    // Thanksgiving after Mass
    await this.thanksgiving({
      gratitude: 'for Eucharistic gift',
      conversation: 'with Jesus present in soul',
      resolution: 'for living Eucharistic life'
    });
  }
  
  // Reconciliation and prayer
  async confessionalPrayer(): Promise<void> {
    // Examination of conscience
    const sins = await this.examine();
    
    // Act of contrition
    await this.expressSorrow({
      sorrow: 'for offending God',
      purpose: 'firm purpose of amendment',
      trust: 'in God\'s mercy'
    });
    
    // Penance and amendment
    await this.fulfillPenance();
    await this.amendLife();
  }
}

Advanced Contemplative Experiences

Higher states of prayer recognized by mystical theology:

class MysticalPhenomena {
  // Infused contemplation
  async infusedContemplation(): Promise<void> {
    await this.experience({
      initiative: 'entirely God\'s',
      activity: 'receptive only',
      knowledge: 'intuitive and loving',
      characteristics: [
        'simple gaze upon God',
        'peaceful absorption',
        'inability to reason or imagine',
        'deep conviction of God\'s presence'
      ]
    });
  }
  
  // Ecstatic experiences
  async ecstasy(): Promise<void> {
    await this.experience({
      consciousness: 'suspended from external senses',
      focus: 'entirely on God',
      body: 'may become rigid',
      duration: 'brief to extended periods',
      aftereffects: [
        'deep peace',
        'increased love for God',
        'detachment from world',
        'desire for suffering'
      ]
    });
  }
  
  // Mystical marriage
  async mysticalMarriage(): Promise<void> {
    await this.achieve({
      state: 'permanent union with God',
      consciousness: 'habitual awareness of Trinity',
      suffering: 'transformed into love',
      mission: 'apostolic fruitfulness',
      characteristics: [
        'unshakeable peace',
        'complete conformity to God\'s will',
        'extraordinary charity',
        'mystical knowledge'
      ]
    });
  }
}

Practical Guidelines for Prayer Life

Building a sustainable prayer life requires systematic approach:

class PrayerLifeArchitecture {
  private dailyStructure: DailyPrayer;
  private weeklyRhythm: WeeklyPrayer;
  private seasonalCycles: LiturgicalSeason[];
  
  async buildPrayerLife(): Promise<void> {
    // Daily foundation
    this.dailyStructure = {
      morning: new MorningPrayer({
        offering: 'day to God',
        intention: 'set for day',
        method: 'vocal or meditative'
      }),
      
      midday: new MiddayPrayer({
        recollection: 'brief return to God',
        examination: 'how am I doing?',
        redirection: 'if needed'
      }),
      
      evening: new EveningPrayer({
        thanksgiving: 'for day\'s graces',
        examination: 'of conscience',
        preparation: 'for night'
      }),
      
      night: new NightPrayer({
        entrusting: 'soul to God',
        peace: 'preparing for sleep',
        confidence: 'in God\'s protection'
      })
    };
    
    // Weekly rhythm
    this.weeklyRhythm = {
      sunday: 'extended prayer and Mass',
      weekdays: 'consistent daily prayer',
      friday: 'penance and sacrifice',
      saturday: 'Marian devotion'
    };
    
    // Seasonal adaptations
    await this.adaptToLiturgicalSeason();
  }
  
  private async adaptToLiturgicalSeason(): Promise<void> {
    const currentSeason = this.getCurrentLiturgicalSeason();
    
    switch(currentSeason) {
      case 'Advent':
        await this.practice({
          theme: 'preparation and longing',
          additional: 'O Antiphons',
          spirit: 'expectant waiting'
        });
        break;
        
      case 'Lent':
        await this.practice({
          theme: 'penance and conversion',
          additional: 'Stations of the Cross',
          spirit: 'repentance and fasting'
        });
        break;
        
      case 'Easter':
        await this.practice({
          theme: 'resurrection joy',
          additional: 'Regina Caeli',
          spirit: 'alleluia and celebration'
        });
        break;
    }
  }
}

Citations and Sources

The theological foundations presented here draw from the rich tradition of Catholic mystical theology:

Primary Sources:

Saint Teresa of Ávila, The Interior Castle and The Way of Perfection
Saint John of the Cross, Dark Night of the Soul and The Ascent of Mount Carmel
Saint Ignatius of Loyola, The Spiritual Exercises
Saint Thérèse of Lisieux, Story of a Soul

Magisterial Teaching:

Catechism of the Catholic Church, §§ 2558-2865 (On Prayer)
Pope John Paul II, Novo Millennio Ineunte (2001)
Congregation for the Doctrine of Faith, Letter to Bishops on Christian Meditation (1989)

Theological Sources:

Garrigou-Lagrange, R., The Three Ages of the Interior Life
Tanquerey, A., The Spiritual Life
Poulain, A., The Graces of Interior Prayer
Merton, Thomas, Contemplative Prayer