Development Panel

The default lazy development command serves a DevTools-style panel under /_golazy/. The panel remains available while the app is building, failed to compile, running, or crashed. It uses a compact top tab bar, toolbar rows, dense status panes, and a bottom status bar.

The panel can run inside the page, inside an iframe opened from the launcher, or inside the Chrome DevTools extension. Each top-level tab is its own panel page; clicking a tab performs a Turbo visit inside the panel instead of rendering every tab at once. The bottom status bar is a permanent Turbo frame, so app and service status chips stay connected while moving between tabs.

Open the panel

Start the app from the application root:

lazy

After the local HTTPS setup is trusted, open the panel directly:

https://127.0.0.1:3000/_golazy/

You can also use the GoLazy launcher injected into proxied app pages. When the Chrome extension is installed, it hosts the same /_golazy/ panel inside Chrome DevTools.

App

The App panel shows service status, lazy lifecycle events, changed-file groups, and rebuild, restart, and open-app controls.

Services

The Services panel shows a tree with the App service, managed services, lifecycle scripts, and all discovered mise tasks. It caps logs at 100 rows, batches live log updates, parses JSON log lines into message and attribute columns, and exposes reload, stop, or play actions for managed services.

Clicking a service in the bottom status bar opens the Services tab with that service selected.

Jobs

The Jobs panel shows the app's lazyjobs state. It reads job definitions, counts, and recent job state from the app's lazydev control plane.

Routes

The Routes panel shows the registered route table from the app's lazydev control plane. Static GET route clicks are sent to the app through the injected host client.

BuildInfo

The BuildInfo panel shows the running app's Go version, module path, last build time, phase timing, and top slow packages on the left. Runtime details, settings, and dependencies are available as right-side tabs.

Requests

The Requests panel shows captured request paths. It combines DevTools-style path search with handler filter chips that include All as the default, and opens lazy-loaded Headers, Tracing, and Logs detail tabs.

The request detail Tracing tab starts with a request status strip, then a backend-sorted region table and a flamegraph. Turn on Include golazy to include middleware, router, dispatch, and other framework regions.

Dependencies

The Dependencies panel shows the lazydeps service graph as service rows and directed edges, then uses Stimulus to enhance those rows into an SVG graph.

Assets

The Assets panel lists lazy asset manifest entries and public paths.

Cache

The Cache panel shows cache usage, a searchable key table, selected entry content, and cache controls. Cache inspection and cache on/off requests are proxied to the app control plane so browser requests stay on the public development origin.

Panel behavior

The public development address accepts HTTP and HTTPS on the same port. Plain HTTP serves the local HTTPS setup page until the browser trusts the GoLazy certificate authority. HTTPS serves the panel under /_golazy/ and proxies normal app traffic to the running app process.

The panel JavaScript is served as normal external assets. GoLazy does not inline development-panel JavaScript into app HTML. Proxied app pages receive hidden markup for a spacer, fixed bottom GoLazy development panel iframe, and rounded-square GoLazy launcher button with the padded, yellow-backed square logo, followed by the standalone panel.js host client. That client bootstraps devpanel_controller.js, which shows, hides, resizes, persists the in-page panel, and binds the launcher click to reopen it while loading /_golazy/ in the iframe.

The markup starts hidden so the page does not flash panel UI before JavaScript runs. When the in-page panel is closed and the extension is not installed, the controller shows the GoLazy launcher in the bottom right corner. The launcher stays hidden when the extension is installed, the DevTools panel is open, or the in-page panel is visible. The host client exposes window.disableDevPanel() so the Chrome extension can hide both the in-page panel and launcher after the page script loads.

The development panel remembers the last top-level tab in session storage and restores it when the embedded panel loads at the default App tab. Panel layout uses Turbo morph refreshes with scroll preservation so refreshes can patch the panel document without resetting the user's position.

Shared panel tables remember resized column widths in browser localStorage. When a dragged header boundary reaches a neighboring column's minimum width, the resize continues by compressing the next column in the same direction. When a containing pane is resized, columns scale proportionally until they reach their minimum widths. Grouped or multi-row table headers resize the leaf columns they cover proportionally, so header cells with colspan do not become separate physical columns. Rows that link into a Turbo Frame update their selected state immediately on click.

Chrome DevTools extension

The chrome-extension directory contains an unpacked Chrome extension for the development panel. It adds a GoLazy icon to the Chrome extension bar and a GoLazy panel in Chrome DevTools.

The extension is a thin host for the lazy-served panel. When the DevTools panel opens, it reads the inspected page URL, probes the page origin at GET /_golazy/extension, and expects 200 OK with the exact plain-text body i love being lazy. If the probe succeeds, the extension creates an iframe pointed at the same origin's /_golazy/ route. If the probe fails, it shows a local DevTools-style unavailable state with the cd project / lazy startup snippet.

The panel must fit inside the DevTools viewport and should not duplicate the request, console, app-log, traces, routes, assets, or cache UI served by the lazy panel app.

Read Lazydev Mode for the development-only build tag and control-plane endpoints that feed the panel. Read Lazy for the full development loop.