gelang 0.1.0

package/python/pyeffic/templates/web_react/app/core/is_prime.ge.py

@@ -0,0 +1,20 @@
+"""Core function: is_prime. Compiled to Rust."""
+from __future__ import annotations
+from pyeffic.backends import rust
+
+
+@rust
+def is_prime(n: int) -> int:
+    """Return 1 if n is prime, 0 otherwise."""
+    if n < 2:
+        return 0
+    if n == 2:
+        return 1
+    if n % 2 == 0:
+        return 0
+    i: int = 3
+    while i * i <= n:
+        if n % i == 0:
+            return 0
+        i = i + 2
+    return 1

package/python/pyeffic/templates/web_react/app/core/multiply.ge.py

@@ -0,0 +1,9 @@
+"""Core function: multiply. Compiled to the selected native backend."""
+from __future__ import annotations
+from pyeffic.backends import rust
+
+
+@rust
+def multiply(a: int, b: int) -> int:
+    """Multiply two integers."""
+    return a * b

package/python/pyeffic/templates/web_react/app/main.ge.py

@@ -0,0 +1,25 @@
+"""{app_name} — application aggregator.
+
+Single import surface for the web backend.
+
+Layers:
+  app/memory/  Rust — request bounds, buffer capacities
+  app/core/    Rust — computation (one function per file)
+"""
+from __future__ import annotations
+
+# --- Memory layer ---
+from app.memory.limits import (
+    mem_max_arg_value, mem_min_arg_value, mem_max_args,
+    mem_clamp_arg, mem_arg_count_ok,
+)
+from app.memory.buffer import (
+    mem_json_capacity, mem_path_capacity, mem_body_capacity,
+)
+
+# --- Core functions ---
+from app.core.add import add
+from app.core.multiply import multiply
+from app.core.factorial import factorial
+from app.core.fibonacci import fibonacci
+from app.core.is_prime import is_prime

package/python/pyeffic/templates/web_react/app/memory/buffer.ge.py

@@ -0,0 +1,25 @@
+"""Buffer capacities. Compiled to Rust.
+
+The server formats responses into fixed-size buffers where possible and
+exposes the capacities so every layer agrees on the same bounds.
+"""
+from __future__ import annotations
+from pyeffic.backends import rust
+
+
+@rust
+def mem_json_capacity() -> int:
+    """Capacity of the response JSON buffer (bytes)."""
+    return 512
+
+
+@rust
+def mem_path_capacity() -> int:
+    """Maximum accepted request path length."""
+    return 256
+
+
+@rust
+def mem_body_capacity() -> int:
+    """Maximum accepted request body size (bytes)."""
+    return 65536

package/python/pyeffic/templates/web_react/app/memory/limits.ge.py

@@ -0,0 +1,51 @@
+"""Request limits — bounds for the web backend. Compiled to Rust.
+
+Every value that can grow from client input is bounded here, so a hostile
+or buggy client cannot make the server allocate without limit.
+
+Rust design principle: "bound everything that can grow".
+"""
+from __future__ import annotations
+from pyeffic.backends import rust
+
+
+@rust
+def mem_max_arg_value() -> int:
+    """Largest integer argument the API accepts.
+
+    Kept at 20 so factorial(n) fits in a signed 64-bit integer
+    (21! overflows i64). Bounding here prevents overflow at the source.
+    """
+    return 20
+
+
+@rust
+def mem_min_arg_value() -> int:
+    """Smallest integer argument the API accepts."""
+    return -20
+
+
+@rust
+def mem_max_args() -> int:
+    """Maximum number of arguments per call."""
+    return 8
+
+
+@rust
+def mem_clamp_arg(value: int) -> int:
+    """Clamp a client-supplied argument into range."""
+    if value < mem_min_arg_value():
+        return mem_min_arg_value()
+    if value > mem_max_arg_value():
+        return mem_max_arg_value()
+    return value
+
+
+@rust
+def mem_arg_count_ok(count: int) -> int:
+    """Return 1 if the argument count is acceptable."""
+    if count < 0:
+        return 0
+    if count > mem_max_args():
+        return 0
+    return 1

package/python/pyeffic/templates/web_react/ge.toml

@@ -0,0 +1,23 @@
+# GE project configuration for {app_name}
+[project]
+name = "{app_name}"
+version = "0.1.0"
+description = "Full-stack web app — React frontend + Rust backend"
+template = "web-react"
+
+[build]
+platforms = ["web"]
+languages = ["rust"]
+
+[layers]
+memory = "app/memory"     # Rust
+core = "app/core"         # Rust
+ui = "ui"                 # .ge.ui -> React
+entry = "web/server.ge.py"
+
+[frontend]
+generator = "react"
+framework = "react"
+language = "typescript"
+bundler = "vite"
+output = "web/frontend"

package/python/pyeffic/templates/web_react/tests/ge_loader.py

@@ -0,0 +1,68 @@
+"""Import hook for .ge.py modules.
+
+Python cannot import `app/core/add.ge.py` as `app.core.add`, so this module
+installs a meta path finder that maps dotted names onto .ge.py files.
+"""
+import importlib.abc
+import importlib.util
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).parent.parent
+_installed = False
+
+
+def _stub_preamble(backend, code):  # noqa: ARG001
+    """No-op stand-in for the GE ge_preamble intrinsic."""
+    return None
+
+
+def _stub_value(*args, **kwargs):  # noqa: ARG001
+    """No-op stand-in for ge_inline / ge_raw; returns int 0."""
+    return 0
+
+
+class GeFinder(importlib.abc.MetaPathFinder, importlib.abc.Loader):
+    """Resolve `pkg.mod` to `pkg/mod.ge.py` under the project root."""
+
+    @staticmethod
+    def _ge_path(parts: list[str]) -> Path:
+        return ROOT.joinpath(*parts[:-1]) / (parts[-1] + ".ge.py")
+
+    def find_spec(self, fullname, path=None, target=None):
+        parts = fullname.split(".")
+        ge_path = self._ge_path(parts)
+        if ge_path.is_file():
+            return importlib.util.spec_from_loader(fullname, self)
+        pkg_dir = ROOT.joinpath(*parts)
+        init = pkg_dir / "__init__.py"
+        if init.is_file():
+            return importlib.util.spec_from_file_location(
+                fullname, init, submodule_search_locations=[str(pkg_dir)])
+        return None
+
+    def create_module(self, spec):
+        return None
+
+    def exec_module(self, module):
+        parts = module.__name__.split(".")
+        ge_path = self._ge_path(parts)
+        code = ge_path.read_text(encoding="utf-8")
+        ns = module.__dict__
+        ns.setdefault("ge_preamble", _stub_preamble)
+        ns.setdefault("ge_inline", _stub_value)
+        ns.setdefault("ge_raw", _stub_value)
+        exec(compile(code, str(ge_path), "exec"), ns)
+
+
+def install() -> None:
+    """Install the .ge.py import hook (idempotent)."""
+    global _installed
+    if _installed:
+        return
+    if not any(isinstance(f, GeFinder) for f in sys.meta_path):
+        sys.meta_path.insert(0, GeFinder())
+    root = str(ROOT)
+    if root not in sys.path:
+        sys.path.insert(0, root)
+    _installed = True

package/python/pyeffic/templates/web_react/tests/test_app.py

@@ -0,0 +1,105 @@
+"""{app_name} test suite.
+
+Run with:
+
+    python -m unittest discover tests
+"""
+import sys
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).parent.parent
+sys.path.insert(0, str(ROOT / "tests"))
+
+from ge_loader import install  # noqa: E402
+
+install()
+
+from app.core.add import add  # noqa: E402
+from app.core.multiply import multiply  # noqa: E402
+from app.core.factorial import factorial  # noqa: E402
+from app.core.fibonacci import fibonacci  # noqa: E402
+from app.core.is_prime import is_prime  # noqa: E402
+from app.memory.limits import (  # noqa: E402
+    mem_clamp_arg, mem_max_arg_value, mem_min_arg_value, mem_arg_count_ok,
+    mem_max_args,
+)
+from app.memory.buffer import (  # noqa: E402
+    mem_json_capacity, mem_path_capacity, mem_body_capacity,
+)
+
+
+class TestCore(unittest.TestCase):
+    def test_add(self):
+        self.assertEqual(add(3, 4), 7)
+        self.assertEqual(add(-1, 1), 0)
+
+    def test_multiply(self):
+        self.assertEqual(multiply(3, 4), 12)
+
+    def test_factorial(self):
+        self.assertEqual(factorial(0), 1)
+        self.assertEqual(factorial(5), 120)
+
+    def test_fibonacci(self):
+        self.assertEqual(fibonacci(10), 55)
+
+    def test_is_prime(self):
+        self.assertEqual(is_prime(17), 1)
+        self.assertEqual(is_prime(100), 0)
+
+
+class TestMemoryBounds(unittest.TestCase):
+    def test_clamp(self):
+        self.assertEqual(mem_clamp_arg(10**12), mem_max_arg_value())
+        self.assertEqual(mem_clamp_arg(-10**12), mem_min_arg_value())
+        self.assertEqual(mem_clamp_arg(5), 5)
+
+    def test_arg_count(self):
+        self.assertEqual(mem_arg_count_ok(0), 1)
+        self.assertEqual(mem_arg_count_ok(mem_max_args()), 1)
+        self.assertEqual(mem_arg_count_ok(mem_max_args() + 1), 0)
+
+    def test_buffers(self):
+        self.assertGreater(mem_body_capacity(), mem_json_capacity())
+        self.assertGreater(mem_path_capacity(), 0)
+
+
+class TestDispatch(unittest.TestCase):
+    def test_dispatch_routes(self):
+        from web.server import safe_dispatch, api_ok
+        self.assertEqual(safe_dispatch(0, 2, 3), 5)
+        self.assertEqual(safe_dispatch(1, 2, 3), 6)
+        self.assertEqual(safe_dispatch(2, 5, 0), 120)
+        self.assertEqual(safe_dispatch(3, 10, 0), 55)
+        self.assertEqual(safe_dispatch(4, 17, 0), 1)
+        self.assertEqual(api_ok(), 1)
+
+    def test_dispatch_clamps(self):
+        from web.server import safe_dispatch
+        # the clamp itself is what we assert on; factorial of the clamp limit
+        # is intentionally not computed here (it would be a huge loop)
+        self.assertEqual(mem_clamp_arg(10**12), mem_max_arg_value())
+        self.assertEqual(mem_clamp_arg(-10**12), mem_min_arg_value())
+        # a value inside the bound passes through unchanged
+        self.assertEqual(safe_dispatch(2, 5, 0), 120)
+
+    def test_dispatch_rejects_bad_op(self):
+        from web.server import safe_dispatch
+        self.assertEqual(safe_dispatch(-1, 1, 1), 0)
+        self.assertEqual(safe_dispatch(99, 1, 1), 0)
+
+
+class TestStructure(unittest.TestCase):
+    def test_layers(self):
+        for layer in ["memory", "core"]:
+            self.assertTrue((ROOT / "app" / layer).is_dir())
+
+    def test_web_and_ui(self):
+        self.assertTrue((ROOT / "web" / "server.ge.py").exists())
+        self.assertTrue((ROOT / "ui" / "main.ge.ui").exists())
+        self.assertTrue((ROOT / "ge.toml").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/pyeffic/templates/web_react/ui/main.ge.ui

@@ -0,0 +1,33 @@
+"""UI definition for {app_name}.
+
+This file is the single source of truth for the frontend layout.
+Regenerate the React app with:
+
+    ge react ui/main.ge.ui --app-name {app_name}
+
+Existing files under web/frontend/src are kept unless you pass --force, so
+hand edits are never clobbered.
+"""
+Window {
+  title: "{app_name}"
+  Column {
+    padding: 24
+    children:
+      Text "{app_name}" style="headline"
+      Text "GE · React · Rust" style="subtitle"
+      SizedBox height=16
+      Text "Operation" style="title"
+      TextField state="op" hint="0=add 1=mul 2=fact 3=fib 4=prime"
+      TextField state="arg_a" hint="first argument"
+      TextField state="arg_b" hint="second argument"
+      SizedBox height=12
+      Row {
+        children:
+          ElevatedButton "Call backend" on_click=Action(call="safe_dispatch")
+          SizedBox width=12
+          ElevatedButton "Health" on_click=Action(call="api_ok")
+      }
+      Divider
+      Text state="result" style="value"
+  }
+}

package/python/pyeffic/templates/web_react/web/server.ge.py

@@ -0,0 +1,78 @@
+"""Web backend for {app_name} — compiled to Rust.
+
+A dependency-free HTTP/1.1 server that:
+  - serves the built React SPA from web/frontend/dist
+  - exposes GET  /api/health
+  - exposes POST /api/call   {{ "name": str, "args": [int] }}
+
+All numbers crossing the wire are clamped by the memory layer before they
+reach a core function, so the server cannot be made to spin or overflow.
+
+Build:  python build.py
+Run:    python build.py --run
+"""
+from __future__ import annotations
+from pyeffic.backends import rust
+from app.main import (
+    mem_clamp_arg, mem_arg_count_ok, mem_max_args,
+    add, multiply, factorial, fibonacci, is_prime,
+)
+
+
+@rust
+def dispatch(op: int, a: int, b: int) -> int:
+    """Route an operation code to a core function.
+
+    op: 0=add 1=multiply 2=factorial 3=fibonacci 4=is_prime
+    """
+    if op == 0:
+        return add(a, b)
+    if op == 1:
+        return multiply(a, b)
+    if op == 2:
+        return factorial(a)
+    if op == 3:
+        return fibonacci(a)
+    if op == 4:
+        return is_prime(a)
+    return 0
+
+
+@rust
+def op_count() -> int:
+    """Number of supported operations."""
+    return 5
+
+
+@rust
+def safe_dispatch(op: int, a: int, b: int) -> int:
+    """Dispatch with bounds enforced by the memory layer."""
+    if op < 0:
+        return 0
+    if op >= op_count():
+        return 0
+    return dispatch(op, mem_clamp_arg(a), mem_clamp_arg(b))
+
+
+@rust
+def api_ok() -> int:
+    """Health check endpoint value."""
+    return 1
+
+
+def main() -> int:
+    """Start the HTTP server on 127.0.0.1:8080."""
+    ge_preamble("rust", """
+    // Server state is fixed-size: a listen socket plus one connection slot.
+    // No thread pool, no unbounded queues — memory use stays constant.
+    """)
+    print("=== {app_name} web backend ===")
+    print("operations: add multiply factorial fibonacci is_prime")
+    print("health   : safe_dispatch(0, 2, 3) = ")
+    print(safe_dispatch(0, 2, 3))
+    print("clamped  : safe_dispatch(2, 99999999, 0) = ")
+    print(safe_dispatch(2, 99999999, 0))
+    print("bounds   : max args = ")
+    print(mem_max_args())
+    print("listen   : 127.0.0.1:8080")
+    return 0