The framework that compiles
physics into functions.

# FastAPI + Pydantic + httpx — complete integration pattern
# pip install fastapi uvicorn httpx pydantic
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import httpx, os

app = FastAPI(title="Physics-Grounded API")
ZEQ_KEY = os.environ["ZEQ_API_KEY"]
ZEQ_URL = "https://www.zeqsdk.com/api/zeq/compute"

class ComputeRequest(BaseModel):
    domain: str
    inputs: dict
    operators: list[str] = []

class ZeqState(BaseModel):
    operators: list[str]
    masterSum: float   # R(t) — grounded result
    phase:     float   # φ ∈ [0, 1]
    zeqond:    int     # τ — Zeqond count at compute time
    precision: float   # always ≤ 0.001
    pulseHz:   float   # always 1.287

@app.post("/compute")
async def compute(req: ComputeRequest) -> dict:
    async with httpx.AsyncClient() as client:
        r = await client.post(
            ZEQ_URL,
            headers={"Authorization": f"Bearer {ZEQ_KEY}"},
            json={"domain": req.domain,
                  "operators": req.operators,
                  "inputs": req.inputs},
            timeout=30.0,
        )
    if r.status_code != 200:
        raise HTTPException(status_code=r.status_code, detail=r.text)
    data = r.json()
    zeq  = data["zeqState"]

    # Validate — reject if KO42 missing or precision violated
    if "KO42" not in zeq["operators"] or zeq["precision"] > 0.001:
        raise HTTPException(500, "ZeqState failed validation")

    return {"zeqState": zeq, "result": data["result"]}

# Run: uvicorn main:app --reload
# Or on Replit: add ZEQ_API_KEY to Secrets, then run uvicorn

// Works in Node.js, Deno, Bun, Cloudflare Workers, browser
const response = await fetch("https://www.zeqsdk.com/api/zeq/compute", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.ZEQ_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    domain: "quantum-mechanics",
    inputs: { energy_eV: 13.6, mass_kg: 9.109e-31 },
  }),
});
const { zeqState, result } = await response.json();

// Validate
console.assert(zeqState.precision <= 0.001, "precision exceeded");
console.assert(zeqState.operators.includes("KO42"), "KO42 missing");
console.log(zeqState.masterSum);  // R(t) — grounded result
console.log(zeqState.zeqond);     // Zeqond count at compute time

import requests, os

r = requests.post(
    "https://www.zeqsdk.com/api/zeq/compute",
    headers={"Authorization": f"Bearer {os.environ['ZEQ_API_KEY']}"},
    json={
        "domain": "thermodynamics",
        "operators": ["THERMO_ENTROPY"],
        "inputs": {"temp_K": 500, "pressure_Pa": 101325},
    },
)
data = r.json()
zeq  = data["zeqState"]

assert "KO42" in zeq["operators"]
assert zeq["precision"] <= 0.001
print(zeq["masterSum"])   # R(t)
print(zeq["zeqond"])     # current Zeqond
print(zeq["phase"])      # φ ∈ [0, 1]

package main

import (
    "bytes"; "encoding/json"; "net/http"; "os"
)

func zeqCompute(domain string, inputs map[string]any) (map[string]any, error) {
    body, _ := json.Marshal(map[string]any{
        "domain": domain, "inputs": inputs,
    })
    req, _ := http.NewRequest("POST",
        "https://www.zeqsdk.com/api/zeq/compute",
        bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ZEQ_API_KEY"))
    req.Header.Set("Content-Type", "application/json")
    resp, err := http.DefaultClient.Do(req)
    if err != nil { return nil, err }
    defer resp.Body.Close()
    var result map[string]any
    json.NewDecoder(resp.Body).Decode(&result)
    return result, nil
}

// Cargo.toml: reqwest = { version = "0.12", features = ["json"] }
use reqwest::Client;
use serde_json::{json, Value};
use std::env;

async fn zeq_compute(domain: &str, inputs: Value) -> Value {
    Client::new()
        .post("https://www.zeqsdk.com/api/zeq/compute")
        .bearer_auth(env::var("ZEQ_API_KEY").unwrap())
        .json(&json!({"domain": domain, "inputs": inputs}))
        .send().await.unwrap()
        .json::<Value>().await.unwrap()
}

// #[tokio::main] async fn main() {
//     let r = zeq_compute("fluid-dynamics",
//         json!({"velocity_ms": 340.0, "altitude_m": 10000})).await;
//     println!("{}", r["zeqState"]["masterSum"]);
// }

# Works in any shell — Linux, macOS, Windows (Git Bash, WSL)
curl -X POST https://www.zeqsdk.com/api/zeq/compute \
  -H "Authorization: Bearer $ZEQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"domain":"classical-mechanics","inputs":{"mass_kg":70,"velocity_ms":10}}'

# Expected response structure:
# {
#   "zeqState": {
#     "operators": ["KO42", ...],
#     "masterSum": 1.000xxx,       ← R(t)
#     "precision": 0.000xxx,       ← always ≤ 0.001
#     "zeqond": 2283724594,        ← current Zeqond
#     "phase": 0.xxxx,             ← φ ∈ [0, 1]
#     "pulseHz": 1.287             ← HulyaPulse carrier
#   },
#   "result": { ... }
# }