pz-cli 5.0.0__py3-none-any.whl

pz_foundation/host/web.py

@@ -0,0 +1,790 @@
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+from dataclasses import replace
+import importlib
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+
+from fastapi import APIRouter, FastAPI
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import JSONResponse
+from fastapi.routing import APIRoute
+from fastapi.staticfiles import StaticFiles
+from starlette.routing import compile_path
+
+from pz_core.assembly.project import active_project_import_root
+from pz_settings_center.public import active_settings_project, bound_settings_snapshot
+
+from ..runtime import bind_runtime_context, reset_runtime_context
+from ..routing import (
+    DeclaredUrlSpec,
+    build_route_registry_entry,
+    clean_and_reorder_routes,
+    compile_route_manifest,
+    graft_router,
+    load_declared_url_specs,
+)
+from ..routing.canonical import is_file_like_path
+from ..routing.exports import _merge_lifespan_context
+from ..routing.manifest import require_foundation_url_manifest, route_path_decls_from_router
+from ..routing.utils import _join_path_prefix
+from .db.request_adapter import wrap_db_request_scope
+from .lifespan import start_infra_background_tasks
+
+
+class _HostAsgiWrapper:
+    def __init__(self, app: FastAPI, wrapped: Any):
+        self._app = app
+        self._wrapped = wrapped
+        self.state = app.state
+        self.router = app.router
+        self.title = getattr(app, "title", "")
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._app, name)
+
+    async def __call__(self, scope: dict[str, Any], receive: Any, send: Any) -> None:
+        await self._wrapped(scope, receive, send)
+
+
+def _bind_host_state_surface(target: Any, app: FastAPI) -> Any:
+    for key, value in (
+        ("state", app.state),
+        ("router", app.router),
+        ("title", getattr(app, "title", "")),
+        ("_pz_host_app", app),
+    ):
+        try:
+            setattr(target, key, value)
+        except Exception:
+            continue
+    return target
+
+def _resolve_dotted(target: Any) -> Any:
+    if not isinstance(target, str) or not target.strip():
+        return target
+    raw = target.strip()
+    if ":" in raw:
+        module_name, attr_name = raw.split(":", 1)
+    else:
+        module_name, attr_name = raw.rsplit(".", 1)
+    module = importlib.import_module(module_name)
+    return getattr(module, attr_name)
+
+def _iter_payload_items(payload: Any) -> list[Any]:
+    if payload is None:
+        return []
+    if isinstance(payload, (list, tuple)):
+        return [item for item in payload if item is not None]
+    return [payload]
+
+
+def _load_host_extensions(plan: Any, *, kinds: set[str] | None = None) -> list[Any]:
+    loaded: list[Any] = []
+    for extension in plan.extension_registry.extensions:
+        kind = str(getattr(extension, "kind", "") or "").strip()
+        if kinds is not None and kind not in kinds:
+            continue
+        loaded.append(
+            SimpleNamespace(
+                id=getattr(extension, "id", ""),
+                owner=getattr(extension, "owner_app", ""),
+                kind=kind,
+                title=getattr(extension, "title", ""),
+                priority=int(getattr(extension, "priority", 100) or 100),
+                payload=dict(getattr(extension, "payload", None) or {}),
+                source=getattr(extension, "source", ""),
+                provides=tuple(getattr(extension, "provides", ()) or ()),
+                conflicts=tuple(getattr(extension, "conflicts", ()) or ()),
+            )
+        )
+    loaded.sort(key=lambda ext: (int(getattr(ext, "priority", 100) or 100), str(getattr(ext, "id", "") or "")))
+    return loaded
+
+
+def _router_has_catchall(router: Any) -> bool:
+    for route in getattr(router, "routes", []) or []:
+        path = str(getattr(route, "path", "") or "")
+        if ":path}" in path:
+            return True
+    return False
+
+
+def _set_route_path(route: APIRoute, path: str) -> None:
+    path_regex, path_format, param_convertors = compile_path(path)
+    route.path = path
+    route.path_regex = path_regex
+    route.path_format = path_format
+    route.param_convertors = param_convertors
+    dependant = getattr(route, "dependant", None)
+    if dependant is not None:
+        try:
+            dependant.path = path_format
+        except Exception:
+            pass
+
+
+def _is_directory_page_route(route: APIRoute, *, path_prefix: str = "") -> bool:
+    path = str(getattr(route, "path", "") or "").strip()
+    if not path or path == "/" or path.endswith("/"):
+        return False
+    effective_path = _join_path_prefix(path_prefix, path)
+    if (
+        effective_path.startswith("/api/")
+        or effective_path.startswith("/static/")
+        or is_file_like_path(effective_path)
+    ):
+        return False
+    methods = {str(method).upper() for method in (getattr(route, "methods", None) or ())}
+    if methods and not methods.issubset({"GET", "HEAD"}):
+        return False
+    return effective_path == "/admin" or effective_path.startswith("/admin/")
+
+
+def _normalize_directory_page_routes(router: APIRouter, *, path_prefix: str = "") -> None:
+    for route in list(getattr(router, "routes", []) or []):
+        if not isinstance(route, APIRoute) or not _is_directory_page_route(route, path_prefix=path_prefix):
+            continue
+        path = str(getattr(route, "path", "") or "").strip()
+        _set_route_path(route, f"{path}/")
+
+
+def _ensure_route_registry(app: FastAPI) -> list[dict[str, Any]]:
+    registry = getattr(app.state, "pz_route_registry", None)
+    if isinstance(registry, list):
+        return registry
+    registry = []
+    app.state.pz_route_registry = registry
+    return registry
+
+
+def _record_route_mount(
+    app: FastAPI,
+    *,
+    namespace: str,
+    path_prefix: str,
+    router: APIRouter,
+    source: str,
+    route_hints: tuple[str, ...] = (),
+    conflict_policy: str = "fail",
+) -> None:
+    registry = _ensure_route_registry(app)
+    mounted_paths: list[str] = []
+    for route in getattr(router, "routes", ()) or ():
+        path = getattr(route, "path", None)
+        if isinstance(path, str) and path:
+            mounted_paths.append(path)
+        try:
+            setattr(route, "pz_route_namespace", namespace)
+            setattr(route, "pz_route_source", source)
+        except Exception:
+            continue
+    registry.append(
+        {
+            "namespace": namespace,
+            "path_prefix": path_prefix,
+            "source": source,
+            "paths": tuple(mounted_paths),
+            "route_hints": tuple(route_hints or ()),
+            "conflict_policy": str(conflict_policy or "fail"),
+        }
+    )
+
+
+def _validate_route_registry(app: FastAPI) -> None:
+    registry = _ensure_route_registry(app)
+    seen: dict[str, dict[str, Any]] = {}
+    for item in registry:
+        namespace = str(item.get("namespace") or "").strip()
+        if not namespace:
+            raise RuntimeError("mounted route specs must carry a non-empty namespace.")
+        previous = seen.get(namespace)
+        if previous is not None:
+            raise RuntimeError(
+                "duplicate mounted route namespace "
+                f"{namespace!r}: {previous.get('source', '<unknown>')} and {item.get('source', '<unknown>')}"
+            )
+        seen[namespace] = item
+
+
+def _host_route_routers(
+    *,
+    app: FastAPI,
+    runtime: Any,
+) -> list[DeclaredUrlSpec]:
+    routers: list[tuple[int, DeclaredUrlSpec]] = []
+    for ext in _load_host_extensions(runtime.plan, kinds={"host.route"}):
+        payload = dict(getattr(ext, "payload", {}) or {})
+        target = _resolve_dotted(payload.get("router"))
+        if target is None:
+            raise RuntimeError(f"Host route extension '{getattr(ext, 'id', '<unknown>')}' must declare payload.router.")
+        if isinstance(target, APIRouter):
+            resolved = target
+        else:
+            resolved = target(
+                app=app,
+                host=app,
+                runtime=runtime,
+                plan=runtime.plan,
+                bindings=runtime.bindings,
+            )
+        path_prefix = str(payload.get("path_prefix") or "").strip()
+        for router in _iter_payload_items(resolved):
+            if not isinstance(router, APIRouter):
+                raise RuntimeError(
+                    f"Host route extension '{getattr(ext, 'id', '<unknown>')}' must resolve to APIRouter instances."
+                )
+            _normalize_directory_page_routes(router, path_prefix=path_prefix)
+            routers.append(
+                (
+                    int(getattr(ext, "priority", 100) or 100),
+                    DeclaredUrlSpec(
+                        router=router,
+                        path_prefix=path_prefix,
+                        namespace=str(getattr(ext, "id", "") or getattr(ext, "owner", "") or "host.route"),
+                    ),
+                )
+            )
+    return [router for _, router in sorted(routers, key=lambda item: item[0])]
+
+
+def _iter_router_paths(router: APIRouter) -> list[str]:
+    out: list[str] = []
+    for route in list(getattr(router, "routes", []) or []):
+        path = getattr(route, "path", None)
+        if isinstance(path, str) and path:
+            out.append(path)
+    return out
+
+
+def _admin_panel_routers(
+    *,
+    app: FastAPI,
+    runtime: Any,
+) -> list[DeclaredUrlSpec]:
+    routers: list[tuple[int, DeclaredUrlSpec]] = []
+    for ext in _load_host_extensions(runtime.plan, kinds={"admin.panel"}):
+        payload = dict(getattr(ext, "payload", {}) or {})
+        target = _resolve_dotted(payload.get("router"))
+        if target is None:
+            continue
+        if isinstance(target, APIRouter):
+            resolved = target
+        else:
+            resolved = target(
+                app=app,
+                host=app,
+                runtime=runtime,
+                plan=runtime.plan,
+                bindings=runtime.bindings,
+            )
+        for router in _iter_payload_items(resolved):
+            if not isinstance(router, APIRouter):
+                continue
+            route_paths = _iter_router_paths(router)
+            if not route_paths or not all(path.startswith("/admin") for path in route_paths):
+                continue
+            _normalize_directory_page_routes(router)
+            routers.append(
+                (
+                    int(getattr(ext, "priority", 100) or 100),
+                    DeclaredUrlSpec(
+                        router=router,
+                        path_prefix="",
+                        namespace=str(getattr(ext, "id", "") or getattr(ext, "owner", "") or "admin.panel"),
+                    ),
+                )
+            )
+    return [router for _, router in sorted(routers, key=lambda item: item[0])]
+
+
+def _declared_url_specs_from_manifest(runtime: Any) -> list[tuple[str, DeclaredUrlSpec]]:
+    manifest = require_foundation_url_manifest(getattr(runtime, "plan", None))
+    specs: list[tuple[str, DeclaredUrlSpec]] = []
+    specs_by_namespace: dict[str, DeclaredUrlSpec] = {}
+    loaded_by_entrypoint: dict[str, tuple[DeclaredUrlSpec, ...]] = {}
+    for entry in manifest.entries:
+        entrypoint = str(entry.entrypoint or "").strip()
+        if not entrypoint:
+            raise RuntimeError(f"compiled URL manifest entry {entry.namespace!r} is missing its app entrypoint.")
+        if entrypoint in loaded_by_entrypoint:
+            continue
+        declared_url_specs = load_declared_url_specs(entrypoint)
+        loaded_by_entrypoint[entrypoint] = declared_url_specs
+        for spec in declared_url_specs:
+            specs_by_namespace[str(spec.namespace or "").strip()] = spec
+    for entry in manifest.entries:
+        spec = specs_by_namespace.get(str(entry.namespace or "").strip())
+        if spec is None:
+            raise RuntimeError(
+                f"compiled URL manifest entry {entry.namespace!r} does not have a matching materialized router."
+            )
+        if route_path_decls_from_router(spec.router) != tuple(entry.routes):
+            raise RuntimeError(
+                f"materialized router for compiled URL manifest entry {entry.namespace!r} "
+                "does not match the RuntimePlan URL manifest."
+            )
+        specs.append((str(entry.owner_app or ""), spec))
+    return specs
+
+
+def _mount_app_routers(
+    app: FastAPI,
+    *,
+    runtime: Any,
+) -> None:
+    normal_routers: list[DeclaredUrlSpec] = []
+    catchall_routers: list[DeclaredUrlSpec] = []
+    registry_entries = []
+    manifest_specs = _declared_url_specs_from_manifest(runtime)
+    for owner_app, declared_spec in manifest_specs:
+        if not isinstance(declared_spec, DeclaredUrlSpec):
+            raise RuntimeError(f"router mount for {owner_app} must resolve to DeclaredUrlSpec instances.")
+        router = declared_spec.router
+        if not isinstance(router, APIRouter):
+            raise RuntimeError(f"router mount for {owner_app} must resolve to APIRouter instances.")
+        _normalize_directory_page_routes(router, path_prefix=str(declared_spec.path_prefix or ""))
+        spec = DeclaredUrlSpec(
+            router=router,
+            path_prefix=str(declared_spec.path_prefix or ""),
+            dependencies=tuple(declared_spec.dependencies or ()),
+            namespace=str(declared_spec.namespace or owner_app),
+            replace_target=str(declared_spec.replace_target or ""),
+            route_hints=tuple(declared_spec.route_hints or ()),
+            conflict_policy=str(declared_spec.conflict_policy or "fail"),
+        )
+        registry_entries.append(
+            build_route_registry_entry(
+                owner_app=str(owner_app),
+                spec=spec,
+            )
+        )
+        bucket = catchall_routers if _router_has_catchall(router) else normal_routers
+        bucket.append(spec)
+    for spec in _host_route_routers(app=app, runtime=runtime):
+        registry_entries.append(
+            build_route_registry_entry(
+                owner_app=str(spec.namespace or "host.route"),
+                spec=spec,
+                route_hints=("host.route",),
+            )
+        )
+        bucket = catchall_routers if _router_has_catchall(spec.router) else normal_routers
+        bucket.append(spec)
+    for spec in _admin_panel_routers(app=app, runtime=runtime):
+        registry_entries.append(
+            build_route_registry_entry(
+                owner_app=str(spec.namespace or "admin.panel"),
+                spec=spec,
+                route_hints=("admin.panel",),
+            )
+        )
+        bucket = catchall_routers if _router_has_catchall(spec.router) else normal_routers
+        bucket.append(spec)
+    app.state.pz_route_manifest = compile_route_manifest(registry_entries)
+    app.state.pz_compiled_route_registry = app.state.pz_route_manifest.entries
+    for spec in normal_routers + catchall_routers:
+        graft_router(
+            app,
+            spec.router,
+            path_prefix=spec.path_prefix,
+            dependencies=spec.dependencies,
+        )
+        _record_route_mount(
+            app,
+            namespace=spec.namespace,
+            path_prefix=spec.path_prefix,
+            router=spec.router,
+            source=spec.namespace,
+            route_hints=tuple(spec.route_hints or ()),
+            conflict_policy=str(spec.conflict_policy or "fail"),
+        )
+    _validate_route_registry(app)
+
+
+def _attach_runtime_state(
+    app: FastAPI,
+    *,
+    project_dir: Path,
+    plan: Any,
+    bindings: Any,
+    lifecycle_state: Any,
+    settings_snapshot: Any,
+    bind_context: bool = True,
+) -> None:
+    app.state.project_dir = str(project_dir)
+    app.state.app_name = str(settings_snapshot.get("project", "name") or "PZ Project")
+    app.state.settings_snapshot = settings_snapshot
+    app.state.pz_runtime_plan = plan
+    app.state.pz_runtime_bindings = bindings
+    app.state.pz_runtime_state = lifecycle_state
+    if bind_context:
+        owner = getattr(app.state, "pz_foundation_owner", None)
+        if owner:
+            bind_runtime_context(
+                owner=str(owner),
+                project_dir=project_dir,
+                bindings=bindings,
+                plan=plan,
+                lifecycle_state=lifecycle_state,
+            )
+
+
+def _to_jsonable(value: Any) -> Any:
+    return jsonable_encoder(value)
+
+
+def _requires_database_readiness(payload: dict[str, Any]) -> bool:
+    statuses = payload.get("capability_statuses")
+    if not isinstance(statuses, dict):
+        return False
+    return statuses.get("database") not in (None, "disabled")
+
+
+def _database_lifecycle_payload() -> dict[str, Any]:
+    try:
+        from ..db.lifecycle_status import connection_lifecycle_status
+        from ..db.tortoise_manager import tortoise_manager
+
+        status = connection_lifecycle_status(tortoise_manager)
+    except Exception as exc:  # noqa: BLE001
+        return {"default_ready": False, "status": "lookup_failed", "error_type": type(exc).__name__}
+    payload = _to_jsonable(status)
+    if isinstance(payload, dict):
+        payload["default_ready"] = status.default_ready
+        payload["read_only_ready"] = status.read_only_ready
+        return payload
+    return {"default_ready": bool(status.default_ready), "read_only_ready": bool(status.read_only_ready)}
+
+
+def _apply_readiness_lifecycle(payload: dict[str, Any]) -> dict[str, Any]:
+    if not _requires_database_readiness(payload):
+        return payload
+    lifecycle = _database_lifecycle_payload()
+    payload["database_lifecycle"] = lifecycle
+    if bool(lifecycle.get("default_ready")):
+        return payload
+    payload["status"] = "unavailable"
+    statuses = payload.get("capability_statuses")
+    if isinstance(statuses, dict):
+        statuses["database"] = "unavailable"
+    unavailable = list(payload.get("unavailable_capabilities") or ())
+    if "database" not in unavailable:
+        unavailable.append("database")
+    payload["unavailable_capabilities"] = unavailable
+    return payload
+
+
+def _has_route_path(app: FastAPI, path: str) -> bool:
+    for route in getattr(app.router, "routes", []) or []:
+        if getattr(route, "path", None) == path:
+            return True
+    return False
+
+
+def _resource_output_dir(manifest: Any, name: str) -> Path:
+    for item in getattr(manifest, "items", ()) or ():
+        if str(getattr(item, "name", "") or "").strip() == name:
+            output_dir = getattr(item, "output_dir", None)
+            if output_dir is not None:
+                return Path(output_dir)
+    raise RuntimeError(f"runtime resource item '{name}' is missing from manifest")
+
+
+def _mount_runtime_static(app: FastAPI, *, bindings: Any) -> None:
+    if _has_route_path(app, "/static"):
+        return
+    manifest = bindings.resources.manifest()
+    static_dir = _resource_output_dir(manifest, "static")
+    if not static_dir.exists():
+        raise RuntimeError("runtime static resources must be built before mounting '/static'")
+    app.mount("/static", StaticFiles(directory=str(static_dir), check_dir=False), name="static")
+
+
+def _build_runtime_resources(*, plan: Any, bindings: Any, host: object | None = None) -> None:
+    bindings.providers.activate_declared(
+        plan=plan,
+        bindings=bindings,
+        host=host,
+        owner="pz_foundation",
+    )
+
+
+def _apply_host_state_extensions(
+    app: FastAPI,
+    *,
+    runtime: Any,
+) -> None:
+    extensions = _load_host_extensions(runtime.plan, kinds={"host.state"})
+    for ext in extensions:
+        payload = dict(getattr(ext, "payload", {}) or {})
+        if "values" in payload:
+            values = dict(payload.get("values") or {})
+        else:
+            provider = _resolve_dotted(payload.get("provider"))
+            values = dict(
+                provider(
+                    app=app,
+                    host=app,
+                    runtime=runtime,
+                    plan=runtime.plan,
+                    bindings=runtime.bindings,
+                )
+                or {}
+            )
+        for key, value in values.items():
+            setattr(app.state, str(key), value)
+
+
+def _apply_host_route_extensions(
+    app: FastAPI,
+    *,
+    runtime: Any,
+) -> None:
+    for spec in _host_route_routers(app=app, runtime=runtime):
+        graft_router(
+            app,
+            spec.router,
+            path_prefix=spec.path_prefix,
+            dependencies=spec.dependencies,
+        )
+        _record_route_mount(
+            app,
+            namespace=spec.namespace,
+            path_prefix=spec.path_prefix,
+            router=spec.router,
+            source=spec.namespace,
+            route_hints=tuple(spec.route_hints or ()),
+            conflict_policy=str(spec.conflict_policy or "fail"),
+        )
+    _validate_route_registry(app)
+
+
+def _apply_host_mount_extensions(
+    app: FastAPI,
+    *,
+    runtime: Any,
+) -> None:
+    kinds = {"host.mount", "host.static"}
+    extensions = _load_host_extensions(runtime.plan, kinds=kinds)
+    project_dir = Path(getattr(runtime.plan.project, "project_dir", ".")).resolve()
+    for ext in extensions:
+        payload = dict(getattr(ext, "payload", {}) or {})
+        path = str(payload.get("path") or "").strip()
+        if not path:
+            raise RuntimeError(f"Host mount extension '{getattr(ext, 'id', '<unknown>')}' must declare payload.path.")
+        name = str(payload.get("name") or getattr(ext, "id", "host-mount"))
+        if getattr(ext, "kind", "") == "host.static":
+            raw_directory = str(payload.get("directory") or "").strip()
+            if not raw_directory:
+                raise RuntimeError(
+                    f"Host static extension '{getattr(ext, 'id', '<unknown>')}' must declare payload.directory."
+                )
+            directory = Path(raw_directory)
+            if not directory.is_absolute():
+                directory = (project_dir / directory).resolve()
+            mounted = StaticFiles(
+                directory=str(directory),
+                check_dir=bool(payload.get("check_dir", False)),
+            )
+        else:
+            target = _resolve_dotted(payload.get("app"))
+            if target is None:
+                raise RuntimeError(
+                    f"Host mount extension '{getattr(ext, 'id', '<unknown>')}' must declare payload.app."
+                )
+            if isinstance(target, (FastAPI, StaticFiles)):
+                mounted = target
+            else:
+                mounted = target(
+                    app=app,
+                    host=app,
+                    runtime=runtime,
+                    plan=runtime.plan,
+                    bindings=runtime.bindings,
+                )
+        app.mount(path, mounted, name=name)
+
+
+def _build_http_app(
+    *,
+    plan: Any,
+    lifecycle_state: Any,
+    bindings: Any,
+    project_dir: Path,
+    health_facade_cls,
+    activate_runtime_plan,
+    shutdown_runtime_plan,
+    apply_runtime_middlewares,
+    active_runtime_plan,
+) -> Any:
+    settings_snapshot = plan.settings
+    runtime_refs: dict[str, Any] = {}
+
+    _build_runtime_resources(plan=plan, bindings=bindings)
+
+    @asynccontextmanager
+    async def _lifespan(host_app: FastAPI):
+        started = False
+        try:
+            with (
+                active_settings_project(str(project_dir)),
+                active_runtime_plan(plan),
+                active_project_import_root(
+                    project_dir,
+                    extra_import_roots=getattr(settings_snapshot, "import_roots", ()),
+                    preserve_loaded_modules=True,
+                ),
+            ):
+                started_state = await activate_runtime_plan(
+                    plan,
+                    lifecycle_state,
+                    bindings=bindings,
+                    host=host_app,
+                )
+                started_bindings = replace(
+                    bindings,
+                    health=health_facade_cls(plan, started_state, providers=bindings.providers),
+                )
+                started_runtime = SimpleNamespace(
+                    plan=plan,
+                    state=started_state,
+                    bindings=started_bindings,
+                )
+                runtime_refs["started_state"] = started_state
+                runtime_refs["started_bindings"] = started_bindings
+                _attach_runtime_state(
+                    host_app,
+                    project_dir=project_dir,
+                    plan=plan,
+                    bindings=started_bindings,
+                    lifecycle_state=started_state,
+                    settings_snapshot=settings_snapshot,
+                )
+                start_infra_background_tasks(
+                    getattr(host_app.state, "pz_foundation_lifecycle_infra_context", None)
+                )
+                _apply_host_state_extensions(host_app, runtime=started_runtime)
+                wrapped = apply_runtime_middlewares(
+                    host_app,
+                    plan=plan,
+                    bindings=started_bindings,
+                )
+                _bind_host_state_surface(wrapped, host_app)
+                wrapped = wrap_db_request_scope(wrapped, project_dir=project_dir)
+                _bind_host_state_surface(wrapped, host_app)
+                runtime_refs["wrapped_app"] = wrapped
+                started = True
+            yield
+        finally:
+            if started:
+                owner = str(getattr(host_app.state, "pz_foundation_owner", "pz_foundation"))
+                current_bindings = getattr(
+                    host_app.state,
+                    "pz_runtime_bindings",
+                    runtime_refs.get("started_bindings"),
+                )
+                current_state = getattr(
+                    host_app.state,
+                    "pz_runtime_state",
+                    runtime_refs.get("started_state"),
+                )
+                if current_bindings is None or current_state is None:
+                    return
+                stopped_state = await shutdown_runtime_plan(
+                    plan,
+                    current_state,
+                    bindings=current_bindings,
+                    host=host_app,
+                )
+                stopped_bindings = replace(
+                    current_bindings,
+                    health=health_facade_cls(plan, stopped_state, providers=current_bindings.providers),
+                )
+                _attach_runtime_state(
+                    host_app,
+                    project_dir=project_dir,
+                    plan=plan,
+                    bindings=stopped_bindings,
+                    lifecycle_state=stopped_state,
+                    settings_snapshot=settings_snapshot,
+                    bind_context=False,
+                )
+                reset_runtime_context(owner=owner)
+
+    project_http = settings_snapshot.get("project", "http", default={}) or {}
+    if hasattr(project_http, "to_dict") and callable(project_http.to_dict):
+        project_http = project_http.to_dict()
+    if not isinstance(project_http, dict):
+        project_http = {}
+    app = FastAPI(
+        title=str(settings_snapshot.get("project", "name") or "Manga Translate"),
+        **dict(project_http),
+    )
+    app.router.redirect_slashes = False
+    app.router.lifespan_context = _merge_lifespan_context(_lifespan, app.router.lifespan_context)
+
+    app.state.pz_foundation_owner = f"pz_foundation:{id(app)}"
+    _attach_runtime_state(
+        app,
+        project_dir=project_dir,
+        plan=plan,
+        bindings=bindings,
+        lifecycle_state=lifecycle_state,
+        settings_snapshot=settings_snapshot,
+    )
+    _mount_runtime_static(app, bindings=bindings)
+    runtime_refs["wrapped_app"] = app
+
+    @app.get("/health")
+    async def _health() -> JSONResponse:
+        snapshot = app.state.pz_runtime_bindings.health.liveness()
+        return JSONResponse(_to_jsonable(snapshot))
+
+    @app.get("/live")
+    async def _live() -> JSONResponse:
+        snapshot = app.state.pz_runtime_bindings.health.liveness()
+        return JSONResponse(_to_jsonable(snapshot))
+
+    @app.get("/ready")
+    async def _ready() -> JSONResponse:
+        snapshot = app.state.pz_runtime_bindings.health.readiness()
+        payload = _apply_readiness_lifecycle(_to_jsonable(snapshot))
+        status_code = 200 if payload.get("status") in {"ok", "disabled"} else 503
+        return JSONResponse(payload, status_code=status_code)
+
+    with (
+        active_settings_project(str(project_dir)),
+        active_runtime_plan(plan),
+        active_project_import_root(
+            project_dir,
+            extra_import_roots=getattr(settings_snapshot, "import_roots", ()),
+            preserve_loaded_modules=True,
+        ),
+    ):
+        pre_start_runtime = SimpleNamespace(
+            plan=plan,
+            state=lifecycle_state,
+            bindings=bindings,
+        )
+        _apply_host_mount_extensions(app, runtime=pre_start_runtime)
+        _mount_app_routers(app, runtime=pre_start_runtime)
+        clean_and_reorder_routes(app)
+
+    async def _scoped(scope, receive, send):
+        with (
+            bound_settings_snapshot(plan.settings, project_dir=str(project_dir)),
+            active_settings_project(str(project_dir)),
+            active_runtime_plan(plan),
+        ):
+            wrapped_app = runtime_refs.get("wrapped_app", app)
+            await wrapped_app(scope, receive, send)
+
+    _bind_host_state_surface(_scoped, app)
+
+    return _HostAsgiWrapper(app, _scoped)
+__all__ = [
+    "_build_http_app",
+]