App

class App:
    def __init__(
        self,
        routes: Sequence[Route | Layout] | None = None,
        codegen: CodegenConfig | None = None,
        middleware: PulseMiddleware | Sequence[PulseMiddleware] | None = None,
        plugins: Sequence[Plugin] | None = None,
        cookie: Cookie | None = None,
        session_store: SessionStore | None = None,
        server_address: str | None = None,
        dev_server_address: str = "http://localhost:8000",
        internal_server_address: str | None = None,
        not_found: str = "/not-found",
        mode: PulseMode = "single-server",
        api_prefix: str = "/_pulse",
        cors: CORSOptions | None = None,
        fastapi: dict[str, Any] | None = None,
        session_timeout: float = 60.0,
        connection_status: ConnectionStatusConfig | None = None,
    ): ...

def run(
    self,
    address: str = "localhost",
    port: int = 8000,
    find_port: bool = True,
    reload: bool = True,
) -> None

def asgi_factory(self) -> ASGIApp

def run_codegen(
    self,
    address: str | None = None,
    internal_address: str | None = None,
) -> None

def setup(self, server_address: str) -> None

import pulse as ps

app = ps.App(
    routes=[
        ps.Route("/", render=home),
        ps.Route("/users/:id", render=user_detail),
    ],
    session_timeout=120.0,
)

if __name__ == "__main__":
    app.run(port=8000)

PulseMode = Literal["subdomains", "single-server"]

@dataclass
class CodegenConfig:
    web_dir: Path | str = "web"
    pulse_dir: Path | str = "pulse"
    base_dir: Path | None = None

@dataclass
class ConnectionStatusConfig:
    initial_connecting_delay: float = 2.0
    initial_error_delay: float = 8.0
    reconnect_error_delay: float = 8.0

class Route:
    def __init__(
        self,
        path: str,
        render: Component[[]],
        children: Sequence[Route | Layout] | None = None,
        dev: bool = False,
    ): ...

ps.Route(
    "/users",
    render=users_page,
    children=[
        ps.Route(":id", render=user_detail),
        ps.Route(":id/edit", render=user_edit),
    ],
)

class Layout:
    def __init__(
        self,
        render: Component[...],
        children: Sequence[Route | Layout] | None = None,
        dev: bool = False,
    ): ...

@ps.component
def AppLayout():
    return ps.div(
        Header(),
        ps.main(ps.Outlet()),
        Footer(),
    )

ps.Layout(
    render=AppLayout,
    children=[
        ps.Route("/", render=home),
        ps.Route("/about", render=about),
    ],
)

class RouteInfo(TypedDict):
    pathname: str        # Current URL path
    hash: str            # URL hash (after #)
    query: str           # Query string (after ?)
    queryParams: dict[str, str]   # Parsed query parameters
    pathParams: dict[str, str]    # Dynamic path parameters
    catchall: list[str]  # Catch-all segments

class Plugin:
    priority: int = 0

    def routes(self) -> list[Route | Layout]:
        """Return routes to add to the app."""
        return []

    def middleware(self) -> list[PulseMiddleware]:
        """Return middleware to add to the app."""
        return []

    def on_setup(self, app: App) -> None:
        """Called after FastAPI routes are configured."""
        ...

    def on_startup(self, app: App) -> None:
        """Called when the app starts."""
        ...

    def on_shutdown(self, app: App) -> None:
        """Called when the app shuts down."""
        ...

class AuthPlugin(ps.Plugin):
    priority = 10  # Higher priority runs first

    def routes(self):
        return [ps.Route("/login", render=login_page)]

    def middleware(self):
        return [AuthMiddleware()]

    def on_startup(self, app):
        print("Auth plugin started")

PulseEnv = Literal["dev", "ci", "prod"]

from pulse.env import env

env.pulse_env        # Get/set: "dev", "ci", "prod"
env.pulse_host       # Get/set: hostname (default "localhost")
env.pulse_port       # Get/set: port number (default 8000)
env.pulse_secret     # Get/set: secret key for JWT sessions
env.codegen_disabled # Get/set: disable code generation

def mode() -> PulseEnv