@aulunarcana/ephemeris 0.1.0

package/LICENSE

@@ -0,0 +1,46 @@
+AuLun Ephemeris — Proprietary License
+Free for Non-Commercial Use
+
+Copyright (c) 2026 AuLun Arcana LLC. All rights reserved.
+
+This license governs the compiled AuLun Ephemeris package (the
+"Software"): the WASM binary, the JavaScript/TypeScript wrapper, and
+the embedded astronomical data as distributed. Source code is not
+included and is not licensed.
+
+1. NON-COMMERCIAL GRANT. You may install and use the Software free of
+   charge for personal, educational, research, and other
+   non-commercial purposes. "Non-commercial" excludes any use in or
+   for a product, service, or activity that is sold, monetized, or
+   operated for commercial advantage, whether or not for profit.
+
+2. COMMERCIAL USE. Any commercial use requires a separate commercial
+   license from the copyright holder. Contact:
+   https://github.com/routerbad
+
+3. RESTRICTIONS. You may not (a) redistribute, sublicense, sell, or
+   host the Software for use by third parties except as an
+   incidental, non-separable part of a permitted non-commercial
+   application; (b) modify, adapt, or create derivative works of the
+   Software; (c) reverse engineer, decompile, or disassemble the
+   Software, or extract its embedded implementation, except to the
+   extent applicable law expressly permits despite this limitation;
+   (d) remove or alter proprietary notices.
+
+4. DATA. The astronomical data embedded in the Software derives from
+   public-domain and factual sources (documented by the copyright
+   holder); nothing in this license restricts your independent use of
+   those underlying public sources.
+
+5. OWNERSHIP. The Software is licensed, not sold. The copyright
+   holder retains all rights not expressly granted.
+
+6. TERMINATION. This license terminates automatically if you breach
+   it. Upon termination you must cease use and destroy copies.
+
+7. NO WARRANTY. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+   ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, ACCURACY, AND
+   NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE
+   FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM THE USE OF
+   THE SOFTWARE.

package/README.md

@@ -0,0 +1,146 @@
+# @aulunarcana/ephemeris
+
+AuLun Ephemeris — an astronomical ephemeris and natal chart engine
+compiled to WebAssembly. Sub-arcsecond accuracy validated against JPL
+Horizons across 1900–2100 (Moon median 0.06″). **Free for
+non-commercial use**; commercial licenses available (see License
+below).
+
+## Install
+
+```bash
+npm install @aulunarcana/ephemeris
+```
+
+Node 18+. Self-contained — all ephemeris data (~13 MB) is embedded.
+
+## Quick start — tropical zodiac, Placidus houses
+
+```js
+import { Ephemeris, degreesToRadians, radiansToDegrees } from "@aulunarcana/ephemeris";
+
+const engine = new Ephemeris(); // parses embedded data once — construct once, reuse
+
+const chart = engine.computeChart(
+  { year: 1990, month: 6, day: 15, hour: 21, minute: 30 }, // local civil time
+  "America/Los_Angeles",                                   // IANA timezone
+  { latitudeRad: degreesToRadians(34.05), longitudeRad: degreesToRadians(-118.24) },
+  { houseSystem: "placidus" },                             // tropical is the default zodiac
+);
+
+radiansToDegrees(chart.ascendantRad);      // Ascendant
+chart.bodies.sun.longitudeRad;             // apparent ecliptic longitude
+chart.bodies.moon.longitudeRateRadPerDay;  // negative = retrograde
+chart.houses.cuspsRad;                     // the 12 Placidus cusps
+chart.aspects;                             // aspects with applying/separating
+chart.patterns;                            // grand trines, T-squares, …
+```
+
+All angles are radians; convert with `radiansToDegrees` /
+`degreesToRadians`. The full result shape is in `index.d.ts`
+(`Chart`).
+
+## What a chart contains
+
+- **Bodies** (`chart.bodies`): `sun`, `moon`, `mercury`, `venus`,
+  `mars`, `jupiter`, `saturn`, `uranus`, `neptune`, `pluto`,
+  `chiron` — each with apparent ecliptic longitude, latitude,
+  distance, and daily motion (negative = retrograde).
+- **Angles and houses**: Ascendant, Midheaven, 12 house cusps.
+- **Lunar points**: mean and true North/South Node and Lilith.
+- **Hermetic lots**: Fortune, Spirit, Eros, Necessity, Courage,
+  Victory, Nemesis (day/night sect handled via `isDayChart`).
+- **Aspects**: major and minor aspects with orb, exact angle, and
+  applying/separating; plus detected patterns (grand trine,
+  T-square, …).
+
+## House systems
+
+Pass one of these as `houseSystem` (default: `"placidus"`):
+
+| Value | System |
+|---|---|
+| `"placidus"` | Placidus |
+| `"koch"` | Koch |
+| `"whole_sign"` | Whole Sign |
+| `"equal"` | Equal |
+| `"porphyry"` | Porphyry |
+| `"regiomontanus"` | Regiomontanus |
+| `"campanus"` | Campanus |
+| `"alcabitius"` | Alcabitius |
+| `"topocentric"` | Topocentric (Polich–Page) |
+| `"morinus"` | Morinus |
+| `"meridian"` | Meridian (Axial) |
+
+## Zodiac: tropical and sidereal (Vedic)
+
+Every chart is computed in the **tropical** zodiac. To also get
+sidereal values, pass an `ayanamsa`:
+
+| Value | Tradition |
+|---|---|
+| `"lahiri"` | Vedic / Jyotish standard (Chitrapaksha) |
+| `"fagan_bradley"` | Western sidereal |
+
+```js
+const vedic = engine.computeChart(civil, zone, observer, {
+  houseSystem: "whole_sign",
+  ayanamsa: "lahiri",
+});
+vedic.bodies.moon.siderealLongitudeRad; // sidereal position
+vedic.siderealHouses.cuspsRad;          // sidereal cusps
+vedic.ayanamsaRad;                      // the ayanamsa applied
+```
+
+Sidereal output is additive — the tropical fields are always present.
+
+## Extended minor bodies (optional)
+
+Sixteen additional bodies are supported but not embedded: `ceres`,
+`pallas`, `juno`, `vesta`, `eris`, `sedna`, `haumea`, `makemake`,
+`quaoar`, `orcus`, `varuna`, `ixion`, `gonggong`, `pholus`, `nessus`,
+`chariklo`. Load a body's data table first, then request it:
+
+```js
+engine.loadMinorBodyTable("ceres", ceresTableText);
+const chart = engine.computeChart(civil, zone, observer, {
+  includeMinorBodies: ["ceres"],
+});
+```
+
+A requested body whose table isn't loaded (or whose date is outside
+table coverage) is listed in `chart.outOfRange` instead of failing
+the chart.
+
+## Time handling
+
+`computeChart` takes naive civil time plus an IANA zone and resolves
+DST correctly:
+
+- Ambiguous local times (DST fall-back) throw
+  `AmbiguousLocalTimeError` unless you pass `fold` (`0` = earlier
+  instant, `1` = later).
+- Nonexistent local times (spring-forward gap) always throw
+  `NonexistentLocalTimeError`.
+
+If you already have UTC, use
+`engine.computeChartUtc(utc, observer, options)` and skip timezone
+resolution entirely.
+
+## Accuracy
+
+Apparent positions are computed from VSOP87E, ELP/MPP02, and
+JPL-derived state vectors with full IAU 2000A/2006 precession-
+nutation, light-time, and relativistic aberration. Validated against
+JPL Horizons over 1900–2100: sub-arcsecond median accuracy for every
+supported body.
+
+## License
+
+Proprietary. **Free for non-commercial use** — personal, educational,
+and research use is free of charge under the LICENSE shipped with
+this package. Use in or for anything sold, monetized, or operated for
+commercial advantage requires a commercial license: contact the
+copyright holder via https://github.com/AuLunArcana.
+
+© 2026 AuLun Arcana LLC. All rights reserved.

package/index.d.ts

@@ -0,0 +1,158 @@
+/** Type surface for @aulunarcana/ephemeris. All angles are radians
+ * unless a name says otherwise; use radiansToDegrees for display. */
+
+export interface CivilTime {
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second?: number;
+}
+
+export interface UtcFields {
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second: number;
+}
+
+export interface Observer {
+  latitudeRad: number;
+  longitudeRad: number;
+  heightM?: number;
+}
+
+export type HouseSystem =
+  | "whole_sign"
+  | "equal"
+  | "porphyry"
+  | "meridian"
+  | "regiomontanus"
+  | "campanus"
+  | "alcabitius"
+  | "placidus"
+  | "koch"
+  | "topocentric"
+  | "morinus";
+
+export type Ayanamsa = "lahiri" | "fagan_bradley";
+
+export interface ChartOptions {
+  houseSystem?: HouseSystem;
+  includeMinorBodies?: string[];
+  ayanamsa?: Ayanamsa;
+  /** null rejects ambiguous local times; 0 = earlier, 1 = later. */
+  fold?: 0 | 1 | null;
+}
+
+export interface BodyPosition {
+  longitudeRad: number;
+  latitudeRad: number;
+  distanceAu: number;
+  longitudeRateRadPerDay: number;
+  siderealLongitudeRad: number | null;
+}
+
+export interface Houses {
+  ascendantRad: number;
+  midheavenRad: number;
+  cuspsRad: number[];
+}
+
+export interface AspectHit {
+  bodyA: string;
+  bodyB: string;
+  aspect: string;
+  exactAngleRad: number;
+  separationRad: number;
+  orbRad: number;
+  applying: boolean | null;
+}
+
+export interface PatternHit {
+  pattern: string;
+  bodies: string[];
+}
+
+export interface LunarPoints {
+  meanNodeRad: number;
+  trueNodeRad: number;
+  meanSouthNodeRad: number;
+  trueSouthNodeRad: number;
+  meanLilithRad: number;
+  trueLilithRad: number;
+}
+
+export interface Lots {
+  fortune: number;
+  spirit: number;
+  eros: number;
+  necessity: number;
+  courage: number;
+  victory: number;
+  nemesis: number;
+}
+
+export interface Chart {
+  jdUtc: number;
+  jdTt: number;
+  houseSystem: string;
+  ayanamsaName: string | null;
+  ayanamsaRad: number | null;
+  bodies: Record<string, BodyPosition>;
+  outOfRange: string[];
+  ascendantRad: number;
+  midheavenRad: number;
+  houses: Houses;
+  siderealHouses: Houses | null;
+  lunarPoints: LunarPoints;
+  isDayChart: boolean;
+  lots: Lots;
+  aspects: AspectHit[];
+  patterns: PatternHit[];
+  utc?: UtcFields;
+  ianaZone?: string;
+}
+
+export class AmbiguousLocalTimeError extends Error {}
+export class NonexistentLocalTimeError extends Error {}
+
+export function resolveCivilToUtc(
+  local: CivilTime,
+  zone: string,
+  fold?: 0 | 1 | null,
+): UtcFields;
+
+export function radiansToDegrees(rad: number): number;
+export function degreesToRadians(deg: number): number;
+
+export interface BodyPositionLite {
+  longitudeRad: number;
+  latitudeRad: number;
+  distanceAu: number;
+  longitudeRateRadPerDay: number;
+}
+
+export interface BodyPositions {
+  jdUtc: number;
+  jdTt: number;
+  bodies: Record<string, BodyPositionLite>;
+  outOfRange: string[];
+}
+
+export class Ephemeris {
+  constructor();
+  loadMinorBodyTable(name: string, content: string): void;
+  computeChart(
+    civil: CivilTime,
+    zone: string,
+    observer: Observer,
+    options?: ChartOptions,
+  ): Chart;
+  computeChartUtc(utc: UtcFields, observer: Observer, options?: ChartOptions): Chart;
+  /** Positions-only fast path for a subset of bodies (transit scans). */
+  computeBodies(utc: Omit<UtcFields, "second"> & { second?: number }, bodies: string[]): BodyPositions;
+}

package/index.mjs

@@ -0,0 +1,243 @@
+/**
+ * @aulunarcana/ephemeris — JS/TS surface over the WASM engine.
+ *
+ * Civil-time resolution lives HERE (port design decision 1): the WASM
+ * core takes a resolved UTC instant. Resolution uses Temporal with
+ * explicit disambiguation when the runtime ships it, and otherwise an
+ * Intl.DateTimeFormat offset-prober implementing the same semantics as
+ * the Python prototype's resolve_civil_datetime_to_utc:
+ *   - fold null on an ambiguous local time (DST fall-back): throws
+ *     AmbiguousLocalTimeError; fold 0 selects the earlier UTC instant,
+ *     fold 1 the later.
+ *   - a nonexistent local time (spring-forward gap) throws
+ *     NonexistentLocalTimeError regardless of fold.
+ * Conformance is tested against Python-generated fold vectors
+ * (test/fold_vectors.json).
+ */
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const wasm = require("./pkg/ephemeris_wasm.js");
+
+export class AmbiguousLocalTimeError extends Error {}
+export class NonexistentLocalTimeError extends Error {}
+
+const DAY_MS = 86400000;
+
+function wallFieldsAt(epochMs, zone) {
+  const dtf = new Intl.DateTimeFormat("en-US", {
+    timeZone: zone,
+    era: "short",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false,
+  });
+  const parts = Object.fromEntries(
+    dtf.formatToParts(new Date(epochMs)).map((p) => [p.type, p.value]),
+  );
+  let year = Number(parts.year);
+  if (parts.era === "BC") year = 1 - year;
+  return {
+    year,
+    month: Number(parts.month),
+    day: Number(parts.day),
+    hour: Number(parts.hour) % 24, // some ICU builds format midnight as "24"
+    minute: Number(parts.minute),
+    second: Number(parts.second),
+  };
+}
+
+function fieldsAsUtcMs(f) {
+  // NOT Date.UTC(...): it silently remaps years 0-99 to 1900-1999
+  // (review finding). setUTCFullYear takes the year literally, so
+  // ancient/first-century dates resolve correctly, matching both the
+  // Python prototype and the Temporal path.
+  const d = new Date(0);
+  d.setUTCFullYear(f.year, f.month - 1, f.day);
+  d.setUTCHours(f.hour, f.minute, f.second ?? 0, 0);
+  return d.getTime();
+}
+
+function zoneOffsetMs(epochMs, zone) {
+  return fieldsAsUtcMs(wallFieldsAt(epochMs, zone)) - epochMs;
+}
+
+function msToUtcFields(epochMs) {
+  const d = new Date(epochMs);
+  return {
+    year: d.getUTCFullYear(),
+    month: d.getUTCMonth() + 1,
+    day: d.getUTCDate(),
+    hour: d.getUTCHours(),
+    minute: d.getUTCMinutes(),
+    second: d.getUTCSeconds(),
+  };
+}
+
+function resolveViaIntl(local, zone, fold) {
+  const guess = fieldsAsUtcMs(local);
+  // Probe the zone offset around the guess: any transition within a
+  // day of the target surfaces both candidate offsets.
+  const offsets = new Set([
+    zoneOffsetMs(guess - DAY_MS, zone),
+    zoneOffsetMs(guess, zone),
+    zoneOffsetMs(guess + DAY_MS, zone),
+  ]);
+  const candidates = [];
+  for (const offset of offsets) {
+    const instant = guess - offset;
+    // Valid iff the round trip reproduces the requested wall time.
+    if (zoneOffsetMs(instant, zone) === offset) {
+      candidates.push(instant);
+    }
+  }
+  const unique = [...new Set(candidates)].sort((a, b) => a - b);
+  if (unique.length === 0) {
+    throw new NonexistentLocalTimeError(
+      `${JSON.stringify(local)} in ${zone} does not exist (DST spring-forward gap).`,
+    );
+  }
+  if (unique.length === 1) {
+    return msToUtcFields(unique[0]);
+  }
+  if (fold === null || fold === undefined) {
+    throw new AmbiguousLocalTimeError(
+      `${JSON.stringify(local)} in ${zone} is ambiguous (DST fall-back); ` +
+        "pass fold 0 (earlier) or 1 (later) explicitly.",
+    );
+  }
+  return msToUtcFields(fold === 0 ? unique[0] : unique[unique.length - 1]);
+}
+
+function resolveViaTemporal(local, zone, fold) {
+  const plain = new Temporal.PlainDateTime(
+    local.year,
+    local.month,
+    local.day,
+    local.hour,
+    local.minute,
+    local.second ?? 0,
+  );
+  let zoned;
+  try {
+    zoned = plain.toZonedDateTime(zone, {
+      disambiguation:
+        fold === null || fold === undefined
+          ? "reject"
+          : fold === 0
+            ? "earlier"
+            : "later",
+    });
+  } catch (error) {
+    // Temporal's reject covers BOTH gap and ambiguity; a Python-style
+    // round-trip re-probe classifies which, and the gap case must
+    // throw even with an explicit fold.
+    return classifyRejection(local, zone, fold);
+  }
+  // Temporal resolves gap times under earlier/later; Python raises for
+  // gaps regardless of fold. Round-trip check preserves that contract.
+  const roundTrip = zoned.toPlainDateTime();
+  if (
+    roundTrip.year !== plain.year ||
+    roundTrip.month !== plain.month ||
+    roundTrip.day !== plain.day ||
+    roundTrip.hour !== plain.hour ||
+    roundTrip.minute !== plain.minute ||
+    roundTrip.second !== plain.second
+  ) {
+    throw new NonexistentLocalTimeError(
+      `${JSON.stringify(local)} in ${zone} does not exist (DST spring-forward gap).`,
+    );
+  }
+  return msToUtcFields(zoned.epochMilliseconds);
+}
+
+function classifyRejection(local, zone, fold) {
+  // Temporal's 'reject' throws for BOTH gap and ambiguity; the Intl
+  // prober re-derives which, throwing our typed error (or resolving,
+  // if Temporal rejected something the prober can settle).
+  return resolveViaIntl(local, zone, fold);
+}
+
+/**
+ * Resolve a naive local civil time + IANA zone to UTC fields.
+ * fold: null/undefined (reject ambiguity), 0 (earlier), 1 (later).
+ */
+export function resolveCivilToUtc(local, zone, fold = null) {
+  if (typeof globalThis.Temporal !== "undefined") {
+    return resolveViaTemporal(local, zone, fold);
+  }
+  return resolveViaIntl(local, zone, fold);
+}
+
+const RAD_TO_DEG = 180 / Math.PI;
+export function radiansToDegrees(rad) {
+  return rad * RAD_TO_DEG;
+}
+export function degreesToRadians(deg) {
+  return deg / RAD_TO_DEG;
+}
+
+/**
+ * The one-call chart surface. Construct once (parses ~13 MB of
+ * embedded ephemeris data), then computeChart per birth.
+ */
+export class Ephemeris {
+  constructor() {
+    this.engine = new wasm.Engine();
+  }
+
+  /** Load one extended minor body's vendored table text at runtime. */
+  loadMinorBodyTable(name, content) {
+    this.engine.loadMinorBodyTable(name, content);
+  }
+
+  /**
+   * civil: {year, month, day, hour, minute, second?}; zone: IANA name;
+   * observer: {latitudeRad, longitudeRad, heightM?} (radians — use
+   * degreesToRadians for degree inputs); options: {houseSystem?,
+   * includeMinorBodies?, ayanamsa?, fold?}.
+   * Returns the chart object (all angles radians) with utc attached.
+   */
+  computeChart(civil, zone, observer, options = {}) {
+    const utc = resolveCivilToUtc(civil, zone, options.fold ?? null);
+    const chart = this.computeChartUtc(utc, observer, options);
+    chart.utc = utc;
+    chart.ianaZone = zone;
+    return chart;
+  }
+
+  /** Same, from an already-resolved UTC instant. */
+  computeChartUtc(utc, observer, options = {}) {
+    const request = JSON.stringify({
+      utc,
+      observer,
+      options: {
+        houseSystem: options.houseSystem,
+        includeMinorBodies: options.includeMinorBodies,
+        ayanamsa: options.ayanamsa,
+      },
+    });
+    return JSON.parse(this.engine.computeChartJson(request));
+  }
+
+  /**
+   * Positions-only fast path: apparent geocentric longitude/latitude/
+   * distance/rate for just the requested bodies (same numbers as the
+   * full chart's `bodies`), skipping houses, lunar points, lots,
+   * aspects, and patterns. Built for transit scans that sample a few
+   * slow bodies across thousands of instants — a one-body query costs
+   * a fraction of a full chart. utc: resolved UTC fields; bodies:
+   * array of body names (chart bodies and loaded minors).
+   */
+  computeBodies(utc, bodies) {
+    const request = JSON.stringify({
+      utc: { second: 0, ...utc },
+      bodies,
+    });
+    return JSON.parse(this.engine.computeBodiesJson(request));
+  }
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@aulunarcana/ephemeris",
+  "version": "0.1.0",
+  "description": "AuLun Ephemeris: NASA-grade astronomical ephemeris and chart engine (WASM). Free for non-commercial use; commercial licenses available.",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AuLunArcana/ephemeris.git"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "main": "index.mjs",
+  "types": "index.d.ts",
+  "files": ["index.mjs", "index.d.ts", "pkg/", "LICENSE"],
+  "scripts": {
+    "prepack": "cd .. && wasm-pack build --target nodejs --release --out-dir js/pkg && node -e \"fs.rmSync('js/pkg/.gitignore',{force:true})\"",
+    "test": "node test/smoke.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/pkg/LICENSE

@@ -0,0 +1,46 @@
+AuLun Ephemeris — Proprietary License
+Free for Non-Commercial Use
+
+Copyright (c) 2026 AuLun Arcana LLC. All rights reserved.
+
+This license governs the compiled AuLun Ephemeris package (the
+"Software"): the WASM binary, the JavaScript/TypeScript wrapper, and
+the embedded astronomical data as distributed. Source code is not
+included and is not licensed.
+
+1. NON-COMMERCIAL GRANT. You may install and use the Software free of
+   charge for personal, educational, research, and other
+   non-commercial purposes. "Non-commercial" excludes any use in or
+   for a product, service, or activity that is sold, monetized, or
+   operated for commercial advantage, whether or not for profit.
+
+2. COMMERCIAL USE. Any commercial use requires a separate commercial
+   license from the copyright holder. Contact:
+   https://github.com/routerbad
+
+3. RESTRICTIONS. You may not (a) redistribute, sublicense, sell, or
+   host the Software for use by third parties except as an
+   incidental, non-separable part of a permitted non-commercial
+   application; (b) modify, adapt, or create derivative works of the
+   Software; (c) reverse engineer, decompile, or disassemble the
+   Software, or extract its embedded implementation, except to the
+   extent applicable law expressly permits despite this limitation;
+   (d) remove or alter proprietary notices.
+
+4. DATA. The astronomical data embedded in the Software derives from
+   public-domain and factual sources (documented by the copyright
+   holder); nothing in this license restricts your independent use of
+   those underlying public sources.
+
+5. OWNERSHIP. The Software is licensed, not sold. The copyright
+   holder retains all rights not expressly granted.
+
+6. TERMINATION. This license terminates automatically if you breach
+   it. Upon termination you must cease use and destroy copies.
+
+7. NO WARRANTY. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+   ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, ACCURACY, AND
+   NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE
+   FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM THE USE OF
+   THE SOFTWARE.

package/pkg/ephemeris_wasm.d.ts

@@ -0,0 +1,36 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class Engine {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Positions-only fast path: apparent geocentric longitude,
+     * latitude, distance, and daily rate for a caller-chosen subset
+     * of bodies. Same numbers as the full chart's `bodies` (same
+     * pipeline), skipping houses/lunar points/lots/aspects/patterns
+     * entirely -- built for transit scans that sample one or a few
+     * slow bodies across thousands of instants. Input JSON:
+     * {"utc": {...}, "bodies": ["jupiter", ...]}.
+     */
+    computeBodiesJson(request_json: string): string;
+    /**
+     * Computes a chart from a RESOLVED UTC instant. Input/output are
+     * JSON strings (the JS wrapper owns object conversion, degree
+     * helpers, and civil-time resolution). All angles radians,
+     * tropical true-ecliptic-of-date; sidereal fields additive.
+     */
+    computeChartJson(request_json: string): string;
+    /**
+     * Loads one extended minor body's vendored table content
+     * (data/minor_bodies/<name>_vectors.txt) at runtime -- the 16
+     * extended minors are not embedded. Charts requesting an
+     * unloaded minor degrade it into `out_of_range` (M3).
+     */
+    loadMinorBodyTable(name: string, content: string): void;
+    /**
+     * Parses every embedded dataset once (do this at startup, not
+     * per chart).
+     */
+    constructor();
+}

package/pkg/ephemeris_wasm.js

@@ -0,0 +1,218 @@
+/* @ts-self-types="./ephemeris_wasm.d.ts" */
+
+class Engine {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EngineFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_engine_free(ptr, 0);
+    }
+    /**
+     * Positions-only fast path: apparent geocentric longitude,
+     * latitude, distance, and daily rate for a caller-chosen subset
+     * of bodies. Same numbers as the full chart's `bodies` (same
+     * pipeline), skipping houses/lunar points/lots/aspects/patterns
+     * entirely -- built for transit scans that sample one or a few
+     * slow bodies across thousands of instants. Input JSON:
+     * {"utc": {...}, "bodies": ["jupiter", ...]}.
+     * @param {string} request_json
+     * @returns {string}
+     */
+    computeBodiesJson(request_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.engine_computeBodiesJson(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * Computes a chart from a RESOLVED UTC instant. Input/output are
+     * JSON strings (the JS wrapper owns object conversion, degree
+     * helpers, and civil-time resolution). All angles radians,
+     * tropical true-ecliptic-of-date; sidereal fields additive.
+     * @param {string} request_json
+     * @returns {string}
+     */
+    computeChartJson(request_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.engine_computeChartJson(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * Loads one extended minor body's vendored table content
+     * (data/minor_bodies/<name>_vectors.txt) at runtime -- the 16
+     * extended minors are not embedded. Charts requesting an
+     * unloaded minor degrade it into `out_of_range` (M3).
+     * @param {string} name
+     * @param {string} content
+     */
+    loadMinorBodyTable(name, content) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_loadMinorBodyTable(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Parses every embedded dataset once (do this at startup, not
+     * per chart).
+     */
+    constructor() {
+        const ret = wasm.engine_new();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        EngineFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) Engine.prototype[Symbol.dispose] = Engine.prototype.free;
+exports.Engine = Engine;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_92b29b0548f8b746: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./ephemeris_wasm_bg.js": import0,
+    };
+}
+
+const EngineFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_engine_free(ptr, 1));
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/ephemeris_wasm_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
+let wasm = wasmInstance.exports;
+wasm.__wbindgen_start();

package/pkg/ephemeris_wasm_bg.wasm.d.ts

@@ -0,0 +1,14 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_engine_free: (a: number, b: number) => void;
+export const engine_computeBodiesJson: (a: number, b: number, c: number) => [number, number, number, number];
+export const engine_computeChartJson: (a: number, b: number, c: number) => [number, number, number, number];
+export const engine_loadMinorBodyTable: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const engine_new: () => [number, number, number];
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;

package/pkg/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "ephemeris-wasm",
+  "description": "WASM bindings for the ephemeris engine",
+  "version": "0.1.0",
+  "license": "SEE LICENSE IN LICENSE",
+  "files": [
+    "ephemeris_wasm_bg.wasm",
+    "ephemeris_wasm.js",
+    "ephemeris_wasm.d.ts"
+  ],
+  "main": "ephemeris_wasm.js",
+  "types": "ephemeris_wasm.d.ts"
+}