AssayFluxScientificSystems 0.1.0__tar.gz

assayfluxscientificsystems-0.1.0/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## 0.1.0 — unified alpha
+
+- Consolidated the language/runtime foundation, diagnostics, security policy, C++ build helper, and retained original project sources.
+- Standardized distribution identity to **AssayFlux Scientific Systems** (`AssayFluxScientificSystems`) while retaining the `assayflux` Python import.
+- Added the `pycall` language expression with explicit capabilities and a curated Python callable allowlist (`math`, `statistics`, `json`, optional `numpy`).
+- Added `assayflux syntax` language reference command and a complete implemented-subset syntax document.
+- Added starter project creation and initial AssayFluxOS roadmap/info commands.
+- Added Gradle wrapper generation and Android Gradle build commands.
+- Added optional `science` dependencies and a PyPI token upload notebook.
+- Preserved the original historical `docs/grammar.md` byte-for-byte.
+
+This is an alpha foundation. See the verification report for features that remain incomplete or unverified.

assayfluxscientificsystems-0.1.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Md Safarujjaman / AssayFlux
+
+MIT License
+
+Copyright (c) 2026 AssayFlux contributors
+
+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.

assayfluxscientificsystems-0.1.0/MANIFEST.in

@@ -0,0 +1,10 @@
+include README.md LICENSE CHANGELOG.md
+recursive-include docs *.md
+recursive-include examples *.assayflux *.cpp
+recursive-include editor *.json
+recursive-include tests *.py
+recursive-include scripts *.sh
+recursive-include legacy_sources *.py *.md *.toml *.txt *.sh *.af *.png *.yml *.in *.gitignore
+
+recursive-include templates *
+recursive-include notebooks *.ipynb

assayfluxscientificsystems-0.1.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: AssayFluxScientificSystems
+Version: 0.1.0
+Summary: AssayFlux Scientific Systems: language runtime, scientific Python bridge, project builder, and OS development tools
+Author-email: Md Safarujjaman <assayflux@gmail.com>
+Maintainer-email: AssayFlux / Md Safarujjaman <mdsafarujjaman@assayflux.com>
+License-Expression: MIT
+Project-URL: Homepage, https://www.assayflux.com
+Project-URL: Documentation, https://www.assayflux.com
+Keywords: assayflux,scientific-computing,programming-language,interpreter,project-builder,assayfluxos,android,termux
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lark<2,>=1.1.9
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Provides-Extra: science
+Requires-Dist: numpy>=1.26; extra == "science"
+Requires-Dist: scipy>=1.11; extra == "science"
+Requires-Dist: pandas>=2.1; extra == "science"
+Requires-Dist: matplotlib>=3.8; extra == "science"
+Dynamic: license-file
+
+# AssayFlux Scientific Systems
+
+**Version 0.1.0 · Alpha · Created by Md Safarujjaman · AssayFlux**
+
+AssayFlux Scientific Systems is the umbrella Python distribution for the AssayFlux language/runtime, diagnostics and security checkpoints, scientific Python bridge, project starter builder, native C++ build helper, and early AssayFluxOS development utilities.
+
+- **Author:** Md Safarujjaman
+- **Organization/project:** AssayFlux
+- **Email:** `assayflux@gmail.com`
+- **Project contact:** `mdsafarujjaman@assayflux.com`
+- **Website:** https://www.assayflux.com
+- **PyPI distribution:** `AssayFluxScientificSystems` (the normalized package name; display name is “AssayFlux Scientific Systems”)
+- **Python import:** `assayflux`
+- **Version:** `0.1.0`
+- **Python:** 3.11+
+
+## Install
+
+```bash
+python -m pip install AssayFluxScientificSystems
+assayflux --version
+assayflux doctor
+assayflux setup --science  # optional, after this version is published
+```
+
+Pip automatically installs declared Python dependencies (currently Lark). Optional scientific packages can be installed with:
+
+```bash
+python -m pip install 'AssayFluxScientificSystems[science]'
+```
+
+The `science` extra installs NumPy, SciPy, pandas, and Matplotlib. These are optional because they are comparatively large and not needed for the core language. Java/JDK, Android SDK, C++ compiler, Git, Node.js, and Gradle are external system tools and are not silently installed by pip. `assayflux doctor` reports their availability.
+
+## Quick start
+
+```bash
+assayflux check examples/hello.assayflux
+assayflux run examples/hello.assayflux
+assayflux syntax
+assayflux syntax python
+assayflux project create ./MyProject --name 'My Project'
+assayflux os info
+```
+
+Python bridge example:
+
+```assayflux
+let root = pycall("math", "sqrt", 81)
+print(root)
+```
+
+Enable the capability explicitly:
+
+```bash
+assayflux run main.assayflux --allow-python --python-modules math
+```
+
+The currently supported bridge modules are `math`, `statistics`, `json`, and optional `numpy`, `pandas`, and `scipy.stats`. Only allowlisted functions and primitive-compatible values cross the boundary. Python interoperability executes in the host process and is **not a sandbox**; use only with trusted source and trusted modules.
+
+## CLI commands
+
+- `assayflux check FILE` — parse and perform static checks without execution.
+- `assayflux run FILE` — interpret source with execution budgets.
+- `assayflux syntax [topic]` — display implemented syntax and examples.
+- `assayflux doctor` — report Python and optional external-tool availability.
+- `assayflux setup --science` — download optional scientific Python dependencies (requires this release to be available from PyPI).
+- `assayflux setup --dev` — download test/build tools (requires this release to be available from PyPI).
+- `assayflux report list|show|export` — inspect local diagnostic reports.
+- `assayflux project create PATH --name NAME` — create a starter project.
+- `assayflux os info|roadmap` — explain the current AssayFluxOS prototype and roadmap.
+- `assayflux build FILE.cpp` — compile trusted C++ source; does not execute the resulting binary.
+- `assayflux android wrapper PROJECT --gradle-version 8.9` — generate the Gradle wrapper (requires Gradle installed once).
+- `assayflux android build PROJECT --variant debug` — run `assembleDebug` through the wrapper.
+- Add `--bundle` to Android build to request an AAB (`bundleDebug` or `bundleRelease`).
+
+Aliases: `af`, `assayfluxos`, and `assayflux-builder` are installed entry points to the same command router; the separate tool areas are exposed as command groups (`project`, `os`, `android`, etc.). They are not separate operating systems or independent binaries yet.
+
+## Maturity and security
+
+The active parser/runtime implements a deliberate starter subset: application label, variable declarations/assignment, literals, arithmetic/comparison/unary operators, `print`, `if/else`, `while`, and an explicitly enabled `pycall` bridge. It does not yet implement every historical grammar production or every legacy generator feature. Native C++ build compiles an existing trusted C++ file; it does not compile AssayFlux source into C++.
+
+The in-process runtime is not an OS-enforced sandbox. Native code and Python extensions can perform host actions. Sentinel diagnostics cover defined error classes and do not guarantee finding every bug. Android build success depends on a valid Android project, JDK, SDK/licenses, and compatible plugins. A wrapper downloads its configured Gradle distribution after wrapper files are generated and committed; the SDK and JDK are not automatically installed.
+
+The historical grammar document retains its original `0.2.0` metadata by design; the active parser subset and release metadata are documented separately in `docs/GRAMMAR_PRESERVATION_NOTE.md`. See `docs/VERIFICATION_REPORT.md`, `docs/SYNTAX_REFERENCE.md`, `docs/SECURITY_MODEL.md`, and `docs/ROADMAP.md` for verified scope and remaining work. The original `docs/grammar.md` is preserved byte-for-byte; new implemented bridge syntax is documented separately and does not rewrite that historical file.
+
+## Source preservation
+
+The three original source projects are retained under `legacy_sources/` as migration references. Their presence does not mean every legacy feature is active in the canonical runtime.
+
+## License
+
+MIT. See `LICENSE`.

assayfluxscientificsystems-0.1.0/README.md

@@ -0,0 +1,92 @@
+# AssayFlux Scientific Systems
+
+**Version 0.1.0 · Alpha · Created by Md Safarujjaman · AssayFlux**
+
+AssayFlux Scientific Systems is the umbrella Python distribution for the AssayFlux language/runtime, diagnostics and security checkpoints, scientific Python bridge, project starter builder, native C++ build helper, and early AssayFluxOS development utilities.
+
+- **Author:** Md Safarujjaman
+- **Organization/project:** AssayFlux
+- **Email:** `assayflux@gmail.com`
+- **Project contact:** `mdsafarujjaman@assayflux.com`
+- **Website:** https://www.assayflux.com
+- **PyPI distribution:** `AssayFluxScientificSystems` (the normalized package name; display name is “AssayFlux Scientific Systems”)
+- **Python import:** `assayflux`
+- **Version:** `0.1.0`
+- **Python:** 3.11+
+
+## Install
+
+```bash
+python -m pip install AssayFluxScientificSystems
+assayflux --version
+assayflux doctor
+assayflux setup --science  # optional, after this version is published
+```
+
+Pip automatically installs declared Python dependencies (currently Lark). Optional scientific packages can be installed with:
+
+```bash
+python -m pip install 'AssayFluxScientificSystems[science]'
+```
+
+The `science` extra installs NumPy, SciPy, pandas, and Matplotlib. These are optional because they are comparatively large and not needed for the core language. Java/JDK, Android SDK, C++ compiler, Git, Node.js, and Gradle are external system tools and are not silently installed by pip. `assayflux doctor` reports their availability.
+
+## Quick start
+
+```bash
+assayflux check examples/hello.assayflux
+assayflux run examples/hello.assayflux
+assayflux syntax
+assayflux syntax python
+assayflux project create ./MyProject --name 'My Project'
+assayflux os info
+```
+
+Python bridge example:
+
+```assayflux
+let root = pycall("math", "sqrt", 81)
+print(root)
+```
+
+Enable the capability explicitly:
+
+```bash
+assayflux run main.assayflux --allow-python --python-modules math
+```
+
+The currently supported bridge modules are `math`, `statistics`, `json`, and optional `numpy`, `pandas`, and `scipy.stats`. Only allowlisted functions and primitive-compatible values cross the boundary. Python interoperability executes in the host process and is **not a sandbox**; use only with trusted source and trusted modules.
+
+## CLI commands
+
+- `assayflux check FILE` — parse and perform static checks without execution.
+- `assayflux run FILE` — interpret source with execution budgets.
+- `assayflux syntax [topic]` — display implemented syntax and examples.
+- `assayflux doctor` — report Python and optional external-tool availability.
+- `assayflux setup --science` — download optional scientific Python dependencies (requires this release to be available from PyPI).
+- `assayflux setup --dev` — download test/build tools (requires this release to be available from PyPI).
+- `assayflux report list|show|export` — inspect local diagnostic reports.
+- `assayflux project create PATH --name NAME` — create a starter project.
+- `assayflux os info|roadmap` — explain the current AssayFluxOS prototype and roadmap.
+- `assayflux build FILE.cpp` — compile trusted C++ source; does not execute the resulting binary.
+- `assayflux android wrapper PROJECT --gradle-version 8.9` — generate the Gradle wrapper (requires Gradle installed once).
+- `assayflux android build PROJECT --variant debug` — run `assembleDebug` through the wrapper.
+- Add `--bundle` to Android build to request an AAB (`bundleDebug` or `bundleRelease`).
+
+Aliases: `af`, `assayfluxos`, and `assayflux-builder` are installed entry points to the same command router; the separate tool areas are exposed as command groups (`project`, `os`, `android`, etc.). They are not separate operating systems or independent binaries yet.
+
+## Maturity and security
+
+The active parser/runtime implements a deliberate starter subset: application label, variable declarations/assignment, literals, arithmetic/comparison/unary operators, `print`, `if/else`, `while`, and an explicitly enabled `pycall` bridge. It does not yet implement every historical grammar production or every legacy generator feature. Native C++ build compiles an existing trusted C++ file; it does not compile AssayFlux source into C++.
+
+The in-process runtime is not an OS-enforced sandbox. Native code and Python extensions can perform host actions. Sentinel diagnostics cover defined error classes and do not guarantee finding every bug. Android build success depends on a valid Android project, JDK, SDK/licenses, and compatible plugins. A wrapper downloads its configured Gradle distribution after wrapper files are generated and committed; the SDK and JDK are not automatically installed.
+
+The historical grammar document retains its original `0.2.0` metadata by design; the active parser subset and release metadata are documented separately in `docs/GRAMMAR_PRESERVATION_NOTE.md`. See `docs/VERIFICATION_REPORT.md`, `docs/SYNTAX_REFERENCE.md`, `docs/SECURITY_MODEL.md`, and `docs/ROADMAP.md` for verified scope and remaining work. The original `docs/grammar.md` is preserved byte-for-byte; new implemented bridge syntax is documented separately and does not rewrite that historical file.
+
+## Source preservation
+
+The three original source projects are retained under `legacy_sources/` as migration references. Their presence does not mean every legacy feature is active in the canonical runtime.
+
+## License
+
+MIT. See `LICENSE`.

assayfluxscientificsystems-0.1.0/docs/ARCHITECTURE.md

@@ -0,0 +1,20 @@
+# Architecture
+
+```text
+source file -> source guard -> Lark parser -> AST -> semantic checks
+           -> policy/capability boundary -> interpreter -> result/report
+```
+
+- `language/grammar.lark`: official starter grammar.
+- `language/parser.py`: Lark parser and AST construction.
+- `language/ast_nodes.py`: immutable source-located AST.
+- `language/semantic.py`: conservative static analysis.
+- `security/checkpoints.py`: source checks and shared policy limits.
+- `runtime/interpreter.py`: step-budgeted execution.
+- `runtime/python_bridge.py`: allowlisted, primitive-value Python interop helper.
+- `runtime/sqlite_runtime.py`: workspace-bound SQLite helper.
+- `diagnostics/`: stable diagnostic types and local report writer.
+- `developer/doctor.py`: environment health checks.
+- `cli.py`: single command-line entry point.
+
+The legacy source archives are retained as migration references only. Their modules are not imported automatically by the new engine. Generator, task, shell and project-builder code will be ported only after API contracts and security boundaries are reviewed.

assayfluxscientificsystems-0.1.0/docs/FEATURE_MATRIX.md

@@ -0,0 +1,25 @@
+# Feature availability matrix — 0.1.0
+
+| Area | Available in canonical package | Scope / caveat |
+|---|---|---|
+| Language parser | Yes | Lark-based parser and AST; small explicit subset only. |
+| Variables and expressions | Yes | `let`, assignment, numbers, strings, booleans, null, arithmetic, comparisons, unary minus/not. |
+| Control flow | Yes | `print`, `if/else`, `while`; bounded runtime. |
+| Python interoperability | Yes, opt-in | `pycall` to curated callables in `math`, `statistics`, `json`; optional `numpy`, `pandas`, `scipy.stats`. Requires `--allow-python` and module allowlist. Not a sandbox. |
+| Structured diagnostics | Yes | Stable diagnostic codes, source location, local JSONL reports, export/list/show. |
+| Security checkpoints | Partial | Source size, AST, numeric, loop, step and output budgets; capabilities. No OS isolation or full taint analysis. |
+| Environment doctor | Yes | Detects Python/Lark/SQLite and optional external tools (compiler, Java, Gradle, adb, Git, Node, Android SDK variables). |
+| Project builder | Starter only | Creates a starter `main.assayflux` and README. Not a complete multi-language project generator. |
+| Native C++ | Partial | Compiles an existing trusted `.cpp` file with workspace and timeout checks. No source-to-C++ compiler and no automatic binary execution. |
+| SQLite runtime | Library API | Local SQLite helper exists, but SQL is not yet first-class syntax integrated into the language grammar/CLI. |
+| HTML/CSS/JavaScript/SQL/Python generators | Legacy/reference only | Original implementations retained under `legacy_sources/`; not all are ported to the canonical package. |
+| AssayFluxOS | Prototype/reference | Host-side OS development utilities and legacy shell/filesystem/plugin prototypes. No bootable OS, distro, or kernel. |
+| Android Gradle wrapper | Command integration | Can generate wrapper via an installed Gradle; wrapper then downloads the selected Gradle distribution. No Gradle wrapper JAR bundled in the Python package. |
+| Android APK/AAB | Build command only | Calls `assembleDebug`/`assembleRelease` or `bundleDebug`/`bundleRelease` in a supplied Android project. Requires configured JDK, Android SDK/licenses, plugin compatibility, and a complete Android app. No APK/AAB verified in this release. |
+| VS Code syntax highlighting | Yes | TextMate JSON grammar validates as JSON; highlighting completeness not exhaustively tested. |
+| PyPI publishing notebook | Yes | Builds/tests and uploads via a hidden token prompt; owner must run it and authorize publication. Not published by this release build. |
+| Original grammar preservation | Yes | `docs/grammar.md` byte-for-byte matches the owner-provided source; new syntax is documented separately. |
+
+## Feature boundary
+
+The presence of files in `legacy_sources/` is preservation for migration, not proof of live integration. The active language does not yet support user-defined functions, list/dictionary literals, general imports, classes, async, a full standard library, complete HTML/CSS/JS/SQL generation, or direct AssayFlux-to-native compilation.

assayfluxscientificsystems-0.1.0/docs/GRAMMAR_PRESERVATION_NOTE.md

@@ -0,0 +1,5 @@
+# Grammar preservation note
+
+`docs/grammar.md` is the original owner-supplied grammar document. It is preserved byte-for-byte as requested, including its historical metadata line `Current package version: 0.2.0`. That version label describes the original document's provenance, not the package release version in `pyproject.toml`, which is `0.1.0`.
+
+The canonical runtime parser uses `src/assayflux/language/grammar.lark`. It implements only the subset documented in `SYNTAX_REFERENCE.md`; it does not yet implement all constructs described in the historical grammar. New implementation syntax is additive and documented separately rather than rewriting the preserved grammar.

assayfluxscientificsystems-0.1.0/docs/LANGUAGE_SPECIFICATION.md

@@ -0,0 +1,32 @@
+# AssayFlux language specification — starter subset 0.2
+
+This is an intentionally small first subset, not the final language design.
+
+## Source
+- UTF-8 text; NUL is rejected.
+- One statement per line; semicolons may separate statements.
+- `#` begins a comment through the end of the line.
+- Braced blocks are used with `if` and `while`.
+
+## Statements
+```text
+app "Program name"
+let value = expression
+value = expression
+print(expression)
+if condition { statements } else { statements }
+while condition { statements }
+```
+
+`let` declares a name once in its lexical block. Assignments update an existing variable. Names declared inside an `if`/`while` block do not escape that block. `app` is optional metadata.
+
+## Values and operators
+- Values: integers, decimal floating-point numbers, strings, booleans (`true`, `false`), and `null`.
+- Arithmetic: `+`, `-`, `*`, `/`, `%`; `+` also concatenates two strings.
+- Comparisons: `==`, `!=`, `<`, `>`, `<=`, `>=`.
+- Unary operators: `-`, `not`.
+- Conditions must evaluate to booleans; truthy/falsy coercion is not performed.
+- Division uses Python-style numeric division in this interpreter; exact decimal semantics remain an open specification decision.
+
+## Current limitations
+No user-defined functions, collections, module imports, async, classes, exception syntax, type annotations, network APIs, UI bindings, or native compilation are implemented in the current core. PythonBridge and SQLiteRuntime are host-side APIs, not source-language syntax yet.

assayfluxscientificsystems-0.1.0/docs/PROJECT_MERGE_AUDIT.md

@@ -0,0 +1,11 @@
+# Source consolidation audit
+
+Three source archives were inspected and retained unchanged in logical source form under `legacy_sources/` (generated egg-info metadata removed). The unified package does not import legacy code implicitly.
+
+| Source | Original role | Consolidation decision |
+|---|---|---|
+| `AssayFlux-main` | Custom language, parser/interpreter, generators and interop adapters | Kept as a reference; new engine uses a formal Lark grammar and explicit AST/runtime contracts rather than depending on the legacy lexer/parser API coupling. Generator/interop modules require staged porting and dedicated tests. |
+| `AssayFlux-Professional` | CLI, project builder, runtime detection, validation and developer tools | Retained as reference. CLI and Doctor baseline implemented in the canonical package; project builder/task/registry behavior still requires contract-by-contract migration. |
+| `AssayFluxOS` | FluxScript subset, shell, workspace filesystem and plugin configuration | Retained as reference. The new language is intended to become the single language core; shell/filesystem/plugin APIs remain to be migrated and security-reviewed. |
+
+The merge is an architectural consolidation and new tested foundation, not a claim that every legacy feature is already ported. Existing prototypes are not automatically considered secure merely because they are preserved in this repository.

assayfluxscientificsystems-0.1.0/docs/ROADMAP.md

@@ -0,0 +1,32 @@
+# Roadmap
+
+## Stage 0 — Consolidated baseline (current)
+- Unified Python package and CLI aliases.
+- Lark grammar, source-located AST, static checks and budgeted interpreter.
+- Sentinel diagnostics, local bug report log, Doctor checks.
+- Python bridge allowlist and SQLite helper.
+- Starter tests, VS Code TextMate grammar, preserved source prototypes.
+
+## Stage 1 — Language correctness
+- Formal grammar and specification review; complete escape handling and source-span fidelity.
+- Functions, modules/imports, lexical scopes, collections, structured exceptions, and defined numeric semantics.
+- Stronger type system and semantic test matrix.
+- Property-based/fuzz tests and malformed-input corpus.
+
+## Stage 2 — Runtime and security
+- Capability/effect model; process-isolated Python worker for untrusted programs.
+- Explicit module manifest and package lock file.
+- Hardened SQL transaction semantics and schema migration support.
+- Resource and cancellation model.
+
+## Stage 3 — Targets and developer tools
+- HTML/CSS/JS/Python/SQL generators migrated behind tested interfaces.
+- C++ backend with safe subprocess invocation, compiler detection, build directory isolation and reproducible build metadata.
+- Project imports, dependency graph, diagnostics protocol, LSP/editor integration.
+- Regression coverage for migrated toolkit and OS shell.
+
+## Stage 4 — OS and Android
+- One shared core package used by CLI, OS shell/workspace and Android bridge.
+- Linux-based developer environment first; distribution engineering after reproducible builds and package management.
+- Android packaging and device tests after core API stabilizes.
+- Independent kernel research is a separate long-term project, not a result of this Python package.

assayfluxscientificsystems-0.1.0/docs/SECURITY_MODEL.md

@@ -0,0 +1,33 @@
+# AssayFlux security model (initial baseline)
+
+## Threat model
+Assume source projects can be malformed or hostile. Inputs may be oversized, syntax may be crafted to exhaust resources, imported Python packages may be defective, and generated/native code may be unsafe. The current interpreter is an in-process development runtime, **not a sandbox for hostile code**.
+
+## Security defaults
+- UTF-8 source only, NUL rejected, source byte limit enforced before parsing.
+- Formal Lark grammar; no execution of source via Python `eval` or `exec`.
+- Static checks reject undefined names, duplicate declarations, incompatible assignment types, and invalid known operand types.
+- Runtime step, loop and output budgets.
+- Privileged operations use a deny-by-default capability manager. Python calls require `python.call` plus `python.module:<name>` and an approved module/callable. SQLite requires `database.read` and/or `database.write`. Native compilation requires `native.build`; the CLI grants it only when the user explicitly invokes `assayflux build`.
+- Python bridge uses an explicit module/callable allowlist, primitive-value conversion and bounded nested values. Allowed modules remain trusted code; allowlisting is not process isolation.
+- SQLite database path is confined to a project workspace, extension loading disabled, parameters are passed separately, and risky SQL commands are denied by default.
+- Local diagnostic reports use restrictive file modes where supported and do not capture source code or environment variables by default.
+- Optional native compilers are not invoked by the interpreter. The current native build helper uses argument arrays (never shell interpolation), a temporary build directory, a timeout, workspace path checks, hardened compiler flags and does not execute the output. It still compiles source with the host compiler, so only compile trusted generated source; a compiler exploit or hostile source can still affect the build host.
+
+## Required future hardening before untrusted execution
+1. Run untrusted programs in a separate OS process with a least-privilege account/container and OS-enforced CPU, memory, file, process and network limits.
+2. Use per-project capability grants for filesystem, network, subprocess, database and device access; deny by default.
+3. Add a formal effect model and capability-aware imports.
+4. Audit dependencies, lock versions and verify artifact provenance.
+5. Fuzz lexer/parser/AST/serialization, property-test interpreter invariants, and run static security analysis.
+6. Review symlink/path race handling, logs, permissions, denial-of-service resistance, and cross-platform behavior.
+7. Have independent security review and threat-model testing before claiming production readiness.
+
+## Bug reports
+Reports are local JSON Lines under `~/.assayflux/reports/diagnostics.jsonl` by default. No automatic upload is performed. Reports intentionally omit source contents and environment values. Users should review an export before sharing it because filenames and error details can still reveal project information.
+
+## Guarantees
+Sentinel is a set of checks and diagnostics, not a proof that programs are bug-free. Static analysis cannot identify every logic defect; runtime monitoring cannot detect every wrong result; Python and native extensions can bypass language-level protections. Security claims must be tied to tested, documented guarantees.
+
+## Capability grants
+The `CapabilityManager` is deny-by-default. The initial capability names include `python.call`, `python.module:<module>`, `database.read`, `database.write`, `native.build`, `filesystem.read`, `filesystem.write`, `network.connect`, and `subprocess.run`. A module allowlist and a capability grant are separate requirements. Only trusted host configuration should issue grants; AssayFlux source code must not be allowed to grant capabilities to itself. The CLI's explicit `build` command grants `native.build` for that one requested host operation.

assayfluxscientificsystems-0.1.0/docs/SYNTAX_REFERENCE.md

@@ -0,0 +1,98 @@
+# AssayFlux syntax reference (implemented subset, v0.1.0)
+
+This reference describes the **implemented parser/runtime subset**, not every construct in the preserved historical `grammar.md`.
+
+## Program declaration and statements
+
+```assayflux
+app "Scientific demo"       # optional application label
+let count = 6 * 7            # declaration (once per name)
+count = count + 1            # assignment to a declared variable
+print(count)                 # print one line
+```
+
+Statements are separated by a newline or semicolon. Comments begin with `#` and continue to the end of the line.
+
+## Values and operators
+
+- Values: integer and decimal numbers, single- or double-quoted strings, `true`, `false`, `null`.
+- Arithmetic: `+`, `-`, `*`, `/`, `%`.
+- Comparisons: `==`, `!=`, `<`, `>`, `<=`, `>=`.
+- Unary: numeric `-value`, boolean `not value`.
+- Conditions must evaluate to booleans. Strings can be concatenated with `+`.
+
+## Control flow
+
+```assayflux
+let n = 0
+while n < 3 {
+  print(n)
+  n = n + 1
+}
+if n == 3 {
+  print("finished")
+} else {
+  print("not finished")
+}
+```
+
+Block-local declarations do not escape their block. Re-declaration/shadowing is currently rejected by semantic checks.
+
+## Approved Python library bridge
+
+The only direct bridge expression currently implemented is `pycall(module_string, function_string, args...)`:
+
+```assayflux
+let root = pycall("math", "sqrt", 81)
+print(root)
+let encoded = pycall("json", "dumps", "hello")
+print(encoded)
+```
+
+Enable explicitly at run time:
+
+```bash
+assayflux run main.assayflux --allow-python --python-modules math,statistics,json
+```
+
+Optional NumPy calls are available when NumPy is installed:
+
+```assayflux
+let values = pycall("json", "loads", "[1, 2, 3, 4]")
+let average = pycall("numpy", "mean", values)
+print(average)
+let zscores = pycall("scipy.stats", "zscore", values)
+print(zscores)
+let table = pycall("pandas", "DataFrame", pycall("json", "loads", "[{\"x\":1},{\"x\":2}]"))
+print(table)
+```
+
+```bash
+python -m pip install 'AssayFluxScientificSystems[science]'
+assayflux run main.assayflux --allow-python --python-modules json,numpy,scipy.stats,pandas
+```
+
+The bridge supports only allowlisted public callables and primitive/list/dictionary-compatible arguments and return values. It is for trusted code, **not a sandbox**. Python modules can execute arbitrary code on import/call; only enable Python interoperability for code you trust. The current language does not yet support arbitrary Python `import`, Python attribute access, user-defined functions, list/dictionary literals, classes, or general Python object values.
+
+## CLI reference
+
+```bash
+assayflux --version
+assayflux check examples/hello.assayflux
+assayflux run examples/hello.assayflux
+assayflux run main.assayflux --allow-python --python-modules math
+assayflux syntax
+assayflux syntax python
+assayflux doctor
+assayflux report list
+assayflux project create ./MyProject --name "My Project"
+assayflux os info
+assayflux os roadmap
+assayflux build examples/native.cpp --workspace .
+assayflux android wrapper ./AndroidProject --gradle-version 8.9
+assayflux android build ./AndroidProject --variant debug
+```
+
+## Not yet implemented in the core language
+
+Function definitions/calls (other than the built-in `pycall`), collection literals/indexing, user modules/import statements, classes, exceptions, async/concurrency, full HTML/CSS/JavaScript/SQL generation syntax, and direct AssayFlux-to-C++ compilation are not implemented in the active parser/runtime. Some related prototypes remain in `legacy_sources/` and are not automatically active.

assayfluxscientificsystems-0.1.0/docs/VERIFICATION_REPORT.md

@@ -0,0 +1,41 @@
+# Verification report — AssayFlux Scientific Systems 0.1.0
+
+## Identity
+- Product: AssayFlux Scientific Systems
+- PyPI distribution name: `AssayFluxScientificSystems` (PyPI canonicalizes case; install with `python -m pip install AssayFluxScientificSystems`)
+- Python import package: `assayflux`
+- Version: `0.1.0`
+- Author: Md Safarujjaman (`assayflux@gmail.com`)
+- Contact: `mdsafarujjaman@assayflux.com`
+- Website: `https://www.assayflux.com`
+- Python requirement: `>=3.11`
+- Historical grammar SHA-256: `5f08dbd4791a2b4e74b3c374c83ca92b8fccbb4e4ec7f68df8e9b004534c3c1e`
+
+## Checks passed in this build environment
+- `python -m pytest -q`: **36 passed** (the `src` import path is configured in `pyproject.toml`).
+- `PYTHONPATH=src python -m unittest discover -s tests -q`: **36 passed**.
+- `python -m compileall -q src tests`: passed.
+- CLI version, syntax catalogue, `check`, `run`, starter project generation, and setup help smoke checks: passed.
+- Both shipped examples ran and produced expected output.
+- Regression test: non-boolean `if`/`while` conditions produce a controlled language runtime diagnostic rather than an unhandled Python exception.
+- Security policy rejects invalid/non-positive resource limits and malformed Python module allowlists.
+- Explicit Python bridge capability test: denied without grant; math call succeeds with grant.
+- Scientific integration smoke test using JSON + NumPy + SciPy stats + pandas passed in the tested environment where optional libraries were installed.
+- VS Code TextMate grammar JSON: valid.
+- Package metadata: `Name: AssayFluxScientificSystems`, `Version: 0.1.0`.
+- Wheel built: `assayfluxscientificsystems-0.1.0-py3-none-any.whl`.
+- Wheel installed into an isolated target directory; import, version, parser, interpreter, and runtime-diagnostic smoke tests passed.
+- Source distribution built with the installed setuptools build backend.
+- Publishing notebook JSON parsed successfully; it now installs Lark, uses fail-fast test/build subprocesses, checks the preserved grammar hash, builds wheel + sdist, runs Twine validation, and requires explicit token-protected confirmation before upload.
+- Historical `docs/grammar.md` matches the supplied original file byte-for-byte. SHA-256: `5f08dbd4791a2b4e74b3c374c83ca92b8fccbb4e4ec7f68df8e9b004534c3c1e`. Its historical `Current package version: 0.2.0` line is intentionally retained; it is not the release metadata.
+
+## Not verified / not claimed
+- **Not published to PyPI.** Name availability/ownership and token-authenticated upload must be checked by running the notebook against live PyPI. Case in a package name is normalized by PyPI; punctuation matters, so this requested no-hyphen name is distinct from `assayflux-scientific-systems`.
+- Twine validation and actual upload were not executed in this offline environment; the Colab notebook installs Twine and runs the checks before the separate publish step.
+- No Gradle wrapper generation or APK/AAB build was executed; Gradle, JDK, Android SDK/licenses, and a valid Android project are environment-specific.
+- Termux / Python 3.14 was not tested here. The declared minimum is Python 3.11.
+- No independent security audit, penetration test, fuzzing campaign, formal verification, or OS sandbox validation was performed.
+- Python bridge and native C++ build are for trusted code only; they are not sandboxed.
+- Full legacy generator parity, complete module/import semantics, SQL syntax integration, source-to-C++ compilation, a bootable AssayFluxOS, Linux distribution, independent kernel, and Android native application are not complete.
+
+A passing test suite demonstrates only that the included tests passed; it does not prove absence of defects or vulnerabilities.