Your Vedic chart and Vimshottari dasha, computed.

"use strict";

// This harness uses CommonJS. Save it as adopt-vimshottari.cjs so it also runs
// inside Node.js projects whose package.json declares "type": "module".
// Download this immutable release once, then run the harness against the local file:
// https://chartingstars.com/vedic-chart/conformance/vimshottari-conformance-2026-09-04-v1.json
// Scope: supplied, already-sidereal Moon longitudes and Dasha arithmetic only.
// This does not compute or validate an ephemeris, ayanamsa, astronomical position,
// predictive result, or civil date.

const { createHash } = require("node:crypto");
const { readFileSync } = require("node:fs");

const RELEASE_ID = "vimshottari-conformance-2026-09-04-v1";
const RELEASE_URL =
  "https://chartingstars.com/vedic-chart/conformance/vimshottari-conformance-2026-09-04-v1.json";
const DEFAULT_RELEASE_PATH = "./vimshottari-conformance-2026-09-04-v1.json";
const ARTIFACT_SHA256 =
  "f37e8f3b3514d160fde235857b2b2838de6107fb4f613c590ec2d5afbbef108a";
const RECORD_SET_SHA256 =
  "297fb4ccff0cf62202b71d7108a5805679813bcbf02288529164abffef0d1bd6";
const SCHEMA_VERSION = 1;
const RECORD_COUNT = 81;
const ABSOLUTE_TOLERANCE = 1e-9;

const EXACT_FIELDS = [
  "nakshatraIndex",
  "nakshatra",
  "startingLord",
  "periodCount",
  "finalLord",
  "sequenceContiguous",
  "antardashasContiguous",
  "antardashasSumToParents",
  "closesAtAge120",
];

const TOLERANCE_FIELDS = [
  "remainingFraction",
  "openingBalanceYears",
  "startAge",
  "endAge",
];

function sha256(value) {
  return createHash("sha256").update(value).digest("hex");
}

function requireCondition(condition, message) {
  if (!condition) {
    throw new Error(message);
  }
}

function requireExact(actual, expected, label) {
  requireCondition(
    Object.is(actual, expected),
    label + ": expected " + String(expected) + ", received " + String(actual),
  );
}

function loadConformanceSet(releasePath = DEFAULT_RELEASE_PATH) {
  const rawArtifact = readFileSync(releasePath);
  requireExact(
    sha256(rawArtifact),
    ARTIFACT_SHA256,
    "raw JSON artifact SHA-256",
  );

  let dataset;
  try {
    dataset = JSON.parse(rawArtifact.toString("utf8"));
  } catch (error) {
    throw new Error("release is not valid UTF-8 JSON", { cause: error });
  }

  requireCondition(
    dataset !== null && typeof dataset === "object" && !Array.isArray(dataset),
    "release root must be an object",
  );
  requireExact(dataset.schemaVersion, SCHEMA_VERSION, "schemaVersion");
  requireExact(dataset.releaseId, RELEASE_ID, "releaseId");
  requireExact(dataset.recordCount, RECORD_COUNT, "recordCount");
  requireCondition(Array.isArray(dataset.records), "records must be an array");
  requireExact(dataset.records.length, RECORD_COUNT, "records.length");

  const ids = new Set();
  dataset.records.forEach((record, index) => {
    requireCondition(
      record !== null && typeof record === "object" && !Array.isArray(record),
      "record " + index + " must be an object",
    );
    requireCondition(
      typeof record.id === "string" && record.id.length > 0,
      "record " + index + " must have a non-empty string id",
    );
    ids.add(record.id);
  });
  requireExact(ids.size, RECORD_COUNT, "unique record IDs");

  // JSON.parse preserves the published property order, so this compact digest
  // can additionally pin the record projection in JavaScript.
  requireExact(
    sha256(Buffer.from(JSON.stringify(dataset.records), "utf8")),
    RECORD_SET_SHA256,
    "record-set SHA-256",
  );

  return dataset.records;
}

function assertImplementation(computeCase, records) {
  requireCondition(typeof computeCase === "function", "computeCase must be a function");
  requireCondition(Array.isArray(records), "records must be an array");
  requireExact(records.length, RECORD_COUNT, "records.length");

  records.forEach((expected) => {
    const actual = computeCase(expected.siderealMoonLongitude);
    requireCondition(
      actual !== null && typeof actual === "object" && !Array.isArray(actual),
      expected.id + ": computeCase must return an object",
    );

    EXACT_FIELDS.forEach((field) => {
      requireCondition(
        Object.prototype.hasOwnProperty.call(actual, field),
        expected.id + ": missing " + field,
      );
      requireExact(actual[field], expected[field], expected.id + ": " + field);
    });

    TOLERANCE_FIELDS.forEach((field) => {
      requireCondition(
        Object.prototype.hasOwnProperty.call(actual, field),
        expected.id + ": missing " + field,
      );
      requireCondition(
        typeof actual[field] === "number" && Number.isFinite(actual[field]),
        expected.id + ": " + field + " must be a finite number",
      );
      const difference = Math.abs(actual[field] - expected[field]);
      requireCondition(
        difference <= ABSOLUTE_TOLERANCE,
        expected.id + ": " + field + " differs by " + difference,
      );
    });
  });

  return records.length;
}

module.exports = Object.freeze({
  RELEASE_ID,
  RELEASE_URL,
  ARTIFACT_SHA256,
  loadConformanceSet,
  assertImplementation,
});

// Adapter shape:
// const records = loadConformanceSet();
// assertImplementation((siderealMoonLongitude) => {
//   return yourDashaEngine.computeConformanceCase(siderealMoonLongitude);
// }, records);

"""Offline harness for the immutable Open Vimshottari conformance release.

Download this release once, then run the harness against the local file:
https://chartingstars.com/vedic-chart/conformance/vimshottari-conformance-2026-09-04-v1.json

Scope: supplied, already-sidereal Moon longitudes and Dasha arithmetic only.
This does not compute or validate an ephemeris, ayanamsa, astronomical position,
predictive result, or civil date.
"""

from collections.abc import Mapping
from hashlib import sha256
from math import isfinite
from pathlib import Path

import json


RELEASE_ID = "vimshottari-conformance-2026-09-04-v1"
RELEASE_URL = (
    "https://chartingstars.com/vedic-chart/conformance/"
    "vimshottari-conformance-2026-09-04-v1.json"
)
DEFAULT_RELEASE_PATH = Path("./vimshottari-conformance-2026-09-04-v1.json")
ARTIFACT_SHA256 = (
    "f37e8f3b3514d160fde235857b2b2838de6107fb4f613c590ec2d5afbbef108a"
)
SCHEMA_VERSION = 1
RECORD_COUNT = 81
ABSOLUTE_TOLERANCE = 1e-9

EXACT_FIELDS = (
    "nakshatraIndex",
    "nakshatra",
    "startingLord",
    "periodCount",
    "finalLord",
    "sequenceContiguous",
    "antardashasContiguous",
    "antardashasSumToParents",
    "closesAtAge120",
)

TOLERANCE_FIELDS = (
    "remainingFraction",
    "openingBalanceYears",
    "startAge",
    "endAge",
)


def _require(condition, message):
    if not condition:
        raise AssertionError(message)


def _require_exact(actual, expected, label):
    _require(
        type(actual) is type(expected) and actual == expected,
        f"{label}: expected {expected!r}, received {actual!r}",
    )


def load_conformance_set(release_path=DEFAULT_RELEASE_PATH):
    """Verify the raw local artifact before returning its 81 records."""
    raw_artifact = Path(release_path).read_bytes()
    _require_exact(
        sha256(raw_artifact).hexdigest(),
        ARTIFACT_SHA256,
        "raw JSON artifact SHA-256",
    )

    dataset = json.loads(raw_artifact)
    _require(type(dataset) is dict, "release root must be an object")
    _require_exact(dataset.get("schemaVersion"), SCHEMA_VERSION, "schemaVersion")
    _require_exact(dataset.get("releaseId"), RELEASE_ID, "releaseId")
    _require_exact(dataset.get("recordCount"), RECORD_COUNT, "recordCount")

    records = dataset.get("records")
    _require(type(records) is list, "records must be an array")
    _require_exact(len(records), RECORD_COUNT, "records length")

    ids = set()
    for index, record in enumerate(records):
        _require(type(record) is dict, f"record {index} must be an object")
        record_id = record.get("id")
        _require(
            type(record_id) is str and len(record_id) > 0,
            f"record {index} must have a non-empty string id",
        )
        ids.add(record_id)
    _require_exact(len(ids), RECORD_COUNT, "unique record IDs")

    # The raw artifact hash above is the cross-language byte contract. Do not
    # recreate the JavaScript record digest with json.dumps: Python's number
    # serialization is not the published JSON.stringify serialization.
    return records


def assert_implementation(compute_case, records):
    """Run compute_case(longitude) against every published Dasha vector."""
    _require(callable(compute_case), "compute_case must be callable")
    _require(type(records) is list, "records must be an array")
    _require_exact(len(records), RECORD_COUNT, "records length")

    for expected in records:
        actual = compute_case(expected["siderealMoonLongitude"])
        _require(
            isinstance(actual, Mapping),
            f"{expected['id']}: compute_case must return a mapping",
        )

        for field in EXACT_FIELDS:
            _require(field in actual, f"{expected['id']}: missing {field}")
            _require_exact(
                actual[field],
                expected[field],
                f"{expected['id']}: {field}",
            )

        for field in TOLERANCE_FIELDS:
            _require(field in actual, f"{expected['id']}: missing {field}")
            value = actual[field]
            _require(
                not isinstance(value, bool)
                and isinstance(value, (int, float))
                and isfinite(value),
                f"{expected['id']}: {field} must be a finite number",
            )
            difference = abs(value - expected[field])
            _require(
                difference <= ABSOLUTE_TOLERANCE,
                f"{expected['id']}: {field} differs by {difference}",
            )

    return len(records)


# Adapter shape:
# records = load_conformance_set()
# assert_implementation(
#     lambda sidereal_moon_longitude: your_dasha_engine.compute_conformance_case(
#         sidereal_moon_longitude
#     ),
#     records,
# )