diff --git a/doc.go b/doc.go
new file mode 100644
index 0000000..073f40d
--- /dev/null
+++ b/doc.go
@@ -0,0 +1 @@
+package telemetry
diff --git a/go.mod b/go.mod
new file mode 100644
index 0000000..f427f76
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,3 @@
+module golang.org/x/telemetry
+
+go 1.20
diff --git a/go.sum b/go.sum
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/go.sum
diff --git a/godev/go.mod b/godev/go.mod
new file mode 100644
index 0000000..fbeacf7
--- /dev/null
+++ b/godev/go.mod
@@ -0,0 +1,17 @@
+module golang.org/x/telemetry/godev
+
+go 1.20
+
+require (
+	github.com/evanw/esbuild v0.17.19
+	github.com/google/go-cmp v0.5.9
+	github.com/yuin/goldmark v1.5.4
+	golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1
+)
+
+require gopkg.in/yaml.v2 v2.4.0 // indirect
+
+require (
+	github.com/yuin/goldmark-meta v1.1.0
+	golang.org/x/sys v0.8.0 // indirect
+)
diff --git a/godev/go.sum b/godev/go.sum
new file mode 100644
index 0000000..ec938e0
--- /dev/null
+++ b/godev/go.sum
@@ -0,0 +1,17 @@
+github.com/evanw/esbuild v0.17.19 h1:JdzNCvfFEoUCXKHhdP326Vn2mhCu8PybXeBDHaSRyWo=
+github.com/evanw/esbuild v0.17.19/go.mod h1:iINY06rn799hi48UqEnaQvVfZWe6W9bET78LbvN8VWk=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/yuin/goldmark v1.5.4 h1:2uY/xC0roWy8IBEGLgB1ywIoEJFGmRrX21YQcvGZzjU=
+github.com/yuin/goldmark v1.5.4/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+github.com/yuin/goldmark-meta v1.1.0 h1:pWw+JLHGZe8Rk0EGsMVssiNb/AaPMHfSRszZeUeiOUc=
+github.com/yuin/goldmark-meta v1.1.0/go.mod h1:U4spWENafuA7Zyg+Lj5RqK/MF+ovMYtBvXi1lBb2VP0=
+golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1 h1:k/i9J1pBpvlfR+9QsetwPyERsqu1GIbi967PQMq3Ivc=
+golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
diff --git a/godev/internal/content/content.go b/godev/internal/content/content.go
new file mode 100644
index 0000000..b522f26
--- /dev/null
+++ b/godev/internal/content/content.go
@@ -0,0 +1,312 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package content implements a basic web serving framework.
+//
+// # Content Server
+//
+// A content server is an http.Handler that serves requests from a file system.
+// Use Server(fsys) to create a new content server.
+//
+// The server is defined primarily by the content of its file system fsys,
+// which holds files to be served. It renders markdown files and golang
+// templates into HTML and transforms TypeScript into JavaScript.
+//
+// # Page Rendering
+//
+// A request for a path like "/page" will search the file system for
+// "page.md", "page.html", "page/index.md", and "page/index.html" and
+// render HTML output for the first file found.
+//
+// Partial templates with the extension ".tmpl" at the root of the file system
+// and in the same directory as the requested page are included in the
+// html/template execution step to allow for sharing and composing logic from
+// multiple templates.
+package content
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"html/template"
+	"io/fs"
+	"net/http"
+	"path"
+	"strconv"
+	"strings"
+
+	"github.com/yuin/goldmark"
+	meta "github.com/yuin/goldmark-meta"
+	"github.com/yuin/goldmark/extension"
+	"github.com/yuin/goldmark/parser"
+	"github.com/yuin/goldmark/renderer/html"
+	"golang.org/x/exp/slog"
+)
+
+// contentServer serves requests for a given file system. It can also render
+// templates and transform TypeScript into JavaScript.
+type contentServer struct {
+	fsys     fs.FS
+	fserv    http.Handler
+	handlers map[string]handlerFunc
+}
+
+type handler struct {
+	path string
+	fn   handlerFunc
+}
+
+type handlerFunc func(http.ResponseWriter, *http.Request, fs.FS) error
+
+// Server returns a handler that serves HTTP requests with the contents
+// of the file system rooted at fsys. For requests to a path without an
+// extension, the server will search fsys for markdown or html templates
+// first by appending .md, .html, /index.md, and /index.html to the
+// requested url path.
+//
+// The default behavior of looking for templates within fsys can be overriden
+// by using an optional set of content handlers.
+//
+// For example, a server can be constructed for a file system with a single
+// template, “index.html“, in a directory, “content“, and a handler:
+//
+//	 s := content.Server(os.DirFS("content"),
+//		 content.Handler("/", func(w http.ReponseWriter, _ *http.Request, fsys fs.FS) error {
+//		 	 return content.Template(w, fsys, "index.html", nil, http.StatusOK)
+//		 }))
+//
+// or without a handler:
+//
+//	content.Server(os.DirFS("content"))
+//
+// Both examples will render the template index.html for requests to "/".
+func Server(fsys fs.FS, handlers ...*handler) http.Handler {
+	fserv := http.FileServer(http.FS(fsys))
+	hs := make(map[string]handlerFunc)
+	for _, h := range handlers {
+		if _, ok := hs[h.path]; ok {
+			panic("multiple registrations for " + h.path)
+		}
+		hs[h.path] = h.fn
+	}
+	return &contentServer{fsys, fserv, hs}
+}
+
+func Handler(path string, h handlerFunc) *handler {
+	return &handler{path, h}
+}
+
+func (c *contentServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if len(r.URL.Path) > 255 {
+		Error(w, r, errors.New("url too long"), http.StatusBadRequest)
+		return
+	}
+
+	if handler, ok := c.handlers[r.URL.Path]; ok {
+		err := handler(w, r, c.fsys)
+		if err != nil {
+			Error(w, r, err, http.StatusInternalServerError)
+		}
+		return
+	}
+
+	ext := path.Ext(r.URL.Path)
+	if ext == ".md" || ext == ".html" {
+		http.Redirect(w, r, strings.TrimSuffix(r.URL.Path, ext), http.StatusMovedPermanently)
+		return
+	}
+
+	filepath, info, err := stat(c.fsys, r.URL.Path)
+	if errors.Is(err, fs.ErrNotExist) {
+		Error(w, r, errors.New("page not found"), http.StatusNotFound)
+		return
+	}
+	if err == nil {
+		if strings.HasSuffix(r.URL.Path, "/index") {
+			http.Redirect(w, r, strings.TrimSuffix(r.URL.Path, "/index"), http.StatusMovedPermanently)
+			return
+		}
+		switch path.Ext(filepath) {
+		case ".html":
+			err = Template(w, c.fsys, filepath, nil, http.StatusOK)
+		case ".md":
+			err = markdown(w, c.fsys, filepath, http.StatusOK)
+		case ".ts":
+			err = script(w, c.fsys, filepath, info)
+		default:
+			c.fserv.ServeHTTP(w, r)
+		}
+	}
+	if err != nil {
+		Error(w, r, err, http.StatusInternalServerError)
+	}
+}
+
+// Template executes a template response.
+func Template(w http.ResponseWriter, fsys fs.FS, tmplPath string, data any, code int) error {
+	patterns, err := tmplPatterns(fsys, tmplPath)
+	if err != nil {
+		return err
+	}
+	patterns = append(patterns, tmplPath)
+	tmpl, err := template.ParseFS(fsys, patterns...)
+	if err != nil {
+		return err
+	}
+	name := path.Base(tmplPath)
+	var buf bytes.Buffer
+	if err := tmpl.ExecuteTemplate(&buf, name, data); err != nil {
+		return err
+	}
+	if code != 0 {
+		w.WriteHeader(code)
+	}
+	w.Header().Set("Content-Type", "text/html")
+	w.Header().Set("Content-Length", strconv.Itoa(buf.Len()))
+	if _, err := w.Write(buf.Bytes()); err != nil {
+		return err
+	}
+	return nil
+}
+
+// JSON encodes data as JSON response with a status code.
+func JSON(w http.ResponseWriter, data any, code int) error {
+	var buf bytes.Buffer
+	if err := json.NewEncoder(&buf).Encode(data); err != nil {
+		return err
+	}
+	if code != 0 {
+		w.WriteHeader(code)
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("Content-Length", strconv.Itoa(buf.Len()))
+	if _, err := w.Write(buf.Bytes()); err != nil {
+		return err
+	}
+	return nil
+}
+
+// Text formats data as a text response with a status code.
+func Text(w http.ResponseWriter, data any, code int) error {
+	var buf bytes.Buffer
+	if _, err := fmt.Fprint(&buf, data); err != nil {
+		return err
+	}
+	if code != 0 {
+		w.WriteHeader(code)
+	}
+	w.Header().Set("Content-Type", "text/plain")
+	w.Header().Set("Content-Length", strconv.Itoa(buf.Len()))
+	if _, err := w.Write(buf.Bytes()); err != nil {
+		return err
+	}
+	return nil
+}
+
+// Error writes an error as an HTTP response with a status code.
+func Error(w http.ResponseWriter, req *http.Request, err error, code int) {
+	if code == http.StatusInternalServerError {
+		http.Error(w, http.StatusText(http.StatusInternalServerError), code)
+	} else {
+		http.Error(w, err.Error(), code)
+	}
+	slog.Error("request error",
+		slog.String("method", req.Method),
+		slog.String("uri", req.RequestURI),
+		slog.Int("status", code),
+		slog.String("error", err.Error()),
+	)
+}
+
+// markdown renders a markdown template as html.
+func markdown(w http.ResponseWriter, fsys fs.FS, tmplPath string, code int) error {
+	markdown, err := fs.ReadFile(fsys, tmplPath)
+	if err != nil {
+		return err
+	}
+	md := goldmark.New(
+		goldmark.WithParserOptions(
+			parser.WithHeadingAttribute(),
+			parser.WithAutoHeadingID(),
+		),
+		goldmark.WithRendererOptions(
+			html.WithUnsafe(),
+			html.WithXHTML(),
+		),
+		goldmark.WithExtensions(
+			extension.GFM,
+			extension.NewTypographer(),
+			meta.Meta,
+		),
+	)
+	var content bytes.Buffer
+	ctx := parser.NewContext()
+	if err := md.Convert(markdown, &content, parser.WithContext(ctx)); err != nil {
+		return err
+	}
+	data := meta.Get(ctx)
+	if data == nil {
+		data = map[string]interface{}{}
+	}
+	data["Content"] = template.HTML(content.String())
+	if _, ok := data["Template"]; !ok {
+		data["Template"] = "base.html"
+	}
+	return Template(w, fsys, data["Template"].(string), data, code)
+}
+
+// script serves TypeScript code tranformed into JavaScript.
+func script(w http.ResponseWriter, fsys fs.FS, filepath string, info fs.FileInfo) error {
+	data, err := fs.ReadFile(fsys, filepath)
+	if err != nil {
+		return err
+	}
+	output := esbuild(data)
+	w.Header().Set("Content-Type", "text/javascript")
+	w.Header().Set("Content-Length", strconv.Itoa(output.Len()))
+	w.Header().Set("Last-Modified", info.ModTime().Format("Mon, 02 Jan 2006 15:04:05 GMT"))
+	if _, err := w.Write(output.Bytes()); err != nil {
+		return err
+	}
+	return nil
+}
+
+// stat trys to coerce a urlPath into an openable file then returns the
+// file path and file info.
+func stat(fsys fs.FS, urlPath string) (string, fs.FileInfo, error) {
+	cleanPath := path.Clean(strings.TrimPrefix(urlPath, "/"))
+	ext := path.Ext(cleanPath)
+	filePaths := []string{cleanPath}
+	if ext == "" || ext == "." {
+		md := cleanPath + ".md"
+		html := cleanPath + ".html"
+		indexMD := path.Join(cleanPath, "index.md")
+		indexHTML := path.Join(cleanPath, "index.html")
+		filePaths = []string{md, html, indexMD, indexHTML, cleanPath}
+	}
+	var p string
+	var stat fs.FileInfo
+	var err error
+	for _, p = range filePaths {
+		if stat, err = fs.Stat(fsys, p); err == nil {
+			break
+		}
+	}
+	return p, stat, err
+}
+
+// tmplPatters generates a slice of file patterns to use in template.ParseFS.
+func tmplPatterns(fsys fs.FS, tmplPath string) ([]string, error) {
+	var patterns []string
+	globs := []string{"*.tmpl", path.Join(path.Dir(tmplPath), "*.tmpl")}
+	for _, g := range globs {
+		matches, err := fs.Glob(fsys, g)
+		if err != nil {
+			return nil, err
+		}
+		patterns = append(patterns, matches...)
+	}
+	return patterns, nil
+}
diff --git a/godev/internal/content/content_test.go b/godev/internal/content/content_test.go
new file mode 100644
index 0000000..1d2bcc5
--- /dev/null
+++ b/godev/internal/content/content_test.go
@@ -0,0 +1,158 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !plan9
+
+package content
+
+import (
+	"errors"
+	"io/fs"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+func TestServer_ServeHTTP(t *testing.T) {
+	server := Server(os.DirFS("testdata"),
+		Handler("/data", handleTemplate),
+		Handler("/json", handleJSON),
+		Handler("/text", handleText),
+		Handler("/error", handleError),
+	)
+
+	tests := []struct {
+		path     string
+		wantOut  string
+		wantCode int
+	}{
+		{
+			"/index.html",
+			"redirect.html.out",
+			http.StatusMovedPermanently,
+		},
+		{
+			"/index",
+			"redirect.out",
+			http.StatusMovedPermanently,
+		},
+		{
+			"/json",
+			"json.out",
+			http.StatusOK,
+		},
+		{
+			"/text",
+			"text.out",
+			http.StatusOK,
+		},
+		{
+			"/error",
+			"error.out",
+			http.StatusBadRequest,
+		},
+		{
+			"/script.ts",
+			"script.ts.out",
+			http.StatusOK,
+		},
+		{
+			"/style.css",
+			"style.css.out",
+			http.StatusOK,
+		},
+		{
+			"/",
+			"index.html.out",
+			http.StatusOK,
+		},
+		{
+			"/data",
+			"data.html.out",
+			http.StatusOK,
+		},
+		{
+			"/markdown",
+			"markdown.md.out",
+			http.StatusOK,
+		},
+		{
+			"/404",
+			"404.html.out",
+			http.StatusNotFound,
+		},
+		{
+			"/subdir",
+			"subdir/index.html.out",
+			http.StatusOK,
+		},
+		{
+			"/noindex/",
+			"noindex/noindex.html.out",
+			http.StatusOK,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.path, func(t *testing.T) {
+			rr := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", tt.path, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			server.ServeHTTP(rr, req)
+			got := rr.Body.String()
+			data, err := os.ReadFile(path.Join("testdata", tt.wantOut))
+			if err != nil {
+				t.Fatal(err)
+			}
+			wantBody := string(data)
+			if diff := cmp.Diff(wantBody, got); diff != "" {
+				t.Errorf("GET %s response body mismatch (-want, +got):\n%s", tt.path, diff)
+			}
+			if diff := cmp.Diff(tt.wantCode, rr.Code); diff != "" {
+				t.Errorf("GET %s response code (-want, +got):\n%s", tt.path, diff)
+			}
+		})
+	}
+}
+
+func Test_stat(t *testing.T) {
+	fsys := os.DirFS("testdata")
+	tests := []struct {
+		urlPath string
+		want    string
+	}{
+		{"/", "index.html"},
+		{"/markdown", "markdown.md"},
+		{"/sub/path", "sub/path"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.urlPath, func(t *testing.T) {
+			if got, _, _ := stat(fsys, tt.urlPath); got != tt.want {
+				t.Errorf("stat() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func handleTemplate(w http.ResponseWriter, _ *http.Request, fsys fs.FS) error {
+	return Template(w, fsys, "data.html", "Data from Handler", http.StatusOK)
+}
+
+func handleJSON(w http.ResponseWriter, _ *http.Request, fsys fs.FS) error {
+	return JSON(w, struct{ Data string }{Data: "Data"}, http.StatusOK)
+}
+
+func handleText(w http.ResponseWriter, _ *http.Request, fsys fs.FS) error {
+	return Text(w, "Hello, World!", http.StatusOK)
+}
+
+func handleError(w http.ResponseWriter, r *http.Request, fsys fs.FS) error {
+	Error(w, r, errors.New("Bad Request"), http.StatusBadRequest)
+	return nil
+}
diff --git a/godev/internal/content/esbuild.go b/godev/internal/content/esbuild.go
new file mode 100644
index 0000000..0c743cf
--- /dev/null
+++ b/godev/internal/content/esbuild.go
@@ -0,0 +1,36 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !plan9
+
+package content
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+
+	"github.com/evanw/esbuild/pkg/api"
+)
+
+func esbuild(data []byte) *bytes.Buffer {
+	// TODO: cache the output of this transform operation, minify the output.
+	js := api.Transform(string(data), api.TransformOptions{
+		Loader: api.LoaderTS,
+	})
+	output := bytes.NewBuffer(js.Code)
+	if len(js.Warnings) != 0 {
+		messages := api.FormatMessages(js.Warnings, api.FormatMessagesOptions{})
+		for _, m := range messages {
+			fmt.Fprintf(output, ";console.warn(`%s`);", strings.ReplaceAll(m, "`", "\\`"))
+		}
+	}
+	if len(js.Errors) != 0 {
+		messages := api.FormatMessages(js.Errors, api.FormatMessagesOptions{})
+		for _, m := range messages {
+			fmt.Fprintf(output, ";console.error(`%s`);", strings.ReplaceAll(m, "`", "\\`"))
+		}
+	}
+	return output
+}
diff --git a/godev/internal/content/esbuild_plan9.go b/godev/internal/content/esbuild_plan9.go
new file mode 100644
index 0000000..aec014e
--- /dev/null
+++ b/godev/internal/content/esbuild_plan9.go
@@ -0,0 +1,13 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build plan9
+
+package content
+
+import "bytes"
+
+func esbuild(data []byte) *bytes.Buffer {
+	return &bytes.Buffer{}
+}
diff --git a/godev/internal/content/testdata/404.html.out b/godev/internal/content/testdata/404.html.out
new file mode 100644
index 0000000..3261618
--- /dev/null
+++ b/godev/internal/content/testdata/404.html.out
@@ -0,0 +1 @@
+page not found
diff --git a/godev/internal/content/testdata/base.html b/godev/internal/content/testdata/base.html
new file mode 100644
index 0000000..ab01ea7
--- /dev/null
+++ b/godev/internal/content/testdata/base.html
@@ -0,0 +1,7 @@
+<!--
+  Copyright 2023 The Go Authors. All rights reserved.
+  Use of this source code is governed by a BSD-style
+  license that can be found in the LICENSE file.
+-->
+
+{{template "base" .}}
diff --git a/godev/internal/content/testdata/base.tmpl b/godev/internal/content/testdata/base.tmpl
new file mode 100644
index 0000000..417e9ae
--- /dev/null
+++ b/godev/internal/content/testdata/base.tmpl
@@ -0,0 +1,19 @@
+<!--
+  Copyright 2023 The Go Authors. All rights reserved.
+  Use of this source code is governed by a BSD-style
+  license that can be found in the LICENSE file.
+-->
+
+{{define "base"}}
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <title>{{block "title" .}}{{.Title}}{{end}}</title>
+</head>
+<body>
+  <main>
+  {{block "content" .}}{{.Content}}{{end}}
+  </main>
+</body>
+</html>
+{{end}}
diff --git a/godev/internal/content/testdata/data.html b/godev/internal/content/testdata/data.html
new file mode 100644
index 0000000..a4e2d2d
--- /dev/null
+++ b/godev/internal/content/testdata/data.html
@@ -0,0 +1,13 @@
+<!--
+  Copyright 2023 The Go Authors. All rights reserved.
+  Use of this source code is governed by a BSD-style
+  license that can be found in the LICENSE file.
+-->
+
+{{template "base" .}}
+{{define "title"}}Page Title{{end}}
+{{define "content"}}
+  <header>
+    <h1>{{.}}</h1>
+  </header>
+{{end}}
diff --git a/godev/internal/content/testdata/data.html.out b/godev/internal/content/testdata/data.html.out
new file mode 100644
index 0000000..9273ec1
--- /dev/null
+++ b/godev/internal/content/testdata/data.html.out
@@ -0,0 +1,21 @@
+
+
+
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <title>Page Title</title>
+</head>
+<body>
+  <main>
+  
+  <header>
+    <h1>Data from Handler</h1>
+  </header>
+
+  </main>
+</body>
+</html>
+
+
+
diff --git a/godev/internal/content/testdata/error.out b/godev/internal/content/testdata/error.out
new file mode 100644
index 0000000..489ff97
--- /dev/null
+++ b/godev/internal/content/testdata/error.out
@@ -0,0 +1 @@
+Bad Request
diff --git a/godev/internal/content/testdata/index.html b/godev/internal/content/testdata/index.html
new file mode 100644
index 0000000..12efa77
--- /dev/null
+++ b/godev/internal/content/testdata/index.html
@@ -0,0 +1,13 @@
+<!--
+  Copyright 2023 The Go Authors. All rights reserved.
+  Use of this source code is governed by a BSD-style
+  license that can be found in the LICENSE file.
+-->
+
+{{template "base" .}}
+{{define "title"}}Page Title{{end}}
+{{define "content"}}
+  <header>
+    <h1>Page Title</h1>
+  </header>
+{{end}}
diff --git a/godev/internal/content/testdata/index.html.out b/godev/internal/content/testdata/index.html.out
new file mode 100644
index 0000000..1d50474
--- /dev/null
+++ b/godev/internal/content/testdata/index.html.out
@@ -0,0 +1,21 @@
+
+
+
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <title>Page Title</title>
+</head>
+<body>
+  <main>
+  
+  <header>
+    <h1>Page Title</h1>
+  </header>
+
+  </main>
+</body>
+</html>
+
+
+
diff --git a/godev/internal/content/testdata/json.out b/godev/internal/content/testdata/json.out
new file mode 100644
index 0000000..34948e3
--- /dev/null
+++ b/godev/internal/content/testdata/json.out
@@ -0,0 +1 @@
+{"Data":"Data"}
diff --git a/godev/internal/content/testdata/markdown.md b/godev/internal/content/testdata/markdown.md
new file mode 100644
index 0000000..cb76515
--- /dev/null
+++ b/godev/internal/content/testdata/markdown.md
@@ -0,0 +1,9 @@
+---
+Title: Page Title
+---
+
+# This is a heading
+
+## This is a subheading
+
+[link](https://go.dev)
\ No newline at end of file
diff --git a/godev/internal/content/testdata/markdown.md.out b/godev/internal/content/testdata/markdown.md.out
new file mode 100644
index 0000000..861b57c
--- /dev/null
+++ b/godev/internal/content/testdata/markdown.md.out
@@ -0,0 +1,18 @@
+
+
+
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <title>Page Title</title>
+</head>
+<body>
+  <main>
+  <h1 id="this-is-a-heading">This is a heading</h1>
+<h2 id="this-is-a-subheading">This is a subheading</h2>
+<p><a href="https://go.dev">link</a></p>
+
+  </main>
+</body>
+</html>
+
diff --git a/godev/internal/content/testdata/noindex/noindex.html.out b/godev/internal/content/testdata/noindex/noindex.html.out
new file mode 100644
index 0000000..59ecac5
--- /dev/null
+++ b/godev/internal/content/testdata/noindex/noindex.html.out
@@ -0,0 +1,3 @@
+<pre>
+<a href="noindex.html.out">noindex.html.out</a>
+</pre>
diff --git a/godev/internal/content/testdata/redirect.html.out b/godev/internal/content/testdata/redirect.html.out
new file mode 100644
index 0000000..4245802
--- /dev/null
+++ b/godev/internal/content/testdata/redirect.html.out
@@ -0,0 +1,2 @@
+<a href="/index">Moved Permanently</a>.
+
diff --git a/godev/internal/content/testdata/redirect.out b/godev/internal/content/testdata/redirect.out
new file mode 100644
index 0000000..266448d
--- /dev/null
+++ b/godev/internal/content/testdata/redirect.out
@@ -0,0 +1,2 @@
+<a href="/">Moved Permanently</a>.
+
diff --git a/godev/internal/content/testdata/script.ts b/godev/internal/content/testdata/script.ts
new file mode 100644
index 0000000..2dab8f8
--- /dev/null
+++ b/godev/internal/content/testdata/script.ts
@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2023 The Go Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style
+ * license that can be found in the LICENSE file.
+ */
+
+interface Greeter {
+  (target: string): void;
+}
+
+const hello: Greeter = (target) => console.log(`Hello, ${target}!`);
+
+hello("world");
+
+export {};
diff --git a/godev/internal/content/testdata/script.ts.out b/godev/internal/content/testdata/script.ts.out
new file mode 100644
index 0000000..95f7be9
--- /dev/null
+++ b/godev/internal/content/testdata/script.ts.out
@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2023 The Go Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style
+ * license that can be found in the LICENSE file.
+ */
+const hello = (target) => console.log(`Hello, ${target}!`);
+hello("world");
+export {};
diff --git a/godev/internal/content/testdata/style.css b/godev/internal/content/testdata/style.css
new file mode 100644
index 0000000..447a4c6
--- /dev/null
+++ b/godev/internal/content/testdata/style.css
@@ -0,0 +1,9 @@
+/*!
+ * Copyright 2023 The Go Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style
+ * license that can be found in the LICENSE file.
+ */
+
+a {
+  color: blue;
+}
diff --git a/godev/internal/content/testdata/style.css.out b/godev/internal/content/testdata/style.css.out
new file mode 100644
index 0000000..447a4c6
--- /dev/null
+++ b/godev/internal/content/testdata/style.css.out
@@ -0,0 +1,9 @@
+/*!
+ * Copyright 2023 The Go Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style
+ * license that can be found in the LICENSE file.
+ */
+
+a {
+  color: blue;
+}
diff --git a/godev/internal/content/testdata/subdir/index.html b/godev/internal/content/testdata/subdir/index.html
new file mode 100644
index 0000000..91d35a5
--- /dev/null
+++ b/godev/internal/content/testdata/subdir/index.html
@@ -0,0 +1,13 @@
+<!--
+  Copyright 2023 The Go Authors. All rights reserved.
+  Use of this source code is governed by a BSD-style
+  license that can be found in the LICENSE file.
+-->
+
+{{template "base" .}}
+{{define "title"}}Page Title{{end}}
+{{define "content"}}
+  <header>
+    <h1>Page in subdirectory</h1>
+  </header>
+{{end}}
diff --git a/godev/internal/content/testdata/subdir/index.html.out b/godev/internal/content/testdata/subdir/index.html.out
new file mode 100644
index 0000000..49e1c29
--- /dev/null
+++ b/godev/internal/content/testdata/subdir/index.html.out
@@ -0,0 +1,21 @@
+
+
+
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <title>Page Title</title>
+</head>
+<body>
+  <main>
+  
+  <header>
+    <h1>Page in subdirectory</h1>
+  </header>
+
+  </main>
+</body>
+</html>
+
+
+
diff --git a/godev/internal/content/testdata/text.out b/godev/internal/content/testdata/text.out
new file mode 100644
index 0000000..b45ef6f
--- /dev/null
+++ b/godev/internal/content/testdata/text.out
@@ -0,0 +1 @@
+Hello, World!
\ No newline at end of file
diff --git a/godev/internal/middleware/middleware.go b/godev/internal/middleware/middleware.go
new file mode 100644
index 0000000..33fb42f
--- /dev/null
+++ b/godev/internal/middleware/middleware.go
@@ -0,0 +1,81 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package middleware implements a simple middleware pattern for http handlers,
+// along with implementations for some common middlewares.
+package middleware
+
+import (
+	"fmt"
+	"net/http"
+	"runtime/debug"
+	"time"
+
+	"golang.org/x/exp/slog"
+)
+
+var Default = Chain(Log, Recover)
+
+// A Middleware is a func that wraps an http.Handler.
+type Middleware func(http.Handler) http.Handler
+
+// Chain creates a new Middleware that applies a sequence of Middlewares, so
+// that they execute in the given order when handling an http request.
+//
+// In other words, Chain(m1, m2)(handler) = m1(m2(handler))
+//
+// A similar pattern is used in e.g. github.com/justinas/alice:
+// https://github.com/justinas/alice/blob/ce87934/chain.go#L45
+func Chain(middlewares ...Middleware) Middleware {
+	return func(h http.Handler) http.Handler {
+		for i := range middlewares {
+			h = middlewares[len(middlewares)-1-i](h)
+		}
+		return h
+	}
+}
+
+// Log is a middleware that logs request start, end, duration, and status.
+func Log(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		start := time.Now()
+		slog.Info("request start",
+			slog.String("method", r.Method),
+			slog.String("uri", r.RequestURI),
+		)
+		w2 := &statusRecorder{w, 200}
+		next.ServeHTTP(w2, r)
+		slog.Info("request end",
+			slog.String("method", r.Method),
+			slog.String("uri", r.RequestURI),
+			slog.Int("status", w2.status),
+			slog.Duration("duration", time.Since(start)),
+		)
+	})
+}
+
+// Recover is a middleware that recovers from panics in the delegate
+// handler and prints a stack trace.
+func Recover(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		defer func() {
+			if err := recover(); err != nil {
+				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+				slog.Error(r.RequestURI, fmt.Errorf(`panic("%s")`, err))
+				fmt.Println(string(debug.Stack()))
+			}
+		}()
+		next.ServeHTTP(w, r)
+	})
+}
+
+type statusRecorder struct {
+	http.ResponseWriter
+	status int
+}
+
+func (rec *statusRecorder) WriteHeader(code int) {
+	rec.status = code
+	rec.ResponseWriter.WriteHeader(code)
+}
diff --git a/godev/internal/unionfs/testdata/dir1/file1 b/godev/internal/unionfs/testdata/dir1/file1
new file mode 100644
index 0000000..d46a0e4
--- /dev/null
+++ b/godev/internal/unionfs/testdata/dir1/file1
@@ -0,0 +1 @@
+file 1 content from dir 1
diff --git a/godev/internal/unionfs/testdata/dir2/file1 b/godev/internal/unionfs/testdata/dir2/file1
new file mode 100644
index 0000000..af7eea4
--- /dev/null
+++ b/godev/internal/unionfs/testdata/dir2/file1
@@ -0,0 +1 @@
+file 1 content from dir 2
\ No newline at end of file
diff --git a/godev/internal/unionfs/testdata/dir2/file2 b/godev/internal/unionfs/testdata/dir2/file2
new file mode 100644
index 0000000..b8947b7
--- /dev/null
+++ b/godev/internal/unionfs/testdata/dir2/file2
@@ -0,0 +1 @@
+file 2 content
diff --git a/godev/internal/unionfs/unionfs.go b/godev/internal/unionfs/unionfs.go
new file mode 100644
index 0000000..139a6fa
--- /dev/null
+++ b/godev/internal/unionfs/unionfs.go
@@ -0,0 +1,82 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package unionfs allows multiple file systems to be read as a union.
+package unionfs
+
+import (
+	"io/fs"
+)
+
+var _ fs.ReadDirFS = FS{}
+
+// A FS is an FS presenting the union of the file systems in the slice. If
+// multiple file systems provide a particular file, Open uses the FS listed
+// earlier in the slice.
+type FS []fs.FS
+
+// Sub returns an FS corresponding to the merged subtree rooted at a set of
+// fsys's dirs.
+func Sub(fsys fs.FS, dirs ...string) (FS, error) {
+	var subs FS
+	for _, dir := range dirs {
+		if _, err := fs.Stat(fsys, dir); err != nil {
+			return nil, err
+		}
+		sub, err := fs.Sub(fsys, dir)
+		if err != nil {
+			return nil, err
+		}
+		subs = append(subs, sub)
+	}
+	return subs, nil
+}
+
+func (fsys FS) Open(name string) (fs.File, error) {
+	var errOut error
+	for _, sub := range fsys {
+		f, err := sub.Open(name)
+		if err == nil {
+			return f, nil
+		}
+		if errOut == nil {
+			errOut = err
+		}
+	}
+	return nil, errOut
+}
+
+func (fsys FS) ReadDir(name string) ([]fs.DirEntry, error) {
+	var all []fs.DirEntry
+	var seen map[string]bool // seen[name] is true if name is listed in all; lazily initialized
+	var errOut error
+	for _, sub := range fsys {
+		list, err := fs.ReadDir(sub, name)
+		if err != nil {
+			errOut = err
+		}
+		if len(all) == 0 {
+			all = append(all, list...)
+		} else {
+			if seen == nil {
+				// Initialize seen only after we get two different directory listings.
+				seen = make(map[string]bool)
+				for _, d := range all {
+					seen[d.Name()] = true
+				}
+			}
+			for _, d := range list {
+				name := d.Name()
+				if !seen[name] {
+					seen[name] = true
+					all = append(all, d)
+				}
+			}
+		}
+	}
+	if len(all) > 0 {
+		return all, nil
+	}
+	return nil, errOut
+}
diff --git a/godev/internal/unionfs/unionfs_test.go b/godev/internal/unionfs/unionfs_test.go
new file mode 100644
index 0000000..d839b82
--- /dev/null
+++ b/godev/internal/unionfs/unionfs_test.go
@@ -0,0 +1,113 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package unionfs
+
+import (
+	"io"
+	"os"
+	"reflect"
+	"testing"
+)
+
+func TestFS_Open(t *testing.T) {
+	fsys, err := Sub(os.DirFS("testdata"), "dir1", "dir2")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	type args struct {
+		name string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr bool
+	}{
+		{
+			name: "file1 from dir1",
+			args: args{
+				name: "file1",
+			},
+			want:    "file 1 content from dir 1\n",
+			wantErr: false,
+		},
+		{
+			name: "file2 from dir2",
+			args: args{
+				name: "file2",
+			},
+			want:    "file 2 content\n",
+			wantErr: false,
+		},
+		{
+			name: "file not found",
+			args: args{
+				name: "file3",
+			},
+			want:    "file3",
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			file, err := fsys.Open(tt.args.name)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("FS.Open() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !tt.wantErr {
+				bytes, err := io.ReadAll(file)
+				if err != nil {
+					t.Fatal(err)
+				}
+				got := string(bytes)
+				if got != tt.want {
+					t.Errorf("FS.Open() = %v, want %v", got, tt.want)
+				}
+			}
+		})
+	}
+}
+
+func TestFS_ReadDir(t *testing.T) {
+	var err error
+	fsys, err := Sub(os.DirFS("testdata"), "dir1", "dir2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	type args struct {
+		name string
+	}
+	tests := []struct {
+		name      string
+		args      args
+		fsys      FS
+		wantFiles []string
+	}{
+		{
+			name:      "",
+			args:      args{"."},
+			fsys:      fsys,
+			wantFiles: []string{"file1", "file2"},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dirs, err := tt.fsys.ReadDir(tt.args.name)
+			if err != nil {
+				t.Errorf("FS.ReadDir() error = %v", err)
+				return
+			}
+			var got []string
+			for _, v := range dirs {
+				got = append(got, v.Name())
+			}
+			if !reflect.DeepEqual(got, tt.wantFiles) {
+				t.Errorf("FS.ReadDir() = %v, want %v", got, tt.wantFiles)
+			}
+		})
+	}
+}