kshana 0.7.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Ashforde OÜ
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,538 @@
+<h1 align="center">
+  <img src="docs/assets/kshana-banner.svg" alt="Kshana — the precise instant. Open, reproducible hybrid quantum/classical PNT performance simulation." width="760">
+</h1>
+
+<p align="center">
+  <a href="https://github.com/ashfordeOU/kshana/actions/workflows/ci.yml"><img src="https://github.com/ashfordeOU/kshana/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <a href="https://github.com/ashfordeOU/kshana/releases"><img src="https://img.shields.io/github/v/release/ashfordeOU/kshana?sort=semver" alt="Release"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/License-Apache_2.0-blue.svg" alt="License: Apache-2.0"></a>
+  <a href="Cargo.toml"><img src="https://img.shields.io/badge/rust-1.75%2B-orange.svg" alt="Rust 1.75+"></a>
+</p>
+
+<p align="center">
+  <strong>Kshana</strong> (क्षण, Sanskrit: <em>"the precise instant"</em>) is an open, reproducible
+  simulator for <strong>hybrid quantum/classical PNT</strong> — positioning, navigation, and timing.
+</p>
+
+It quantifies, in hard and reproducible numbers, what quantum clocks, quantum
+inertial sensors, and optical time-transfer buy a navigation system over classical
+PNT — scored against the operational figures of merit that matter for resilient
+navigation. Every result is reproducible from `scenario + seed + engine version`,
+and every sensor parameter is traceable to a published source.
+
+*Free and open source under Apache-2.0, professionally developed and maintained by
+Ashforde OÜ — commercial support, integration, and proprietary extensions available.*
+
+> **Status: research-grade, v0.6.0.** Four sensor packs that each report all six
+> operational figures of merit (including a clock-aided spoof-detection security
+> score, with an active spoofing-attack demonstrator), a joint Kalman fusion
+> estimator and an integrity bound, multi-constellation geometry-derived GNSS
+> availability *and* position accuracy (dilution of precision) from orbits — synthetic
+> Walker, Keplerian mean elements, or full two-line element sets propagated with
+> **SGP4/SDP4** (validated against the AIAA 2006-6753 vectors) — a full IMU
+> Allan-variance noise model, Monte Carlo confidence bands,
+> trade-study parameter sweeps, and a shareable HTML scorecard — all calibrated to
+> published data and validated against the standard relations, with optional Python and
+> WebAssembly bindings and a browser playground. Read [`docs/VALIDATION.md`](docs/VALIDATION.md)
+> before citing any number — each noise term is labelled `validated` or `not modeled`,
+> and optical-clock figures are *space goals on ground hardware* (no strontium optical
+> clock has flown).
+
+> **Try it in your browser:** the [playground](web/) runs the engine client-side as
+> WebAssembly — pick a scenario, edit the parameters, and see the result, with nothing
+> uploaded. Build it locally with `./web/build.sh` (see [`web/README.md`](web/README.md)),
+> or publish it to GitHub Pages via the `pages` workflow.
+
+> **New to this?** In plain terms: GPS-style satellite signals tell things *where they
+> are* and *what time it is*. When those signals are lost (jammed, blocked, or out of
+> view in space), a system has to keep going on its own onboard clock and motion
+> sensors — and they slowly drift. "Quantum" clocks and sensors drift far more slowly.
+> Kshana measures, in honest numbers, **how much longer a quantum-equipped system can
+> coast** before it exceeds its accuracy limits. New readers should start with the
+> [plain-language primer](docs/CONCEPTS.md) and the [glossary](docs/GLOSSARY.md).
+
+---
+
+## Contents
+
+- [Why](#why) · [What it is / is not](#what-it-is--is-not) · [Results](#results)
+- [Install & build](#install--build) · [Usage](#usage) ([Python](#python), [WebAssembly](#webassembly))
+- [Scenario format](#scenario-format) · [Output](#output) · [Architecture](#architecture)
+- [Repository layout](#repository-layout) · [Validation & honesty](#validation-reproducibility--honesty)
+- [Documentation](#documentation) · [FAQ](#faq) · [Troubleshooting](#troubleshooting)
+- [Roadmap](#roadmap) · [Contributing](#contributing) · [Citing](#citing) · [License](#license)
+- [Support & professional services](#support--professional-services) · [References](#key-references)
+
+## Why
+
+Resilient PNT depends on holding position and time when GNSS is denied or jammed.
+Quantum sensors promise far slower drift during those outages. There is no good
+**open** tool to quantify that advantage honestly and reproducibly — so primes,
+agencies, and labs each rebuild private one-offs. Kshana aims to be the neutral,
+citable reference for exactly this question.
+
+The engine knows nothing about "quantum" vs "classical": each sensor is an
+**error model** plugged into a common pipeline, so a quantum and a classical
+device are compared *apples-to-apples* on the same scenario, with independent
+noise realizations.
+
+## What it is / is not
+
+**It is:** a deterministic engine that runs a GNSS-outage scenario, evolves
+calibrated sensor error models, runs a holdover/dead-reckoning estimator, and
+scores the result against six figures of merit, emitting a JSON result and an SVG
+chart.
+
+**It is not:** flight hardware, a quantum-payload design, or a full GNSS receiver.
+Quantum-hardware fidelity comes from published error models, not from this tool.
+
+## Results
+
+Each scenario compares a quantum sensor against its classical counterpart through a
+~1.8 h GNSS outage. Numbers are reproducible (`scenario + seed + version`).
+
+<p align="center">
+  <img src="docs/assets/inertial-deadreckoning.svg" alt="Inertial dead-reckoning: position error during a GNSS outage — the quantum (cold-atom) sensor stays near the spec line while the navigation-grade sensor diverges to tens of kilometres" width="80%">
+  <br><em>Dead-reckoning position error during a GNSS outage: the quantum sensor (blue)
+  stays flat near the spec; the classical sensor (red) diverges to tens of kilometres.
+  Generated by Kshana from <code>scenarios/imu-deadreckoning.toml</code>.</em>
+</p>
+
+| Pack | Scenario | Quantum | Classical |
+|------|----------|---------|-----------|
+| **1 — Clock holdover** | `clock-holdover.toml` (20 ns spec) | optical clock holds the full outage | CSAC breaches the spec mid-outage |
+| **2 — Inertial dead-reckoning** | `imu-deadreckoning.toml` (100 m spec) | cold-atom: **~41 m**, holds full outage | nav-grade: breaches in **~350 s** → tens of km |
+| **3 — Time transfer** (optical inter-satellite link) | `timetransfer.toml` | optical: **~0.3 mm** ranging | RF (TWSTFT): **~150 mm** ranging |
+| **4 — Hybrid fusion** (capstone) | `hybrid-pnt.toml` | full position+timing for the whole outage | **position-limited at ~350 s** |
+
+The capstone shows the fusion thesis: optical inter-satellite time-transfer keeps even
+a classical *clock* locked, isolating the *inertial* sensor as the classical suite's
+weak link — i.e. quantum inertial + optical timing together.
+
+A further scenario, `orbit-gnss-challenged.toml`, derives GNSS availability from
+**orbital geometry** rather than hand-authored windows: a spacecraft inside the GNSS
+shell is propagated against a GPS-like Walker constellation, and the visible-satellite
+count (line-of-sight, Earth-occultation, elevation mask) sets the fix state at each
+step. Over a day the user is in fix only ~59% of the time; the quantum clock holds a
+5 ns timing solution through every gap (availability **1.0**), the chip-scale clock
+only **~0.83**.
+
+The constellation can also be given as real two-line element sets. A *full* TLE
+(line 1 + line 2) is propagated with the full **SGP4/SDP4** model — including
+atmospheric drag and the deep-space lunar-solar and 12 h / 24 h resonance terms that
+matter for ~12 h GNSS orbits — validated against the official AIAA 2006-6753 vectors
+to a worst-case ≈ 4 mm (`scenarios/orbit-sgp4-gps.toml`). A line-2-only block keeps
+the analytic two-body propagation (`scenarios/orbit-real-tle.toml`); the two forms can
+be mixed in one constellation.
+
+## Install & build
+
+Requires a Rust toolchain (≥ 1.75; developed on 1.93).
+
+```bash
+git clone https://github.com/AshfordeOU/kshana
+cd kshana
+cargo build --release
+cargo test          # all tests pass
+```
+
+## Usage
+
+Run any scenario; the CLI dispatches on the scenario's `kind` field and writes a
+`<scenario>.result.json` and a `<scenario>.chart.svg` next to it:
+
+```bash
+cargo run -- scenarios/clock-holdover.toml
+cargo run -- scenarios/imu-deadreckoning.toml
+cargo run -- scenarios/timetransfer.toml
+cargo run -- scenarios/hybrid-pnt.toml
+cargo run -- scenarios/orbit-gnss-challenged.toml
+cargo run -- scenarios/orbit-sgp4-gps.toml
+```
+
+Example output (clock holdover — note the Integrity and Security figures of merit):
+
+```
+scenario c827e5d40d25 | quantum holdover 6600s p95 0.0ns integrity 1.000 security 0.997 | classical holdover 2610s p95 19.7ns integrity 1.000 security 0.000
+wrote scenarios/clock-holdover.result.json and scenarios/clock-holdover.chart.svg
+```
+
+The optical clock's tight detection floor keeps `security 0.997`; the chip-scale
+clock's own noise over the monitoring window exceeds the 20 ns spec, so it has no
+spoof-detection margin (`security 0.000`). The orbit scenario additionally reports a
+geometry block — fraction of samples with a fix, and best/median PDOP and position
+accuracy — alongside the clock result.
+
+### Python
+
+An optional Python extension (PyO3, abi3) wraps the same engine. Build and install
+it with [maturin](https://www.maturin.rs/):
+
+```bash
+pip install maturin
+maturin develop --features python   # or: maturin build --features python
+```
+
+```python
+import json, kshana
+
+result = json.loads(kshana.run(open("scenarios/clock-holdover.toml").read()))
+print(result["quantum"]["fom"]["integrity"])
+
+# json, svg, and a one-line summary at once:
+result_json, chart_svg, summary = kshana.run_full(open("scenarios/orbit-gnss-challenged.toml").read())
+print(kshana.version(), summary)
+```
+
+Wheels are built for Linux, macOS, and Windows by the `wheels` workflow on each
+release tag.
+
+### WebAssembly
+
+The engine also runs in the browser via [wasm-pack](https://rustwasm.github.io/wasm-pack/):
+
+```bash
+wasm-pack build --target web -- --features wasm
+```
+
+```js
+import init, { run, chart_svg, version } from "./pkg/kshana.js";
+await init();
+const result = JSON.parse(run(tomlText));
+console.log(version(), result.classical.fom.timing_p95_ns);
+```
+
+## Scenario format
+
+Scenarios are declarative TOML. A top-level `kind` selects the pack
+(`clock` is the default if omitted; `inertial`, `timetransfer`, `hybrid`, `orbit`).
+Common fields: `seed`, a `[time]` grid, a `[gnss]` availability timeline (the outage
+driver), and per-sensor blocks with `provenance` strings citing the source of every
+figure. Example (clock):
+
+```toml
+seed = 42
+threshold_ns = 20.0
+[time]
+step_s = 10.0
+duration_s = 7200.0
+[gnss]
+windows = [
+  { t0 = 0.0,   t1 = 600.0,  state = "nominal" },  # 10 min GNSS sync
+  { t0 = 600.0, t1 = 7200.0, state = "denied"  },  # ~1.8 h outage
+]
+[clock_quantum]
+id = "optical-sr-lattice"
+provenance = "Strontium optical lattice clock, space-oriented goal sigma_y(1s)=1e-15 (arXiv:1503.08457)"
+y0 = 5.0e-17
+q_wf = 1.0e-30   # white FM:  q_wf = sigma_y(1s)^2
+q_rw = 0.0       # random-walk FM
+drift = 0.0      # linear aging (per second)
+[clock_classical]
+id = "csac-sa45s"
+provenance = "Microchip SA65 / SA.45s CSAC datasheet sigma_y(1s)=3e-10"
+y0 = 5.0e-10
+q_wf = 9.0e-20
+q_rw = 0.0
+drift = 0.0
+```
+
+Optional fields (off when absent): a clock may add `flicker_floor` (1/f FM Allan
+floor); an inertial sensor may add `gyro_bias` and `q_arw` (gyro bias and angular
+random walk), and `bias_instability` and `q_aa` (the Allan bias-instability floor and
+acceleration random walk), completing the IMU Allan-variance noise model. A
+clock-holdover scenario may add `runs` (> 1) to run a **Monte Carlo ensemble** — each
+figure of merit is then reported as a mean with a 5th–95th-percentile spread and the
+chart shades the error confidence band (see `scenarios/clock-ensemble.toml`).
+
+A `fusion` scenario (same blocks as `hybrid`) runs a single joint Kalman filter as the
+navigator — fusing the clock and position states, disciplined by GNSS and aided by
+optical time transfer — and reports fused holdover with a joint-covariance integrity
+(see `scenarios/fusion-pnt.toml`).
+
+A `spoof` scenario injects a ramping false-time spoof (an `[attack]` block with
+`start_s` and `rate_ns_per_s`) and runs each clock's integrity monitor, reporting
+whether and when the spoof is detected and whether it reaches the spec undetected — a
+concrete demonstration of the Security figure of merit (see `scenarios/spoof-attack.toml`).
+
+A `sweep` scenario runs a **trade study**: it varies one `parameter` (`threshold_ns`,
+`duration_s`, `quantum_q_wf`, or `classical_q_wf`) from `start` to `stop` over `steps`
+points on a `lin` or `log` `scale`, records a `metric` (e.g. `holdover_s`) for both
+clocks, and charts the two curves. The base scenario goes under `[base]` (see
+`scenarios/sweep-clock-stability.toml`).
+
+An `orbit` scenario derives the `[gnss]` timeline from geometry instead of authoring
+it — give a `[user]` orbit, a `[constellation]`, an elevation `mask_deg`, and the two
+clock blocks. It also reports position accuracy from the satellite geometry; the
+optional `sigma_uere_m` (1-sigma user-equivalent range error, default 1 m) scales the
+position dilution of precision into a position sigma. The user orbit may be made
+**eccentric** with `eccentricity` and `argp_deg`, and `j2 = true` adds Earth-oblateness
+secular drift (see `scenarios/orbit-molniya.toml`). The constellation can instead be a
+**real one**: give `[constellation]` a `tle` block of two-line element sets and the
+satellites are parsed from it (see `scenarios/orbit-real-tle.toml`). Add one or more
+`[[constellations]]` blocks for **multi-GNSS** (e.g. GPS + Galileo; see
+`scenarios/orbit-multignss.toml`):
+
+```toml
+kind = "orbit"
+seed = 7
+threshold_ns = 5.0
+mask_deg = 10.0
+sigma_uere_m = 1.0           # optional; position sigma = position-DOP * this
+[time]
+step_s = 60.0
+duration_s = 86400.0
+[user]                       # spacecraft (altitude in km, angles in deg)
+altitude_km = 8000.0
+inclination_deg = 0.0
+[constellation]              # Walker-delta GNSS (GPS-like)
+altitude_km = 20180.0
+inclination_deg = 55.0
+planes = 6
+sats_per_plane = 4
+phasing_f = 1.0
+[clock_quantum]  # ... as above
+[clock_classical]  # ... as above
+```
+
+See `scenarios/` for one example of every kind.
+
+## Output
+
+The result artifact is versioned, self-describing JSON: per-step time series, the
+scored figures of merit, the active model specs (with provenance), the seed, and a
+**scenario hash** — so any chart can be reproduced from the file. The figures of
+merit follow the standard operational PNT figures of merit:
+
+| Figure of merit | How Kshana computes it |
+|-----------------|------------------------|
+| Positioning / Timing Performance | RMS + 95th-percentile error over the outage |
+| Autonomy | holdover duration — time in-spec after GNSS loss |
+| Resilience | error-growth slope during the outage |
+| Availability | fraction of the run with an in-spec solution |
+| Integrity | protection-level containment — fraction of outage samples whose error stays inside the Kalman filter's k-sigma bound (clock pack) |
+| Security | clock-aided spoof-detection score — how far below the timing spec a time-spoof can be flagged by cross-checking GNSS time against the clock's own coasted prediction (clock and orbit packs) |
+
+New to these terms? Each is defined in plain language in the [glossary](docs/GLOSSARY.md).
+
+## Architecture
+
+One engine; each sensor pack plugs in via a common error-model interface. See
+[`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) for the full set of diagrams.
+
+```mermaid
+flowchart LR
+    SCN["Scenario (.toml)<br/>seed · GNSS timeline · sensor params"] --> ENG
+    subgraph ENG["Engine (per step)"]
+      direction TB
+      M["Error model<br/>step(): evolve noise state"] --> E["Estimator<br/>GNSS-disciplined holdover"]
+      E --> F["FoM scoring<br/>vs the 6 figures of merit"]
+    end
+    ENG --> OUT["result.json + chart.svg<br/>(reproducible: scenario+seed+version)"]
+```
+
+```mermaid
+flowchart TD
+    cli["CLI · Python · WebAssembly"] --> api["api — run_toml: dispatch by kind"]
+    subgraph shared["Shared core"]
+      types["types"]
+      scenario["scenario · GNSS timeline"]
+      allan["allan — Allan deviation"]
+    end
+    subgraph p1["Pack 1 · Clock"]
+      models["models — ClockModel (+ flicker)"]
+      estimator["estimator — holdover"]
+      kalman["kalman — Integrity bound"]
+      security["security — spoof-detection score"]
+      fom["fom · report · run"]
+    end
+    p2["Pack 2 · inertial — accel + gyro"]
+    p3["Pack 3 · timetransfer — optical/RF link"]
+    p4["Pack 4 · hybrid — fused PNT suite"]
+    orbit["orbit — geometry → GNSS timeline + DOP"]
+    api --> p1
+    api --> p2
+    api --> p3
+    api --> p4
+    p1 --> shared
+    p2 --> shared
+    p3 --> shared
+    orbit --> p1
+    p4 -. composes .-> p1
+    p4 -. composes .-> p2
+    p4 -. composes .-> p3
+```
+
+## Repository layout
+
+```
+kshana/
+├── src/
+│   ├── types.rs        # Seconds, TimeGrid, ModelSpec
+│   ├── scenario.rs     # GNSS timeline, clock scenario config
+│   ├── models.rs       # ErrorModel trait, ClockModel (white FM, RWFM, aging)
+│   ├── estimator.rs    # HoldoverEstimator (quadratic offset+aging removal)
+│   ├── fom.rs          # figure-of-merit scoring
+│   ├── allan.rs        # overlapping Allan deviation
+│   ├── kalman.rs       # two-state Kalman clock estimator + integrity bound
+│   ├── report.rs       # result schema, scenario hash, SVG chart (clock)
+│   ├── run.rs          # clock + orbit-clock run pipelines
+│   ├── inertial.rs     # Pack 2: inertial dead-reckoning (accel + gyro) + FoMs
+│   ├── timetransfer.rs # Pack 3: optical/RF time-transfer link
+│   ├── hybrid.rs       # Pack 4: combined PNT suite + ISL clock-aiding
+│   ├── orbit.rs        # orbit propagation + GNSS line-of-sight visibility
+│   ├── api.rs          # scenario dispatch shared by the CLI and bindings
+│   ├── python.rs       # optional PyO3 extension (feature = "python")
+│   ├── wasm.rs         # optional wasm-bindgen module (feature = "wasm")
+│   └── main.rs         # CLI
+├── scenarios/          # cited scenarios (one per pack + a geometry-driven one)
+├── scripts/            # reproducibility + repo-hygiene guards
+├── docs/               # CONCEPTS, ARCHITECTURE, VALIDATION, GLOSSARY, assets/
+├── .github/workflows/  # CI gate, release, and wheel-build pipelines
+├── pyproject.toml      # Python packaging (maturin)
+├── CHANGELOG.md        # Keep a Changelog + SemVer
+└── CONTRIBUTING.md
+```
+
+## Documentation
+
+| Document | For whom | What's in it |
+|----------|----------|--------------|
+| [Concepts primer](docs/CONCEPTS.md) | everyone, start here | what Kshana does and why, from zero to the physics |
+| [Playground](web/README.md) | everyone | run the engine in your browser (WebAssembly); build &amp; deploy notes |
+| [Glossary](docs/GLOSSARY.md) | everyone | plain-language definitions of every term |
+| [Architecture](docs/ARCHITECTURE.md) | developers / reviewers | module map, engine pipeline, dispatch, and diagrams |
+| [Validation status](docs/VALIDATION.md) | reviewers / citers | what is `validated` vs `not modeled`, with evidence |
+| [Changelog](CHANGELOG.md) | everyone | released history (Keep a Changelog + SemVer) |
+| [Contributing](CONTRIBUTING.md) | contributors | build, guards, test/citation discipline, DCO |
+| [Code of Conduct](CODE_OF_CONDUCT.md) | community | expected conduct (Contributor Covenant) |
+| [Security policy](SECURITY.md) | reporters | how to report a vulnerability; dual-use note |
+
+## Validation, reproducibility & honesty
+
+- Every noise term is calibrated to a **published, cited** figure and validated
+  against the standard relation (Allan deviation for clocks; Groves' dead-reckoning
+  error growth for inertial; the timing→ranging conversion for time transfer). Status
+  per term is tracked in [`docs/VALIDATION.md`](docs/VALIDATION.md) as `validated` or
+  `not modeled` — nothing is presented as validated that is not.
+- **Reproducible by construction:** `scenario + seed + engine version → identical
+  bits`. `scripts/check-reproducible.sh` enforces it; quantum and classical runs use
+  independent seeds so their noise is uncorrelated.
+- Maturity is stated honestly: optical-clock and optical-link figures are *targets /
+  ground-demonstrator* results, not flown.
+
+## FAQ
+
+**Do I need to understand quantum physics to use this?**
+No. If you can run a command line you can run Kshana. Start with the
+[plain-language primer](docs/CONCEPTS.md); look terms up in the [glossary](docs/GLOSSARY.md).
+
+**Is this a quantum-hardware design or flight software?**
+No. It is a performance *simulator*. Quantum-hardware fidelity comes from published
+error models, not from this tool. See [What it is / is not](#what-it-is--is-not).
+
+**Are the quantum results realistic, or marketing?**
+Every parameter is cited to a datasheet or paper, every model is validated against a
+textbook relation, and maturity is labelled honestly in
+[VALIDATION.md](docs/VALIDATION.md) — including that no strontium optical clock has
+flown. The engine is neutral: quantum and classical are the same code with different
+published numbers.
+
+**Can I trust two runs to agree?**
+Yes — runs are deterministic: `scenario + seed + engine version → bit-identical output`,
+enforced by `scripts/check-reproducible.sh`.
+
+**Can I use it from Python or in a browser?**
+Yes — see [Python](#python) and [WebAssembly](#webassembly). Both call the same engine.
+
+**How do I model my own sensor?**
+Write a scenario `.toml` with your sensor's published figures in the `provenance`
+fields. See [Scenario format](#scenario-format) and the examples in `scenarios/`.
+
+**Is it free for commercial use?**
+Yes, under Apache-2.0. Optional commercial support and proprietary extensions are
+available — see [Support](#support--professional-services).
+
+## Troubleshooting
+
+**`cargo build` fails on an old toolchain.** Kshana needs Rust ≥ 1.75. Update with
+`rustup update`.
+
+**Building the Python extension fails to link on macOS** (`Undefined symbols … _Py…`).
+A Python extension resolves its symbols at load time. `maturin` sets the right linker
+flag automatically — use `maturin develop --features python` rather than a bare
+`cargo build`.
+
+**The Python build complains the interpreter is newer than PyO3 knows.** Set
+`PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1` (abi3 wheels are forward-compatible across
+CPython versions).
+
+**WebAssembly build can't find the target.** Install it once with
+`rustup target add wasm32-unknown-unknown`, then `wasm-pack build --target web -- --features wasm`.
+
+**Where did my output go?** Each run writes `<scenario>.result.json` and
+`<scenario>.chart.svg` next to the input `.toml`. These are git-ignored by design.
+
+## Roadmap
+
+See [`CHANGELOG.md`](CHANGELOG.md) for released history and the `[Unreleased]`
+section for what's next (higher-fidelity SGP4 orbit propagation). An active
+spoofing-attack demonstrator, multi-constellation availability, a full IMU
+Allan-variance noise model, a joint Kalman fusion estimator, real constellation
+geometry from TLEs, an HTML scorecard report, a clock-aided spoof-detection Security
+score across all four packs, geometry-derived GNSS availability *and* position
+accuracy (dilution of precision) from Keplerian orbits with eccentricity and J2 drift,
+Monte Carlo confidence bands, trade-study parameter sweeps, an in-browser WebAssembly
+playground, and optional Python (PyO3) and WebAssembly (wasm-bindgen) bindings have
+landed on `main`.
+
+## Contributing
+
+See [`CONTRIBUTING.md`](CONTRIBUTING.md). In short: tests pass (`cargo test`), the
+two guard scripts pass, Conventional Commits, and a `CHANGELOG.md` `[Unreleased]`
+entry for every user-visible change. Participation is governed by our
+[Code of Conduct](CODE_OF_CONDUCT.md). To report a security issue, see the
+[Security policy](SECURITY.md) — please do not open a public issue for vulnerabilities.
+
+## Citing
+
+If you use Kshana in academic or technical work, please cite it. Machine-readable
+metadata is in [`CITATION.cff`](CITATION.cff) (GitHub renders a "Cite this repository"
+button from it); cite the version you used (e.g. `v0.6.0`).
+
+## License
+
+Apache-2.0 — see [`LICENSE`](LICENSE). Contributions are accepted under the same
+license (inbound = outbound); sign commits off per the Developer Certificate of
+Origin with `git commit -s`.
+
+**Trademark.** "Kshana" and its marks are trademarks of Ashforde OÜ. The license
+covers the code, not the name — please rename forks and derivative distributions.
+
+## Support & professional services
+
+Kshana is free and open source under Apache-2.0 and **professionally developed and
+maintained by Ashforde OÜ** (Estonia). The open engine is complete and usable on its
+own. For organisations that need more, Ashforde OÜ offers:
+
+- **Commercial support & integration** — embedding Kshana in your toolchain, custom
+  scenarios, and priority fixes.
+- **Custom sensor models** — calibrated to your hardware, including export-sensitive
+  resilience models maintained in a private overlay.
+- **Kshana Pro** — proprietary model-based systems-engineering and programme tooling
+  that plugs into the open engine to complete the workflow.
+- **Training & consulting** on quantum/classical PNT performance analysis.
+
+This is the open-core model: the engine is, and stays, openly licensed; the sustaining
+business is expertise, support, and the proprietary extensions — not license fees.
+Contact **contact@ashforde.org**.
+
+## Key references
+
+- Riley, *Handbook of Frequency Stability Analysis* — [NIST SP 1065](https://tf.nist.gov/general/pdf/2220.pdf) (Allan-deviation relations).
+- Origlia, Schiller, Bongs et al. — [arXiv:1503.08457](https://arxiv.org/abs/1503.08457) (strontium optical lattice clock, space-oriented goal).
+- Oelker et al., *Nature Photonics* (2019) — [JILA PDF](https://jila-pfc.colorado.edu/sites/default/files/2019-09/Oelker-Sr%20record%20stability_2019-Nature_Photonics.pdf) (laboratory Sr clock, 4.8×10⁻¹⁷).
+- Templier et al., *Science Advances* (2022) — [arXiv:2209.13209](https://arxiv.org/abs/2209.13209) (hybrid quantum accelerometer triad).
+- Groves, *Principles of GNSS, Inertial, and Multisensor Integrated Navigation* — [IEEE AESS tutorial (UCL Discovery)](https://discovery.ucl.ac.uk/id/eprint/1470141/) (dead-reckoning error growth).
+- Giorgetta et al., *Nature Photonics* 7, 434 (2013) — [arXiv:1211.4902](https://arxiv.org/abs/1211.4902); Deschênes et al., *Phys. Rev. X* 6, 021016 (2016) — [APS](https://journals.aps.org/prx/abstract/10.1103/PhysRevX.6.021016) (optical two-way time-frequency transfer).
+- Optical inter-satellite time-transfer concept — see Giorgetta and Deschênes above.

package/kshana.d.ts

@@ -0,0 +1,61 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Run a scenario and return its SVG chart.
+ */
+export function chart_svg(toml: string): string;
+
+/**
+ * Run a scenario given as a TOML string; returns the result document as a JSON
+ * string. Throws a JS error if the scenario is invalid.
+ */
+export function run(toml: string): string;
+
+/**
+ * Run a scenario and return its one-line human-readable summary.
+ */
+export function summary(toml: string): string;
+
+/**
+ * Engine version (the crate version).
+ */
+export function version(): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly chart_svg: (a: number, b: number) => [number, number, number, number];
+    readonly run: (a: number, b: number) => [number, number, number, number];
+    readonly summary: (a: number, b: number) => [number, number, number, number];
+    readonly version: () => [number, number];
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/kshana.js

@@ -0,0 +1,300 @@
+/* @ts-self-types="./kshana.d.ts" */
+
+/**
+ * Run a scenario and return its SVG chart.
+ * @param {string} toml
+ * @returns {string}
+ */
+export function chart_svg(toml) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(toml, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.chart_svg(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);
+    }
+}
+
+/**
+ * Run a scenario given as a TOML string; returns the result document as a JSON
+ * string. Throws a JS error if the scenario is invalid.
+ * @param {string} toml
+ * @returns {string}
+ */
+export function run(toml) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(toml, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.run(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);
+    }
+}
+
+/**
+ * Run a scenario and return its one-line human-readable summary.
+ * @param {string} toml
+ * @returns {string}
+ */
+export function summary(toml) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(toml, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.summary(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);
+    }
+}
+
+/**
+ * Engine version (the crate version).
+ * @returns {string}
+ */
+export function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.version();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __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,
+        "./kshana_bg.js": import0,
+    };
+}
+
+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();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = 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;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('kshana_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "kshana",
+  "type": "module",
+  "collaborators": [
+    "Chakshu Baweja <contact@ashforde.org>"
+  ],
+  "description": "Open hybrid quantum/classical PNT performance simulator",
+  "version": "0.7.0",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AshfordeOU/kshana"
+  },
+  "files": [
+    "kshana_bg.wasm",
+    "kshana.js",
+    "kshana.d.ts"
+  ],
+  "main": "kshana.js",
+  "homepage": "https://github.com/AshfordeOU/kshana",
+  "types": "kshana.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ],
+  "keywords": [
+    "pnt",
+    "navigation",
+    "quantum",
+    "gnss",
+    "simulation"
+  ]
+}