First commit

Readme.md

@@ -0,0 +1,214 @@
+
+
+# Unify Developer Manual
+
+### Build full applications with a single, unified codebase.
+
+Unify is a full-stack application framework designed to remove the accidental complexity of modern web development. Instead of hand-wiring HTTP requests, state management, SQL queries, UI updates, permissions, and caching — Unify turns each **domain object** into a **live application object** that exists simultaneously on the server and client.
+
+You write your application *once*.
+Unify takes care of syncing it everywhere it needs to be.
+
+---
+
+## Why Unify?
+
+Most web apps are assembled from disconnected technologies:
+React + REST + ORM + SQL + State Manager + WebSockets + UI Framework + Access Control…
+
+Each layer requires boilerplate to keep everything in sync:
+
+* serialize → send → parse → update → re-render → validate permissions
+* write SQL + write endpoints + write frontend state logic for the same entity
+
+Unify eliminates these seams.
+
+> **One class = data + logic + UI + permissions + real-time behavior**
+
+The framework:
+
+* turns your class into a database table (server)
+* generates UI components from that class (client)
+* syncs all changes via a structured WebSocket protocol
+* applies permissions automatically based on user role
+* integrates filtering, joins, pagination at the SQL level
+* caches and updates only changed fields
+
+You focus on the domain model.
+Unify handles the rest.
+
+---
+
+
+### Why Unify Is AI-Optimized
+
+Unify applications are self-describing graphs.
+The object structure defines:
+
+UI layout
+
+Backend relationships
+
+Permissions
+
+Sync rules
+
+Navigation
+
+A human developer may lose track of where objects live in the graph.
+
+But AI can:
+
+infer full graph topology
+
+find optimal traversal paths
+
+safely modify relationships
+
+rewrite UI interactions without breaking structure
+
+This means Unify enables:
+
+AI-generated UI actions
+
+AI-guided refactoring
+
+AI-assisted CRUD creation
+
+Automated join discovery
+
+Intelligent navigation handling
+
+
+
+## What does development feel like?
+
+Example: define a `News` class
+
+```javascript
+export default class news extends table {
+    title = new text("Title");
+    body  = new text("Message");
+    price = new number("Price");
+
+    permission() {
+        this.allow(groups.visitor, "READ");
+        this.allow(groups.admin, "WRITE");
+    }
+}
+```
+
+And a list view:
+
+```javascript
+export default class newsListTable extends gridView {
+    header = new newsListTableHeader();
+    body   = new newsListTableBody(newsListItem, new collection(news));
+}
+```
+
+You don’t manually:
+
+* write SQL queries
+* define REST endpoints
+* build WebSocket handlers
+* implement CRUD actions
+* code client state syncing
+* generate UI markup
+
+Unify does all of that from your object graph.
+
+---
+
+## Architecture: What’s inside
+
+| Layer                  | Responsibility                             |
+| ---------------------- | ------------------------------------------ |
+| **Domain Objects**     | Single class shared by server + client     |
+| **Render Collections** | Auto-loaded lists with pagination + search |
+| **Table Controller**   | Database operations + joins                |
+| **Socket Controller**  | Real-time communication layer              |
+| **UI Runtime**         | Live elements, animations, events          |
+| **Permission Engine**  | Automatic security per object/action       |
+
+This creates a **Behavioral ORM**:
+
+* objects contain their own server logic
+* queries are automatically composed from UI actions
+* users see only what they are permitted to interact with
+
+---
+
+## Why does this matter?
+
+Modern software complexity isn’t caused by features — it’s caused by **glue code**.
+For every feature, you implement it 3–6 times: backend models, database schema, API routes, frontend state, UI bindings…
+
+Unify collapses those layers into **one source of truth**.
+
+The result:
+
+* drastically fewer bugs
+* ultra-fast iteration cycles
+* real-time UX without extra work
+* secure-by-construction access rules
+* smaller teams can ship full apps
+
+---
+
+## Current focus
+
+The goal of this release is to give developers a working demonstration of:
+
+* full-stack sync with no REST boilerplate
+* real-time UI updates
+* built-in permissions
+* SQL searching / joining from the UI
+* cross-platform dynamic UI rendering (Windows / Mac / Web)
+
+The included **News Application** shows:
+
+* search/filter with SQL operators (`LIKE`, `OR`, `>=`)
+* item detail transitions + CRUD dialogs
+* login + role-based access
+* pagination
+* dynamic view/layout behavior
+
+---
+
+## Who is Unify for?
+
+✔ Full-stack developers
+✔ Product developers who hate glue code
+✔ Teams who want to ship faster
+✔ Anyone who believes software should be simpler
+
+---
+
+## Status
+
+Unify is actively developed and evolving.
+Contributions, feedback, and architectural discussion are welcome.
+
+> Help define the future of unified application development.
+
+---
+
+## Get started
+
+The source includes:
+
+* `unify_source/` – the core framework
+* `unify_application/` – working reference application
+
+Clone and run the app to see the architecture in motion:
+
+```
+git clone https://.../unify
+cd unify_application
+npm install
+npm start
+```
+
+Documentation and complete API references are coming.
+