chart2txt 0.6.0 → 0.7.1

package/dist/core/stelliums.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectStelliums = detectStelliums;
+exports.formatStellium = formatStellium;
+const astrology_1 = require("./astrology");
+const houseCalculations_1 = require("../utils/houseCalculations");
+const formatting_1 = require("../utils/formatting");
+/**
+ * Convert Point to PlanetPosition
+ */
+function pointToPlanetPosition(point, houseCusps) {
+    const sign = (0, astrology_1.getDegreeSign)(point.degree);
+    const house = houseCusps
+        ? (0, houseCalculations_1.getHouseForPoint)(point.degree, houseCusps) || undefined
+        : undefined;
+    return {
+        name: point.name,
+        degree: point.degree,
+        sign,
+        house,
+    };
+}
+/**
+ * Detect Stellium patterns (3+ planets in same sign or adjacent houses)
+ * This function requires house information and is specific to single-chart analysis
+ */
+function detectStelliums(planets, houseCusps, minPlanets = 3) {
+    const patterns = [];
+    // Group by sign
+    const signGroups = new Map();
+    planets.forEach((planet) => {
+        const sign = (0, astrology_1.getDegreeSign)(planet.degree);
+        if (!signGroups.has(sign)) {
+            signGroups.set(sign, []);
+        }
+        signGroups.get(sign).push(planet);
+    });
+    // Check sign-based stelliums
+    signGroups.forEach((planetsInSign, sign) => {
+        if (planetsInSign.length >= minPlanets) {
+            const planetPositions = planetsInSign.map((p) => pointToPlanetPosition(p, houseCusps));
+            const houses = planetPositions
+                .map((p) => p.house)
+                .filter((h) => h !== undefined);
+            const degrees = planetsInSign.map((p) => p.degree);
+            const span = Math.max(...degrees) - Math.min(...degrees);
+            patterns.push({
+                type: 'Stellium',
+                planets: planetPositions,
+                sign,
+                houses: [...new Set(houses)].sort(),
+                span,
+            });
+        }
+    });
+    // Check house-based stelliums (if house cusps available)
+    if (houseCusps) {
+        const houseGroups = new Map();
+        planets.forEach((planet) => {
+            const house = (0, houseCalculations_1.getHouseForPoint)(planet.degree, houseCusps);
+            if (house) {
+                if (!houseGroups.has(house)) {
+                    houseGroups.set(house, []);
+                }
+                houseGroups.get(house).push(planet);
+            }
+        });
+        houseGroups.forEach((planetsInHouse, house) => {
+            if (planetsInHouse.length >= minPlanets) {
+                const planetPositions = planetsInHouse.map((p) => pointToPlanetPosition(p, houseCusps));
+                const degrees = planetsInHouse.map((p) => p.degree);
+                const span = Math.max(...degrees) - Math.min(...degrees);
+                // Only add if not already covered by sign stellium
+                const existingSignStellium = patterns.find((p) => p.type === 'Stellium' &&
+                    p.planets.some((planet) => planetPositions.some((pp) => pp.name === planet.name)));
+                if (!existingSignStellium) {
+                    patterns.push({
+                        type: 'Stellium',
+                        planets: planetPositions,
+                        houses: [house],
+                        span,
+                    });
+                }
+            }
+        });
+    }
+    return patterns;
+}
+/**
+ * Format a Stellium pattern for display in compact format
+ */
+function formatStellium(pattern) {
+    const planetNames = pattern.planets.map((p) => p.name).join(', ');
+    let location = '';
+    if (pattern.sign) {
+        location = pattern.sign;
+    }
+    if (pattern.houses && pattern.houses.length > 0) {
+        const houseStr = pattern.houses.length === 1
+            ? `${(0, formatting_1.getOrdinal)(pattern.houses[0])} House`
+            : pattern.houses.map((h) => `${(0, formatting_1.getOrdinal)(h)} House`).join('-');
+        location += location ? ` (${houseStr})` : houseStr;
+    }
+    const locationStr = location ? ` in ${location}` : '';
+    return [
+        `Stellium (${pattern.span.toFixed(1)}°): ${planetNames}${locationStr}`,
+    ];
+}

package/dist/formatters/text/sections/aspectPatterns.d.ts

@@ -2,6 +2,8 @@ import { AspectPattern } from '../../../types';
 /**
  * Generates the [ASPECT PATTERNS] section of the chart output.
  * @param patterns Array of detected aspect patterns
+ * @param customTitle Optional custom title for the section
+ * @param showChartNames Whether to show chart names for planets (false for single charts, true for multi-chart)
  * @returns An array of strings for the output.
  */
-export declare function generateAspectPatternsOutput(patterns: AspectPattern[]): string[];
+export declare function generateAspectPatternsOutput(patterns: AspectPattern[], customTitle?: string, showChartNames?: boolean): string[];

package/dist/formatters/text/sections/aspectPatterns.js

@@ -6,164 +6,188 @@ const formatting_1 = require("../../../utils/formatting");
 /**
  * Format a planet position for display
  */
-function formatPlanetPosition(planet) {
+function formatPlanetPosition(planet, includeHouse = false, showChartNames = true) {
     const degInSign = Math.floor((0, astrology_1.getDegreeInSign)(planet.degree));
-    const houseStr = planet.house ? ` (${(0, formatting_1.getOrdinal)(planet.house)} house)` : '';
-    return `${planet.name} ${degInSign}° ${planet.sign}${houseStr}`;
+    const houseStr = includeHouse && planet.house ? ` (${(0, formatting_1.getOrdinal)(planet.house)} house)` : '';
+    const chartPrefix = showChartNames && planet.chartName ? `${planet.chartName}'s ` : '';
+    return `${chartPrefix}${planet.name} ${degInSign}° ${planet.sign}${houseStr}`;
 }
 /**
- * Format a T-Square pattern
+ * Format a T-Square pattern in compact format
  */
-function formatTSquare(pattern) {
+function formatTSquare(pattern, showChartNames = true) {
     if (pattern.type !== 'T-Square')
         return [];
-    const output = ['T-Square:'];
-    output.push(`  - Apex: ${formatPlanetPosition(pattern.apex)}`);
-    output.push(`  - Opposition: ${formatPlanetPosition(pattern.opposition[0])} - ${formatPlanetPosition(pattern.opposition[1])}`);
-    output.push(`  - Mode: ${pattern.mode}`);
-    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
-    output.push('');
-    return output;
+    const apex = formatPlanetPosition(pattern.apex, false, showChartNames);
+    const opp1 = formatPlanetPosition(pattern.opposition[0], false, showChartNames);
+    const opp2 = formatPlanetPosition(pattern.opposition[1], false, showChartNames);
+    return [
+        `T-Square (${pattern.mode}, ${pattern.averageOrb.toFixed(1)}°): ${apex} ← ${opp1} ↔ ${opp2}`,
+    ];
 }
 /**
- * Format a Grand Trine pattern
+ * Format a Grand Trine pattern in compact format
  */
-function formatGrandTrine(pattern) {
+function formatGrandTrine(pattern, showChartNames = true) {
     if (pattern.type !== 'Grand Trine')
         return [];
-    const output = ['Grand Trine:'];
-    pattern.planets.forEach((planet, index) => {
-        output.push(`  - Planet ${index + 1}: ${formatPlanetPosition(planet)}`);
-    });
-    output.push(`  - Element: ${pattern.element}`);
-    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
-    output.push('');
-    return output;
-}
-/**
- * Format a Stellium pattern
- */
-function formatStellium(pattern) {
-    if (pattern.type !== 'Stellium')
-        return [];
-    const output = ['Stellium:'];
-    const planetNames = pattern.planets.map((p) => p.name).join(', ');
-    output.push(`  - Planets: ${planetNames}`);
-    if (pattern.sign) {
-        output.push(`  - Sign: ${pattern.sign}`);
-    }
-    if (pattern.houses.length > 0) {
-        const houseStr = pattern.houses.length === 1
-            ? `${(0, formatting_1.getOrdinal)(pattern.houses[0])}`
-            : pattern.houses.map((h) => (0, formatting_1.getOrdinal)(h)).join('-');
-        output.push(`  - Houses: ${houseStr}`);
-    }
-    output.push(`  - Span: ${pattern.span.toFixed(1)}°`);
-    output.push('');
-    return output;
+    const planets = pattern.planets
+        .map((p) => formatPlanetPosition(p, false, showChartNames))
+        .join(' △ ');
+    return [
+        `Grand Trine (${pattern.element}, ${pattern.averageOrb.toFixed(1)}°): ${planets}`,
+    ];
 }
 /**
- * Format a Grand Cross pattern
+ * Format a Grand Cross pattern in compact format
  */
-function formatGrandCross(pattern) {
+function formatGrandCross(pattern, showChartNames = true) {
     if (pattern.type !== 'Grand Cross')
         return [];
-    const output = ['Grand Cross:'];
-    pattern.planets.forEach((planet, index) => {
-        output.push(`  - Planet ${index + 1}: ${formatPlanetPosition(planet)}`);
-    });
-    output.push(`  - Mode: ${pattern.mode}`);
-    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
-    output.push('');
-    return output;
+    const planets = pattern.planets
+        .map((p) => formatPlanetPosition(p, false, showChartNames))
+        .join(' ⨯ ');
+    return [
+        `Grand Cross (${pattern.mode}, ${pattern.averageOrb.toFixed(1)}°): ${planets}`,
+    ];
 }
 /**
- * Format a Yod pattern
+ * Format a Yod pattern in compact format
  */
-function formatYod(pattern) {
+function formatYod(pattern, showChartNames = true) {
     if (pattern.type !== 'Yod')
         return [];
-    const output = ['Yod:'];
-    output.push(`  - Apex: ${formatPlanetPosition(pattern.apex)}`);
-    output.push(`  - Base planet 1: ${formatPlanetPosition(pattern.base[0])}`);
-    output.push(`  - Base planet 2: ${formatPlanetPosition(pattern.base[1])}`);
-    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
-    output.push('');
-    return output;
+    const apex = formatPlanetPosition(pattern.apex, false, showChartNames);
+    const base1 = formatPlanetPosition(pattern.base[0], false, showChartNames);
+    const base2 = formatPlanetPosition(pattern.base[1], false, showChartNames);
+    return [
+        `Yod (${pattern.averageOrb.toFixed(1)}°): ${apex} ← ${base1} • ${base2}`,
+    ];
 }
 /**
- * Format a Mystic Rectangle pattern
+ * Format a Mystic Rectangle pattern in compact format
  */
-function formatMysticRectangle(pattern) {
+function formatMysticRectangle(pattern, showChartNames = true) {
     if (pattern.type !== 'Mystic Rectangle')
         return [];
-    const output = ['Mystic Rectangle:'];
-    output.push(`  - Opposition 1: ${formatPlanetPosition(pattern.oppositions[0][0])} - ${formatPlanetPosition(pattern.oppositions[0][1])}`);
-    output.push(`  - Opposition 2: ${formatPlanetPosition(pattern.oppositions[1][0])} - ${formatPlanetPosition(pattern.oppositions[1][1])}`);
-    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
-    output.push('');
-    return output;
+    const opp1_1 = formatPlanetPosition(pattern.oppositions[0][0], false, showChartNames);
+    const opp1_2 = formatPlanetPosition(pattern.oppositions[0][1], false, showChartNames);
+    const opp2_1 = formatPlanetPosition(pattern.oppositions[1][0], false, showChartNames);
+    const opp2_2 = formatPlanetPosition(pattern.oppositions[1][1], false, showChartNames);
+    return [
+        `Mystic Rectangle (${pattern.averageOrb.toFixed(1)}°): ${opp1_1} ↔ ${opp1_2} | ${opp2_1} ↔ ${opp2_2}`,
+    ];
 }
 /**
- * Format a Kite pattern
+ * Format a Kite pattern in compact format
  */
-function formatKite(pattern) {
+function formatKite(pattern, showChartNames = true) {
     if (pattern.type !== 'Kite')
         return [];
-    const output = ['Kite:'];
-    const grandTrineStr = pattern.grandTrine.map((p) => p.name).join(', ');
-    output.push(`  - Grand Trine planets: ${grandTrineStr}`);
-    output.push(`  - Opposition planet: ${formatPlanetPosition(pattern.opposition)}`);
-    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
-    output.push('');
-    return output;
+    const grandTrineStr = pattern.grandTrine
+        .map((p) => formatPlanetPosition(p, false, showChartNames))
+        .join(' △ ');
+    const oppositionPlanet = formatPlanetPosition(pattern.opposition, false, showChartNames);
+    // Get the element from the first planet's sign for context
+    const element = pattern.grandTrine[0].sign
+        ? getElementFromSign(pattern.grandTrine[0].sign)
+        : '';
+    const elementStr = element ? `${element}, ` : '';
+    return [
+        `Kite (${elementStr}${pattern.averageOrb.toFixed(1)}°): [${grandTrineStr}] ← ${oppositionPlanet}`,
+    ];
+}
+/**
+ * Helper function to get element from sign
+ */
+function getElementFromSign(sign) {
+    const fireSigns = ['Aries', 'Leo', 'Sagittarius'];
+    const earthSigns = ['Taurus', 'Virgo', 'Capricorn'];
+    const airSigns = ['Gemini', 'Libra', 'Aquarius'];
+    const waterSigns = ['Cancer', 'Scorpio', 'Pisces'];
+    if (fireSigns.includes(sign))
+        return 'Fire';
+    if (earthSigns.includes(sign))
+        return 'Earth';
+    if (airSigns.includes(sign))
+        return 'Air';
+    if (waterSigns.includes(sign))
+        return 'Water';
+    return '';
+}
+/**
+ * Check if a Grand Trine is part of any Kite pattern within the same analysis context
+ * Uses exact planet identity matching (chart name + planet name + degree)
+ */
+function isGrandTrinePartOfKite(grandTrine, patterns) {
+    if (grandTrine.type !== 'Grand Trine')
+        return false;
+    return patterns.some((pattern) => {
+        if (pattern.type !== 'Kite')
+            return false;
+        // Create unique identifiers for exact planet identity matching
+        const createPlanetId = (p) => `${p.chartName || ''}-${p.name}-${p.degree}`;
+        const kiteGrandTrinePlanets = pattern.grandTrine.map(createPlanetId);
+        const grandTrinePlanets = grandTrine.planets.map(createPlanetId);
+        // Check if the sets of planets are identical (same planets, same count)
+        return (kiteGrandTrinePlanets.length === grandTrinePlanets.length &&
+            kiteGrandTrinePlanets.every((kp) => grandTrinePlanets.includes(kp)));
+    });
 }
 /**
  * Generates the [ASPECT PATTERNS] section of the chart output.
  * @param patterns Array of detected aspect patterns
+ * @param customTitle Optional custom title for the section
+ * @param showChartNames Whether to show chart names for planets (false for single charts, true for multi-chart)
  * @returns An array of strings for the output.
  */
-function generateAspectPatternsOutput(patterns) {
-    const output = ['[ASPECT PATTERNS]'];
+function generateAspectPatternsOutput(patterns, customTitle, showChartNames = true) {
+    const output = [
+        customTitle ? `[ASPECT PATTERNS: ${customTitle}]` : '[ASPECT PATTERNS]',
+    ];
     if (patterns.length === 0) {
-        output.push('No aspect patterns detected.');
+        output.push('No T-Squares detected.');
+        output.push('No Grand Trines detected.');
         return output;
     }
+    // Filter out Grand Trines that are part of Kites to avoid duplication
+    const filteredPatterns = patterns.filter((pattern) => {
+        if (pattern.type === 'Grand Trine') {
+            return !isGrandTrinePartOfKite(pattern, patterns);
+        }
+        return true;
+    });
     // Sort patterns by type for consistent output
     const sortOrder = [
         'T-Square',
         'Grand Trine',
         'Grand Cross',
-        'Stellium',
         'Yod',
         'Mystic Rectangle',
         'Kite',
     ];
-    const sortedPatterns = patterns.sort((a, b) => {
+    const sortedPatterns = filteredPatterns.sort((a, b) => {
         return sortOrder.indexOf(a.type) - sortOrder.indexOf(b.type);
     });
     sortedPatterns.forEach((pattern) => {
         switch (pattern.type) {
             case 'T-Square':
-                output.push(...formatTSquare(pattern));
+                output.push(...formatTSquare(pattern, showChartNames));
                 break;
             case 'Grand Trine':
-                output.push(...formatGrandTrine(pattern));
-                break;
-            case 'Stellium':
-                output.push(...formatStellium(pattern));
+                output.push(...formatGrandTrine(pattern, showChartNames));
                 break;
             case 'Grand Cross':
-                output.push(...formatGrandCross(pattern));
+                output.push(...formatGrandCross(pattern, showChartNames));
                 break;
             case 'Yod':
-                output.push(...formatYod(pattern));
+                output.push(...formatYod(pattern, showChartNames));
                 break;
             case 'Mystic Rectangle':
-                output.push(...formatMysticRectangle(pattern));
+                output.push(...formatMysticRectangle(pattern, showChartNames));
                 break;
             case 'Kite':
-                output.push(...formatKite(pattern));
+                output.push(...formatKite(pattern, showChartNames));
                 break;
         }
     });

package/dist/formatters/text/sections/aspects.d.ts

@@ -1,14 +1,11 @@
 import { AspectData } from '../../../types';
-import { ChartSettings } from '../../../config/ChartSettings';
 /**
- * Generates aspect sections (e.g., [ASPECTS], [PLANET-PLANET ASPECTS], [TRANSIT ASPECTS: Name]).
+ * Generates aspect sections from a pre-grouped map of aspects.
  * @param title The main title for this aspect block (e.g., "[ASPECTS]").
- * @param aspects Array of calculated aspect data.
- * @param settings The chart settings, containing aspect categories.
+ * @param groupedAspects A map of category names to aspect data arrays.
  * @param p1ChartName Optional: Name of the first chart/entity for synastry/transit aspects.
  * @param p2ChartName Optional: Name of the second chart/entity for synastry aspects.
  * @param p2IsTransit Optional: Boolean indicating if p2 represents transiting points.
  * @returns An array of strings for the output.
  */
-export declare function generateAspectsOutput(title: string, aspects: AspectData[], settings: ChartSettings, p1ChartName?: string, p2ChartName?: string, // For synastry, this is the second person's name. For transits, it could be "Current" or the transit chart name.
-p2IsTransit?: boolean): string[];
+export declare function generateAspectsOutput(title: string, groupedAspects?: Map<string, AspectData[]>, p1ChartName?: string, p2ChartName?: string, p2IsTransit?: boolean): string[];

package/dist/formatters/text/sections/aspects.js

@@ -2,66 +2,49 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateAspectsOutput = generateAspectsOutput;
 /**
- * Generates aspect sections (e.g., [ASPECTS], [PLANET-PLANET ASPECTS], [TRANSIT ASPECTS: Name]).
+ * Generates the output for a single aspect line.
+ * @param asp The aspect data.
+ * @param p1ChartName Optional name of the first chart.
+ * @param p2ChartName Optional name of the second chart.
+ * @param p2IsTransit Optional flag if the second chart is for transits.
+ * @returns A formatted string for the aspect.
+ */
+function formatAspectLine(asp, p1ChartName, p2ChartName, p2IsTransit = false) {
+    const p1NameStr = p1ChartName
+        ? `${p1ChartName}'s ${asp.planetA}`
+        : asp.planetA;
+    let p2NameStr = asp.planetB;
+    if (p2IsTransit) {
+        p2NameStr = `transiting ${asp.planetB}`;
+    }
+    else if (p2ChartName) {
+        p2NameStr = `${p2ChartName}'s ${asp.planetB}`;
+    }
+    const applicationStr = asp.application && asp.application !== 'exact'
+        ? ` (${asp.application})`
+        : '';
+    return `${p1NameStr} ${asp.aspectType} ${p2NameStr}: ${asp.orb.toFixed(1)}°${applicationStr}`;
+}
+/**
+ * Generates aspect sections from a pre-grouped map of aspects.
  * @param title The main title for this aspect block (e.g., "[ASPECTS]").
- * @param aspects Array of calculated aspect data.
- * @param settings The chart settings, containing aspect categories.
+ * @param groupedAspects A map of category names to aspect data arrays.
  * @param p1ChartName Optional: Name of the first chart/entity for synastry/transit aspects.
  * @param p2ChartName Optional: Name of the second chart/entity for synastry aspects.
  * @param p2IsTransit Optional: Boolean indicating if p2 represents transiting points.
  * @returns An array of strings for the output.
  */
-function generateAspectsOutput(title, aspects, settings, p1ChartName, p2ChartName, // For synastry, this is the second person's name. For transits, it could be "Current" or the transit chart name.
-p2IsTransit = false) {
+function generateAspectsOutput(title, groupedAspects, p1ChartName, p2ChartName, p2IsTransit = false) {
     const output = [title];
-    let aspectsFoundInAnyCategory = false;
-    settings.aspectCategories.forEach((category) => {
-        const categoryAspects = aspects.filter((asp) => {
-            const orb = asp.orb;
-            const minOrbCheck = category.minOrb === undefined ? true : orb > category.minOrb;
-            const maxOrbCheck = orb <= category.maxOrb;
-            return minOrbCheck && maxOrbCheck;
-        });
-        if (categoryAspects.length > 0) {
-            aspectsFoundInAnyCategory = true;
-            let orbRangeStr = `orb under ${category.maxOrb.toFixed(1)}°`;
-            if (category.minOrb !== undefined) {
-                // Ensure minOrb is less than maxOrb for sensible range string
-                orbRangeStr =
-                    category.minOrb < category.maxOrb
-                        ? `orb ${category.minOrb.toFixed(1)}-${category.maxOrb.toFixed(1)}°`
-                        : `orb over ${category.minOrb.toFixed(1)}° & under ${category.maxOrb.toFixed(1)}°`; // Fallback for unusual category def
-            }
-            output.push(`[${category.name}: ${orbRangeStr}]`);
-            categoryAspects.sort((a, b) => a.orb - b.orb); // Sort by orb tightness
-            categoryAspects.forEach((asp) => {
-                const p1NameStr = p1ChartName
-                    ? `${p1ChartName}'s ${asp.planetA}`
-                    : asp.planetA;
-                let p2NameStr = asp.planetB;
-                if (p2IsTransit) {
-                    // For "Transit Aspects: Alice", p1 is Alice, p2 is the transiting planet.
-                    // Example: "Alice's Mercury opposition transiting Neptune: 0.3°" - here p2ChartName is not used for the planet itself.
-                    p2NameStr = `transiting ${asp.planetB}`;
-                }
-                else if (p2ChartName) {
-                    // For "Synastry: Alice-Bob", "Planet-Planet Aspects"
-                    // Example: "Alice's Mercury opposition Bob's Neptune: 0.3°"
-                    p2NameStr = `${p2ChartName}'s ${asp.planetB}`;
-                }
-                // If neither p2IsTransit nor p2ChartName, it's a natal chart aspect, e.g. "Venus opposition Pluto: 1.2°"
-                const applicationStr = asp.application && asp.application !== 'exact'
-                    ? ` (${asp.application})`
-                    : '';
-                output.push(`${p1NameStr} ${asp.aspectType} ${p2NameStr}: ${asp.orb.toFixed(1)}°${applicationStr}`);
-            });
-        }
-    });
-    if (!aspectsFoundInAnyCategory && aspects.length > 0) {
-        output.push('No aspects within defined categories.');
-    }
-    else if (aspects.length === 0) {
+    if (!groupedAspects || groupedAspects.size === 0) {
         output.push('None');
+        return output;
     }
+    groupedAspects.forEach((categoryAspects, categoryName) => {
+        output.push(categoryName); // The category name is the pre-formatted key from the map
+        categoryAspects.forEach((asp) => {
+            output.push(formatAspectLine(asp, p1ChartName, p2ChartName, p2IsTransit));
+        });
+    });
     return output;
 }

package/dist/formatters/text/sections/dispositors.d.ts

@@ -1,7 +1,8 @@
-import { Point } from '../../../types';
 /**
  * Generates the [DISPOSITOR TREE] section of the chart output.
- * @param planets Array of planet points.
+ * @param dispositors A map of planet names to their full dispositor chain string, or summary data.
  * @returns An array of strings for the output.
  */
-export declare function generateDispositorsOutput(planets: Point[]): string[];
+export declare function generateDispositorsOutput(dispositors: {
+    [key: string]: string;
+}): string[];

package/dist/formatters/text/sections/dispositors.js

@@ -1,20 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDispositorsOutput = generateDispositorsOutput;
-const dispositors_1 = require("../../../core/dispositors");
 /**
  * Generates the [DISPOSITOR TREE] section of the chart output.
- * @param planets Array of planet points.
+ * @param dispositors A map of planet names to their full dispositor chain string, or summary data.
  * @returns An array of strings for the output.
  */
-function generateDispositorsOutput(planets) {
+function generateDispositorsOutput(dispositors) {
+    // Check if this is summary format (finals mode)
+    if (dispositors['summary']) {
+        return [`[DISPOSITORS] ${dispositors['summary']}`];
+    }
+    // Traditional format
     const output = ['[DISPOSITOR TREE]'];
-    if (planets.length === 0) {
-        output.push('No planets available for dispositor analysis.');
+    if (Object.keys(dispositors).length === 0) {
+        output.push('No dispositor data available.');
         return output;
     }
-    const analysis = (0, dispositors_1.analyzeDispositors)(planets);
-    const formattedAnalysis = (0, dispositors_1.formatDispositorAnalysis)(analysis);
-    output.push(...formattedAnalysis);
+    for (const planet in dispositors) {
+        output.push(dispositors[planet]);
+    }
     return output;
 }

package/dist/formatters/text/sections/houseOverlays.d.ts

@@ -1,10 +1,15 @@
-import { ChartData } from '../../../types';
-import { ChartSettings } from '../../../config/ChartSettings';
 /**
  * Generates the [HOUSE OVERLAYS] section for synastry.
- * @param chart1 The first chart data.
- * @param chart2 The second chart data.
- * @param settings The chart settings, containing the house system calculator.
+ * @param overlays The pre-calculated house overlay data.
+ * @param chart1Name The name of the first chart.
+ * @param chart2Name The name of the second chart.
  * @returns An array of strings for the output.
  */
-export declare function generateHouseOverlaysOutput(chart1: ChartData, chart2: ChartData, settings: ChartSettings): string[];
+export declare function generateHouseOverlaysOutput(overlays: {
+    chart1InChart2Houses: {
+        [key: string]: number;
+    };
+    chart2InChart1Houses: {
+        [key: string]: number;
+    };
+}, chart1Name: string, chart2Name: string): string[];