python-materialsdb 0.0.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

materialsdb/gui/server.py

@@ -0,0 +1,730 @@
+"""Local web UI + HTTP API for exploring and exporting materialsdb materials."""
+
+import http.server
+import json
+import secrets
+import time
+from dataclasses import asdict
+from pathlib import Path
+from urllib.parse import parse_qs, unquote, urlparse
+
+from materialsdb import config, utils
+from materialsdb.construction import finite_or_none
+from materialsdb.ifc.material_builder import add_material
+
+STATIC_DIR = Path(__file__).with_name("static")
+
+_LISTENER_STALE_S = 5.0
+
+
+def _float(value):
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _resolve_display_name(names, lang):
+    return str(names.get(lang) or names.get("") or "")
+
+
+class GuiState:
+    def __init__(self, store=None):
+        self.token = secrets.token_urlsafe(16)
+        self.store = store
+        self.session_path = None
+        self.file = None
+        # client_id -> {"model_path": str, "last_seen": float, "pending": dict | None, "last_status": dict | None}
+        self.listeners = {}
+        # constructions pushed from a model (newest first, capped at 20)
+        self.incoming = []
+
+    def resolve_store(self):
+        if self.store is not None:
+            return self.store
+        from materialsdb import query
+
+        return query.get_store()
+
+
+def detail_payload(store_, material_id):
+    from materialsdb.classes import Material  # noqa: F401 - typing aid only
+
+    summary = store_.get_summary(material_id)
+    if summary is None:
+        return None
+    material = store_.get(material_id)
+    payload = asdict(summary)
+    country = config.get_country()
+    if summary.type == "btk":
+        u_values = []
+        variations = getattr(getattr(material, "variations", None), "variation", ()) or ()
+        for variation in variations:
+            thermal = utils.get_by_country(variation.vthermal or (), country)
+            if thermal is not None and thermal.U_value_without is not None:
+                u_values.append(thermal.U_value_without)
+        payload["u_value_without"] = [min(u_values), max(u_values)] if u_values else None
+        payload.pop("lambda_min", None)
+        payload.pop("lambda_max", None)
+    elif summary.type == "construction":
+        construction = getattr(material, "construction", None)
+        payload["consref"] = str(getattr(construction, "consref", "") or "")
+        payload["designusage"] = str(getattr(construction, "designusage", "") or "")
+    layers = []
+    variations = []
+    if summary.type == "btk":
+        raw_variations = getattr(getattr(material, "variations", None), "variation", ()) or ()
+        for variation in raw_variations:
+            geometry = utils.get_by_country(variation.vgeometry or (), country)
+            thermal = utils.get_by_country(variation.vthermal or (), country)
+            variations.append(
+                {
+                    "id": str(getattr(variation, "id", "")),
+                    "thick": getattr(geometry, "thick", None),
+                    "u_value_without": getattr(thermal, "U_value_without", None),
+                }
+            )
+    elif summary.type == "simple":
+        for layer in utils.get_material_layers(material):
+            thermal = utils.get_by_country(layer.thermal or (), country)
+            geometry = utils.get_by_country(layer.geometry or (), country)
+            layers.append(
+                {
+                    "id": str(getattr(layer, "id", "")),
+                    "thick": getattr(geometry, "thick", None) if geometry is not None else None,
+                    "lambda_value": getattr(thermal, "lambda_value", None) if thermal is not None else None,
+                }
+            )
+    payload["layers"] = layers
+    payload["variations"] = variations
+    return payload
+
+
+class GuiHandler(http.server.BaseHTTPRequestHandler):
+    state: GuiState
+    server_version = "materialsdb-gui"
+
+    def log_message(self, format, *args):
+        pass
+
+    def _send(self, status, payload=None, content_type="application/json", raw=None):
+        body = raw if raw is not None else json.dumps(payload).encode("utf-8")
+        try:
+            self.send_response(status)
+            self.send_header("Content-Type", content_type)
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+        except ConnectionError:
+            # client went away mid-response (tab close, aborted fetch):
+            # drop the connection instead of crashing the handler thread
+            self.close_connection = True
+
+    def _authorized(self):
+        return self.headers.get("X-MaterialsDB-Token") == self.state.token
+
+    def _read_json(self):
+        length = int(self.headers.get("Content-Length") or 0)
+        raw = self.rfile.read(length) if length else b""
+        return json.loads(raw) if raw else {}
+
+    def _prune_listeners(self):
+        now = time.time()
+        stale = [cid for cid, l in self.state.listeners.items() if now - l["last_seen"] > _LISTENER_STALE_S]
+        for cid in stale:
+            del self.state.listeners[cid]
+
+    def _listener_register(self, payload):
+        client_id = str(payload.get("client_id") or "")
+        if not client_id:
+            self._send(400, {"error": "client_id required"})
+            return
+        self._prune_listeners()
+        self.state.listeners[client_id] = {
+            "model_path": str(payload.get("model_path") or ""),
+            "last_seen": time.time(),
+            "pending": None,
+            "last_status": None,
+        }
+        self._send(200, {"ok": True})
+
+    def _listener_poll(self, parsed):
+        client_id = (parse_qs(parsed.query).get("client_id") or [""])[0]
+        listener = self.state.listeners.get(client_id)
+        if listener is None:
+            self._send(404, {"error": f"unknown listener: {client_id}"})
+            return
+        listener["last_seen"] = time.time()
+        payload = listener["pending"]
+        listener["pending"] = None
+        if payload is None:
+            self._send_204()
+            return
+        self._send(200, {"payload": payload})
+
+    def _send_204(self):
+        try:
+            self.send_response(204)
+            self.end_headers()
+        except ConnectionError:
+            self.close_connection = True
+
+    def _listener_send(self, store_, payload):
+        client_id = str(payload.get("client_id") or "")
+        listener = self.state.listeners.get(client_id)
+        if listener is None:
+            self._send(404, {"error": f"unknown listener: {client_id}"})
+            return
+        action = str(payload.get("action") or "add_materials")
+        missing = []
+        if action == "add_materials":
+            from materialsdb.gui.listener import build_add_materials_payload
+
+            resolved, missing = build_add_materials_payload(store_, payload.get("items") or [])
+            if not resolved["materials"]:
+                self._send(400, {"error": "nothing resolvable to send", "missing": missing})
+                return
+            queued = len(resolved["materials"])
+            summary = f"{queued} material(s)"
+        elif action == "add_construction":
+            from materialsdb.gui.listener import build_add_construction_payload
+
+            resolved, problems = build_add_construction_payload(store_, payload.get("construction"))
+            if resolved is None:
+                self._send(400, {"error": "; ".join(problems)})
+                return
+            queued = len(resolved["construction"]["layers"])
+            summary = f"construction '{resolved['construction']['name']}' ({queued} layer(s))"
+        else:
+            self._send(400, {"error": f"unsupported action: {action}"})
+            return
+        listener["pending"] = resolved
+        # a fresh push invalidates the previous applied/error mark: the
+        # dropdown shows a pending state until the add-on reports the new one
+        listener["last_status"] = {"status": "pending", "detail": ""}
+        self._send(200, {"ok": True, "queued": queued, "summary": summary, "missing": missing})
+
+    def _listener_status(self, payload):
+        client_id = str(payload.get("client_id") or "")
+        listener = self.state.listeners.get(client_id)
+        if listener is None:
+            self._send(404, {"error": f"unknown listener: {client_id}"})
+            return
+        listener["last_status"] = {
+            "status": str(payload.get("status") or "error"),
+            "detail": str(payload.get("detail") or ""),
+        }
+        self._send(200, {"ok": True})
+
+    def _listener_clients(self):
+        self._prune_listeners()
+        clients = [
+            {"client_id": cid, "model_path": l["model_path"], "last_status": l["last_status"]}
+            for cid, l in sorted(self.state.listeners.items())
+        ]
+        self._send(200, {"clients": clients})
+
+    def _composer_push(self, payload):
+        name = str(payload.get("name") or "").strip()
+        layers = payload.get("layers")
+        if not name:
+            self._send(400, {"error": "name required"})
+            return
+        if not isinstance(layers, list) or not layers:
+            self._send(400, {"error": "at least one layer required"})
+            return
+        checked = []
+        for index, entry in enumerate(layers):
+            if not isinstance(entry, dict):
+                self._send(400, {"error": f"layer {index}: invalid entry"})
+                return
+            thickness = finite_or_none(entry.get("thickness_m"))
+            if thickness is None or thickness < 0:
+                self._send(400, {"error": f"layer {index}: thickness must be >= 0"})
+                return
+            layer = {"material_id": entry.get("material_id") or None, "thickness_m": thickness}
+            placeholder = entry.get("placeholder")
+            if placeholder is not None and not isinstance(placeholder, dict):
+                self._send(400, {"error": f"layer {index}: invalid placeholder"})
+                return
+            if placeholder is not None:
+                layer["placeholder"] = {
+                    "name": str(placeholder.get("name") or ""),
+                    "lambda_value": finite_or_none(placeholder.get("lambda_value")),
+                }
+            checked.append(layer)
+        self.state.incoming.insert(
+            0,
+            {
+                "name": name,
+                "design_usage": payload.get("design_usage") or None,
+                "layers": checked,
+            },
+        )
+        del self.state.incoming[20:]
+        self._send(200, {"ok": True, "count": len(self.state.incoming)})
+
+    def _composer_consume(self, payload):
+        try:
+            index = int(payload.get("index"))
+        except (TypeError, ValueError):
+            self._send(400, {"error": "index required"})
+            return
+        if index < 0 or index >= len(self.state.incoming):
+            self._send(404, {"error": f"no incoming at index {index}"})
+            return
+        item = self.state.incoming.pop(index)
+        self._send(200, {"construction": item})
+
+    def do_GET(self):
+        parsed = urlparse(self.path)
+        store_ = self.state.resolve_store()
+        if parsed.path == "/":
+            try:
+                html = (STATIC_DIR / "index.html").read_text(encoding="utf-8")
+            except FileNotFoundError:
+                self._send(404, {"error": "not found"})
+                return
+            html = html.replace("__TOKEN__", self.state.token)
+            self._send(200, content_type="text/html; charset=utf-8", raw=html.encode("utf-8"))
+            return
+        if parsed.path == "/app.js":
+            try:
+                js = (STATIC_DIR / "app.js").read_text(encoding="utf-8")
+            except FileNotFoundError:
+                self._send(404, {"error": "not found"})
+                return
+            self._send(200, content_type="text/javascript; charset=utf-8", raw=js.encode("utf-8"))
+            return
+        if parsed.path in ("/constructions.html",):
+            try:
+                html = (STATIC_DIR / "constructions.html").read_text(encoding="utf-8")
+            except FileNotFoundError:
+                self._send(404, {"error": "not found"})
+                return
+            html = html.replace("__TOKEN__", self.state.token)
+            self._send(200, content_type="text/html; charset=utf-8", raw=html.encode("utf-8"))
+            return
+        if parsed.path == "/app-constructions.js":
+            try:
+                js = (STATIC_DIR / "app-constructions.js").read_text(encoding="utf-8")
+            except FileNotFoundError:
+                self._send(404, {"error": "not found"})
+                return
+            self._send(200, content_type="text/javascript; charset=utf-8", raw=js.encode("utf-8"))
+            return
+        if parsed.path == "/picker-core.js":
+            try:
+                js = (STATIC_DIR / "picker-core.js").read_text(encoding="utf-8")
+            except FileNotFoundError:
+                self._send(404, {"error": "not found"})
+                return
+            self._send(200, content_type="text/javascript; charset=utf-8", raw=js.encode("utf-8"))
+            return
+        if parsed.path == "/api/materials":
+            params = {k: v[0] for k, v in parse_qs(parsed.query).items()}
+            rows = store_.summaries(
+                company=params.get("company") or None,
+                category=params.get("category") or None,
+                type=params.get("type") or None,
+                min_lambda=_float(params.get("min_lambda")),
+                max_lambda=_float(params.get("max_lambda")),
+                min_thick=_float(params.get("min_thick")),
+                max_thick=_float(params.get("max_thick")),
+                usage=params.get("usage") or None,
+                text=params.get("text") or None,
+                sort=params.get("sort") or "company",
+                ascending=params.get("order") != "desc",
+                lang=params.get("lang") or None,
+            )
+            lang = params.get("lang") or config.get_lang()
+            materials = []
+            for row in rows:
+                item = asdict(row)
+                item["display_name"] = _resolve_display_name(item["names"], lang)
+                materials.append(item)
+            self._send(200, {"materials": materials})
+            return
+        if parsed.path.startswith("/api/materials/"):
+            material_id = parsed.path.rsplit("/", 1)[1]
+            payload = detail_payload(store_, material_id)
+            if payload is None:
+                self._send(404, {"error": f"Unknown material id: {material_id}"})
+            else:
+                self._send(200, payload)
+            return
+        if parsed.path.startswith("/api/constructions/legacy/"):
+            material_id = unquote(parsed.path.rsplit("/", 1)[1])
+            payload = self._legacy_construction(store_, material_id)
+            if payload is None:
+                self._send(404, {"error": f"Unknown material id: {material_id}"})
+            else:
+                self._send(200, payload)
+            return
+        if parsed.path == "/api/constructions":
+            from materialsdb import construction as cm
+
+            self._send(200, {"constructions": cm.list_constructions()})
+            return
+        if parsed.path == "/api/config":
+            from materialsdb import config as cfg
+
+            self._send(200, {"lang": cfg.get_lang(), "country": cfg.get_country()})
+            return
+        if parsed.path == "/api/listener/poll":
+            if not self._authorized():
+                self._send(403, {"error": "forbidden"})
+                return
+            self._listener_poll(parsed)
+            return
+        if parsed.path == "/api/listener/clients":
+            if not self._authorized():
+                self._send(403, {"error": "forbidden"})
+                return
+            self._listener_clients()
+            return
+        if parsed.path == "/api/composer/incoming":
+            self._send(200, {"incoming": self.state.incoming})
+            return
+        if parsed.path.startswith("/api/constructions/"):
+            from materialsdb import construction as cm
+
+            name = unquote(parsed.path.rsplit("/", 1)[1])
+            construction = cm.load_construction(name, store_)
+            if construction is None:
+                self._send(404, {"error": f"unknown construction: {name}"})
+            else:
+                self._send(200, cm._to_body(construction))
+            return
+        self._send(404, {"error": "not found"})
+
+    def _legacy_construction(self, store_, material_id):
+        """Best-effort read-only decode of a NON-SPEC vendor construction
+        string (see construction.parse_legacy_stack). Never fatal: layers
+        with unresolvable guids are flagged instead of dropped."""
+        from materialsdb import construction as cm
+
+        material = store_.get(material_id)
+        if material is None:
+            return None
+        construction_el = getattr(material, "construction", None)
+        body = getattr(construction_el, "xml_body_text", "") or ""
+        decoded = cm.parse_legacy_stack(body)
+        country = config.get_country()
+        variants = []
+        for variant in decoded["variants"]:
+            layers = []
+            stack_layers = []
+            unresolved_count = 0
+            for layer in variant["layers"]:
+                guid = str(layer["guid"])
+                summary = store_.get_summary(guid)
+                name = ""
+                if summary is not None:
+                    name = summary.names.get(country) or summary.names.get("") or ""
+                lambda_value = cm.resolve_lambda(store_, guid, country)
+                if summary is None:
+                    unresolved_count += 1
+                else:
+                    stack_layers.append(cm.ConstructionLayer(material_id=guid, thickness_m=float(layer["thickness_m"])))
+                layers.append(
+                    {
+                        "guid": guid,
+                        "thickness_m": float(layer["thickness_m"]),
+                        "name": name,
+                        "lambda_value": lambda_value,
+                        "resolvable": summary is not None,
+                    }
+                )
+            stack = cm.Construction(
+                name=f"{material_id[:8]} legacy",
+                design_usage=getattr(construction_el, "designusage", None),
+                layers=stack_layers,
+            )
+            result = cm.u_value(stack, store_) if stack.layers else None
+            variants.append(
+                {
+                    "header_raw": variant["header_raw"],
+                    "layers": layers,
+                    "u": result.u if result is not None else None,
+                    "unresolved_count": unresolved_count,
+                }
+            )
+        return {
+            "material_id": material_id,
+            "consref": str(getattr(construction_el, "consref", "") or ""),
+            "designusage": str(getattr(construction_el, "designusage", "") or ""),
+            "raw": decoded["raw"],
+            "variants": variants,
+        }
+
+    def do_POST(self):
+        parsed = urlparse(self.path)
+        if not self._authorized():
+            self._send(403, {"error": "forbidden"})
+            return
+        try:
+            payload = self._read_json()
+        except ValueError as err:
+            self._send(400, {"error": f"invalid json: {err}"})
+            return
+        store_ = self.state.resolve_store()
+        try:
+            if parsed.path == "/api/export":
+                self._export(store_, payload)
+            elif parsed.path == "/api/session/open":
+                self._session_open(payload)
+            elif parsed.path == "/api/pick":
+                self._pick(store_, payload)
+            elif parsed.path == "/api/session/save":
+                self._session_save(payload)
+            elif parsed.path == "/api/config":
+                self._config(payload)
+            elif parsed.path == "/api/refresh":
+                self._refresh(payload)
+            elif parsed.path == "/api/u_value":
+                self._u_value(store_, payload)
+            elif parsed.path == "/api/export-construction":
+                self._export_construction(store_, payload)
+            elif parsed.path == "/api/append-construction":
+                self._append_construction(store_, payload)
+            elif parsed.path == "/api/composer/push":
+                self._composer_push(payload)
+            elif parsed.path == "/api/composer/incoming/consume":
+                self._composer_consume(payload)
+            elif parsed.path.startswith("/api/constructions/"):
+                self._construction_save(store_, parsed, payload)
+            elif parsed.path == "/api/listener/register":
+                self._listener_register(payload)
+            elif parsed.path == "/api/listener/send":
+                self._listener_send(store_, payload)
+            elif parsed.path == "/api/listener/status":
+                self._listener_status(payload)
+            else:
+                self._send(404, {"error": "not found"})
+        except Exception as err:  # noqa: BLE001 - one bad request must not kill the server
+            self._send(500, {"error": str(err)})
+
+    def do_DELETE(self):
+        if not self._authorized():
+            self._send(403, {"error": "forbidden"})
+            return
+        parsed = urlparse(self.path)
+        if parsed.path.startswith("/api/constructions/"):
+            from materialsdb import construction as cm
+
+            name = unquote(parsed.path.rsplit("/", 1)[1])
+            if cm.delete_construction(name):
+                self._send(200, {"deleted": True})
+            else:
+                self._send(404, {"error": f"unknown construction: {name}"})
+            return
+        self._send(404, {"error": "not found"})
+
+    def _export(self, store_, payload):
+        import tempfile
+        import uuid
+
+        from materialsdb import utils
+        from materialsdb.ifc.project_library import ProjectLibrary
+
+        items = payload.get("items") or []
+        if not items:
+            self._send(400, {"error": "items required"})
+            return
+        library = ProjectLibrary()
+        library.create_project_library(
+            company="MaterialsDB Export",
+            companyid=str(uuid.uuid4()),
+            ver=1,
+            crd=utils.new_tdatetime(),
+        )
+        for item in items:
+            if not isinstance(item, dict):
+                self._send(400, {"error": f"invalid item: {item!r}"})
+                return
+            material_id = item.get("id")
+            summary = store_.get_summary(material_id)
+            material = store_.get(material_id)
+            if summary is None or material is None:
+                continue
+            add_material(
+                library.file,
+                material,
+                company_id=summary.company_id or "",
+                company=summary.company,
+                layer_ids=item.get("layer_ids"),
+            )
+        handle = tempfile.NamedTemporaryFile(suffix=".ifc", delete=False)  # noqa: SIM115 - closed immediately
+        handle.close()
+        try:
+            library.file.write(handle.name)
+            data = Path(handle.name).read_bytes()
+        finally:
+            Path(handle.name).unlink(missing_ok=True)
+        self.send_response(200)
+        self.send_header("Content-Type", "application/ifc")
+        self.send_header("Content-Disposition", 'attachment; filename="materialsdb_export.ifc"')
+        self.send_header("Content-Length", str(len(data)))
+        self.end_headers()
+        self.wfile.write(data)
+
+    def _session_open(self, payload):
+        import ifcopenshell
+
+        path = payload.get("path")
+        candidate = Path(path) if path else None
+        if candidate is None or not candidate.exists():
+            self._send(400, {"error": f"path does not exist: {path}"})
+            return
+        try:
+            self.state.file = ifcopenshell.open(str(candidate))
+        except Exception as err:  # noqa: BLE001 - malformed ifc must surface as a 400, not a crash
+            self._send(400, {"error": f"could not open ifc: {err}"})
+            return
+        self.state.session_path = candidate
+        self._send(200, {"path": str(candidate)})
+
+    def _pick(self, store_, payload):
+        if self.state.file is None:
+            self._send(409, {"error": "no session open"})
+            return
+        items = payload.get("items") or []
+        if not items:
+            self._send(400, {"error": "items required"})
+            return
+        replace = bool(payload.get("replace"))
+        added = 0
+        missing = []
+        for item in items:
+            if not isinstance(item, dict):
+                self._send(400, {"error": f"invalid item: {item!r}"})
+                return
+            material_id = item.get("id")
+            summary = store_.get_summary(material_id)
+            material = store_.get(material_id)
+            if summary is None or material is None:
+                missing.append(material_id)
+                continue
+            add_material(
+                self.state.file,
+                material,
+                company_id=summary.company_id or "",
+                company=summary.company,
+                replace=replace,
+                layer_ids=item.get("layer_ids"),
+            )
+            added += 1
+        self._send(200, {"added": added, "missing": missing})
+
+    def _session_save(self, payload):
+        if self.state.file is None:
+            self._send(409, {"error": "no session open"})
+            return
+        destination = Path(payload.get("path") or self.state.session_path)  # ty: ignore[invalid-argument-type]
+        self.state.file.write(str(destination))
+        self._send(200, {"saved": str(destination)})
+
+    def _config(self, payload):
+        from materialsdb import config
+
+        lang = payload.get("lang")
+        country = payload.get("country")
+        if lang:
+            config.set_lang(str(lang).lower())
+        if country:
+            config.set_country(str(country).upper())
+        self._send(200, {"ok": True})
+
+    def _refresh(self, payload):
+        from materialsdb import query
+
+        report = query.refresh(force=bool(payload.get("force")))
+        self._send(
+            200,
+            {
+                "existing": len(report.existing),
+                "updated": [str(p) for p in report.updated],
+                "deleted": [str(p) for p in report.deleted],
+                "skipped": [str(p) for p in report.skipped],
+                "duplicates": [
+                    {"material_id": d.material_id, "kept": d.kept_source, "skipped": d.skipped_source}
+                    for d in report.duplicates
+                ],
+            },
+        )
+
+    def _construction_save(self, store_, parsed, payload):
+        from materialsdb import construction as cm
+
+        name = unquote(parsed.path.rsplit("/", 1)[1])
+        body = dict(payload)
+        body.setdefault("name", name)
+        construction, problems = cm.validate_construction(body, store_)
+        if problems:
+            self._send(400, {"error": "; ".join(problems)})
+            return
+        cm.save_construction(construction, store_)
+        self._send(200, {"saved": construction.name})
+
+    def _u_value(self, store_, payload):
+        from materialsdb import construction as cm
+
+        body = payload.get("construction") or {}
+        construction, problems = cm.validate_construction(body, store_)
+        if problems:
+            self._send(400, {"error": "; ".join(problems)})
+            return
+        result = cm.u_value(construction, store_, preset=payload.get("preset") or "ISO6946")
+        self._send(200, asdict(result))
+
+    def _export_construction(self, store_, payload):
+        import tempfile
+
+        from materialsdb import construction as cm
+
+        construction, problems = cm.validate_construction(payload.get("construction") or {}, store_)
+        if problems:
+            self._send(400, {"error": "; ".join(problems)})
+            return
+        file = cm.to_ifc_layer_set(construction, store_)
+        handle = tempfile.NamedTemporaryFile(suffix=".ifc", delete=False)  # noqa: SIM115 - closed immediately
+        handle.close()
+        try:
+            file.write(handle.name)
+            data = Path(handle.name).read_bytes()
+        finally:
+            Path(handle.name).unlink(missing_ok=True)
+        self.send_response(200)
+        self.send_header("Content-Type", "application/ifc")
+        self.send_header("Content-Disposition", f'attachment; filename="{cm.slugify(construction.name)}.ifc"')
+        self.send_header("Content-Length", str(len(data)))
+        self.end_headers()
+        self.wfile.write(data)
+
+    def _append_construction(self, store_, payload):
+        if self.state.file is None:
+            self._send(409, {"error": "no session open"})
+            return
+        from materialsdb import construction as cm
+
+        construction, problems = cm.validate_construction(payload.get("construction") or {}, store_)
+        if problems:
+            self._send(400, {"error": "; ".join(problems)})
+            return
+        cm.to_ifc_layer_set(construction, store_, file=self.state.file)
+        after = self.state.file.by_type("IfcMaterialLayerSet")
+        self._send(200, {"layer_count": len(after[-1].MaterialLayers)})
+
+
+class GuiServer(http.server.ThreadingHTTPServer):
+    gui_state: GuiState
+
+
+def make_server(state=None, port=0):
+    state = state or GuiState()
+    handler = type("BoundGuiHandler", (GuiHandler,), {"state": state})
+    server = GuiServer(("127.0.0.1", port), handler)
+    server.daemon_threads = True
+    server.gui_state = state
+    return server