docs(go): flesh out webview + forge, expand sidebar nav

webview
  - CDP client overview + connect-to-Chrome quickstart
  - ActionSequence fluent builder with short-circuit-on-fail example
  - ConsoleWatcher + ExceptionWatcher streaming patterns
  - AngularHelper — Zone.js stability, ng router, ng-model bypass
  - Service Register + ServiceOptions example
  - Low-level CDP client escape hatch

forge
  - Two constructors: explicit URL+token vs config-driven
  - Generic Resource[T, C, U] CRUD parameterisation example
  - Three pagination shapes — ListPage, ListAll, ListIter (Go 1.23 range-over-func)
  - Service Register + ServiceOptions example

Sidebar (astro.config.mjs)
  - New "Packages — content" group at top of nav surfaces the five
    fleshed-out pages (store/io/process/webview/forge) ahead of the
    seven stubs that were already linked
  - New "Packages — index" group (collapsed) lists the remaining 26
    stub pages so the full ecosystem scope is visible without
    cluttering the active demo path
  - Each promoted page has working code examples + cross-links

Co-Authored-By: Virgil <virgil@lethean.io>

Author: Snider

astro.config.mjs

@@ -51,8 +51,16 @@ export default defineConfig({
 					],
 				},
 				{
-					label: 'Packages',
+					// Recently fleshed-out — these have real content + examples
+					// today. Promoted to the top of the package list so demos
+					// can jump straight in without hunting through stubs.
+					label: 'Packages — content',
 					items: [
+						{ label: 'store', slug: 'go/store' },
+						{ label: 'io', slug: 'go/io' },
+						{ label: 'process', slug: 'go/process' },
+						{ label: 'webview', slug: 'go/webview' },
+						{ label: 'forge', slug: 'go/forge' },
 						{ label: 'agent', slug: 'go/agent' },
 						{ label: 'mcp', slug: 'go/mcp' },
 						{ label: 'miner', slug: 'go/miner' },
@@ -62,6 +70,41 @@ export default defineConfig({
 						{ label: 'tenant', slug: 'go/tenant' },
 					],
 				},
+				{
+					// Stub pages — `go get` resolves them, human-facing content
+					// fills in as each package converges. Listed so the full
+					// ecosystem scope is visible in the nav.
+					label: 'Packages — index',
+					collapsed: true,
+					items: [
+						{ label: 'ai', slug: 'go/ai' },
+						{ label: 'ansible', slug: 'go/ansible' },
+						{ label: 'api', slug: 'go/api' },
+						{ label: 'build', slug: 'go/build' },
+						{ label: 'cgo', slug: 'go/cgo' },
+						{ label: 'cli', slug: 'go/cli' },
+						{ label: 'config', slug: 'go/config' },
+						{ label: 'container', slug: 'go/container' },
+						{ label: 'crypt', slug: 'go/crypt' },
+						{ label: 'devops', slug: 'go/devops' },
+						{ label: 'dns', slug: 'go/dns' },
+						{ label: 'git', slug: 'go/git' },
+						{ label: 'gui', slug: 'go/gui' },
+						{ label: 'html', slug: 'go/html' },
+						{ label: 'i18n', slug: 'go/i18n' },
+						{ label: 'ide', slug: 'go/ide' },
+						{ label: 'inference', slug: 'go/inference' },
+						{ label: 'log', slug: 'go/log' },
+						{ label: 'ml', slug: 'go/ml' },
+						{ label: 'mlx', slug: 'go/mlx' },
+						{ label: 'netops', slug: 'go/netops' },
+						{ label: 'orm', slug: 'go/orm' },
+						{ label: 'p2p', slug: 'go/p2p' },
+						{ label: 'rag', slug: 'go/rag' },
+						{ label: 'scm', slug: 'go/scm' },
+						{ label: 'ws', slug: 'go/ws' },
+					],
+				},
 			],
 		}),
 	],

src/content/docs/go/forge.mdx

@@ -12,7 +12,11 @@ head:
       content: 'dappco.re/go/forge https://github.com/dappcore/go-forge https://github.com/dappcore/go-forge/tree/main{/dir} https://github.com/dappcore/go-forge/blob/main{/dir}/{file}#L{line}'
 ---
 
-Forgejo client — repo, branch, hook, runner orchestration. Built on the [`core/go`](/go/) primitives.
+Typed HTTP client for Forgejo (and Gitea) — repos, branches, issues, pull
+requests, hooks, runners. Generic `Resource[T, C, U]` and paginated
+helpers cover the long tail of CRUD shapes without hand-writing each
+endpoint. Built on [`core/go`](/go/) — every constructor that touches
+config returns a [`Result`](/go/result/).
 
 ## Install
 
@@ -26,7 +30,100 @@ go get dappco.re/go/forge@latest
 import "dappco.re/go/forge"
 ```
 
-## Status
+## Quick start
 
-Page in flight — content fills in as the package converges. Source of truth
-today is the README and inline docstrings in the repo.
+Two constructors — explicit URL+token or auto-pulled from config flags:
+
+```go
+// Explicit
+fg := forge.NewForge("https://forge.lthn.sh", os.Getenv("FORGEJO_TOKEN"))
+
+// Config-driven (flags first, env fallback)
+r := forge.NewForgeFromConfig("--forge-url", "--forge-token")
+if !r.OK { return r }
+fg := r.Value.(*forge.Forge)
+```
+
+`Forge` wraps a `*Client` plus typed Resource handles for every standard
+endpoint group. Direct HTTP access stays available via `fg.Client()` for
+calls the typed surface doesn't cover yet.
+
+## Generic resources
+
+`Resource[T, C, U]` parameterises CRUD over three types — the read shape,
+the create shape, and the update shape. The package exports pre-bound
+resources for the common Forgejo objects (repos, issues, PRs, hooks,
+runners, …); custom integrations can spin their own:
+
+```go
+type MyKind struct { ID int; Name string }
+type CreateMyKind struct { Name string }
+type UpdateMyKind struct { Name *string }
+
+r := forge.NewResource[MyKind, CreateMyKind, UpdateMyKind](
+    fg.Client(),
+    "/api/v1/orgs/{org}/my-kinds",
+)
+
+items, _ := r.List(ctx, map[string]string{"org": "dappcore"})
+created, _ := r.Create(ctx, CreateMyKind{Name: "shiny"})
+```
+
+## Pagination — three shapes, one signature
+
+Forgejo paginates everything. The helpers give callers a choice of memory
+profile:
+
+```go
+// One page at a time — caller drives the loop
+page, _ := forge.ListPage[Repo](ctx, fg.Client(), "/repos/search", q, forge.ListOptions{
+    Page:    1,
+    PerPage: 50,
+})
+
+// All pages collected — slurp into memory
+all, _ := forge.ListAll[Repo](ctx, fg.Client(), "/repos/search", q)
+
+// Streaming iterator — Go 1.23+ range-over-func
+for repo, err := range forge.ListIter[Repo](ctx, fg.Client(), "/repos/search", q) {
+    if err != nil { return err }
+    fmt.Println(repo.FullName)
+}
+```
+
+`ListIter` is the right default for long results — it fetches pages on
+demand without holding the whole set in memory.
+
+## Service registration
+
+The canonical `core/go` Service pattern — register once on a Core and
+every consumer reaches Forgejo through `c.Action("forge/...")`:
+
+```go
+c := core.New(core.Options{})
+
+if r := forge.Register(c); !r.OK { return r }
+
+// With options
+svc := forge.NewService(forge.ServiceOptions{
+    URL:   "https://forge.lthn.sh",
+    Token: os.Getenv("FORGEJO_TOKEN"),
+})
+if r := svc(c); !r.OK { return r }
+```
+
+The Service constructor reads config + env in the same order as
+`NewForgeFromConfig` so a single Core instance has one consistent Forge
+binding.
+
+## Sibling packages
+
+- [`go/scm`](/go/scm/) — Git operations on the repos forge serves
+- [`go/process`](/go/process/) — supervise long-running runners forge
+  dispatches
+- [`go/webview`](/go/webview/) — the same Result-returning Service shape
+  for browser automation
+
+## Source
+
+[`github.com/dappcore/go-forge`](https://github.com/dappcore/go-forge) — full source, issues, and releases.

src/content/docs/go/webview.mdx

@@ -1,6 +1,6 @@
 ---
 title: webview
-description: WebView runtime — bridge, codegen, transport.
+description: Chrome DevTools Protocol client — browser automation, testing, scraping.
 head:
   - tag: meta
     attrs:
@@ -12,7 +12,13 @@ head:
       content: 'dappco.re/go/webview https://github.com/dappcore/go-webview https://github.com/dappcore/go-webview/tree/main{/dir} https://github.com/dappcore/go-webview/blob/main{/dir}/{file}#L{line}'
 ---
 
-WebView runtime — bridge, codegen, transport. Built on the [`core/go`](/go/) primitives.
+Chrome DevTools Protocol client for browser automation. Connects to an
+externally managed Chrome or Chromium instance running with
+`--remote-debugging-port=9222` and gives you navigation, DOM queries, click
++ type actions, console capture, JavaScript evaluation, screenshots,
+multi-tab support, viewport emulation, and a fluent `ActionSequence`
+builder. Built on [`core/go`](/go/) — every constructor returns a
+[`Result`](/go/result/).
 
 ## Install
 
@@ -26,7 +32,139 @@ go get dappco.re/go/webview@latest
 import "dappco.re/go/webview"
 ```
 
-## Status
+## Quick start
 
-Page in flight — content fills in as the package converges. Source of truth
-today is the README and inline docstrings in the repo.
+Launch Chrome with the remote debugging port open, then point a Webview
+at it:
+
+```bash
+chrome --remote-debugging-port=9222 --user-data-dir=/tmp/cdp-profile
+```
+
+```go
+r := webview.New(webview.WithDebugURL("http://localhost:9222"))
+if !r.OK { return r }
+wv := r.Value.(*webview.Webview)
+defer wv.Close()
+
+wv.Navigate("https://example.com")
+wv.Click("#submit")
+wv.Type("#input", "search term")
+
+png, _ := wv.Screenshot()
+```
+
+## ActionSequence — fluent chain
+
+For test scripts and scrape recipes, `ActionSequence` strings calls together
+and short-circuits on first failure:
+
+```go
+seq := webview.NewActionSequence()
+
+r := seq.
+    Navigate("https://example.com/login").
+    Type("#username", "alice").
+    Type("#password", "s3cret").
+    Click("button[type=submit]").
+    WaitFor("#dashboard").
+    Screenshot("dashboard.png").
+    Run(wv)
+
+if !r.OK { return r }
+```
+
+Each step records its outcome so a failed sequence reports the exact step
+that broke rather than a generic "automation failed".
+
+## Watchers
+
+Two background watchers attach to a `*Webview` and stream
+async-but-relevant events without polling:
+
+```go
+con := webview.NewConsoleWatcher(wv)
+con.Start(ctx)
+go func() {
+    for msg := range con.Messages() {
+        log.Printf("[%s] %s", msg.Level, msg.Text)
+    }
+}()
+
+ex := webview.NewExceptionWatcher(wv)
+ex.Start(ctx)
+go func() {
+    for e := range ex.Exceptions() {
+        log.Printf("page exception: %v", e)
+    }
+}()
+```
+
+Useful for catching JS errors during smoke tests, or capturing
+`console.log` output from instrumented frontends.
+
+## Angular helpers
+
+When the page is an Angular app, `AngularHelper` wires in the framework's
+internals so tests can wait for Zone.js stability, drive the router, and
+read component state directly:
+
+```go
+ng := webview.NewAngularHelper(wv)
+
+ng.WaitForStability(ctx)            // Zone.js settled
+ng.NavigateByUrl("/dashboard")      // ng router
+ng.SetNgModel("input#email", "a@b") // bypass typing
+val, _ := ng.GetComponentField("AppComponent", "user.id")
+```
+
+Skips race conditions that vanilla CDP tests hit when the framework's
+microtasks haven't drained yet.
+
+## Service registration
+
+The package ships the canonical `core/go` Service pattern:
+
+```go
+c := core.New(core.Options{})
+
+if r := webview.Register(c); !r.OK { return r }
+
+// Or with explicit options
+svc := webview.NewService(webview.ServiceOptions{
+    DebugURL: "http://localhost:9222",
+})
+if r := svc(c); !r.OK { return r }
+```
+
+Consumers reach the Webview through `c.Action("webview/...")` so a test
+binary, a scrape worker, and a CI dispatcher all share one entry point.
+
+## Low-level CDP client
+
+If you need to send raw CDP commands, `NewCDPClient` exposes the protocol
+directly without the high-level wrapper:
+
+```go
+r := webview.NewCDPClient("http://localhost:9222")
+if !r.OK { return r }
+cdp := r.Value.(*webview.CDPClient)
+
+cdp.Send("Network.enable", nil)
+cdp.Send("Page.navigate", map[string]any{"url": "https://example.com"})
+```
+
+The high-level `Webview` is built on top of this client, so anything it
+does, you can do too.
+
+## Sibling packages
+
+- [`go/process`](/go/process/) — supervise the Chrome process that
+  Webview connects to
+- [`go/io`](/go/io/) — persist screenshots, scraped payloads
+- [`go/forge`](/go/forge/) — the same Result-returning Service shape for
+  the Forgejo HTTP client
+
+## Source
+
+[`github.com/dappcore/go-webview`](https://github.com/dappcore/go-webview) — full source, issues, and releases.