simple-module-hosting 0.0.19__tar.gz → 0.0.20__tar.gz

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.20}/.gitignore

@@ -61,3 +61,4 @@ Thumbs.db
 .playwright-mcp/*
 host/client_app/.playwright-cli/*
 .superpowers/
+.qa/

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple_module_hosting
-Version: 0.0.19
+Version: 0.0.20
 Summary: FastAPI + Inertia.js host runtime for simple_module — app_builder, middleware stack, CLI (sm / simple-module), scaffolding
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python
@@ -26,8 +26,8 @@ Requires-Dist: fastapi-inertia>=1.0
 Requires-Dist: fastapi>=0.115
 Requires-Dist: httpx>=0.27
 Requires-Dist: jinja2>=3.1
-Requires-Dist: simple-module-core==0.0.19
-Requires-Dist: simple-module-db==0.0.19
+Requires-Dist: simple-module-core==0.0.20
+Requires-Dist: simple-module-db==0.0.20
 Requires-Dist: starlette>=0.44
 Requires-Dist: tomlkit>=0.13
 Requires-Dist: uvicorn[standard]>=0.34

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_hosting"
-version = "0.0.19"
+version = "0.0.20"
 description = "FastAPI + Inertia.js host runtime for simple_module — app_builder, middleware stack, CLI (sm / simple-module), scaffolding"
 readme = "README.md"
 license = "MIT"
@@ -26,8 +26,8 @@ dependencies = [
     "fastapi-inertia>=1.0",
     "httpx>=0.27",
     "jinja2>=3.1",
-    "simple_module_core==0.0.19",
-    "simple_module_db==0.0.19",
+    "simple_module_core==0.0.20",
+    "simple_module_db==0.0.20",
     "starlette>=0.44",
     "tomlkit>=0.13",
     "uvicorn[standard]>=0.34",

simple_module_hosting-0.0.20/simple_module_hosting/__init__.py

@@ -0,0 +1,18 @@
+"""SimpleModule Hosting - App builder, module loader, middleware pipeline."""
+
+from simple_module_hosting.app_builder import create_app
+from simple_module_hosting.logging import correlation_id, setup_logging
+from simple_module_hosting.settings import Settings
+from simple_module_hosting.shared_props import (
+    SharedPropsProvider,
+    register_inertia_shared_provider,
+)
+
+__all__ = [
+    "Settings",
+    "SharedPropsProvider",
+    "correlation_id",
+    "create_app",
+    "register_inertia_shared_provider",
+    "setup_logging",
+]

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.20}/simple_module_hosting/_inertia_setup.py

@@ -2,7 +2,10 @@
 
 from __future__ import annotations
 
+import hashlib
+import json
 import logging
+import tempfile
 from pathlib import Path
 
 from fastapi import FastAPI
@@ -16,6 +19,59 @@ _INERTIA_VERSION = "1.0"
 _ROOT_TEMPLATE_FILENAME = "index.html"
 _ENTRYPOINT_FILENAME = "main.tsx"
 _ROOT_DIRECTORY = "."
+# Built assets are served from the "/static" mount under "dist/", so production
+# asset URLs are prefixed with "static/dist".
+_ASSETS_PREFIX = "static/dist"
+_VITE_MANIFEST_RELPATH = Path("static") / "dist" / ".vite" / "manifest.json"
+
+
+def _prod_manifest_path(project_root: Path) -> str:
+    """Return a manifest path fastapi-inertia can read in production.
+
+    fastapi-inertia looks the entry up by ``f"{root_directory}/{entrypoint}"``
+    (here ``"./main.tsx"``), but Vite keys its manifest by the entry's path
+    relative to the Vite root (``"main.tsx"``) — so the raw Vite manifest would
+    ``KeyError``. Read it, re-key the ``isEntry`` chunk under the key
+    fastapi-inertia expects, and write the normalized copy beside the build
+    output (falling back to a temp file if that dir is read-only). Returns ``""``
+    when no built manifest exists, leaving production assets unconfigured rather
+    than crashing at import time.
+    """
+    candidates = [
+        project_root / "host" / _VITE_MANIFEST_RELPATH,
+        project_root / _VITE_MANIFEST_RELPATH,
+    ]
+    vite_manifest = next((p for p in candidates if p.is_file()), None)
+    if vite_manifest is None:
+        logger.warning(
+            "Production Vite manifest not found (looked in %s)", [str(c) for c in candidates]
+        )
+        return ""
+    try:
+        data = json.loads(vite_manifest.read_text())
+        expected_key = f"{_ROOT_DIRECTORY}/{_ENTRYPOINT_FILENAME}"
+        if expected_key not in data:
+            entry = next((v for v in data.values() if v.get("isEntry")), None)
+            if entry is None:
+                # No entry to re-key: degrade gracefully (same as no-manifest)
+                # rather than returning a path that KeyErrors at render time.
+                logger.warning("No isEntry chunk in Vite manifest %s", vite_manifest)
+                return ""
+            data = {**data, expected_key: entry}
+        out = vite_manifest.parent / "inertia-manifest.json"
+        try:
+            out.write_text(json.dumps(data))
+        except OSError:
+            # Build dir read-only (e.g. immutable container layer): fall back to
+            # a temp file keyed by the source manifest path so multiple apps on
+            # one host don't clobber each other's normalized manifests.
+            digest = hashlib.sha1(str(vite_manifest).encode()).hexdigest()[:12]
+            out = Path(tempfile.gettempdir()) / f"sm-inertia-manifest-{digest}.json"
+            out.write_text(json.dumps(data))
+        return str(out)
+    except Exception:
+        logger.exception("Failed to prepare production Inertia manifest from %s", vite_manifest)
+        return ""
 
 
 def setup_inertia(
@@ -82,6 +138,10 @@ def setup_inertia(
         environment=inertia_environment,
         version=_INERTIA_VERSION,
         dev_url=settings.vite_dev_url if use_dev_server else "",
+        # Production reads built assets from the Vite manifest; dev serves them
+        # from the Vite dev server, so these only matter when not use_dev_server.
+        manifest_json_path="" if use_dev_server else _prod_manifest_path(project_root),
+        assets_prefix="" if use_dev_server else _ASSETS_PREFIX,
         templates=templates,
         root_template_filename=_ROOT_TEMPLATE_FILENAME,
         entrypoint_filename=_ENTRYPOINT_FILENAME,

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.20}/simple_module_hosting/_inertia_shared.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+from typing import Any
 
 from starlette.datastructures import Headers
 from starlette.requests import Request
@@ -59,3 +60,30 @@ def build_i18n_block(scope: Scope, request: Request) -> dict:
         "supportedLocales": registry.available_locales(),
         "messages": registry.messages_snapshot(locale) if send_messages else None,
     }
+
+
+def merge_shared_prop_providers(app: Any, request: Request, shared: dict) -> None:
+    """Merge module-registered Inertia shared-prop providers into ``shared`` in place.
+
+    Providers are read off ``app.state.inertia_shared_providers`` (never importing
+    the plugin — preserves SM009). A provider that raises is skipped and logged; a
+    provider may not clobber a framework-owned key (auth/menus/i18n) or an earlier
+    provider's key.
+    """
+    providers = getattr(app.state, "inertia_shared_providers", None) or ()
+    for provider in providers:
+        name = getattr(provider, "__name__", provider)
+        try:
+            extra = provider(request)
+        except Exception:  # a bad provider must not break the page render
+            logger.warning("shared-prop provider %r raised; skipping", name, exc_info=True)
+            continue
+        for key, value in (extra or {}).items():
+            if key in shared:
+                logger.warning(
+                    "provider %r tried to overwrite reserved shared-prop %r; ignoring",
+                    name,
+                    key,
+                )
+                continue
+            shared[key] = value

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.20}/simple_module_hosting/_phase_helpers.py

@@ -23,6 +23,8 @@ from simple_module_core.diagnostics import Diagnostic, DiagnosticLevel
 from simple_module_core.exceptions import NotFoundError
 from starlette.exceptions import HTTPException
 from starlette.middleware.sessions import SessionMiddleware
+from starlette.responses import Response
+from starlette.types import Scope
 
 from simple_module_hosting._error_handlers import (
     http_exception_handler,
@@ -46,6 +48,28 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+_IMMUTABLE_CACHE_CONTROL = "public, max-age=31536000, immutable"
+
+
+class ImmutableStaticFiles(StaticFiles):
+    """StaticFiles that marks Vite's content-hashed build assets immutable.
+
+    Vite emits files under ``dist/assets/`` with a content hash in the filename
+    (e.g. ``main-3YbShAJ4.js``), so the bytes for a given URL never change —
+    browsers can cache them indefinitely and skip even the revalidation
+    round-trip. The default StaticFiles only sets ETag/Last-Modified, forcing a
+    conditional GET per asset on every visit. Non-hashed paths (the manifest,
+    etc.) keep the default behaviour.
+    """
+
+    async def get_response(self, path: str, scope: Scope) -> Response:
+        response = await super().get_response(path, scope)
+        # StaticFiles hands us an OS-separator path (backslashes on Windows), so
+        # normalize before matching the forward-slash asset prefix.
+        if response.status_code == 200 and path.replace("\\", "/").startswith("dist/assets/"):
+            response.headers["Cache-Control"] = _IMMUTABLE_CACHE_CONTROL
+        return response
+
 
 def register_exception_handlers(app: FastAPI, modules: list) -> None:
     """Install framework-level exception handlers, then per-module handlers."""

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.20}/simple_module_hosting/app_builder.py

@@ -10,7 +10,6 @@ from contextlib import asynccontextmanager
 from pathlib import Path
 
 from fastapi import FastAPI
-from fastapi.staticfiles import StaticFiles
 from simple_module_core.diagnostics import DiagnosticLevel, print_diagnostics, run_diagnostics
 from simple_module_core.discovery import discover_modules, topological_sort
 from simple_module_core.events import EventBus
@@ -26,6 +25,7 @@ from simple_module_db.session import init_db
 from simple_module_hosting._host_services import _HostServices
 from simple_module_hosting._inertia_setup import setup_inertia
 from simple_module_hosting._phase_helpers import (
+    ImmutableStaticFiles,
     attach_public_routes,
     check_settings_registration,
     install_middleware,
@@ -277,7 +277,9 @@ def create_app(settings: Settings | None = None) -> FastAPI:
 
     static_dir = _PROJECT_ROOT / "host" / _STATIC_DIR_NAME
     if static_dir.is_dir():
-        app.mount(_STATIC_MOUNT_PATH, StaticFiles(directory=static_dir), name=_STATIC_DIR_NAME)
+        app.mount(
+            _STATIC_MOUNT_PATH, ImmutableStaticFiles(directory=static_dir), name=_STATIC_DIR_NAME
+        )
 
     mount_module_static_dirs(app, modules)
 

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.20}/simple_module_hosting/middleware.py

@@ -18,7 +18,7 @@ from starlette.datastructures import Headers, MutableHeaders
 from starlette.requests import Request
 from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
-from simple_module_hosting._inertia_shared import build_i18n_block
+from simple_module_hosting._inertia_shared import build_i18n_block, merge_shared_prop_providers
 from simple_module_hosting._observability import (
     CorrelationIdMiddleware,
     RequestLoggingMiddleware,
@@ -277,6 +277,11 @@ class InertiaLayoutDataMiddleware:
             ),
             "i18n": i18n_block,
         }
+
+        # Merge module-registered shared-prop providers (e.g. branding) — read off
+        # app.state without importing the plugin (SM009), defensively.
+        merge_shared_prop_providers(scope["app"], request, shared)
+
         request.state.inertia_shared = shared
 
         await self.app(scope, receive, send)

simple_module_hosting-0.0.20/simple_module_hosting/shared_props.py

@@ -0,0 +1,42 @@
+"""Module-registered Inertia shared-prop providers.
+
+A generic extension point so plugin modules can contribute layout-wide Inertia
+shared props (e.g. branding) on every page, without the framework importing the
+plugin. This mirrors the ``principal_serializer`` precedent: the framework reads
+a registered callable off ``app.state`` rather than reaching into module code,
+keeping the ``SM009`` framework→plugin import ban intact.
+
+A provider is ``Callable[[Request], dict]``. It must be cheap and total — it runs
+for every request. :class:`InertiaLayoutDataMiddleware` merges each provider's
+returned dict into the ``shared`` payload after the built-in ``auth``/``menus``/
+``i18n`` blocks; a provider that raises is skipped and logged, never failing the
+request.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+    from starlette.requests import Request
+
+SharedPropsProvider = Callable[["Request"], dict]
+"""A function mapping a request to a dict merged into Inertia shared props."""
+
+_STATE_ATTR = "inertia_shared_providers"
+
+
+def register_inertia_shared_provider(app: FastAPI, provider: SharedPropsProvider) -> None:
+    """Register a shared-props provider on the app.
+
+    Idempotently initialises ``app.state.inertia_shared_providers`` (a list) and
+    appends ``provider``. Safe to call from a module lifecycle hook before the
+    framework has set up the list.
+    """
+    providers = getattr(app.state, _STATE_ATTR, None)
+    if providers is None:
+        providers = []
+        setattr(app.state, _STATE_ATTR, providers)
+    providers.append(provider)

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.20}/tests/test_app.py

@@ -27,12 +27,14 @@ class TestCreateApp:
 
     async def test_modules_enabled_limits_loaded_modules(self, settings: Settings):
         """Host respects settings.modules_enabled — only listed modules contribute routes."""
+        from simple_module_test import effective_route_paths
+
         # Only Auth should be loaded; Dashboard routes must be absent.
         restricted = settings.model_copy(update={"modules_enabled": ["Auth"]})
         app = create_app(restricted)
-        paths: set[str] = {str(r.path) for r in app.routes if hasattr(r, "path")}
+        paths = effective_route_paths(app)
         # Auth is now contracts-only, so it has no routes — only health remains.
-        assert "/dashboard" not in paths
+        assert not any(p.startswith("/dashboard") for p in paths)
 
     async def test_module_static_mounts_become_app_routes(
         self,
@@ -203,7 +205,9 @@ class TestResolveProjectRoot:
 class TestRouteRegistration:
     async def test_expected_routes_registered(self, app: FastAPI):
         """All modules should have their routes registered in the app."""
-        route_paths = [r.path for r in app.routes if hasattr(r, "path")]
+        from simple_module_test import effective_route_paths
+
+        route_paths = effective_route_paths(app)
 
         assert "/health" in route_paths
         assert "/health/live" in route_paths
@@ -216,8 +220,9 @@ class TestRouteRegistration:
         # landing page at "/" is owned by the host and added in host/main.py,
         # which the create_app fixture doesn't run.
         assert "/dashboard/" in route_paths
-        # Bare-prefix alias — see wire_module_routes for the X-Inertia rationale.
-        assert "/dashboard" in route_paths
+        # The bare-prefix Inertia alias ("/dashboard" without the slash) is
+        # registered with include_in_schema=False, so it isn't enumerable here;
+        # TestProtectedPages::test_dashboard_redirects_unauthenticated covers it.
 
 
 class TestProtectedPages:

simple_module_hosting-0.0.20/tests/test_inertia_manifest.py

@@ -0,0 +1,71 @@
+"""Tests for production Inertia manifest normalization (_prod_manifest_path).
+
+fastapi-inertia looks the entry up by ``f"{root_directory}/{entrypoint}"`` =
+``"./main.tsx"``, but Vite keys its manifest by the entry's source path
+(``"main.tsx"``). _prod_manifest_path bridges the two so production page
+rendering doesn't KeyError. Regression guard for that bug.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from simple_module_hosting._inertia_setup import _prod_manifest_path
+
+
+def _write_vite_manifest(project_root: Path) -> Path:
+    manifest_dir = project_root / "host" / "static" / "dist" / ".vite"
+    manifest_dir.mkdir(parents=True)
+    manifest = {
+        "main.tsx": {
+            "file": "assets/main-ABC123.js",
+            "css": ["assets/main-DEF456.css"],
+            "isEntry": True,
+        },
+        "pages/Foo.tsx": {"file": "assets/Foo-XYZ.js"},
+    }
+    path = manifest_dir / "manifest.json"
+    path.write_text(json.dumps(manifest))
+    return path
+
+
+def test_rekeys_entry_for_fastapi_inertia(tmp_path: Path):
+    _write_vite_manifest(tmp_path)
+    result = _prod_manifest_path(tmp_path)
+
+    assert result, "expected a manifest path, got empty string"
+    data = json.loads(Path(result).read_text())
+    # fastapi-inertia will look up f"{root_directory}/{entrypoint}" == "./main.tsx"
+    assert "./main.tsx" in data
+    assert data["./main.tsx"]["file"] == "assets/main-ABC123.js"
+    assert data["./main.tsx"]["css"] == ["assets/main-DEF456.css"]
+    # original keys are preserved (other chunks still resolvable)
+    assert "pages/Foo.tsx" in data
+
+
+def test_returns_empty_when_no_built_manifest(tmp_path: Path):
+    # No host/static/dist/.vite/manifest.json present.
+    assert _prod_manifest_path(tmp_path) == ""
+
+
+def test_returns_empty_when_no_entry_chunk(tmp_path: Path):
+    # A manifest with no isEntry chunk must degrade to "" (not return a path
+    # that would KeyError at render) — same graceful path as no-manifest.
+    manifest_dir = tmp_path / "host" / "static" / "dist" / ".vite"
+    manifest_dir.mkdir(parents=True)
+    (manifest_dir / "manifest.json").write_text(json.dumps({"pages/Foo.tsx": {"file": "f.js"}}))
+    assert _prod_manifest_path(tmp_path) == ""
+
+
+def test_scaffolded_layout_without_host_dir(tmp_path: Path):
+    # smpy-new apps keep static/ at the project root (no host/ subdir).
+    manifest_dir = tmp_path / "static" / "dist" / ".vite"
+    manifest_dir.mkdir(parents=True)
+    (manifest_dir / "manifest.json").write_text(
+        json.dumps({"main.tsx": {"file": "assets/main-A.js", "isEntry": True}})
+    )
+    result = _prod_manifest_path(tmp_path)
+    assert result
+    data = json.loads(Path(result).read_text())
+    assert data["./main.tsx"]["file"] == "assets/main-A.js"

simple_module_hosting-0.0.20/tests/test_inertia_shared_providers.py

@@ -0,0 +1,91 @@
+"""Verify InertiaLayoutDataMiddleware merges module-registered shared-prop providers.
+
+Modules contribute layout-wide Inertia shared props (e.g. branding) without the
+framework importing the plugin — mirroring the ``principal_serializer`` precedent.
+Providers are registered on ``app.state.inertia_shared_providers`` and merged into
+the ``shared`` dict for every request.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from fastapi import FastAPI
+from simple_module_core.menu import MenuRegistry
+from simple_module_core.permissions import PermissionRegistry
+from simple_module_hosting.middleware import InertiaLayoutDataMiddleware
+from simple_module_hosting.shared_props import register_inertia_shared_provider
+from starlette.middleware.sessions import SessionMiddleware
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.testclient import TestClient
+
+
+def _build_app() -> FastAPI:
+    app = FastAPI()
+
+    @app.get("/shared")
+    def shared(request: Request) -> JSONResponse:
+        return JSONResponse(request.state.inertia_shared)
+
+    app.add_middleware(
+        InertiaLayoutDataMiddleware,
+        menu_registry=MenuRegistry(),
+        permission_registry=PermissionRegistry(),
+    )
+    app.add_middleware(SessionMiddleware, secret_key="test-secret")
+    return app
+
+
+def test_registered_provider_dict_merged_into_shared() -> None:
+    app = _build_app()
+    register_inertia_shared_provider(app, lambda _req: {"branding": {"appName": "Acme"}})
+
+    body = TestClient(app).get("/shared").json()
+
+    assert body["branding"] == {"appName": "Acme"}
+    # Built-in blocks still present.
+    assert "auth" in body
+    assert "menus" in body
+
+
+def test_provider_that_raises_is_skipped_not_fatal(caplog) -> None:
+    app = _build_app()
+
+    def boom(_req: Request) -> dict:
+        raise RuntimeError("provider blew up")
+
+    register_inertia_shared_provider(app, boom)
+    register_inertia_shared_provider(app, lambda _req: {"branding": {"appName": "Acme"}})
+
+    with caplog.at_level(logging.WARNING, logger="simple_module_hosting.middleware"):
+        resp = TestClient(app).get("/shared")
+
+    assert resp.status_code == 200
+    body = resp.json()
+    # The good provider still applied; the failing one was skipped.
+    assert body["branding"] == {"appName": "Acme"}
+    assert "auth" in body
+    assert any("shared-prop" in rec.message.lower() for rec in caplog.records)
+
+
+def test_no_providers_leaves_shared_unchanged() -> None:
+    body = TestClient(_build_app()).get("/shared").json()
+    assert "branding" not in body
+    assert "auth" in body and "menus" in body
+
+
+def test_provider_cannot_clobber_framework_keys(caplog) -> None:
+    app = _build_app()
+    # A misbehaving provider tries to overwrite the framework-owned auth block.
+    register_inertia_shared_provider(
+        app, lambda _req: {"auth": "HIJACKED", "branding": {"ok": True}}
+    )
+
+    with caplog.at_level(logging.WARNING, logger="simple_module_hosting.middleware"):
+        body = TestClient(app).get("/shared").json()
+
+    # auth stays the framework's dict; only the non-reserved key is added.
+    assert isinstance(body["auth"], dict)
+    assert body["branding"] == {"ok": True}
+    assert any("reserved shared-prop" in rec.message for rec in caplog.records)

simple_module_hosting-0.0.20/tests/test_static_caching.py

@@ -0,0 +1,37 @@
+"""ImmutableStaticFiles marks Vite's content-hashed assets immutable.
+
+Hashed filenames (``main-3YbShAJ4.js``) are content-addressed, so browsers can
+cache them forever and skip the per-asset revalidation round-trip. Non-hashed
+paths keep StaticFiles' default (ETag/Last-Modified only).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from simple_module_hosting._phase_helpers import ImmutableStaticFiles
+
+_GET_SCOPE = {"type": "http", "method": "GET", "headers": []}
+
+
+def _make_tree(root: Path) -> None:
+    (root / "dist" / "assets").mkdir(parents=True)
+    (root / "dist" / "assets" / "main-ABC123.js").write_text("console.log(1)")
+    (root / "dist" / ".vite").mkdir(parents=True)
+    (root / "dist" / ".vite" / "manifest.json").write_text("{}")
+
+
+async def test_hashed_asset_is_immutable(tmp_path: Path):
+    _make_tree(tmp_path)
+    static = ImmutableStaticFiles(directory=tmp_path)
+    resp = await static.get_response("dist/assets/main-ABC123.js", _GET_SCOPE)
+    assert resp.status_code == 200
+    assert resp.headers["cache-control"] == "public, max-age=31536000, immutable"
+
+
+async def test_non_asset_keeps_default_caching(tmp_path: Path):
+    _make_tree(tmp_path)
+    static = ImmutableStaticFiles(directory=tmp_path)
+    resp = await static.get_response("dist/.vite/manifest.json", _GET_SCOPE)
+    assert resp.status_code == 200
+    assert "immutable" not in resp.headers.get("cache-control", "")

simple_module_hosting-0.0.19/simple_module_hosting/__init__.py

@@ -1,7 +0,0 @@
-"""SimpleModule Hosting - App builder, module loader, middleware pipeline."""
-
-from simple_module_hosting.app_builder import create_app
-from simple_module_hosting.logging import correlation_id, setup_logging
-from simple_module_hosting.settings import Settings
-
-__all__ = ["Settings", "correlation_id", "create_app", "setup_logging"]