@barefootjs/cli 0.6.0 → 0.7.0

package/dist/docs/core/adapters/go-template-adapter.md

@@ -12,6 +12,27 @@ npm install @barefootjs/go-template
 ```
 
 
+## Server integration
+
+The adapter is **web-framework-agnostic** — it emits plain Go `html/template`
+files plus a small runtime (`FuncMap`, `Renderer`), so any server that can
+parse and execute `html/template` can render the output. The scaffolder
+(`npm create barefootjs@latest -- --adapter <name>`) ships runnable starters
+for four Go servers, all built on this adapter:
+
+| `--adapter` | Framework | Router |
+|-------------|-----------|--------|
+| `echo` | [Echo](https://echo.labstack.com/) | `echo.Renderer` |
+| `gin` | [Gin](https://gin-gonic.com/) | `gin.Engine` |
+| `chi` | [Chi](https://go-chi.io/) | `chi.Router` (net/http) |
+| `nethttp` | Go standard library | `http.ServeMux` |
+
+Each scaffold loads the generated `.tmpl` files into a `template.Template`
+with `bf.FuncMap()`, then renders a component through `bf.NewRenderer(...)`.
+Runnable end-to-end examples for all four live under
+[`integrations/`](https://github.com/piconic-ai/barefootjs/tree/main/integrations).
+
+
 ## Basic Usage
 
 ```typescript
@@ -221,6 +242,14 @@ export function TodoList({ items }: { items: TodoItem[] }) {
 }
 ```
 
+Child component props carry a `ScopeID` used for hydration. You don't have to
+mint these by hand: `bf.Renderer.Render` backfills a unique
+`<Component>_<random>` id for any child (in a slice or a single field) whose
+`ScopeID` is empty — the same shape the generated `New{Component}Props()`
+constructor uses. Build child props with just the data they need (e.g.
+`TodoItemProps{Todo: t}`) and the runtime fills in the rest. Setting `ScopeID`
+explicitly still works and is preserved when you need a stable id.
+
 ## Conditional Rendering
 
 Ternaries become `{{if}}...{{else}}...{{end}}`:

package/dist/docs/core/adapters.md

@@ -26,6 +26,8 @@ JSX Source
 
 > CSR is not an IR→template adapter. It renders components directly in the browser using client-side template functions — use it when the server can't (or shouldn't) emit the initial HTML.
 
+The `GoTemplateAdapter` is web-framework-agnostic: its `html/template` output runs on any Go server. `npm create barefootjs@latest` ships scaffolds for Echo, Gin, Chi, and net/http (via `--adapter`) — see [Go Template Adapter → Server integration](./adapters/go-template-adapter.md#server-integration).
+
 ## Pages
 
 | Topic | Description |

package/dist/docs/core/quick-start.mdx

@@ -152,10 +152,10 @@ This runs `bf build`, generates the final `uno.css`, and calls `wrangler deploy`
 - **[`createSignal`](./reactivity/create-signal.md)** and **[`createMemo`](./reactivity/create-memo.md)** — the reactivity primitives you just used.
 - **[Client Directive](./rendering/client-directive.md)** — exactly what `"use client"` does and when to reach for it.
 - **[Hono Adapter](./adapters/hono-adapter.md)** — adapter-specific configuration and output details.
-- Pick a different backend by passing `--adapter` to the scaffolder. Supported values today: `hono` (default — Cloudflare Workers), `hono-node`, `echo` (Go / Echo), `mojo` (Mojolicious / Perl), `csr` (no backend — pure client render). For example:
+- Pick a different backend by passing `--adapter` to the scaffolder. Supported values today: `hono` (default — Cloudflare Workers), `hono-node`, `echo` (Go / Echo), `gin` (Go / Gin), `chi` (Go / Chi), `nethttp` (Go / net/http stdlib), `mojo` (Mojolicious / Perl), `csr` (no backend — pure client render). For example:
 
   ```bash
   npm create barefootjs@latest -- --adapter hono-node
   ```
 
-  See [Adapter Architecture](./adapters/adapter-architecture.md) for the architectural overview, and the per-adapter pages under [`docs/core/adapters/`](./adapters/) for output details. The `@barefootjs/go-template` package is a compile-time adapter API for generating Go `html/template` files — it does not have a `bf init` scaffold; see [Go Template Adapter](./adapters/go-template-adapter.md) for the programmatic usage.
+  See [Adapter Architecture](./adapters/adapter-architecture.md) for the architectural overview, and the per-adapter pages under [`docs/core/adapters/`](./adapters/) for output details. The four Go scaffolds (`echo`, `gin`, `chi`, `nethttp`) all build on the `@barefootjs/go-template` adapter, which generates Go `html/template` files; see [Go Template Adapter](./adapters/go-template-adapter.md) for its programmatic API.