mozhi 0.1.0__tar.gz

mozhi-0.1.0/LANGUAGE.md

@@ -0,0 +1,71 @@
+# Mozhi language notes
+
+This describes the current CLI and generated asynchronous browser adapter unless a distinction is stated. It is a working language note, not a complete formal specification.
+
+## Grammar shape
+
+```mozhi
+score = 10 vechukko
+"Score: " kooda score sollu
+
+score >= 10 na:
+    "Ready" sollu
+illana:
+    "Try again" sollu
+mudivu
+```
+
+Expressions precede output, return and conditional/loop keywords; assignment combines infix `=` with trailing `vechukko`. Colons, indentation and `mudivu` delimit blocks. Identifiers use ASCII letters, digits and underscore. `#` starts a comment outside strings. Literals include numbers, quoted strings, `true`, `false`, and arrays.
+
+## Loops, functions and arrays
+
+```mozhi
+seiy double(x):
+    x * 2 thirumbu
+mudivu
+double(5) sollu
+
+items = [1, 2] vechukko
+3 ullapodu items
+items veliyapodu
+items[0] sollu
+
+i = 0 vechukko
+i < 3 varaikum:
+    i = i + 1 vechukko
+    i sollu
+mudivu
+```
+
+`nillu` breaks a loop; `thodaru` continues it. Pop is postfix: `items veliyapodu`. Indexed reads are supported; indexed assignment is not implemented. Both adapters update existing variables through the parent scope chain; function and method parameters bind locally.
+
+## Objects
+
+```mozhi
+vagai Counter:
+    seiy start(naan):
+        naan.value = 0 vechukko
+    mudivu
+    seiy show(naan):
+        naan.value sollu
+    mudivu
+mudivu
+c = Counter porul vechukko
+c.start()
+c.show()
+```
+
+The first method parameter receives the instance. Initializer methods are called explicitly, not automatically. Property reads, assignments and method closures work in both adapters. Missing properties and invalid method arguments report errors.
+
+## Builtins and operators
+
+Both adapters support `kelu("Prompt")` and `ketukko("Prompt")` as aliases. Browser input is asynchronously awaited; CLI input is synchronous. Input returns a string. `enn` converts to integer, `padam` to float, `vaari` to string, and `neelam` returns length. `+`/`kooda` concatenate if either operand is a string. `mattrum`, `illaiyal`, `illa` are and/or/not, with short-circuit evaluation of binary operands. They still return `true` or `false`, rather than returning an operand value. Comparison operators and `+ - * / %` are implemented. Exponentiation is right-associative and follows Python precedence: `2 ** 3 ** 2` is `512`, `-2 ** 2` is `-4`, and `2 ** -2` is `0.25`. `podhum` stops the entire current program, including nested calls, in either adapter; it does not kill the reusable browser engine.
+
+Block updates in both adapters search parent environments; new variables are created locally. Function/method parameters bind locally. These are current implementation observations, not a promise of Python semantics.
+
+
+## Validation and execution controls
+
+Indentation must follow a colon and dedent to an existing block level. Tabs expand to four columns; mixing tabs and spaces in a single indentation prefix is rejected. Function/method parameters must be unique and supplied in the correct count. Methods require an instance parameter. `nillu` and `thodaru` must belong to a loop in the current function; `thirumbu` requires a function or method. Array indices must be integers, not booleans. Errors include the failing statement line.
+
+The playground's worker can be stopped or automatically terminated after its configurable execution budget (10 seconds by default). Input waits pause that budget. The CLI has no execution limit; intentionally endless programs require Ctrl+C or an external timeout. Runtime errors stop the current run and leave the playground ready for another program.

mozhi-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 sm1else-bot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mozhi-0.1.0/MANIFEST.in

@@ -0,0 +1,9 @@
+include LICENSE README.md PROVENANCE.md LANGUAGE.md
+recursive-include examples *.mozhi
+recursive-include tests *.py
+recursive-include tools *.py
+include requirements-build.txt
+include packaging/mozhi.spec
+recursive-include packaging *.py *.json *.md
+include src/mozhi.py
+include playground/runtime.py

mozhi-0.1.0/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: mozhi
+Version: 0.1.0
+Summary: A Tamil-inspired, verb-final interpreted programming language
+Author: Jessenth Ebenezer
+License-Expression: MIT
+Project-URL: Homepage, https://projects.jessenth.com/mozhi/
+Project-URL: Repository, https://github.com/sm1else-bot/mozhi
+Project-URL: Documentation, https://projects.jessenth.com/mozhi/learn/
+Project-URL: Issues, https://github.com/sm1else-bot/mozhi/issues
+Keywords: interpreter,programming-language,tamil,tanglish
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Mozhi
+
+A Tanglish programming language with Tamil-inspired, verb-final syntax.
+
+```mozhi
+"Vanakkam, world!" sollu
+a = 10 vechukko
+"Value: " kooda a sollu
+```
+
+Mozhi explores grammar as well as vocabulary. `sollu` (say) follows the expression, `vechukko` (keep/store) closes an assignment, and conditions precede `na` or `varaikum`. Assignment still uses infix `=`, so this is a hybrid syntax rather than a fully postfix stack language. Tamil has many dialects and constructions; Mozhi is an experiment, not a complete model of Tamil grammar.
+
+**Historical note:** Mozhi was conceived on May 31, 2026, and developed further in June 2026. This GitHub repository was first published on October 27, 2026. Its early Git commits are retrospectively dated archival reconstructions from recovered source files and development records, not original commits made at that time. See [PROVENANCE.md](https://github.com/sm1else-bot/mozhi/blob/main/PROVENANCE.md) for methodology and evidence.
+
+## Status
+
+This is an experimental language with an explicitly preserved archival history. The current CLI and browser adapters share parser/runtime fixes through generated browser code. Neither is production-ready, Python-compatible, or a sandbox for untrusted code. Original interpreter stages remain unchanged in the archival commits.
+
+## Run the CLI
+
+For a published PyPI version, install with Python 3.10 or later:
+
+```sh
+python -m pip install mozhi
+mozhi --version
+mozhi repl
+```
+
+See the [PyPI project](https://pypi.org/project/mozhi/) for published versions.
+Create a UTF-8 `.mozhi` file, then use `mozhi run file.mozhi` to execute it or
+`mozhi check file.mozhi` to validate its syntax without running it.
+
+Install from this checkout with Python 3.10 or later (no runtime dependencies):
+
+```sh
+python -m pip install -e .
+mozhi --version
+mozhi run examples/hello.mozhi
+mozhi examples/fibonacci.mozhi
+mozhi check examples/file_io.mozhi
+mozhi repl
+```
+
+`mozhi` works outside the repository after installation. `python -m mozhi` is also supported. Local programs have no execution timeout. Ctrl+C returns exit code 130; source/runtime/I/O errors go to stderr and return 1, and usage errors return 2. Source and terminal pipes use UTF-8. `check` parses without running statements.
+
+The REPL retains variables and functions, continues multiline blocks until `mudivu`, echoes expression values, and recovers from errors. `quit`, `exit`, or EOF ends the session. A failed block may have already changed state; the REPL does not roll back executed statements.
+
+Build Python distributions with `python -m pip install -r requirements-build.txt` and `python -m build`. Standalone Windows, macOS and Linux archives bundle Python with PyInstaller, so end users do not need to install Python. See [distribution and installation](https://github.com/sm1else-bot/mozhi/blob/main/docs/distribution.md) for native build commands, package-manager preparation, and publication status.
+
+**Distribution channels:** PyPI is the first public distribution target; the linked PyPI project page is the source for published versions. Homebrew, WinGet, Chocolatey, AUR, Debian and Fedora packaging is prepared for later releases, and this repository does not claim public availability through those managers. No release is published automatically by a version tag.
+
+Expected hello output:
+
+```text
+Vanakkam, world!
+Value: 10
+```
+
+The legacy `python src/mozhi.py file.mozhi` entry point remains supported; without arguments it still runs the original built-in demo. The installed `mozhi` command shows help without arguments. Existing examples are preserved. New examples cover Fibonacci, recursion, arrays, UTF-8 file I/O, timing, and an 11-second local computation. File I/O is explicitly local-only; the browser retains its own execution limit.
+
+## Use the playground
+
+Open [Mozhi Studio](https://sm1else-bot.github.io/mozhi/) or read [Learn](https://sm1else-bot.github.io/mozhi/learn/). GitHub Pages builds and publishes the combined site after checks pass on each push to `main`.
+
+From the repository root:
+
+```sh
+python -m pip install -r requirements-docs.txt
+python tools/build_site.py
+python -m http.server 8000 --directory site
+```
+
+Open [the playground locally](http://localhost:8000/playground/). The light studio includes eight guided lessons, practice tasks, hints, and progress earned by running working programs. Browse eight examples, including the original demo, library, gossip, and calculator programs. Calculator inputs 1, 10, 5, 6 add ten, show it, and exit the menu.
+
+**Studio** contains the interactive lessons, **Learn** opens the full MkDocs documentation, and **Examples** opens the program gallery. The combined build places these at `playground/`, `learn/`, and `examples/` within the ignored `site/` directory. Its relative links also work when hosted under a repository path. Rebuild after editing sources; generated files are not committed.
+
+The editor includes Mozhi syntax highlighting, keyword tooltips, a searchable reference, error line navigation, font and wrapping controls, file import/export, and a command palette. Use Ctrl+Enter to run, Ctrl+Shift+Enter to stop, Ctrl+K to search, or Ctrl+S to download. The interface adapts to phones and supports keyboard navigation.
+
+Drafts, preferences, lesson progress, and the last eight runs are saved in browser storage on this origin. Replacing edited code asks for confirmation and keeps the previous draft recoverable from editor settings. Clearing browser data removes these records. Download important programs for a durable copy. **Share code** encodes the current program in a URL fragment without uploading it to a storage service. Anyone with the link can read the code; recipients need access to the same hosted website. A localhost link only works on your computer.
+
+CodeMirror 5.65.13 and Pyodide 0.23.4 load from external CDNs, and optional web fonts load from Google Fonts. First loading needs network access. A plain textarea remains usable if CodeMirror fails to load. Stop the local server with Ctrl+C.
+
+Programs execute in a worker. **Stop** terminates even a tight infinite loop, and a configurable execution limit defaults to **10 seconds** (0.1–3600 seconds). Waiting for user input pauses the timer; submitting input resumes the remaining budget. Stopping or timing out cancels pending input and creates a fresh engine. Engine-load failures expose **Retry engine**. Output is capped at 65,536 JavaScript characters to keep runaway printing responsive. This is a usability limit, not a security sandbox.
+
+## Implemented features and differences
+
+| Feature | CLI adapter | Browser adapter |
+| --- | --- | --- |
+| Numbers, strings, booleans, arithmetic, conditions | Present | Present |
+| Functions and return | Present | Present |
+| Arrays, indexing, push/pop | Present | Present |
+| Loops and outer-variable updates | Fixed; updates find the defining scope | Same semantics |
+| Classes and methods | Properties, bound instances, method closures | Same semantics |
+| Input | Synchronous `kelu(...)` or `ketukko(...)` | Both aliases, asynchronously awaited |
+| Length and conversion | `neelam`, `enn`, `padam`, `vaari` | Same names |
+| `podhum` | Terminates the current program, including nested calls | Same semantics; engine remains reusable |
+
+See [LANGUAGE.md](https://github.com/sm1else-bot/mozhi/blob/main/LANGUAGE.md) for the supported syntax and [the documentation source](https://github.com/sm1else-bot/mozhi/blob/main/docs/index.md) for examples. The browser runs a generated asynchronous adapter, `playground/runtime.py`, in Pyodide. `tools/sync_playground.py` generates its parser/runtime from `src/mozhi/core.py`; input/output adapters differ, but language fixes are kept together. After changing the core, run `python tools/sync_playground.py`. A regression check detects a stale generated artifact.
+
+## Known limitations
+
+- This is still an experimental language, not full Python compatibility. Constructors are called manually after `ClassName porul`; indexed assignment and module imports are not implemented.
+- Errors now report source statement lines and validate indentation, argument counts, array indices, properties, input conversion and control-flow placement. There is no exception-handling syntax for recovering within a Mozhi program yet.
+- The browser limit measures elapsed execution time outside input waits, not CPU instructions. A stopped worker must reload Pyodide. Extremely memory-hungry programs are not safely sandboxed. CLI execution remains unbounded; use Ctrl+C or an external process timeout for intentional endless programs.
+- There is no module system, compatibility guarantee, or official GitHub Linguist recognition. Native archives and package-manager metadata are prepared, not claims of accepted registry listings. The playground highlighter is a lightweight token highlighter, not a language server or autocomplete engine.
+
+## Runtime checks
+
+The Python suite runs language regressions against both the synchronous CLI and generated asynchronous browser adapter in bounded subprocesses:
+
+```sh
+python tools/sync_playground.py
+python -m unittest discover -s tests -v
+```
+
+Optional actual-browser checks require Node.js 20 or later, network access, and Playwright's isolated Chromium:
+
+```sh
+npm ci
+npx playwright install chromium
+npm run test:browser
+npm run test:studio
+```
+
+`MOZHI_TEST_BROWSER` may name an existing Chrome/Chromium executable instead of the Playwright download. The checks use a fresh temporary profile, exercise worker Stop/timeout/recovery and input pauses, and do not operate your personal browser session.
+
+## Documentation
+
+```sh
+python -m pip install -r requirements-docs.txt
+python -m mkdocs serve
+python -m mkdocs build --strict
+```
+
+The generated `site/` is ignored. The docs cover [runtime controls](https://github.com/sm1else-bot/mozhi/blob/main/docs/runtime.md), [operators](https://github.com/sm1else-bot/mozhi/blob/main/docs/basics/operators.md), and [error handling](https://github.com/sm1else-bot/mozhi/blob/main/docs/errors.md). Exact original documentation remains in the archival commits.
+
+## Roadmap and contributions
+
+Next: a fuller language specification, deeper runtime coverage, richer editor integration, a larger standard library, and modules. Official Linguist recognition is a future milestone; `.mozhi` files are not relabeled as Python.
+
+Read [CONTRIBUTING.md](https://github.com/sm1else-bot/mozhi/blob/main/CONTRIBUTING.md) before proposing changes. The language concept and syntax were directed by the project author; implementation was AI-assisted with Claude, then Gemini and Google Antigravity. These tools assisted development rather than independently originating the author's language idea.
+
+Licensed under [MIT](https://github.com/sm1else-bot/mozhi/blob/main/LICENSE). [HISTORY.md](https://github.com/sm1else-bot/mozhi/blob/main/HISTORY.md) describes the chronology; [PROVENANCE.md](https://github.com/sm1else-bot/mozhi/blob/main/PROVENANCE.md) explains the retrospective commits.

mozhi-0.1.0/PROVENANCE.md

@@ -0,0 +1,80 @@
+# Provenance and retrospective Git history
+
+**The early Git history was retrospectively reconstructed in October 2026 from recovered source artifacts and development records. Historically dated commits are archival representations, not Git commits originally created on those dates.**
+
+The original project had no Git history. Reconstruction preserves recoverable code stages while keeping later organization and release preparation current-dated. No missing source stage is invented. The original evidence remains private and unchanged.
+
+## Evidence and method
+
+- **E01:** native Claude source-creation input, Lark interpreter. Original stream interval `2026-06-01T01:51:58.964494Z`–`2026-06-01T01:52:50.772340Z`. Recorded tests failed parsing.
+- **E02:** native Claude literal shell-heredoc input, recursive-descent rewrite. Interval `2026-06-01T01:53:13.846065Z`–`2026-06-01T01:54:18.645734Z`. Exact bytes match a subsequently saved standalone file and a Gemini Takeout attachment. The source-size/mtime fields in a bytecode header provide additional timing corroboration; semantic equivalence of that bytecode was not established.
+- **E03:** complete expanded interpreter saved on June 13. Recorded file last-write `2026-06-13T05:48:09.7080931Z` is a conservative snapshot bound. A recovered Gemini code block matches apart from an extra terminal newline. The downloaded file's exact bytes are imported; the timestamp is not authenticated source-generation completion.
+- **E04:** complete browser HTML, verified against the forensic manifest. Last-write `2026-06-13T06:26:01.3559436Z` is corroborated to the second by the recorded final Antigravity patch. It is not dated at the earlier file creation time.
+- **E05:** original documentation and four examples, each verified by SHA-256. Last included source last-write `2026-06-13T06:34:31.0597954Z` bounds the group; saved documentation-generation actions corroborate it. The calculator also has an independently saved, hash-matching editor-history version. Other examples rely on recorded filesystem metadata rather than independently complete early revisions.
+
+The original native Claude records preserve the explicit design proposal at `2026-06-01T01:50:30.305434Z` and naming at `2026-06-01T01:51:46.207303Z` (May 31 evening EDT). A later pasted transcript alone would not authenticate that date. The native export, matching source inputs and Takeout attachment offer stronger corroboration, but local metadata is not signed proof of authorship, priority or immutability.
+
+Both Git author and committer dates use the selected historical second, retaining EDT offset. Subsecond precision is **truncated, not represented by Git**, and retained below and in evidence/snapshots.json. Stream-completion dates describe recorded inputs, not proof of the precise sandbox write time. The configured human/project Git identity is used, not an impersonated AI identity.
+
+No code or modern provenance documents appear before their supported source snapshot. Five normalized HTML states derived by reversing recorded diffs remain in the private evidence package and are not promoted to independent historical originals. A truncated earlier diff limits that reconstruction.
+
+## Commit-to-evidence mapping
+
+| Archival commit | Author and committer timestamp | Source snapshot and SHA-256 | Evidence and limitations |
+| --- | --- | --- | --- |
+| `b9653846a9d004b66f1d19077c8f3d54bdcc3efb` | `2026-05-31T21:52:50-04:00` | `mozhi.py`: `2ef5c23c870aba52952e6891bd2a80db39dc6f9f70e8ca7dfd2b8cc997b5a2eb` | E01: Completion of recorded create_file input stream; known parser failures; does not date original conception. |
+| `98b8f2e81bcc22684572df7489890957c70863a5` | `2026-05-31T21:54:18-04:00` | `mozhi.py`: `97fe0e7c8cb0d9e2c567c3edcb021cd957ada2933b38c9460f1c853b780d87b9` | E02: Completion of literal shell-heredoc input stream; native source equals two later saved copies; known loop bug. |
+| `09b368b4e995789fd80bcf724b06f60ae964eb89` | `2026-06-13T01:48:09-04:00` | `mozhi.py`: `86a9595cbf1c03646100dd39bde717f0a42f9919416c67be179d3538479175c5` | E03: Conservative bound from complete downloaded snapshot last-write; corroborated by Gemini response source differing only in extra terminal newline. Not a feature-discussion timestamp or authenticated generation time. |
+| `524c4f72669882851a4914f1818cc345c13812e4` | `2026-06-13T02:26:01-04:00` | `mozhionline.html`: `c3a6edc1251d0632410dea5f213c37c2ebe6ca9302af0ce2eb7f67a3f2f48e00` | E04: Verified current bytes and filesystem last-write corroborated by saved final Antigravity diff. Not earlier creation time. |
+| `bbf729d5ea046cce2e3bcffd9127d1a6a2c44ba1` | `2026-06-13T02:34:31-04:00` | README, configuration, eight documentation pages and four examples; individual SHA-256 values below | E05: grouped snapshot; current saved content, supported per-file times and documentation actions. |
+
+### Original source precision and file digests
+
+The machine-readable [snapshot index](evidence/snapshots.json) contains full UTC timestamps, file sizes, paths, SHA-256 digests, and commit/tree IDs. It is a modern evidence index, not a historical artifact.
+
+| E05 historical path | Original last-write UTC | SHA-256 |
+| --- | --- | --- |
+| `calculator.mozhi` | `2026-06-13T06:19:05.9332023Z` | `7ccf87031344feff73eab09400d683b89bd853bfd5cc30ef44ad6fdc680a7997` |
+| `demo.mozhi` | `2026-06-13T06:09:51.2074464Z` | `120e8583cf93b0244d5548551b8d9395991436b93e86b2be38ad34e8d964ff0b` |
+| `docs/advanced/arrays.md` | `2026-06-13T06:34:24.7782088Z` | `abb9d2bba7a362e5646f392b29894db87ae19a4e56a4bf17b4400a31ccf57b2e` |
+| `docs/advanced/oop.md` | `2026-06-13T06:34:28.2050439Z` | `39454b650ceaa2988a4840b86ec11990b699afa0d21c60f005c6fec45fcc1484` |
+| `docs/basics/io.md` | `2026-06-13T06:34:16.9309248Z` | `58a3870a442b9ffa68207ec9d35978c51e9cb11822ddc63fed3beb23a9dd1a83` |
+| `docs/basics/variables.md` | `2026-06-13T06:34:14.5512017Z` | `c641aa226f8bd5a4e7cddbc20af5f54a56c78da7ec3b5d8a64a580856ea0f2be` |
+| `docs/control-flow/conditionals.md` | `2026-06-13T06:34:19.5769842Z` | `0557fe3d2b0715c376e4d0ccde1c93c7876a06b8885d5ad015407d4052bf4164` |
+| `docs/control-flow/loops.md` | `2026-06-13T06:34:21.9798026Z` | `e9b30a0862aae466da187a392635a53d1cdc80cd0d4be7db0cae56df33e58c7a` |
+| `docs/examples/calculator.md` | `2026-06-13T06:34:31.0597954Z` | `cddd72cae67b0ca0af6c28464a7b30597791fbf4c9b45f06f79d233abafc9b5d` |
+| `docs/index.md` | `2026-06-13T06:34:12.1938722Z` | `9c992821ab288ae5fd769a8a9879c3292ee3163651a71a474805daa3aef8acb5` |
+| `gossip.mozhi` | `2026-06-13T06:14:59.6839565Z` | `7b63ffbdbb14b3a5925dddaa03b833087e153406871c2fd4906d41daa80392e1` |
+| `library.mozhi` | `2026-06-13T06:09:17.1042686Z` | `de5ebd3aa6bc788eb94e478dec4af1ba04a428a7b0399d3929f5108eef068198` |
+| `mkdocs.yml` | `2026-06-13T06:34:09.7607076Z` | `a27545446ef7edc9bba31bfa57d10a0c3f8488545874ecb1ff549e0e65b01516` |
+| `README.md` | `2026-06-13T06:34:07.3783610Z` | `54f0d1efa5d52955e7542c0dad6c69fc208ce0d2cee6e7190d90e69b055deb5a` |
+
+## Modern path mapping
+
+| Historical Git path | Current path |
+| --- | --- |
+| `mozhi.py` | `src/mozhi/core.py` (via the modern `src/mozhi.py` compatibility launcher; exact expanded snapshot remains in E03) |
+| `mozhionline.html` | `playground/` (later worker UI and generated runtime; exact HTML remains in E04) |
+| Four root `.mozhi` examples | `examples/` (unchanged) |
+| Original README and Markdown docs | Original versions in archival commits; current README replaced and docs corrected in October |
+| Generated MkDocs site | Omitted from Git; retained privately in the forensic archive |
+
+Modern commits use actual October creation times. They add the layout, README, license, language notes, contributor guidance, validation and this provenance index. Their IDs are ordinary Git history; no self-referential current-commit hash is embedded here. Archival commit/tree IDs are frozen and verified independently. Later verification reports are kept outside the public tree.
+
+## Privacy and publication
+
+Public references E01–E05 identify evidence categories without private conversation IDs, personal absolute paths, full transcripts, account data, databases or Takeout archives. No private raw evidence is included. Historical sample first names in documentation are illustrative code, not an exported contact list. Externally loaded frontend libraries are referenced by the original HTML, not vendored into this repository.
+
+This GitHub repository was first published on October 27, 2026, with repository creation recorded at `2026-10-27T06:52:44Z` (02:52:44 EDT). The repository creation date reflects actual publication; older archival commit timestamps are not proof that a GitHub repository existed then. No historical release tags or public priority claims are made. The author explicitly chose MIT for this release.
+
+## Commit-subject revision
+
+In October 2026, the six initial subjects were revised for readability. Each rewritten commit retains its exact source tree and byte-identical author/committer identity and timestamp headers. Only messages and necessarily parent references changed. This provenance refresh is a separate current-dated commit. The archival IDs above refer to the revised sequence.
+
+## Later runtime repairs
+
+After publication, modern work fixes scope, OOP, termination, operators and diagnostics, and moves playground execution into a terminable worker. The browser language engine is now generated from the core source with an asynchronous adapter. None of these fixes is backdated: E01–E05 retain their original bytes and remain the source of the historical SHA-256 values above. Current source hashes are expected to differ from those archival snapshots.
+
+## Modern standalone distribution
+
+The 2026-10-28 packaging work moves the canonical modern interpreter into `src/mozhi/core.py`, adds terminal adapters and release preparation, and regenerates the browser adapter. These are modern changes, not recovered historical artifacts. The archival commits, dates, trees, and evidence hashes above remain unchanged. Native executable bundling includes Python; Mozhi source remains interpreted. Registry acceptance and release publication are separate from preparing package metadata.

mozhi-0.1.0/README.md

@@ -0,0 +1,143 @@
+# Mozhi
+
+A Tanglish programming language with Tamil-inspired, verb-final syntax.
+
+```mozhi
+"Vanakkam, world!" sollu
+a = 10 vechukko
+"Value: " kooda a sollu
+```
+
+Mozhi explores grammar as well as vocabulary. `sollu` (say) follows the expression, `vechukko` (keep/store) closes an assignment, and conditions precede `na` or `varaikum`. Assignment still uses infix `=`, so this is a hybrid syntax rather than a fully postfix stack language. Tamil has many dialects and constructions; Mozhi is an experiment, not a complete model of Tamil grammar.
+
+**Historical note:** Mozhi was conceived on May 31, 2026, and developed further in June 2026. This GitHub repository was first published on October 27, 2026. Its early Git commits are retrospectively dated archival reconstructions from recovered source files and development records, not original commits made at that time. See [PROVENANCE.md](https://github.com/sm1else-bot/mozhi/blob/main/PROVENANCE.md) for methodology and evidence.
+
+## Status
+
+This is an experimental language with an explicitly preserved archival history. The current CLI and browser adapters share parser/runtime fixes through generated browser code. Neither is production-ready, Python-compatible, or a sandbox for untrusted code. Original interpreter stages remain unchanged in the archival commits.
+
+## Run the CLI
+
+For a published PyPI version, install with Python 3.10 or later:
+
+```sh
+python -m pip install mozhi
+mozhi --version
+mozhi repl
+```
+
+See the [PyPI project](https://pypi.org/project/mozhi/) for published versions.
+Create a UTF-8 `.mozhi` file, then use `mozhi run file.mozhi` to execute it or
+`mozhi check file.mozhi` to validate its syntax without running it.
+
+Install from this checkout with Python 3.10 or later (no runtime dependencies):
+
+```sh
+python -m pip install -e .
+mozhi --version
+mozhi run examples/hello.mozhi
+mozhi examples/fibonacci.mozhi
+mozhi check examples/file_io.mozhi
+mozhi repl
+```
+
+`mozhi` works outside the repository after installation. `python -m mozhi` is also supported. Local programs have no execution timeout. Ctrl+C returns exit code 130; source/runtime/I/O errors go to stderr and return 1, and usage errors return 2. Source and terminal pipes use UTF-8. `check` parses without running statements.
+
+The REPL retains variables and functions, continues multiline blocks until `mudivu`, echoes expression values, and recovers from errors. `quit`, `exit`, or EOF ends the session. A failed block may have already changed state; the REPL does not roll back executed statements.
+
+Build Python distributions with `python -m pip install -r requirements-build.txt` and `python -m build`. Standalone Windows, macOS and Linux archives bundle Python with PyInstaller, so end users do not need to install Python. See [distribution and installation](https://github.com/sm1else-bot/mozhi/blob/main/docs/distribution.md) for native build commands, package-manager preparation, and publication status.
+
+**Distribution channels:** PyPI is the first public distribution target; the linked PyPI project page is the source for published versions. Homebrew, WinGet, Chocolatey, AUR, Debian and Fedora packaging is prepared for later releases, and this repository does not claim public availability through those managers. No release is published automatically by a version tag.
+
+Expected hello output:
+
+```text
+Vanakkam, world!
+Value: 10
+```
+
+The legacy `python src/mozhi.py file.mozhi` entry point remains supported; without arguments it still runs the original built-in demo. The installed `mozhi` command shows help without arguments. Existing examples are preserved. New examples cover Fibonacci, recursion, arrays, UTF-8 file I/O, timing, and an 11-second local computation. File I/O is explicitly local-only; the browser retains its own execution limit.
+
+## Use the playground
+
+Open [Mozhi Studio](https://sm1else-bot.github.io/mozhi/) or read [Learn](https://sm1else-bot.github.io/mozhi/learn/). GitHub Pages builds and publishes the combined site after checks pass on each push to `main`.
+
+From the repository root:
+
+```sh
+python -m pip install -r requirements-docs.txt
+python tools/build_site.py
+python -m http.server 8000 --directory site
+```
+
+Open [the playground locally](http://localhost:8000/playground/). The light studio includes eight guided lessons, practice tasks, hints, and progress earned by running working programs. Browse eight examples, including the original demo, library, gossip, and calculator programs. Calculator inputs 1, 10, 5, 6 add ten, show it, and exit the menu.
+
+**Studio** contains the interactive lessons, **Learn** opens the full MkDocs documentation, and **Examples** opens the program gallery. The combined build places these at `playground/`, `learn/`, and `examples/` within the ignored `site/` directory. Its relative links also work when hosted under a repository path. Rebuild after editing sources; generated files are not committed.
+
+The editor includes Mozhi syntax highlighting, keyword tooltips, a searchable reference, error line navigation, font and wrapping controls, file import/export, and a command palette. Use Ctrl+Enter to run, Ctrl+Shift+Enter to stop, Ctrl+K to search, or Ctrl+S to download. The interface adapts to phones and supports keyboard navigation.
+
+Drafts, preferences, lesson progress, and the last eight runs are saved in browser storage on this origin. Replacing edited code asks for confirmation and keeps the previous draft recoverable from editor settings. Clearing browser data removes these records. Download important programs for a durable copy. **Share code** encodes the current program in a URL fragment without uploading it to a storage service. Anyone with the link can read the code; recipients need access to the same hosted website. A localhost link only works on your computer.
+
+CodeMirror 5.65.13 and Pyodide 0.23.4 load from external CDNs, and optional web fonts load from Google Fonts. First loading needs network access. A plain textarea remains usable if CodeMirror fails to load. Stop the local server with Ctrl+C.
+
+Programs execute in a worker. **Stop** terminates even a tight infinite loop, and a configurable execution limit defaults to **10 seconds** (0.1–3600 seconds). Waiting for user input pauses the timer; submitting input resumes the remaining budget. Stopping or timing out cancels pending input and creates a fresh engine. Engine-load failures expose **Retry engine**. Output is capped at 65,536 JavaScript characters to keep runaway printing responsive. This is a usability limit, not a security sandbox.
+
+## Implemented features and differences
+
+| Feature | CLI adapter | Browser adapter |
+| --- | --- | --- |
+| Numbers, strings, booleans, arithmetic, conditions | Present | Present |
+| Functions and return | Present | Present |
+| Arrays, indexing, push/pop | Present | Present |
+| Loops and outer-variable updates | Fixed; updates find the defining scope | Same semantics |
+| Classes and methods | Properties, bound instances, method closures | Same semantics |
+| Input | Synchronous `kelu(...)` or `ketukko(...)` | Both aliases, asynchronously awaited |
+| Length and conversion | `neelam`, `enn`, `padam`, `vaari` | Same names |
+| `podhum` | Terminates the current program, including nested calls | Same semantics; engine remains reusable |
+
+See [LANGUAGE.md](https://github.com/sm1else-bot/mozhi/blob/main/LANGUAGE.md) for the supported syntax and [the documentation source](https://github.com/sm1else-bot/mozhi/blob/main/docs/index.md) for examples. The browser runs a generated asynchronous adapter, `playground/runtime.py`, in Pyodide. `tools/sync_playground.py` generates its parser/runtime from `src/mozhi/core.py`; input/output adapters differ, but language fixes are kept together. After changing the core, run `python tools/sync_playground.py`. A regression check detects a stale generated artifact.
+
+## Known limitations
+
+- This is still an experimental language, not full Python compatibility. Constructors are called manually after `ClassName porul`; indexed assignment and module imports are not implemented.
+- Errors now report source statement lines and validate indentation, argument counts, array indices, properties, input conversion and control-flow placement. There is no exception-handling syntax for recovering within a Mozhi program yet.
+- The browser limit measures elapsed execution time outside input waits, not CPU instructions. A stopped worker must reload Pyodide. Extremely memory-hungry programs are not safely sandboxed. CLI execution remains unbounded; use Ctrl+C or an external process timeout for intentional endless programs.
+- There is no module system, compatibility guarantee, or official GitHub Linguist recognition. Native archives and package-manager metadata are prepared, not claims of accepted registry listings. The playground highlighter is a lightweight token highlighter, not a language server or autocomplete engine.
+
+## Runtime checks
+
+The Python suite runs language regressions against both the synchronous CLI and generated asynchronous browser adapter in bounded subprocesses:
+
+```sh
+python tools/sync_playground.py
+python -m unittest discover -s tests -v
+```
+
+Optional actual-browser checks require Node.js 20 or later, network access, and Playwright's isolated Chromium:
+
+```sh
+npm ci
+npx playwright install chromium
+npm run test:browser
+npm run test:studio
+```
+
+`MOZHI_TEST_BROWSER` may name an existing Chrome/Chromium executable instead of the Playwright download. The checks use a fresh temporary profile, exercise worker Stop/timeout/recovery and input pauses, and do not operate your personal browser session.
+
+## Documentation
+
+```sh
+python -m pip install -r requirements-docs.txt
+python -m mkdocs serve
+python -m mkdocs build --strict
+```
+
+The generated `site/` is ignored. The docs cover [runtime controls](https://github.com/sm1else-bot/mozhi/blob/main/docs/runtime.md), [operators](https://github.com/sm1else-bot/mozhi/blob/main/docs/basics/operators.md), and [error handling](https://github.com/sm1else-bot/mozhi/blob/main/docs/errors.md). Exact original documentation remains in the archival commits.
+
+## Roadmap and contributions
+
+Next: a fuller language specification, deeper runtime coverage, richer editor integration, a larger standard library, and modules. Official Linguist recognition is a future milestone; `.mozhi` files are not relabeled as Python.
+
+Read [CONTRIBUTING.md](https://github.com/sm1else-bot/mozhi/blob/main/CONTRIBUTING.md) before proposing changes. The language concept and syntax were directed by the project author; implementation was AI-assisted with Claude, then Gemini and Google Antigravity. These tools assisted development rather than independently originating the author's language idea.
+
+Licensed under [MIT](https://github.com/sm1else-bot/mozhi/blob/main/LICENSE). [HISTORY.md](https://github.com/sm1else-bot/mozhi/blob/main/HISTORY.md) describes the chronology; [PROVENANCE.md](https://github.com/sm1else-bot/mozhi/blob/main/PROVENANCE.md) explains the retrospective commits.

mozhi-0.1.0/examples/arrays_loops.mozhi

@@ -0,0 +1,9 @@
+# Varisaiyil irukkum engalai serkkalam.
+values = [2, 4, 6, 8] vechukko
+i = 0 vechukko
+total = 0 vechukko
+i < neelam(values) varaikum:
+    total = total + values[i] vechukko
+    i = i + 1 vechukko
+mudivu
+total sollu

mozhi-0.1.0/examples/benchmark.mozhi

@@ -0,0 +1,10 @@
+# Neram alandhu oru siriya kanakku seiyalam.
+start = neram() vechukko
+i = 0 vechukko
+total = 0 vechukko
+i < 10000 varaikum:
+    total = total + i vechukko
+    i = i + 1 vechukko
+mudivu
+total sollu
+"Seconds: " kooda (neram() - start) sollu

mozhi-0.1.0/examples/calculator.mozhi

@@ -0,0 +1,71 @@
+# A simple Calculator in Mozhi
+
+vagai Calculator:
+    seiy initialize(ennoda):
+        ennoda.total = 0 vechukko
+    mudivu
+
+    seiy add(ennoda, val):
+        ennoda.total = ennoda.total + val vechukko
+    mudivu
+
+    seiy subtract(ennoda, val):
+        ennoda.total = ennoda.total - val vechukko
+    mudivu
+
+    seiy multiply(ennoda, val):
+        ennoda.total = ennoda.total * val vechukko
+    mudivu
+
+    seiy divide(ennoda, val):
+        ennoda.total = ennoda.total / val vechukko
+    mudivu
+
+    seiy show(ennoda):
+        "Ippo total: " kooda ennoda.total sollu
+    mudivu
+mudivu
+
+# Main Program
+calc = Calculator porul vechukko
+calc.initialize()
+
+"Mozhi Calculator Ready!" sollu
+"1. Add, 2. Subtract, 3. Multiply, 4. Divide, 5. Show, 6. Podhum" sollu
+
+running = true vechukko
+running varaikum:
+    choice = ketukko("Enna operation? ") vechukko
+    choice = enn(choice) vechukko
+
+    choice == 1 na:
+        val = ketukko("Amount? ") vechukko
+        calc.add(enn(val))
+    illana:
+        choice == 2 na:
+            val = ketukko("Amount? ") vechukko
+            calc.subtract(enn(val))
+        illana:
+            choice == 3 na:
+                val = ketukko("Amount? ") vechukko
+                calc.multiply(enn(val))
+            illana:
+                choice == 4 na:
+                    val = ketukko("Amount? ") vechukko
+                    calc.divide(enn(val))
+                illana:
+                    choice == 5 na:
+                        calc.show()
+                    illana:
+                        choice == 6 na:
+                            running = false vechukko
+                        mudivu
+                    mudivu
+                mudivu
+            mudivu
+        mudivu
+    mudivu
+mudivu
+
+"Bye!" sollu
+podhum

mozhi-0.1.0/examples/demo.mozhi

@@ -0,0 +1,13 @@
+name = "Nanba" vechukko
+greeting = "Vanakkam, " kooda name vechukko
+greeting sollu
+
+numbers = [10, 20, 30] vechukko
+99 ullapodu numbers
+"Array: " kooda numbers sollu
+
+i = 0 vechukko
+i < 3 varaikum:
+    i = i + 1 vechukko
+    i sollu
+mudivu

mozhi-0.1.0/examples/fibonacci.mozhi

@@ -0,0 +1,8 @@
+# Mudhal paththu Fibonacci engal paarkalam.
+seiy fib(n):
+    n < 2 na:
+        n thirumbu
+    mudivu
+    fib(n - 1) + fib(n - 2) thirumbu
+mudivu
+fib(10) sollu

mozhi-0.1.0/examples/file_io.mozhi

@@ -0,0 +1,4 @@
+# Ithu ullooril mattum odum; UTF-8 koppai ezhuthi padikkalam.
+ezhuthu("mozhi-example.txt", "வணக்கம்\n")
+serthu_ezhuthu("mozhi-example.txt", "Mozhi\n")
+padi("mozhi-example.txt") sollu