caelus-mcp 0.1.0

package/dist/src/server.d.ts

@@ -0,0 +1,956 @@
+#!/usr/bin/env node
+/**
+ * caelus-mcp -- MCP server for the caelus ephemeris engine.
+ *
+ * Design (per 2026 MCP practice): one bounded context (chart computation),
+ * a small curated tool surface (6 outcome-level tools, not API wrappers),
+ * and token-frugal outputs (positions to 0.01 deg, terse keys, no prose --
+ * the model does the interpreting, the server does the math).
+ *
+ * Transport: stdio (this file). The same buildServer() can be mounted on
+ * Streamable HTTP for the hosted ephemengine.com deployment.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+export declare const chartOut: z.ZodObject<{
+    utc: z.ZodString;
+    houses: z.ZodEnum<["placidus", "whole_sign", "equal", "porphyry"]>;
+    houses_requested: z.ZodOptional<z.ZodEnum<["placidus", "whole_sign", "equal", "porphyry"]>>;
+    houses_fallback_reason: z.ZodOptional<z.ZodString>;
+    bodies: z.ZodRecord<z.ZodString, z.ZodObject<{
+        lon: z.ZodNumber;
+        pos: z.ZodString;
+        house: z.ZodNumber;
+        speed: z.ZodNumber;
+        rx: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        lon: number;
+        pos: string;
+        house: number;
+        speed: number;
+        rx?: boolean | undefined;
+    }, {
+        lon: number;
+        pos: string;
+        house: number;
+        speed: number;
+        rx?: boolean | undefined;
+    }>>;
+    angles: z.ZodObject<{
+        asc: z.ZodNumber;
+        ascPos: z.ZodString;
+        mc: z.ZodNumber;
+        mcPos: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        asc: number;
+        ascPos: string;
+        mc: number;
+        mcPos: string;
+    }, {
+        asc: number;
+        ascPos: string;
+        mc: number;
+        mcPos: string;
+    }>;
+    cusps: z.ZodArray<z.ZodNumber, "many">;
+    aspects: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    utc: string;
+    houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+    bodies: Record<string, {
+        lon: number;
+        pos: string;
+        house: number;
+        speed: number;
+        rx?: boolean | undefined;
+    }>;
+    angles: {
+        asc: number;
+        ascPos: string;
+        mc: number;
+        mcPos: string;
+    };
+    cusps: number[];
+    aspects: string[];
+    houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+    houses_fallback_reason?: string | undefined;
+}, {
+    utc: string;
+    houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+    bodies: Record<string, {
+        lon: number;
+        pos: string;
+        house: number;
+        speed: number;
+        rx?: boolean | undefined;
+    }>;
+    angles: {
+        asc: number;
+        ascPos: string;
+        mc: number;
+        mcPos: string;
+    };
+    cusps: number[];
+    aspects: string[];
+    houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+    houses_fallback_reason?: string | undefined;
+}>;
+export declare const transitsOut: z.ZodObject<{
+    transit_utc: z.ZodString;
+    transiting: z.ZodRecord<z.ZodString, z.ZodObject<{
+        pos: z.ZodString;
+        natal_house: z.ZodNumber;
+        rx: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        pos: string;
+        natal_house: number;
+        rx?: boolean | undefined;
+    }, {
+        pos: string;
+        natal_house: number;
+        rx?: boolean | undefined;
+    }>>;
+    aspects_to_natal: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    transit_utc: string;
+    transiting: Record<string, {
+        pos: string;
+        natal_house: number;
+        rx?: boolean | undefined;
+    }>;
+    aspects_to_natal: string[];
+}, {
+    transit_utc: string;
+    transiting: Record<string, {
+        pos: string;
+        natal_house: number;
+        rx?: boolean | undefined;
+    }>;
+    aspects_to_natal: string[];
+}>;
+export declare const synastryOut: z.ZodObject<{
+    a: z.ZodObject<{
+        utc: z.ZodString;
+        houses: z.ZodEnum<["placidus", "whole_sign", "equal", "porphyry"]>;
+        houses_requested: z.ZodOptional<z.ZodEnum<["placidus", "whole_sign", "equal", "porphyry"]>>;
+        houses_fallback_reason: z.ZodOptional<z.ZodString>;
+        bodies: z.ZodRecord<z.ZodString, z.ZodObject<{
+            lon: z.ZodNumber;
+            pos: z.ZodString;
+            house: z.ZodNumber;
+            speed: z.ZodNumber;
+            rx: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }>>;
+        angles: z.ZodObject<{
+            asc: z.ZodNumber;
+            ascPos: z.ZodString;
+            mc: z.ZodNumber;
+            mcPos: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        }, {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        }>;
+        cusps: z.ZodArray<z.ZodNumber, "many">;
+        aspects: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        utc: string;
+        houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+        bodies: Record<string, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }>;
+        angles: {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        };
+        cusps: number[];
+        aspects: string[];
+        houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+        houses_fallback_reason?: string | undefined;
+    }, {
+        utc: string;
+        houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+        bodies: Record<string, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }>;
+        angles: {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        };
+        cusps: number[];
+        aspects: string[];
+        houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+        houses_fallback_reason?: string | undefined;
+    }>;
+    b: z.ZodObject<{
+        utc: z.ZodString;
+        houses: z.ZodEnum<["placidus", "whole_sign", "equal", "porphyry"]>;
+        houses_requested: z.ZodOptional<z.ZodEnum<["placidus", "whole_sign", "equal", "porphyry"]>>;
+        houses_fallback_reason: z.ZodOptional<z.ZodString>;
+        bodies: z.ZodRecord<z.ZodString, z.ZodObject<{
+            lon: z.ZodNumber;
+            pos: z.ZodString;
+            house: z.ZodNumber;
+            speed: z.ZodNumber;
+            rx: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }>>;
+        angles: z.ZodObject<{
+            asc: z.ZodNumber;
+            ascPos: z.ZodString;
+            mc: z.ZodNumber;
+            mcPos: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        }, {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        }>;
+        cusps: z.ZodArray<z.ZodNumber, "many">;
+        aspects: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        utc: string;
+        houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+        bodies: Record<string, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }>;
+        angles: {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        };
+        cusps: number[];
+        aspects: string[];
+        houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+        houses_fallback_reason?: string | undefined;
+    }, {
+        utc: string;
+        houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+        bodies: Record<string, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }>;
+        angles: {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        };
+        cusps: number[];
+        aspects: string[];
+        houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+        houses_fallback_reason?: string | undefined;
+    }>;
+    inter_aspects: z.ZodArray<z.ZodString, "many">;
+    a_planets_in_b_houses: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    b_planets_in_a_houses: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    a: {
+        utc: string;
+        houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+        bodies: Record<string, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }>;
+        angles: {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        };
+        cusps: number[];
+        aspects: string[];
+        houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+        houses_fallback_reason?: string | undefined;
+    };
+    b: {
+        utc: string;
+        houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+        bodies: Record<string, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }>;
+        angles: {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        };
+        cusps: number[];
+        aspects: string[];
+        houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+        houses_fallback_reason?: string | undefined;
+    };
+    inter_aspects: string[];
+    a_planets_in_b_houses: Record<string, number>;
+    b_planets_in_a_houses: Record<string, number>;
+}, {
+    a: {
+        utc: string;
+        houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+        bodies: Record<string, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }>;
+        angles: {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        };
+        cusps: number[];
+        aspects: string[];
+        houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+        houses_fallback_reason?: string | undefined;
+    };
+    b: {
+        utc: string;
+        houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+        bodies: Record<string, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }>;
+        angles: {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        };
+        cusps: number[];
+        aspects: string[];
+        houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+        houses_fallback_reason?: string | undefined;
+    };
+    inter_aspects: string[];
+    a_planets_in_b_houses: Record<string, number>;
+    b_planets_in_a_houses: Record<string, number>;
+}>;
+export declare const findAspectDatesOut: z.ZodObject<{
+    query: z.ZodString;
+    hits: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    hits: string[];
+}, {
+    query: string;
+    hits: string[];
+}>;
+export declare const rectificationGridOut: z.ZodObject<{
+    date: z.ZodString;
+    lat: z.ZodNumber;
+    lon: z.ZodNumber;
+    asc_sign_changes: z.ZodArray<z.ZodString, "many">;
+    grid: z.ZodArray<z.ZodObject<{
+        utc: z.ZodString;
+        asc: z.ZodString;
+        mc: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        utc: string;
+        asc: string;
+        mc: string;
+    }, {
+        utc: string;
+        asc: string;
+        mc: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    lon: number;
+    date: string;
+    lat: number;
+    asc_sign_changes: string[];
+    grid: {
+        utc: string;
+        asc: string;
+        mc: string;
+    }[];
+}, {
+    lon: number;
+    date: string;
+    lat: number;
+    asc_sign_changes: string[];
+    grid: {
+        utc: string;
+        asc: string;
+        mc: string;
+    }[];
+}>;
+export declare const OUTPUT_SCHEMAS: {
+    readonly natal_chart: z.ZodObject<{
+        utc: z.ZodString;
+        houses: z.ZodEnum<["placidus", "whole_sign", "equal", "porphyry"]>;
+        houses_requested: z.ZodOptional<z.ZodEnum<["placidus", "whole_sign", "equal", "porphyry"]>>;
+        houses_fallback_reason: z.ZodOptional<z.ZodString>;
+        bodies: z.ZodRecord<z.ZodString, z.ZodObject<{
+            lon: z.ZodNumber;
+            pos: z.ZodString;
+            house: z.ZodNumber;
+            speed: z.ZodNumber;
+            rx: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }>>;
+        angles: z.ZodObject<{
+            asc: z.ZodNumber;
+            ascPos: z.ZodString;
+            mc: z.ZodNumber;
+            mcPos: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        }, {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        }>;
+        cusps: z.ZodArray<z.ZodNumber, "many">;
+        aspects: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        utc: string;
+        houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+        bodies: Record<string, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }>;
+        angles: {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        };
+        cusps: number[];
+        aspects: string[];
+        houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+        houses_fallback_reason?: string | undefined;
+    }, {
+        utc: string;
+        houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+        bodies: Record<string, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }>;
+        angles: {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        };
+        cusps: number[];
+        aspects: string[];
+        houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+        houses_fallback_reason?: string | undefined;
+    }>;
+    readonly current_sky: z.ZodObject<{
+        utc: z.ZodString;
+        houses: z.ZodEnum<["placidus", "whole_sign", "equal", "porphyry"]>;
+        houses_requested: z.ZodOptional<z.ZodEnum<["placidus", "whole_sign", "equal", "porphyry"]>>;
+        houses_fallback_reason: z.ZodOptional<z.ZodString>;
+        bodies: z.ZodRecord<z.ZodString, z.ZodObject<{
+            lon: z.ZodNumber;
+            pos: z.ZodString;
+            house: z.ZodNumber;
+            speed: z.ZodNumber;
+            rx: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }>>;
+        angles: z.ZodObject<{
+            asc: z.ZodNumber;
+            ascPos: z.ZodString;
+            mc: z.ZodNumber;
+            mcPos: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        }, {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        }>;
+        cusps: z.ZodArray<z.ZodNumber, "many">;
+        aspects: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        utc: string;
+        houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+        bodies: Record<string, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }>;
+        angles: {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        };
+        cusps: number[];
+        aspects: string[];
+        houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+        houses_fallback_reason?: string | undefined;
+    }, {
+        utc: string;
+        houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+        bodies: Record<string, {
+            lon: number;
+            pos: string;
+            house: number;
+            speed: number;
+            rx?: boolean | undefined;
+        }>;
+        angles: {
+            asc: number;
+            ascPos: string;
+            mc: number;
+            mcPos: string;
+        };
+        cusps: number[];
+        aspects: string[];
+        houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+        houses_fallback_reason?: string | undefined;
+    }>;
+    readonly transits: z.ZodObject<{
+        transit_utc: z.ZodString;
+        transiting: z.ZodRecord<z.ZodString, z.ZodObject<{
+            pos: z.ZodString;
+            natal_house: z.ZodNumber;
+            rx: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            pos: string;
+            natal_house: number;
+            rx?: boolean | undefined;
+        }, {
+            pos: string;
+            natal_house: number;
+            rx?: boolean | undefined;
+        }>>;
+        aspects_to_natal: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        transit_utc: string;
+        transiting: Record<string, {
+            pos: string;
+            natal_house: number;
+            rx?: boolean | undefined;
+        }>;
+        aspects_to_natal: string[];
+    }, {
+        transit_utc: string;
+        transiting: Record<string, {
+            pos: string;
+            natal_house: number;
+            rx?: boolean | undefined;
+        }>;
+        aspects_to_natal: string[];
+    }>;
+    readonly synastry: z.ZodObject<{
+        a: z.ZodObject<{
+            utc: z.ZodString;
+            houses: z.ZodEnum<["placidus", "whole_sign", "equal", "porphyry"]>;
+            houses_requested: z.ZodOptional<z.ZodEnum<["placidus", "whole_sign", "equal", "porphyry"]>>;
+            houses_fallback_reason: z.ZodOptional<z.ZodString>;
+            bodies: z.ZodRecord<z.ZodString, z.ZodObject<{
+                lon: z.ZodNumber;
+                pos: z.ZodString;
+                house: z.ZodNumber;
+                speed: z.ZodNumber;
+                rx: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                lon: number;
+                pos: string;
+                house: number;
+                speed: number;
+                rx?: boolean | undefined;
+            }, {
+                lon: number;
+                pos: string;
+                house: number;
+                speed: number;
+                rx?: boolean | undefined;
+            }>>;
+            angles: z.ZodObject<{
+                asc: z.ZodNumber;
+                ascPos: z.ZodString;
+                mc: z.ZodNumber;
+                mcPos: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                asc: number;
+                ascPos: string;
+                mc: number;
+                mcPos: string;
+            }, {
+                asc: number;
+                ascPos: string;
+                mc: number;
+                mcPos: string;
+            }>;
+            cusps: z.ZodArray<z.ZodNumber, "many">;
+            aspects: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            utc: string;
+            houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+            bodies: Record<string, {
+                lon: number;
+                pos: string;
+                house: number;
+                speed: number;
+                rx?: boolean | undefined;
+            }>;
+            angles: {
+                asc: number;
+                ascPos: string;
+                mc: number;
+                mcPos: string;
+            };
+            cusps: number[];
+            aspects: string[];
+            houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+            houses_fallback_reason?: string | undefined;
+        }, {
+            utc: string;
+            houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+            bodies: Record<string, {
+                lon: number;
+                pos: string;
+                house: number;
+                speed: number;
+                rx?: boolean | undefined;
+            }>;
+            angles: {
+                asc: number;
+                ascPos: string;
+                mc: number;
+                mcPos: string;
+            };
+            cusps: number[];
+            aspects: string[];
+            houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+            houses_fallback_reason?: string | undefined;
+        }>;
+        b: z.ZodObject<{
+            utc: z.ZodString;
+            houses: z.ZodEnum<["placidus", "whole_sign", "equal", "porphyry"]>;
+            houses_requested: z.ZodOptional<z.ZodEnum<["placidus", "whole_sign", "equal", "porphyry"]>>;
+            houses_fallback_reason: z.ZodOptional<z.ZodString>;
+            bodies: z.ZodRecord<z.ZodString, z.ZodObject<{
+                lon: z.ZodNumber;
+                pos: z.ZodString;
+                house: z.ZodNumber;
+                speed: z.ZodNumber;
+                rx: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                lon: number;
+                pos: string;
+                house: number;
+                speed: number;
+                rx?: boolean | undefined;
+            }, {
+                lon: number;
+                pos: string;
+                house: number;
+                speed: number;
+                rx?: boolean | undefined;
+            }>>;
+            angles: z.ZodObject<{
+                asc: z.ZodNumber;
+                ascPos: z.ZodString;
+                mc: z.ZodNumber;
+                mcPos: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                asc: number;
+                ascPos: string;
+                mc: number;
+                mcPos: string;
+            }, {
+                asc: number;
+                ascPos: string;
+                mc: number;
+                mcPos: string;
+            }>;
+            cusps: z.ZodArray<z.ZodNumber, "many">;
+            aspects: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            utc: string;
+            houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+            bodies: Record<string, {
+                lon: number;
+                pos: string;
+                house: number;
+                speed: number;
+                rx?: boolean | undefined;
+            }>;
+            angles: {
+                asc: number;
+                ascPos: string;
+                mc: number;
+                mcPos: string;
+            };
+            cusps: number[];
+            aspects: string[];
+            houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+            houses_fallback_reason?: string | undefined;
+        }, {
+            utc: string;
+            houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+            bodies: Record<string, {
+                lon: number;
+                pos: string;
+                house: number;
+                speed: number;
+                rx?: boolean | undefined;
+            }>;
+            angles: {
+                asc: number;
+                ascPos: string;
+                mc: number;
+                mcPos: string;
+            };
+            cusps: number[];
+            aspects: string[];
+            houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+            houses_fallback_reason?: string | undefined;
+        }>;
+        inter_aspects: z.ZodArray<z.ZodString, "many">;
+        a_planets_in_b_houses: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        b_planets_in_a_houses: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        a: {
+            utc: string;
+            houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+            bodies: Record<string, {
+                lon: number;
+                pos: string;
+                house: number;
+                speed: number;
+                rx?: boolean | undefined;
+            }>;
+            angles: {
+                asc: number;
+                ascPos: string;
+                mc: number;
+                mcPos: string;
+            };
+            cusps: number[];
+            aspects: string[];
+            houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+            houses_fallback_reason?: string | undefined;
+        };
+        b: {
+            utc: string;
+            houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+            bodies: Record<string, {
+                lon: number;
+                pos: string;
+                house: number;
+                speed: number;
+                rx?: boolean | undefined;
+            }>;
+            angles: {
+                asc: number;
+                ascPos: string;
+                mc: number;
+                mcPos: string;
+            };
+            cusps: number[];
+            aspects: string[];
+            houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+            houses_fallback_reason?: string | undefined;
+        };
+        inter_aspects: string[];
+        a_planets_in_b_houses: Record<string, number>;
+        b_planets_in_a_houses: Record<string, number>;
+    }, {
+        a: {
+            utc: string;
+            houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+            bodies: Record<string, {
+                lon: number;
+                pos: string;
+                house: number;
+                speed: number;
+                rx?: boolean | undefined;
+            }>;
+            angles: {
+                asc: number;
+                ascPos: string;
+                mc: number;
+                mcPos: string;
+            };
+            cusps: number[];
+            aspects: string[];
+            houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+            houses_fallback_reason?: string | undefined;
+        };
+        b: {
+            utc: string;
+            houses: "placidus" | "whole_sign" | "equal" | "porphyry";
+            bodies: Record<string, {
+                lon: number;
+                pos: string;
+                house: number;
+                speed: number;
+                rx?: boolean | undefined;
+            }>;
+            angles: {
+                asc: number;
+                ascPos: string;
+                mc: number;
+                mcPos: string;
+            };
+            cusps: number[];
+            aspects: string[];
+            houses_requested?: "placidus" | "whole_sign" | "equal" | "porphyry" | undefined;
+            houses_fallback_reason?: string | undefined;
+        };
+        inter_aspects: string[];
+        a_planets_in_b_houses: Record<string, number>;
+        b_planets_in_a_houses: Record<string, number>;
+    }>;
+    readonly find_aspect_dates: z.ZodObject<{
+        query: z.ZodString;
+        hits: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        query: string;
+        hits: string[];
+    }, {
+        query: string;
+        hits: string[];
+    }>;
+    readonly rectification_grid: z.ZodObject<{
+        date: z.ZodString;
+        lat: z.ZodNumber;
+        lon: z.ZodNumber;
+        asc_sign_changes: z.ZodArray<z.ZodString, "many">;
+        grid: z.ZodArray<z.ZodObject<{
+            utc: z.ZodString;
+            asc: z.ZodString;
+            mc: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            utc: string;
+            asc: string;
+            mc: string;
+        }, {
+            utc: string;
+            asc: string;
+            mc: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        lon: number;
+        date: string;
+        lat: number;
+        asc_sign_changes: string[];
+        grid: {
+            utc: string;
+            asc: string;
+            mc: string;
+        }[];
+    }, {
+        lon: number;
+        date: string;
+        lat: number;
+        asc_sign_changes: string[];
+        grid: {
+            utc: string;
+            asc: string;
+            mc: string;
+        }[];
+    }>;
+};
+export declare function buildServer(): McpServer;

package/dist/src/server.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+/**
+ * caelus-mcp -- MCP server for the caelus ephemeris engine.
+ *
+ * Design (per 2026 MCP practice): one bounded context (chart computation),
+ * a small curated tool surface (6 outcome-level tools, not API wrappers),
+ * and token-frugal outputs (positions to 0.01 deg, terse keys, no prose --
+ * the model does the interpreting, the server does the math).
+ *
+ * Transport: stdio (this file). The same buildServer() can be mounted on
+ * Streamable HTTP for the hosted ephemengine.com deployment.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+import { Engine, BODIES, julianDay, mod } from "caelus";
+import { loadNodeData } from "caelus/node";
+const require = createRequire(import.meta.url);
+const DATA_DIR = process.env.CAELUS_DATA
+    ?? join(dirname(require.resolve("caelus/package.json")), "data");
+const engine = new Engine(loadNodeData(DATA_DIR, "embedded", "full"));
+// ---------------------------------------------------------------- helpers
+const r2 = (x) => Math.round(x * 100) / 100;
+const SIGNS = ["Ari", "Tau", "Gem", "Cnc", "Leo", "Vir", "Lib", "Sco", "Sgr", "Cap", "Aqr", "Psc"];
+const fmt = (lon) => {
+    const d = mod(lon, 30);
+    return `${Math.floor(d)}°${String(Math.floor(mod(d, 1) * 60)).padStart(2, "0")}'${SIGNS[Math.floor(lon / 30)]}`;
+};
+const latSchema = z.number().min(-90).max(90).describe("Latitude, north positive");
+const lonSchema = z.number().min(-180).max(180).describe("Longitude, EAST positive (Americas are negative)");
+const birth = {
+    date: z.string().describe("UTC date-time, ISO 8601, e.g. 1990-06-10T14:30:00Z. Convert local birth time to UTC first."),
+    lat: latSchema,
+    lon: lonSchema,
+};
+const houseSys = z.enum(["placidus", "whole_sign", "equal", "porphyry"]).default("placidus");
+function jdFromIso(iso) {
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime()))
+        throw new Error(`Invalid date: ${iso}`);
+    return julianDay(d.getUTCFullYear(), d.getUTCMonth() + 1, d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds());
+}
+function chartPayload(iso, lat, lon, hs) {
+    const d = new Date(iso);
+    const c = engine.chart(d.getUTCFullYear(), d.getUTCMonth() + 1, d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), lat, lon, hs);
+    const cusps = c.cusps;
+    const houseOf = (bl) => {
+        for (let i = 0; i < 12; i++) {
+            const a = cusps[i];
+            const b = cusps[(i + 1) % 12];
+            if (mod(bl - a, 360) < mod(b - a, 360))
+                return i + 1;
+        }
+        return 12;
+    };
+    const bodies = {};
+    for (const b of BODIES) {
+        const p = c.bodies[b];
+        bodies[b] = {
+            lon: r2(p.lon), pos: fmt(p.lon), house: houseOf(p.lon),
+            ...(p.retrograde ? { rx: true } : {}), speed: r2(p.speed),
+        };
+    }
+    return {
+        utc: iso, houses: c.houseSystem,
+        ...(c.houseSystem !== hs ? { houses_requested: hs, houses_fallback_reason: "placidus undefined above polar circles" } : {}),
+        bodies,
+        angles: { asc: r2(c.angles.asc), ascPos: fmt(c.angles.asc), mc: r2(c.angles.mc), mcPos: fmt(c.angles.mc) },
+        cusps: cusps.map(r2),
+        aspects: c.aspects.map((a) => `${a.a} ${a.aspect} ${a.b} (${a.orb}°)`),
+    };
+}
+const text = (obj) => ({ content: [{ type: "text", text: JSON.stringify(obj) }] });
+// ---------------------------------------------------------------- output schemas
+// Exported so the integration test validates responses against the same shape
+// the server promises. Kept permissive on optional keys (rx, fallback fields).
+const bodyOut = z.object({
+    lon: z.number(), pos: z.string(), house: z.number().int().min(1).max(12),
+    speed: z.number(), rx: z.boolean().optional(),
+});
+export const chartOut = z.object({
+    utc: z.string(),
+    houses: z.enum(["placidus", "whole_sign", "equal", "porphyry"]),
+    houses_requested: z.enum(["placidus", "whole_sign", "equal", "porphyry"]).optional(),
+    houses_fallback_reason: z.string().optional(),
+    bodies: z.record(z.string(), bodyOut),
+    angles: z.object({ asc: z.number(), ascPos: z.string(), mc: z.number(), mcPos: z.string() }),
+    cusps: z.array(z.number()).length(12),
+    aspects: z.array(z.string()),
+});
+export const transitsOut = z.object({
+    transit_utc: z.string(),
+    transiting: z.record(z.string(), z.object({
+        pos: z.string(), natal_house: z.number().int().min(1).max(12), rx: z.boolean().optional(),
+    })),
+    aspects_to_natal: z.array(z.string()),
+});
+export const synastryOut = z.object({
+    a: chartOut, b: chartOut,
+    inter_aspects: z.array(z.string()),
+    a_planets_in_b_houses: z.record(z.string(), z.number().int().min(1).max(12)),
+    b_planets_in_a_houses: z.record(z.string(), z.number().int().min(1).max(12)),
+});
+export const findAspectDatesOut = z.object({
+    query: z.string(),
+    hits: z.array(z.string()),
+});
+export const rectificationGridOut = z.object({
+    date: z.string(),
+    lat: z.number(), lon: z.number(),
+    asc_sign_changes: z.array(z.string()),
+    grid: z.array(z.object({ utc: z.string(), asc: z.string(), mc: z.string() })),
+});
+export const OUTPUT_SCHEMAS = {
+    natal_chart: chartOut,
+    current_sky: chartOut,
+    transits: transitsOut,
+    synastry: synastryOut,
+    find_aspect_dates: findAspectDatesOut,
+    rectification_grid: rectificationGridOut,
+};
+// ---------------------------------------------------------------- server
+export function buildServer() {
+    const server = new McpServer({ name: "caelus", version: "0.1.0" });
+    server.registerTool("natal_chart", {
+        description: "A person's birth chart. Requires their exact birth date+time and birthplace (all three: date, lat, lon). Use this — not current_sky — whenever the question is about someone's natal/birth chart. Returns 13 bodies (sun–pluto, chiron, nodes) with sign, house, retrograde, speed; ASC/MC; cusps; major aspects with orbs. Vs Swiss Ephemeris (1900–2099): Sun–Saturn ≤1″, Uranus ≤1.9″, Neptune ≤4.6″, Moon ≤2.5″, Pluto ≤2.5″ (series valid 1885–2099), Chiron ≤1″, nodes ≤1″.",
+        inputSchema: { ...birth, house_system: houseSys },
+    }, async ({ date, lat, lon, house_system }) => text(chartPayload(date, lat, lon, house_system)));
+    server.registerTool("current_sky", {
+        description: "The sky at a moment and place — not tied to any person. Use for \"what's the sky/transits right now\" or the chart of a non-birth event. Date defaults to now; lat/lon default to 0,0 (geocentric on the equator at the prime meridian), where houses and ASC/MC are nominal — pass a real location if houses matter. For a specific person's birth chart use natal_chart instead. Returns positions, houses, retrogrades, aspects.",
+        inputSchema: {
+            date: z.string().optional().describe("UTC ISO date-time (convert from local first); omit for now"),
+            lat: latSchema.default(0).describe("Latitude, north positive; default 0 makes houses nominal"),
+            lon: lonSchema.default(0).describe("Longitude, EAST positive (Americas are negative); default 0 makes houses nominal"),
+            house_system: houseSys,
+        },
+    }, async ({ date, lat, lon, house_system }) => text(chartPayload(date ?? new Date().toISOString(), lat, lon, house_system)));
+    server.registerTool("transits", {
+        description: "Transiting planets vs natal chart: aspects within orb (applying/separating), natal house per transiting body.",
+        inputSchema: {
+            ...birth,
+            transit_date: z.string().optional().describe("UTC ISO date-time of transit moment (convert from local first); omit for now"),
+            orb: z.number().min(0.5).max(10).default(3).describe("Max orb in degrees"),
+            house_system: houseSys,
+        },
+    }, async ({ date, lat, lon, transit_date, orb, house_system }) => {
+        const natal = chartPayload(date, lat, lon, house_system);
+        const tIso = transit_date ?? new Date().toISOString();
+        const jdT = jdFromIso(tIso);
+        const ASP = [["conj", 0], ["sext", 60], ["sq", 90], ["tri", 120], ["opp", 180]];
+        const hits = [];
+        const cusps = natal.cusps;
+        const houseOf = (bl) => {
+            for (let i = 0; i < 12; i++) {
+                if (mod(bl - cusps[i], 360) < mod(cusps[(i + 1) % 12] - cusps[i], 360))
+                    return i + 1;
+            }
+            return 12;
+        };
+        const transiting = {};
+        for (const tb of BODIES) {
+            const tp = engine.position(tb, jdT);
+            transiting[tb] = { pos: fmt(tp.lon), natal_house: houseOf(tp.lon), ...(tp.retrograde ? { rx: true } : {}) };
+            for (const nb of BODIES) {
+                const nLon = natal.bodies[nb].lon;
+                const sep = Math.abs(mod(tp.lon - nLon + 180, 360) - 180);
+                for (const [name, angle] of ASP) {
+                    const o = Math.abs(sep - angle);
+                    if (o <= orb) {
+                        const future = Math.abs(mod(tp.lon + tp.speed * 0.5 - nLon + 180, 360) - 180);
+                        const applying = Math.abs(future - angle) < o;
+                        hits.push(`t.${tb} ${name} n.${nb} (${r2(o)}°${applying ? " applying" : " separating"})`);
+                    }
+                }
+            }
+        }
+        return text({ transit_utc: tIso, transiting, aspects_to_natal: hits });
+    });
+    server.registerTool("synastry", {
+        description: "Compare two people's birth charts: inter-chart aspects with orbs, house overlays both ways. Each person needs date+lat+lon. House overlays always use Placidus (not configurable here).",
+        inputSchema: {
+            a: z.object(birth).describe("Person A birth data (UTC date, lat, lon)"),
+            b: z.object(birth).describe("Person B birth data (UTC date, lat, lon)"),
+            orb: z.number().min(0.5).max(10).default(4).describe("Max orb in degrees"),
+        },
+    }, async ({ a, b, orb }) => {
+        const ca = chartPayload(a.date, a.lat, a.lon, "placidus");
+        const cb = chartPayload(b.date, b.lat, b.lon, "placidus");
+        const ASP = [["conj", 0], ["sext", 60], ["sq", 90], ["tri", 120], ["opp", 180]];
+        const inter = [];
+        const houseIn = (cusps, bl) => {
+            for (let i = 0; i < 12; i++) {
+                if (mod(bl - cusps[i], 360) < mod(cusps[(i + 1) % 12] - cusps[i], 360))
+                    return i + 1;
+            }
+            return 12;
+        };
+        const aInB = {};
+        const bInA = {};
+        for (const ba of BODIES) {
+            const la = ca.bodies[ba].lon;
+            aInB[ba] = houseIn(cb.cusps, la);
+            const lb = cb.bodies[ba].lon;
+            bInA[ba] = houseIn(ca.cusps, lb);
+        }
+        for (const ba of BODIES) {
+            for (const bb of BODIES) {
+                const la = ca.bodies[ba].lon;
+                const lb = cb.bodies[bb].lon;
+                const sep = Math.abs(mod(la - lb + 180, 360) - 180);
+                for (const [name, angle] of ASP) {
+                    const o = Math.abs(sep - angle);
+                    if (o <= orb)
+                        inter.push(`A.${ba} ${name} B.${bb} (${r2(o)}°)`);
+                }
+            }
+        }
+        return text({
+            a: ca, b: cb, inter_aspects: inter,
+            a_planets_in_b_houses: aInB, b_planets_in_a_houses: bInA,
+        });
+    });
+    server.registerTool("find_aspect_dates", {
+        description: "Exact dates a transiting body makes an aspect, within a range: to a fixed longitude OR to another transiting body. Provide exactly one of target_lon / target_body. Includes retrograde re-hits. Body names are snake_case (mean_node, true_node); note the output uses abbreviated aspect tokens (conj/sext/sq/tri/opp).",
+        inputSchema: {
+            body: z.enum(BODIES).describe("Transiting body (snake_case, e.g. saturn, true_node)"),
+            aspect: z.enum(["conjunction", "sextile", "square", "trine", "opposition"]),
+            target_lon: z.number().min(0).max(360).optional().describe("Fixed natal longitude in degrees. Provide this OR target_body, not both."),
+            target_body: z.enum(BODIES).optional().describe("Another transiting body. Provide this OR target_lon, not both."),
+            start: z.string().describe("UTC ISO start date (convert from local first)"),
+            end: z.string().describe("UTC ISO end date (convert from local first); range <= 50 years"),
+        },
+    }, async ({ body, aspect, target_lon, target_body, start, end }) => {
+        const angle = { conjunction: 0, sextile: 60, square: 90, trine: 120, opposition: 180 }[aspect];
+        const jd0 = jdFromIso(start);
+        const jd1 = jdFromIso(end);
+        if (jd1 - jd0 > 50 * 366)
+            throw new Error("Range too large (max 50 years)");
+        if (target_lon === undefined && target_body === undefined) {
+            throw new Error("Provide target_lon or target_body");
+        }
+        // A non-axial aspect (sextile/square/trine) is exact at BOTH +angle and
+        // -angle separation; conjunction/opposition have a single geometry.
+        const offsets = angle === 0 || angle === 180 ? [angle] : [angle, -angle];
+        const mkF = (off) => (jd) => {
+            const tl = target_body !== undefined
+                ? engine.longitude(target_body, jd)
+                : target_lon;
+            return mod(engine.longitude(body, jd) - tl - off + 180, 360) - 180;
+        };
+        const hitsJd = [];
+        const step = 1.0;
+        for (const off of offsets) {
+            const f = mkF(off);
+            let prev = f(jd0);
+            for (let jd = jd0 + step; jd <= jd1 && hitsJd.length < 120; jd += step) {
+                const cur = f(jd);
+                if (prev * cur < 0 && Math.abs(cur - prev) < 180) {
+                    let a = jd - step;
+                    let bj = jd;
+                    for (let i = 0; i < 40; i++) { // bisection to ~1 minute
+                        const m = (a + bj) / 2;
+                        if (f(a) * f(m) <= 0)
+                            bj = m;
+                        else
+                            a = m;
+                    }
+                    hitsJd.push((a + bj) / 2);
+                }
+                prev = cur;
+            }
+        }
+        hitsJd.sort((x, y) => x - y);
+        const hits = hitsJd.slice(0, 60).map((t) => new Date((t - 2440587.5) * 86400000).toISOString().slice(0, 16) + "Z");
+        return text({ query: `${body} ${aspect} ${target_body ?? target_lon}`, hits });
+    });
+    server.registerTool("rectification_grid", {
+        description: "Rectification sweep: ASC/MC at each step across a window of UTC hours on one date, with ASC sign-change times. Use when the birth time is unknown and you want candidate times. The sweep runs over window_start_hour..window_end_hour (UTC hours of the given date); the date's time portion is ignored.",
+        inputSchema: {
+            date: z.string().describe("Birth DATE (UTC) as ISO; only the calendar date is used, the time portion is ignored (the window_*_hour fields set the times swept)"),
+            lat: latSchema, lon: lonSchema,
+            window_start_hour: z.number().min(0).max(24).default(0).describe("First UTC hour of the date to sweep"),
+            window_end_hour: z.number().min(0).max(24).default(24).describe("Last UTC hour of the date to sweep"),
+            step_minutes: z.number().min(5).max(120).default(20).describe("Minutes between grid rows"),
+        },
+    }, async ({ date, lat, lon, window_start_hour, window_end_hour, step_minutes }) => {
+        const d = new Date(date);
+        const grid = [];
+        const boundaries = [];
+        let lastAscSign = -1;
+        for (let m = window_start_hour * 60; m <= window_end_hour * 60; m += step_minutes) {
+            const iso = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), 0, m, 0)).toISOString();
+            const c = chartPayload(iso, lat, lon, "whole_sign");
+            const ascLon = c.angles.asc;
+            const ascSign = Math.floor(ascLon / 30);
+            if (lastAscSign >= 0 && ascSign !== lastAscSign) {
+                boundaries.push(`Asc enters ${SIGNS[ascSign]} ~${iso.slice(11, 16)} UTC`);
+            }
+            lastAscSign = ascSign;
+            grid.push({
+                utc: iso.slice(11, 16),
+                asc: c.angles.ascPos,
+                mc: c.angles.mcPos,
+            });
+        }
+        return text({ date: date.slice(0, 10), lat, lon, asc_sign_changes: boundaries, grid });
+    });
+    return server;
+}
+// ---------------------------------------------------------------- main
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+if (isMain) {
+    const server = buildServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("caelus-mcp listening on stdio");
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "caelus-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for caelus chart computation.",
+  "type": "module",
+  "bin": {
+    "caelus-mcp": "dist/src/server.js"
+  },
+  "main": "dist/src/server.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/src/server.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.24.0",
+    "caelus": "^0.1.0"
+  },
+  "devDependencies": {
+    "ajv": "^8.17.1"
+  },
+  "license": "MIT",
+  "files": [
+    "dist/src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/heavyblotto/caelus.git",
+    "directory": "packages/caelus-mcp"
+  },
+  "homepage": "https://ephemengine.com",
+  "keywords": [
+    "astrology",
+    "ephemeris",
+    "mcp",
+    "model-context-protocol",
+    "natal-chart"
+  ]
+}