From 23a5c155cf4278b3cf6dfa0d01aaff095ee87364 Mon Sep 17 00:00:00 2001
From: darakanoit <dara.kamaliev@gmail.com>
Date: Sat, 19 Sep 2026 16:20:51 +0500
Subject: [PATCH 1/5] feat: [#773] add View.Make to render a template to a
 string

Rendering now lives in the view module, so a view can be rendered outside a
request, for example to warm a page cache from a command or a queued job.

The API follows Laravel's split between the view factory and a view instance:
View.Make and View.First return a Template, and Template.Render returns the
HTML. Template also has With, Name and Data.

Templates are resolved the same way the gin and fiber drivers do it:
resources/views, then LoadViewsFrom directories, then LoadViewsFromFS
filesystems, first definition wins. The parsed set is cached and reset when a
new view source is registered.
---
 contracts/view/view.go |  22 ++++
 errors/list.go         |   2 +
 mocks/view/Template.go | 231 +++++++++++++++++++++++++++++++++++++++++
 mocks/view/View.go     | 119 +++++++++++++++++++++
 view/render.go         | 126 ++++++++++++++++++++++
 view/template.go       |  91 ++++++++++++++++
 view/template_test.go  | 217 ++++++++++++++++++++++++++++++++++++++
 view/view.go           |  30 +++++-
 view/view_test.go      |   3 -
 9 files changed, 836 insertions(+), 5 deletions(-)
 create mode 100644 mocks/view/Template.go
 create mode 100644 view/render.go
 create mode 100644 view/template.go
 create mode 100644 view/template_test.go

diff --git a/contracts/view/view.go b/contracts/view/view.go
index d83bda7f3..7a572a9b2 100644
--- a/contracts/view/view.go
+++ b/contracts/view/view.go
@@ -5,6 +5,9 @@ import "io/fs"
 type View interface {
 	// Exists checks if a view with the specified name exists.
 	Exists(view string) bool
+	// First returns a template for the first view in the list that exists. If none of them
+	// exist, rendering the returned template fails.
+	First(views []string, data ...any) Template
 	// LoadViewsFrom registers a package view directory for template fallback.
 	// Templates from registered directories are loaded after app views; if a
 	// template name is already defined by an app view or an earlier package, it is skipped.
@@ -29,6 +32,9 @@ type View interface {
 	// in registration order. Each returned filesystem is already rooted at the root passed to
 	// LoadViewsFromFS, so template paths are relative to it (for example "layouts/app.tmpl").
 	RegisteredViewFS() []fs.FS
+	// Make returns a template for the view. The data may be a map or a struct; it is merged
+	// over the shared data when the template is rendered.
+	Make(view string, data ...any) Template
 	// Share associates a key-value pair, where the key is a string and the value is of any type,
 	// with the current view context. This shared data can be accessed by other parts of the application.
 	Share(key string, value any)
@@ -38,3 +44,19 @@ type View interface {
 	// GetShared returns a map containing all the shared data associated with the current view context.
 	GetShared() map[string]any
 }
+
+type Template interface {
+	// Data returns the data passed to the template, without the shared data.
+	Data() map[string]any
+	// Name returns the name of the view.
+	Name() string
+	// Render renders the view and returns the resulting HTML. Templates are resolved the same
+	// way as for HTTP responses: application views first, then directories registered with
+	// LoadViewsFrom, then filesystems registered with LoadViewsFromFS.
+	//
+	// Rendering happens outside a request, so request-bound values such as csrf_token are
+	// not available.
+	Render() (string, error)
+	// With adds a key-value pair to the template data.
+	With(key string, value any) Template
+}
diff --git a/errors/list.go b/errors/list.go
index 569fbe902..e511c6cd3 100644
--- a/errors/list.go
+++ b/errors/list.go
@@ -375,4 +375,6 @@ var (
 	ViewFSRootNotDirectory = New("view filesystem root %q is not a directory")
 	ViewInvalidFSRoot      = New("invalid view filesystem root %q: %v")
 	ViewTemplateNotExist   = New("view template %s does not exist")
+	ViewInvalidData        = New("view %s data must be a map or struct, got %T")
+	ViewNoneExist          = New("none of the views %v exist")
 )
diff --git a/mocks/view/Template.go b/mocks/view/Template.go
new file mode 100644
index 000000000..65211f3d4
--- /dev/null
+++ b/mocks/view/Template.go
@@ -0,0 +1,231 @@
+// Code generated by mockery. DO NOT EDIT.
+
+package view
+
+import (
+	view "github.com/goravel/framework/contracts/view"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// Template is an autogenerated mock type for the Template type
+type Template struct {
+	mock.Mock
+}
+
+type Template_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Template) EXPECT() *Template_Expecter {
+	return &Template_Expecter{mock: &_m.Mock}
+}
+
+// Data provides a mock function with no fields
+func (_m *Template) Data() map[string]interface{} {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Data")
+	}
+
+	var r0 map[string]interface{}
+	if rf, ok := ret.Get(0).(func() map[string]interface{}); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]interface{})
+		}
+	}
+
+	return r0
+}
+
+// Template_Data_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Data'
+type Template_Data_Call struct {
+	*mock.Call
+}
+
+// Data is a helper method to define mock.On call
+func (_e *Template_Expecter) Data() *Template_Data_Call {
+	return &Template_Data_Call{Call: _e.mock.On("Data")}
+}
+
+func (_c *Template_Data_Call) Run(run func()) *Template_Data_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Template_Data_Call) Return(_a0 map[string]interface{}) *Template_Data_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *Template_Data_Call) RunAndReturn(run func() map[string]interface{}) *Template_Data_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Name provides a mock function with no fields
+func (_m *Template) Name() string {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Name")
+	}
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// Template_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name'
+type Template_Name_Call struct {
+	*mock.Call
+}
+
+// Name is a helper method to define mock.On call
+func (_e *Template_Expecter) Name() *Template_Name_Call {
+	return &Template_Name_Call{Call: _e.mock.On("Name")}
+}
+
+func (_c *Template_Name_Call) Run(run func()) *Template_Name_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Template_Name_Call) Return(_a0 string) *Template_Name_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *Template_Name_Call) RunAndReturn(run func() string) *Template_Name_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Render provides a mock function with no fields
+func (_m *Template) Render() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Render")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Template_Render_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Render'
+type Template_Render_Call struct {
+	*mock.Call
+}
+
+// Render is a helper method to define mock.On call
+func (_e *Template_Expecter) Render() *Template_Render_Call {
+	return &Template_Render_Call{Call: _e.mock.On("Render")}
+}
+
+func (_c *Template_Render_Call) Run(run func()) *Template_Render_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Template_Render_Call) Return(_a0 string, _a1 error) *Template_Render_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Template_Render_Call) RunAndReturn(run func() (string, error)) *Template_Render_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// With provides a mock function with given fields: key, value
+func (_m *Template) With(key string, value interface{}) view.Template {
+	ret := _m.Called(key, value)
+
+	if len(ret) == 0 {
+		panic("no return value specified for With")
+	}
+
+	var r0 view.Template
+	if rf, ok := ret.Get(0).(func(string, interface{}) view.Template); ok {
+		r0 = rf(key, value)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(view.Template)
+		}
+	}
+
+	return r0
+}
+
+// Template_With_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'With'
+type Template_With_Call struct {
+	*mock.Call
+}
+
+// With is a helper method to define mock.On call
+//   - key string
+//   - value interface{}
+func (_e *Template_Expecter) With(key interface{}, value interface{}) *Template_With_Call {
+	return &Template_With_Call{Call: _e.mock.On("With", key, value)}
+}
+
+func (_c *Template_With_Call) Run(run func(key string, value interface{})) *Template_With_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(interface{}))
+	})
+	return _c
+}
+
+func (_c *Template_With_Call) Return(_a0 view.Template) *Template_With_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *Template_With_Call) RunAndReturn(run func(string, interface{}) view.Template) *Template_With_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewTemplate creates a new instance of Template. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewTemplate(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Template {
+	mock := &Template{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/mocks/view/View.go b/mocks/view/View.go
index b2e3bc6c3..3c8c74300 100644
--- a/mocks/view/View.go
+++ b/mocks/view/View.go
@@ -5,6 +5,7 @@ package view
 import (
 	fs "io/fs"
 
+	view "github.com/goravel/framework/contracts/view"
 	mock "github.com/stretchr/testify/mock"
 )
 
@@ -67,6 +68,65 @@ func (_c *View_Exists_Call) RunAndReturn(run func(string) bool) *View_Exists_Cal
 	return _c
 }
 
+// First provides a mock function with given fields: views, data
+func (_m *View) First(views []string, data ...interface{}) view.Template {
+	var _ca []interface{}
+	_ca = append(_ca, views)
+	_ca = append(_ca, data...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for First")
+	}
+
+	var r0 view.Template
+	if rf, ok := ret.Get(0).(func([]string, ...interface{}) view.Template); ok {
+		r0 = rf(views, data...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(view.Template)
+		}
+	}
+
+	return r0
+}
+
+// View_First_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'First'
+type View_First_Call struct {
+	*mock.Call
+}
+
+// First is a helper method to define mock.On call
+//   - views []string
+//   - data ...interface{}
+func (_e *View_Expecter) First(views interface{}, data ...interface{}) *View_First_Call {
+	return &View_First_Call{Call: _e.mock.On("First",
+		append([]interface{}{views}, data...)...)}
+}
+
+func (_c *View_First_Call) Run(run func(views []string, data ...interface{})) *View_First_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]interface{}, len(args)-1)
+		for i, a := range args[1:] {
+			if a != nil {
+				variadicArgs[i] = a.(interface{})
+			}
+		}
+		run(args[0].([]string), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *View_First_Call) Return(_a0 view.Template) *View_First_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *View_First_Call) RunAndReturn(run func([]string, ...interface{}) view.Template) *View_First_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // GetShared provides a mock function with no fields
 func (_m *View) GetShared() map[string]interface{} {
 	ret := _m.Called()
@@ -181,6 +241,65 @@ func (_c *View_LoadViewsFromFS_Call) RunAndReturn(run func(fs.FS, string)) *View
 	return _c
 }
 
+// Make provides a mock function with given fields: _a0, data
+func (_m *View) Make(_a0 string, data ...interface{}) view.Template {
+	var _ca []interface{}
+	_ca = append(_ca, _a0)
+	_ca = append(_ca, data...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Make")
+	}
+
+	var r0 view.Template
+	if rf, ok := ret.Get(0).(func(string, ...interface{}) view.Template); ok {
+		r0 = rf(_a0, data...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(view.Template)
+		}
+	}
+
+	return r0
+}
+
+// View_Make_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Make'
+type View_Make_Call struct {
+	*mock.Call
+}
+
+// Make is a helper method to define mock.On call
+//   - _a0 string
+//   - data ...interface{}
+func (_e *View_Expecter) Make(_a0 interface{}, data ...interface{}) *View_Make_Call {
+	return &View_Make_Call{Call: _e.mock.On("Make",
+		append([]interface{}{_a0}, data...)...)}
+}
+
+func (_c *View_Make_Call) Run(run func(_a0 string, data ...interface{})) *View_Make_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]interface{}, len(args)-1)
+		for i, a := range args[1:] {
+			if a != nil {
+				variadicArgs[i] = a.(interface{})
+			}
+		}
+		run(args[0].(string), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *View_Make_Call) Return(_a0 view.Template) *View_Make_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *View_Make_Call) RunAndReturn(run func(string, ...interface{}) view.Template) *View_Make_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RegisteredViewFS provides a mock function with no fields
 func (_m *View) RegisteredViewFS() []fs.FS {
 	ret := _m.Called()
diff --git a/view/render.go b/view/render.go
new file mode 100644
index 000000000..a700b9d66
--- /dev/null
+++ b/view/render.go
@@ -0,0 +1,126 @@
+package view
+
+import (
+	"bytes"
+	"html/template"
+	"io/fs"
+	"os"
+	stdpath "path"
+	"regexp"
+
+	"github.com/goravel/framework/errors"
+	"github.com/goravel/framework/packages/paths"
+	"github.com/goravel/framework/support"
+)
+
+var defineRe = regexp.MustCompile(`\{\{\s*define\s+"([^"]+)"`)
+
+// render executes the named template with the given values.
+func (r *View) render(name string, values map[string]any) (string, error) {
+	tmpl, err := r.templates()
+	if err != nil {
+		return "", err
+	}
+	if tmpl == nil || tmpl.Lookup(name) == nil {
+		return "", errors.ViewTemplateNotExist.Args(name)
+	}
+
+	var buf bytes.Buffer
+	if err := tmpl.ExecuteTemplate(&buf, name, values); err != nil {
+		return "", err
+	}
+
+	return buf.String(), nil
+}
+
+// templates returns the compiled template set, parsing every view source on first use.
+// The set is reset whenever a new source is registered.
+func (r *View) templates() (*template.Template, error) {
+	r.tmplMu.Lock()
+	defer r.tmplMu.Unlock()
+
+	if r.tmpl != nil {
+		return r.tmpl, nil
+	}
+
+	tmpl, err := r.parse()
+	if err != nil {
+		return nil, err
+	}
+	r.tmpl = tmpl
+
+	return tmpl, nil
+}
+
+func (r *View) resetTemplate() {
+	r.tmplMu.Lock()
+	defer r.tmplMu.Unlock()
+
+	r.tmpl = nil
+}
+
+// parse loads every source into one template set in precedence order: the application's
+// resources/views, then directories registered via LoadViewsFrom, then filesystems registered
+// via LoadViewsFromFS. The first source to define a template name wins. It returns nil when
+// no source contributes a template.
+func (r *View) parse() (*template.Template, error) {
+	var sources []fs.FS
+	if dir := paths.Abs(support.Config.Paths.Resources, "views"); isDir(dir) {
+		sources = append(sources, os.DirFS(dir))
+	}
+	for _, dir := range r.RegisteredViews() {
+		if isDir(dir) {
+			sources = append(sources, os.DirFS(dir))
+		}
+	}
+	sources = append(sources, r.RegisteredViewFS()...)
+
+	tmpl := template.New("")
+	defined := make(map[string]bool)
+	loaded := false
+
+	for _, source := range sources {
+		err := fs.WalkDir(source, ".", func(name string, d fs.DirEntry, err error) error {
+			if err != nil || d.IsDir() {
+				return err
+			}
+
+			content, err := fs.ReadFile(source, name)
+			if err != nil {
+				return err
+			}
+			text := string(content)
+
+			// A file without a define block is addressed by its base name, the name it is parsed as.
+			templateName := stdpath.Base(name)
+			if matches := defineRe.FindStringSubmatch(text); len(matches) > 1 {
+				templateName = matches[1]
+			}
+			if defined[templateName] {
+				return nil
+			}
+			defined[templateName] = true
+
+			if _, err := tmpl.New(stdpath.Base(name)).Parse(text); err != nil {
+				return err
+			}
+			loaded = true
+
+			return nil
+		})
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if !loaded {
+		return nil, nil
+	}
+
+	return tmpl, nil
+}
+
+func isDir(p string) bool {
+	info, err := os.Stat(p)
+	return err == nil && info.IsDir()
+}
diff --git a/view/template.go b/view/template.go
new file mode 100644
index 000000000..bcf3b69d2
--- /dev/null
+++ b/view/template.go
@@ -0,0 +1,91 @@
+package view
+
+import (
+	"reflect"
+
+	contractsview "github.com/goravel/framework/contracts/view"
+	"github.com/goravel/framework/errors"
+)
+
+type Template struct {
+	view *View
+	name string
+	data map[string]any
+	err  error
+}
+
+func NewTemplate(view *View, name string, data ...any) *Template {
+	values, err := toMap(name, data...)
+
+	return &Template{
+		view: view,
+		name: name,
+		data: values,
+		err:  err,
+	}
+}
+
+func (r *Template) Data() map[string]any {
+	return r.data
+}
+
+func (r *Template) Name() string {
+	return r.name
+}
+
+func (r *Template) Render() (string, error) {
+	if r.err != nil {
+		return "", r.err
+	}
+
+	values := r.view.GetShared()
+	for key, value := range r.data {
+		values[key] = value
+	}
+
+	return r.view.render(r.name, values)
+}
+
+func (r *Template) With(key string, value any) contractsview.Template {
+	r.data[key] = value
+
+	return r
+}
+
+// toMap copies the given map or struct into a new map, leaving the caller's data untouched.
+func toMap(view string, data ...any) (map[string]any, error) {
+	values := make(map[string]any)
+	if len(data) == 0 || data[0] == nil {
+		return values, nil
+	}
+
+	value := reflect.ValueOf(data[0])
+	if value.Kind() == reflect.Pointer {
+		if value.IsNil() {
+			return values, nil
+		}
+		value = value.Elem()
+	}
+
+	switch value.Kind() {
+	case reflect.Map:
+		if value.Type().Key().Kind() != reflect.String {
+			return values, errors.ViewInvalidData.Args(view, data[0])
+		}
+		iter := value.MapRange()
+		for iter.Next() {
+			values[iter.Key().String()] = iter.Value().Interface()
+		}
+	case reflect.Struct:
+		for i := 0; i < value.NumField(); i++ {
+			field := value.Type().Field(i)
+			if field.IsExported() {
+				values[field.Name] = value.Field(i).Interface()
+			}
+		}
+	default:
+		return values, errors.ViewInvalidData.Args(view, data[0])
+	}
+
+	return values, nil
+}
diff --git a/view/template_test.go b/view/template_test.go
new file mode 100644
index 000000000..8378dc16c
--- /dev/null
+++ b/view/template_test.go
@@ -0,0 +1,217 @@
+package view
+
+import (
+	"os"
+	"path/filepath"
+	"sync"
+	"testing"
+	"testing/fstest"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/goravel/framework/errors"
+)
+
+func TestTemplateRender(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		"foo.tmpl":      `{{ define "foo.tmpl" }}app foo{{ end }}`,
+		"greeting.tmpl": `{{ define "greeting.tmpl" }}{{ .Greeting }}, {{ .Name }}{{ end }}`,
+		"raw.tmpl":      `raw {{ .Name }}`,
+	})
+
+	pkgDir := t.TempDir()
+	require.NoError(t, os.WriteFile(filepath.Join(pkgDir, "shared.tmpl"), []byte(`{{ define "shared.tmpl" }}from dir{{ end }}`), 0o644))
+
+	pkgB := fstest.MapFS{
+		"views/bar.tmpl":    {Data: []byte(`{{ define "bar.tmpl" }}package bar{{ end }}`)},
+		"views/shared.tmpl": {Data: []byte(`{{ define "shared.tmpl" }}from embedded{{ end }}`)},
+	}
+
+	view := NewView()
+	view.Share("Greeting", "Hello")
+	view.Share("Name", "shared")
+	view.LoadViewsFrom(pkgDir)
+	view.LoadViewsFromFS(testViews, "testdata/views")
+	view.LoadViewsFromFS(pkgB, "views")
+
+	type page struct {
+		Title   string
+		Nav     string
+		private string
+	}
+
+	tests := []struct {
+		name   string
+		view   string
+		data   []any
+		expect string
+	}{
+		{name: "application overrides embedded package", view: "foo.tmpl", expect: "app foo"},
+		{name: "filesystem package overrides embedded package", view: "shared.tmpl", expect: "from dir"},
+		{name: "embedded package fallback", view: "bar.tmpl", expect: "package bar"},
+		{name: "file without define block", view: "raw.tmpl", data: []any{map[string]any{"Name": "Goravel"}}, expect: "raw Goravel"},
+		{name: "shared data only", view: "greeting.tmpl", expect: "Hello, shared"},
+		{name: "map overrides shared data", view: "greeting.tmpl", data: []any{map[string]string{"Name": "Goravel"}}, expect: "Hello, Goravel"},
+		{name: "nil data", view: "greeting.tmpl", data: []any{nil}, expect: "Hello, shared"},
+		{
+			name:   "struct data with nested layout, partial and block",
+			view:   "pages/home.tmpl",
+			data:   []any{page{Title: "Home", Nav: "Menu", private: "hidden"}},
+			expect: "<html><body><nav>Menu</nav><main><h1>Home</h1></main></body></html>",
+		},
+		{
+			name:   "pointer to struct",
+			view:   "pages/home.tmpl",
+			data:   []any{&page{Title: "Home", Nav: "Menu"}},
+			expect: "<html><body><nav>Menu</nav><main><h1>Home</h1></main></body></html>",
+		},
+		{
+			name:   "values are HTML escaped",
+			view:   "greeting.tmpl",
+			data:   []any{map[string]any{"Name": "<script>"}},
+			expect: "Hello, &lt;script&gt;",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			html, err := view.Make(test.view, test.data...).Render()
+			require.NoError(t, err)
+			assert.Equal(t, test.expect, html)
+		})
+	}
+
+	t.Run("caller data is not modified", func(t *testing.T) {
+		data := map[string]any{"Name": "Goravel"}
+		_, err := view.Make("greeting.tmpl", data).With("Greeting", "Hi").Render()
+		require.NoError(t, err)
+		assert.Equal(t, map[string]any{"Name": "Goravel"}, data)
+	})
+
+	t.Run("missing template", func(t *testing.T) {
+		_, err := view.Make("missing.tmpl").Render()
+		assert.ErrorIs(t, err, errors.ViewTemplateNotExist)
+	})
+
+	t.Run("invalid data", func(t *testing.T) {
+		_, err := view.Make("greeting.tmpl", 1).Render()
+		assert.ErrorIs(t, err, errors.ViewInvalidData)
+
+		_, err = view.Make("greeting.tmpl", map[int]string{1: "a"}).Render()
+		assert.ErrorIs(t, err, errors.ViewInvalidData)
+	})
+}
+
+func TestTemplateRender_NoViews(t *testing.T) {
+	setupAppViews(t, nil)
+
+	_, err := NewView().Make("welcome.tmpl").Render()
+	assert.ErrorIs(t, err, errors.ViewTemplateNotExist)
+}
+
+func TestTemplateRender_ParseError(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		"broken.tmpl": `{{ define "broken.tmpl" }}{{ .Name }`,
+	})
+
+	_, err := NewView().Make("broken.tmpl").Render()
+	assert.Error(t, err)
+}
+
+func TestTemplateRender_RecompilesAfterRegisteringSource(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		"foo.tmpl": `{{ define "foo.tmpl" }}app foo{{ end }}`,
+	})
+
+	view := NewView()
+	_, err := view.Make("bar.tmpl").Render()
+	require.ErrorIs(t, err, errors.ViewTemplateNotExist)
+
+	view.LoadViewsFromFS(fstest.MapFS{
+		"views/bar.tmpl": {Data: []byte(`{{ define "bar.tmpl" }}package bar{{ end }}`)},
+	}, "views")
+
+	html, err := view.Make("bar.tmpl").Render()
+	require.NoError(t, err)
+	assert.Equal(t, "package bar", html)
+
+	pkgDir := t.TempDir()
+	require.NoError(t, os.WriteFile(filepath.Join(pkgDir, "baz.tmpl"), []byte(`{{ define "baz.tmpl" }}package baz{{ end }}`), 0o644))
+	view.LoadViewsFrom(pkgDir)
+
+	html, err = view.Make("baz.tmpl").Render()
+	require.NoError(t, err)
+	assert.Equal(t, "package baz", html)
+}
+
+func TestTemplateRender_Concurrent(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		"greeting.tmpl": `{{ define "greeting.tmpl" }}Hello, {{ .Name }}{{ end }}`,
+	})
+
+	view := NewView()
+
+	var wg sync.WaitGroup
+	for i := 0; i < 20; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			view.Share("Name", "Goravel")
+			html, err := view.Make("greeting.tmpl", map[string]any{"Name": "Goravel"}).Render()
+			assert.NoError(t, err)
+			assert.Equal(t, "Hello, Goravel", html)
+		}()
+	}
+	wg.Wait()
+}
+
+func TestTemplateWith(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		"greeting.tmpl": `{{ define "greeting.tmpl" }}{{ .Greeting }}, {{ .Name }}{{ end }}`,
+	})
+
+	view := NewView()
+	view.Share("Greeting", "Hello")
+	view.Share("Name", "shared")
+
+	template := view.Make("greeting.tmpl", map[string]any{"Name": "data"})
+	assert.Equal(t, "greeting.tmpl", template.Name())
+	assert.Equal(t, map[string]any{"Name": "data"}, template.Data())
+
+	html, err := template.With("Name", "Goravel").With("Greeting", "Hi").Render()
+	require.NoError(t, err)
+	assert.Equal(t, "Hi, Goravel", html)
+	assert.Equal(t, map[string]any{"Name": "Goravel", "Greeting": "Hi"}, template.Data())
+	assert.Equal(t, "shared", view.Shared("Name"), "With must not change the shared data")
+
+	html, err = view.Make("greeting.tmpl").With("Name", "Goravel").Render()
+	require.NoError(t, err)
+	assert.Equal(t, "Hello, Goravel", html)
+}
+
+func TestFirst(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		"admin.tmpl":  `{{ define "admin.tmpl" }}admin {{ .Name }}{{ end }}`,
+		"custom.tmpl": `{{ define "custom.tmpl" }}custom {{ .Name }}{{ end }}`,
+	})
+
+	view := NewView()
+	data := map[string]any{"Name": "Goravel"}
+
+	template := view.First([]string{"missing.tmpl", "custom.tmpl", "admin.tmpl"}, data)
+	assert.Equal(t, "custom.tmpl", template.Name())
+	html, err := template.Render()
+	require.NoError(t, err)
+	assert.Equal(t, "custom Goravel", html)
+
+	html, err = view.First([]string{"missing.tmpl", "admin.tmpl"}, data).Render()
+	require.NoError(t, err)
+	assert.Equal(t, "admin Goravel", html)
+
+	template = view.First([]string{"missing.tmpl", "other.tmpl"}, data)
+	assert.Empty(t, template.Name())
+	assert.Equal(t, data, template.Data())
+	_, err = template.Render()
+	assert.ErrorIs(t, err, errors.ViewNoneExist)
+}
diff --git a/view/view.go b/view/view.go
index ca423a83f..75be404f6 100644
--- a/view/view.go
+++ b/view/view.go
@@ -1,12 +1,14 @@
 package view
 
 import (
+	"html/template"
 	"io/fs"
 	"os"
 	"path"
 	"strings"
 	"sync"
 
+	contractsview "github.com/goravel/framework/contracts/view"
 	"github.com/goravel/framework/errors"
 	"github.com/goravel/framework/packages/paths"
 	"github.com/goravel/framework/support"
@@ -17,6 +19,9 @@ type View struct {
 	paths       []string
 	filesystems []fs.FS
 	shared      sync.Map
+
+	tmplMu sync.Mutex
+	tmpl   *template.Template
 }
 
 func NewView() *View {
@@ -52,10 +57,25 @@ func (r *View) Exists(view string) bool {
 	return false
 }
 
+func (r *View) First(views []string, data ...any) contractsview.Template {
+	for _, view := range views {
+		if r.Exists(view) {
+			return r.Make(view, data...)
+		}
+	}
+
+	template := NewTemplate(r, "", data...)
+	template.err = errors.ViewNoneExist.Args(views)
+
+	return template
+}
+
 func (r *View) LoadViewsFrom(path string) {
 	r.mu.Lock()
-	defer r.mu.Unlock()
 	r.paths = append(r.paths, path)
+	r.mu.Unlock()
+
+	r.resetTemplate()
 }
 
 func (r *View) LoadViewsFromFS(fsys fs.FS, root string) {
@@ -83,8 +103,14 @@ func (r *View) LoadViewsFromFS(fsys fs.FS, root string) {
 	}
 
 	r.mu.Lock()
-	defer r.mu.Unlock()
 	r.filesystems = append(r.filesystems, sub)
+	r.mu.Unlock()
+
+	r.resetTemplate()
+}
+
+func (r *View) Make(view string, data ...any) contractsview.Template {
+	return NewTemplate(r, view, data...)
 }
 
 func (r *View) RegisteredViews() []string {
diff --git a/view/view_test.go b/view/view_test.go
index a0d2fa99e..b9cfc99b5 100644
--- a/view/view_test.go
+++ b/view/view_test.go
@@ -7,7 +7,6 @@ import (
 	"io/fs"
 	"os"
 	"path/filepath"
-	"regexp"
 	"testing"
 	"testing/fstest"
 
@@ -335,5 +334,3 @@ func parseAll(t *testing.T, appDir string, view *View) *template.Template {
 
 	return tmpl
 }
-
-var defineRe = regexp.MustCompile(`\{\{\s*define\s+"([^"]+)"`)

From 0b5e8cdb938da210058b67113d34bdbec1991d31 Mon Sep 17 00:00:00 2001
From: darakanoit <dara.kamaliev@gmail.com>
Date: Sat, 19 Sep 2026 16:39:43 +0500
Subject: [PATCH 2/5] test: [#773] cover template execution errors and nil
 pointer data

---
 view/template_test.go | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/view/template_test.go b/view/template_test.go
index 8378dc16c..c409b7eeb 100644
--- a/view/template_test.go
+++ b/view/template_test.go
@@ -54,6 +54,7 @@ func TestTemplateRender(t *testing.T) {
 		{name: "shared data only", view: "greeting.tmpl", expect: "Hello, shared"},
 		{name: "map overrides shared data", view: "greeting.tmpl", data: []any{map[string]string{"Name": "Goravel"}}, expect: "Hello, Goravel"},
 		{name: "nil data", view: "greeting.tmpl", data: []any{nil}, expect: "Hello, shared"},
+		{name: "nil pointer data", view: "greeting.tmpl", data: []any{(*page)(nil)}, expect: "Hello, shared"},
 		{
 			name:   "struct data with nested layout, partial and block",
 			view:   "pages/home.tmpl",
@@ -119,6 +120,16 @@ func TestTemplateRender_ParseError(t *testing.T) {
 	assert.Error(t, err)
 }
 
+func TestTemplateRender_ExecuteError(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		"exec.tmpl": `{{ define "exec.tmpl" }}{{ template "missing.tmpl" }}{{ end }}`,
+	})
+
+	html, err := NewView().Make("exec.tmpl").Render()
+	assert.ErrorContains(t, err, "missing.tmpl")
+	assert.Empty(t, html)
+}
+
 func TestTemplateRender_RecompilesAfterRegisteringSource(t *testing.T) {
 	setupAppViews(t, map[string]string{
 		"foo.tmpl": `{{ define "foo.tmpl" }}app foo{{ end }}`,

From 6b315068f5d3e97bd915daf45cc708e881064e39 Mon Sep 17 00:00:00 2001
From: darakanoit <dara.kamaliev@gmail.com>
Date: Sat, 19 Sep 2026 16:45:27 +0500
Subject: [PATCH 3/5] fix: [#773] match driver data handling and avoid locking
 on every render

Pointer fields in struct data are dereferenced the way the gin and fiber
drivers do it, so a nil pointer renders as an empty value instead of <nil>.

The compiled template set is read through an atomic pointer, so concurrent
renders no longer queue on a mutex. A parse error is kept with it, like the
drivers keep theirs, instead of re-parsing every view source on each render.
The output buffer is sized from the previous render of the same template,
which avoids growing it and copying it at the end.

Adds BenchmarkTemplateRender.
---
 view/render.go        | 67 ++++++++++++++++++++++++++--------------
 view/template.go      | 22 +++++++++++--
 view/template_test.go | 72 +++++++++++++++++++++++++++++++++++++++++++
 view/view.go          | 10 +++---
 view/view_test.go     |  2 +-
 5 files changed, 141 insertions(+), 32 deletions(-)

diff --git a/view/render.go b/view/render.go
index a700b9d66..f2e9dbd12 100644
--- a/view/render.go
+++ b/view/render.go
@@ -1,12 +1,13 @@
 package view
 
 import (
-	"bytes"
 	"html/template"
 	"io/fs"
 	"os"
 	stdpath "path"
 	"regexp"
+	"strings"
+	"sync/atomic"
 
 	"github.com/goravel/framework/errors"
 	"github.com/goravel/framework/packages/paths"
@@ -15,48 +16,68 @@ import (
 
 var defineRe = regexp.MustCompile(`\{\{\s*define\s+"([^"]+)"`)
 
+// compiled is the result of parsing every view source, including a failure, so a broken
+// view is not parsed again on every render.
+type compiled struct {
+	tmpl *template.Template
+	err  error
+	// sizes holds the last output size of each template, used to size the next buffer.
+	sizes map[string]*atomic.Int64
+}
+
 // render executes the named template with the given values.
 func (r *View) render(name string, values map[string]any) (string, error) {
-	tmpl, err := r.templates()
-	if err != nil {
-		return "", err
+	c := r.compile()
+	if c.err != nil {
+		return "", c.err
 	}
-	if tmpl == nil || tmpl.Lookup(name) == nil {
+
+	size, ok := c.sizes[name]
+	if !ok {
 		return "", errors.ViewTemplateNotExist.Args(name)
 	}
 
-	var buf bytes.Buffer
-	if err := tmpl.ExecuteTemplate(&buf, name, values); err != nil {
+	var buf strings.Builder
+	buf.Grow(int(size.Load()))
+	if err := c.tmpl.ExecuteTemplate(&buf, name, values); err != nil {
 		return "", err
 	}
+	size.Store(int64(buf.Len()))
 
 	return buf.String(), nil
 }
 
-// templates returns the compiled template set, parsing every view source on first use.
-// The set is reset whenever a new source is registered.
-func (r *View) templates() (*template.Template, error) {
-	r.tmplMu.Lock()
-	defer r.tmplMu.Unlock()
+// compile returns the parsed view sources, parsing them on first use. The result is kept
+// until a new source is registered.
+func (r *View) compile() *compiled {
+	if c := r.compiled.Load(); c != nil {
+		return c
+	}
+
+	r.compileMu.Lock()
+	defer r.compileMu.Unlock()
 
-	if r.tmpl != nil {
-		return r.tmpl, nil
+	if c := r.compiled.Load(); c != nil {
+		return c
 	}
 
-	tmpl, err := r.parse()
-	if err != nil {
-		return nil, err
+	c := &compiled{sizes: make(map[string]*atomic.Int64)}
+	c.tmpl, c.err = r.parse()
+	if c.tmpl != nil {
+		for _, t := range c.tmpl.Templates() {
+			c.sizes[t.Name()] = &atomic.Int64{}
+		}
 	}
-	r.tmpl = tmpl
+	r.compiled.Store(c)
 
-	return tmpl, nil
+	return c
 }
 
-func (r *View) resetTemplate() {
-	r.tmplMu.Lock()
-	defer r.tmplMu.Unlock()
+func (r *View) resetCompiled() {
+	r.compileMu.Lock()
+	defer r.compileMu.Unlock()
 
-	r.tmpl = nil
+	r.compiled.Store(nil)
 }
 
 // parse loads every source into one template set in precedence order: the application's
diff --git a/view/template.go b/view/template.go
index bcf3b69d2..a7b0cd442 100644
--- a/view/template.go
+++ b/view/template.go
@@ -38,7 +38,11 @@ func (r *Template) Render() (string, error) {
 		return "", r.err
 	}
 
-	values := r.view.GetShared()
+	values := make(map[string]any, len(r.data)+8)
+	r.view.shared.Range(func(key, value any) bool {
+		values[key.(string)] = value
+		return true
+	})
 	for key, value := range r.data {
 		values[key] = value
 	}
@@ -79,8 +83,20 @@ func toMap(view string, data ...any) (map[string]any, error) {
 	case reflect.Struct:
 		for i := 0; i < value.NumField(); i++ {
 			field := value.Type().Field(i)
-			if field.IsExported() {
-				values[field.Name] = value.Field(i).Interface()
+			if !field.IsExported() {
+				continue
+			}
+			// Pointer fields are dereferenced the same way the route drivers do it, so a
+			// nil pointer renders as an empty value instead of "<nil>".
+			fieldValue := value.Field(i)
+			if fieldValue.Kind() == reflect.Pointer {
+				if fieldValue.IsNil() {
+					values[field.Name] = nil
+				} else {
+					values[field.Name] = fieldValue.Elem().Interface()
+				}
+			} else {
+				values[field.Name] = fieldValue.Interface()
 			}
 		}
 	default:
diff --git a/view/template_test.go b/view/template_test.go
index c409b7eeb..74de98a4b 100644
--- a/view/template_test.go
+++ b/view/template_test.go
@@ -3,6 +3,7 @@ package view
 import (
 	"os"
 	"path/filepath"
+	"strings"
 	"sync"
 	"testing"
 	"testing/fstest"
@@ -120,6 +121,43 @@ func TestTemplateRender_ParseError(t *testing.T) {
 	assert.Error(t, err)
 }
 
+func TestTemplateRender_PointerFields(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		"post.tmpl": `{{ define "post.tmpl" }}[{{ .Title }}][{{ .Author }}]{{ end }}`,
+	})
+
+	type post struct {
+		Title  *string
+		Author *string
+	}
+
+	title := "Hello"
+	html, err := NewView().Make("post.tmpl", post{Title: &title}).Render()
+	require.NoError(t, err)
+	assert.Equal(t, "[Hello][]", html)
+}
+
+func TestTemplateRender_ParseErrorIsCached(t *testing.T) {
+	dir := setupAppViews(t, map[string]string{
+		"broken.tmpl": `{{ define "broken.tmpl" }}{{ .Name }`,
+	})
+
+	view := NewView()
+	_, err := view.Make("broken.tmpl").Render()
+	require.Error(t, err)
+
+	// Fixing the file does not help until a new source is registered, the same way the
+	// route drivers compile their views once.
+	require.NoError(t, os.WriteFile(filepath.Join(dir, "broken.tmpl"), []byte(`{{ define "broken.tmpl" }}fixed{{ end }}`), 0o644))
+	_, err = view.Make("broken.tmpl").Render()
+	require.Error(t, err)
+
+	view.LoadViewsFrom(t.TempDir())
+	html, err := view.Make("broken.tmpl").Render()
+	require.NoError(t, err)
+	assert.Equal(t, "fixed", html)
+}
+
 func TestTemplateRender_ExecuteError(t *testing.T) {
 	setupAppViews(t, map[string]string{
 		"exec.tmpl": `{{ define "exec.tmpl" }}{{ template "missing.tmpl" }}{{ end }}`,
@@ -226,3 +264,37 @@ func TestFirst(t *testing.T) {
 	_, err = template.Render()
 	assert.ErrorIs(t, err, errors.ViewNoneExist)
 }
+
+func BenchmarkTemplateRender(b *testing.B) {
+	var page strings.Builder
+	page.WriteString(`{{ define "page.tmpl" }}<html><body><h1>{{ .Title }}</h1><ul>`)
+	for i := 0; i < 200; i++ {
+		page.WriteString(`<li class="item">{{ .Title }} item</li>`)
+	}
+	page.WriteString(`</ul></body></html>{{ end }}`)
+
+	setupAppViews(b, map[string]string{"page.tmpl": page.String()})
+
+	view := NewView()
+	view.Share("Name", "Goravel")
+	data := map[string]any{"Title": "Home"}
+
+	_, err := view.Make("page.tmpl", data).Render()
+	require.NoError(b, err)
+
+	b.Run("serial", func(b *testing.B) {
+		b.ReportAllocs()
+		for b.Loop() {
+			_, _ = view.Make("page.tmpl", data).Render()
+		}
+	})
+
+	b.Run("parallel", func(b *testing.B) {
+		b.ReportAllocs()
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				_, _ = view.Make("page.tmpl", data).Render()
+			}
+		})
+	})
+}
diff --git a/view/view.go b/view/view.go
index 75be404f6..31071bb91 100644
--- a/view/view.go
+++ b/view/view.go
@@ -1,12 +1,12 @@
 package view
 
 import (
-	"html/template"
 	"io/fs"
 	"os"
 	"path"
 	"strings"
 	"sync"
+	"sync/atomic"
 
 	contractsview "github.com/goravel/framework/contracts/view"
 	"github.com/goravel/framework/errors"
@@ -20,8 +20,8 @@ type View struct {
 	filesystems []fs.FS
 	shared      sync.Map
 
-	tmplMu sync.Mutex
-	tmpl   *template.Template
+	compileMu sync.Mutex
+	compiled  atomic.Pointer[compiled]
 }
 
 func NewView() *View {
@@ -75,7 +75,7 @@ func (r *View) LoadViewsFrom(path string) {
 	r.paths = append(r.paths, path)
 	r.mu.Unlock()
 
-	r.resetTemplate()
+	r.resetCompiled()
 }
 
 func (r *View) LoadViewsFromFS(fsys fs.FS, root string) {
@@ -106,7 +106,7 @@ func (r *View) LoadViewsFromFS(fsys fs.FS, root string) {
 	r.filesystems = append(r.filesystems, sub)
 	r.mu.Unlock()
 
-	r.resetTemplate()
+	r.resetCompiled()
 }
 
 func (r *View) Make(view string, data ...any) contractsview.Template {
diff --git a/view/view_test.go b/view/view_test.go
index b9cfc99b5..ce95c5ecd 100644
--- a/view/view_test.go
+++ b/view/view_test.go
@@ -264,7 +264,7 @@ func TestResolveTemplates(t *testing.T) {
 }
 
 // setupAppViews points the application resources path at a temp dir and writes the given views into it.
-func setupAppViews(t *testing.T, files map[string]string) string {
+func setupAppViews(t testing.TB, files map[string]string) string {
 	t.Helper()
 
 	relativePath := support.RelativePath

From 2df615d15771b5b205f633815694e4b1baa24719 Mon Sep 17 00:00:00 2001
From: darakanoit <dara.kamaliev@gmail.com>
Date: Sun, 20 Sep 2026 14:33:18 +0500
Subject: [PATCH 4/5] fix: [#773] resolve views by the names they can be
 rendered by

Rendering looked views up in the template set html/template happens to end
up with, which holds more than the views themselves. A file that only holds
define blocks leaves an empty template named after it, and every set carries
an unnamed root, so Make("app.tmpl") on a resources/views that only has
layouts/app.tmpl returned an empty string and no error at all.

Names are now collected while the sources are parsed, and only those can be
rendered. A file contributes each of its define blocks and, when it has text
of its own around them, its path within the source as well as its base name,
so a nested file without a define block is addressable the way Exists and the
route drivers address it. First asks whether a candidate can be rendered
rather than whether the file exists, so it no longer settles on one it cannot
render, and it keeps the error from invalid data instead of replacing it.

Files are parsed one at a time and their templates moved into the set
individually, so a package that takes a name it does not own loses that name
and not the rest of the file. This drops the regular expression the sources
were scanned with, which missed {{- define }} and let a package override
every define in a file but the first.

Copying the data of a map[string]any no longer goes through reflect, which
boxed every value: 12 allocations become 2 for a small map. Data returns a
copy, like the accessors next to it.
---
 contracts/view/view.go |  11 ++-
 errors/list.go         |   4 +-
 view/render.go         | 146 +++++++++++++++++++++++------
 view/template.go       |  51 +++++++++--
 view/template_test.go  | 203 ++++++++++++++++++++++++++++++++++++++++-
 view/view.go           |  11 ++-
 view/view_test.go      |   7 +-
 7 files changed, 389 insertions(+), 44 deletions(-)

diff --git a/contracts/view/view.go b/contracts/view/view.go
index 7a572a9b2..da70fb2ec 100644
--- a/contracts/view/view.go
+++ b/contracts/view/view.go
@@ -26,15 +26,15 @@ type View interface {
 	//	var views embed.FS
 	//
 	LoadViewsFromFS(fsys fs.FS, root string)
+	// Make returns a template for the view. The data may be a map with string keys or a struct;
+	// it is merged over the shared data when the template is rendered.
+	Make(view string, data ...any) Template
 	// RegisteredViews returns the absolute paths of all registered package view directories.
 	RegisteredViews() []string
 	// RegisteredViewFS returns all package view filesystems registered with LoadViewsFromFS,
 	// in registration order. Each returned filesystem is already rooted at the root passed to
 	// LoadViewsFromFS, so template paths are relative to it (for example "layouts/app.tmpl").
 	RegisteredViewFS() []fs.FS
-	// Make returns a template for the view. The data may be a map or a struct; it is merged
-	// over the shared data when the template is rendered.
-	Make(view string, data ...any) Template
 	// Share associates a key-value pair, where the key is a string and the value is of any type,
 	// with the current view context. This shared data can be accessed by other parts of the application.
 	Share(key string, value any)
@@ -45,8 +45,11 @@ type View interface {
 	GetShared() map[string]any
 }
 
+// Template is a view bound to its data, ready to be rendered. A template collects data as it
+// is built and is not safe for use from several goroutines at once; render it where it was
+// built, or build one per goroutine.
 type Template interface {
-	// Data returns the data passed to the template, without the shared data.
+	// Data returns a copy of the data passed to the template, without the shared data.
 	Data() map[string]any
 	// Name returns the name of the view.
 	Name() string
diff --git a/errors/list.go b/errors/list.go
index e511c6cd3..5395f4db9 100644
--- a/errors/list.go
+++ b/errors/list.go
@@ -373,8 +373,8 @@ var (
 
 	ViewFSRequired         = New("view filesystem is required")
 	ViewFSRootNotDirectory = New("view filesystem root %q is not a directory")
+	ViewInvalidData        = New("view %s data must be a map with string keys or a struct, got %T")
 	ViewInvalidFSRoot      = New("invalid view filesystem root %q: %v")
-	ViewTemplateNotExist   = New("view template %s does not exist")
-	ViewInvalidData        = New("view %s data must be a map or struct, got %T")
 	ViewNoneExist          = New("none of the views %v exist")
+	ViewTemplateNotExist   = New("view template %s does not exist")
 )
diff --git a/view/render.go b/view/render.go
index f2e9dbd12..0339098fc 100644
--- a/view/render.go
+++ b/view/render.go
@@ -5,23 +5,30 @@ import (
 	"io/fs"
 	"os"
 	stdpath "path"
-	"regexp"
 	"strings"
 	"sync/atomic"
+	"text/template/parse"
 
 	"github.com/goravel/framework/errors"
 	"github.com/goravel/framework/packages/paths"
 	"github.com/goravel/framework/support"
 )
 
-var defineRe = regexp.MustCompile(`\{\{\s*define\s+"([^"]+)"`)
+// bodyHolder is the name a file's text is parsed under while it is taken apart. Parsing it
+// under the file's own path would merge the text around the define blocks with a define block
+// carrying that same path, which is the convention these views follow.
+const bodyHolder = "\x00body"
 
 // compiled is the result of parsing every view source, including a failure, so a broken
 // view is not parsed again on every render.
 type compiled struct {
 	tmpl *template.Template
 	err  error
-	// sizes holds the last output size of each template, used to size the next buffer.
+	// sizes is keyed by the names a view can be rendered by and holds the last output size of
+	// each, used to size the next buffer. Those names are not every name html/template ends up
+	// associating with the set: a file that only holds define blocks also leaves an empty
+	// template behind, and every set carries an unnamed root. Rendering either returns an empty
+	// string, which must not pass for a view.
 	sizes map[string]*atomic.Int64
 }
 
@@ -47,6 +54,22 @@ func (r *View) render(name string, values map[string]any) (string, error) {
 	return buf.String(), nil
 }
 
+// renderable reports whether the view resolves to a template that can be rendered, which is
+// the question First has to ask: a file can exist without being addressable under its own
+// name, for example when it holds nothing but define blocks. When the sources cannot be
+// parsed it falls back to Exists, so Render reports the parse error rather than First
+// reporting that none of the views exist.
+func (r *View) renderable(view string) bool {
+	c := r.compile()
+	if c.err != nil {
+		return r.Exists(view)
+	}
+
+	_, ok := c.sizes[view]
+
+	return ok
+}
+
 // compile returns the parsed view sources, parsing them on first use. The result is kept
 // until a new source is registered.
 func (r *View) compile() *compiled {
@@ -62,11 +85,10 @@ func (r *View) compile() *compiled {
 	}
 
 	c := &compiled{sizes: make(map[string]*atomic.Int64)}
-	c.tmpl, c.err = r.parse()
-	if c.tmpl != nil {
-		for _, t := range c.tmpl.Templates() {
-			c.sizes[t.Name()] = &atomic.Int64{}
-		}
+	var names []string
+	c.tmpl, names, c.err = r.parse()
+	for _, name := range names {
+		c.sizes[name] = &atomic.Int64{}
 	}
 	r.compiled.Store(c)
 
@@ -80,11 +102,12 @@ func (r *View) resetCompiled() {
 	r.compiled.Store(nil)
 }
 
-// parse loads every source into one template set in precedence order: the application's
-// resources/views, then directories registered via LoadViewsFrom, then filesystems registered
-// via LoadViewsFromFS. The first source to define a template name wins. It returns nil when
-// no source contributes a template.
-func (r *View) parse() (*template.Template, error) {
+// sources returns every place templates are loaded from, in precedence order: the
+// application's resources/views, then directories registered via LoadViewsFrom, then
+// filesystems registered via LoadViewsFromFS. The first source to contribute a name owns it,
+// so a package can never replace a view the application, or a package registered before it,
+// already provides.
+func (r *View) sources() []fs.FS {
 	var sources []fs.FS
 	if dir := paths.Abs(support.Config.Paths.Resources, "views"); isDir(dir) {
 		sources = append(sources, os.DirFS(dir))
@@ -94,13 +117,49 @@ func (r *View) parse() (*template.Template, error) {
 			sources = append(sources, os.DirFS(dir))
 		}
 	}
-	sources = append(sources, r.RegisteredViewFS()...)
 
+	return append(sources, r.RegisteredViewFS()...)
+}
+
+// parse loads every source into one template set and returns the names the set can be
+// rendered by. A file contributes each of its define blocks, and, when it has text of its own
+// around them, its path within the source plus, for a nested file, its base name, which is
+// what html/template.ParseFS and the route drivers address it by. Names are owned per source:
+// views in one directory override each other the way html/template behaves on its own, while
+// a later source is only used for the names no earlier source contributed. It returns a nil
+// template when no source contributes one.
+func (r *View) parse() (*template.Template, []string, error) {
 	tmpl := template.New("")
-	defined := make(map[string]bool)
+	owned := make(map[string]bool)
+	var names []string
 	loaded := false
 
-	for _, source := range sources {
+	for _, source := range r.sources() {
+		contributed := make(map[string]bool)
+
+		// claim moves one template into the set unless an earlier source owns the name. An alias
+		// only ever fills a free name: it is a second way to address a file, never a view in its
+		// own right, so it must not displace one.
+		claim := func(name string, tree *parse.Tree, alias bool) error {
+			if owned[name] || (alias && contributed[name]) {
+				return nil
+			}
+
+			// AddParseTree keeps an existing body rather than letting an empty one replace it, so
+			// a layout's {{ block }} placeholder cannot wipe the page that fills it, whichever of
+			// the two is walked first.
+			tree.Name = name
+			if _, err := tmpl.AddParseTree(name, tree); err != nil {
+				return err
+			}
+			if !contributed[name] {
+				contributed[name] = true
+				names = append(names, name)
+			}
+
+			return nil
+		}
+
 		err := fs.WalkDir(source, ".", func(name string, d fs.DirEntry, err error) error {
 			if err != nil || d.IsDir() {
 				return err
@@ -112,33 +171,66 @@ func (r *View) parse() (*template.Template, error) {
 			}
 			text := string(content)
 
-			// A file without a define block is addressed by its base name, the name it is parsed as.
-			templateName := stdpath.Base(name)
-			if matches := defineRe.FindStringSubmatch(text); len(matches) > 1 {
-				templateName = matches[1]
+			// The file is parsed on its own and its templates are moved into the set one at a
+			// time. Parsing it straight into the set would apply all of its define blocks at once,
+			// letting a package take a name it does not own because another name in the same file
+			// happened to be free.
+			file, err := template.New(bodyHolder).Parse(text)
+			if err != nil {
+				return parseError(name, text, err)
 			}
-			if defined[templateName] {
+			loaded = true
+
+			for _, sub := range file.Templates() {
+				if sub.Name() == bodyHolder || sub.Tree == nil {
+					continue
+				}
+				// Report positions against the file rather than the name it was parsed under.
+				sub.Tree.ParseName = name
+				if err := claim(sub.Name(), sub.Tree, false); err != nil {
+					return err
+				}
+			}
+
+			body := file.Lookup(bodyHolder)
+			if body == nil || body.Tree == nil || parse.IsEmptyTree(body.Tree.Root) {
 				return nil
 			}
-			defined[templateName] = true
+			body.Tree.ParseName = name
 
-			if _, err := tmpl.New(stdpath.Base(name)).Parse(text); err != nil {
+			if err := claim(name, body.Tree, false); err != nil {
 				return err
 			}
-			loaded = true
+			if base := stdpath.Base(name); base != name {
+				return claim(base, body.Tree.Copy(), true)
+			}
 
 			return nil
 		})
 		if err != nil {
-			return nil, err
+			return nil, nil, err
+		}
+
+		for name := range contributed {
+			owned[name] = true
 		}
 	}
 
 	if !loaded {
-		return nil, nil
+		return nil, nil, nil
+	}
+
+	return tmpl, names, nil
+}
+
+// parseError reports a parse failure under the file's path, which is not the name the text was
+// parsed under and so not the name the failure would otherwise carry.
+func parseError(name, text string, err error) error {
+	if _, named := template.New(name).Parse(text); named != nil {
+		return named
 	}
 
-	return tmpl, nil
+	return err
 }
 
 func isDir(p string) bool {
diff --git a/view/template.go b/view/template.go
index a7b0cd442..0f433d5da 100644
--- a/view/template.go
+++ b/view/template.go
@@ -7,6 +7,10 @@ import (
 	"github.com/goravel/framework/errors"
 )
 
+var _ contractsview.Template = (*Template)(nil)
+
+// Template is a view bound to its data. Data that cannot be rendered, and a First that matched
+// nothing, are reported by Render rather than when the template is built.
 type Template struct {
 	view *View
 	name string
@@ -14,6 +18,8 @@ type Template struct {
 	err  error
 }
 
+// NewTemplate binds a view to its data. The data may be a map with string keys or a struct,
+// and is copied, so later changes to the caller's value are not picked up.
 func NewTemplate(view *View, name string, data ...any) *Template {
 	values, err := toMap(name, data...)
 
@@ -26,7 +32,12 @@ func NewTemplate(view *View, name string, data ...any) *Template {
 }
 
 func (r *Template) Data() map[string]any {
-	return r.data
+	data := make(map[string]any, len(r.data))
+	for key, value := range r.data {
+		data[key] = value
+	}
+
+	return data
 }
 
 func (r *Template) Name() string {
@@ -58,15 +69,37 @@ func (r *Template) With(key string, value any) contractsview.Template {
 
 // toMap copies the given map or struct into a new map, leaving the caller's data untouched.
 func toMap(view string, data ...any) (map[string]any, error) {
-	values := make(map[string]any)
 	if len(data) == 0 || data[0] == nil {
+		return make(map[string]any), nil
+	}
+
+	// The map the templates already want is copied directly: reflect boxes every value it
+	// reads back, which for this type costs an allocation per entry and buys nothing.
+	switch typed := data[0].(type) {
+	case map[string]any:
+		values := make(map[string]any, len(typed))
+		for key, value := range typed {
+			values[key] = value
+		}
+
+		return values, nil
+	case *map[string]any:
+		if typed == nil {
+			return make(map[string]any), nil
+		}
+
+		values := make(map[string]any, len(*typed))
+		for key, value := range *typed {
+			values[key] = value
+		}
+
 		return values, nil
 	}
 
 	value := reflect.ValueOf(data[0])
 	if value.Kind() == reflect.Pointer {
 		if value.IsNil() {
-			return values, nil
+			return make(map[string]any), nil
 		}
 		value = value.Elem()
 	}
@@ -74,13 +107,17 @@ func toMap(view string, data ...any) (map[string]any, error) {
 	switch value.Kind() {
 	case reflect.Map:
 		if value.Type().Key().Kind() != reflect.String {
-			return values, errors.ViewInvalidData.Args(view, data[0])
+			return make(map[string]any), errors.ViewInvalidData.Args(view, data[0])
 		}
+		values := make(map[string]any, value.Len())
 		iter := value.MapRange()
 		for iter.Next() {
 			values[iter.Key().String()] = iter.Value().Interface()
 		}
+
+		return values, nil
 	case reflect.Struct:
+		values := make(map[string]any, value.NumField())
 		for i := 0; i < value.NumField(); i++ {
 			field := value.Type().Field(i)
 			if !field.IsExported() {
@@ -99,9 +136,9 @@ func toMap(view string, data ...any) (map[string]any, error) {
 				values[field.Name] = fieldValue.Interface()
 			}
 		}
+
+		return values, nil
 	default:
-		return values, errors.ViewInvalidData.Args(view, data[0])
+		return make(map[string]any), errors.ViewInvalidData.Args(view, data[0])
 	}
-
-	return values, nil
 }
diff --git a/view/template_test.go b/view/template_test.go
index 74de98a4b..a3622dcdb 100644
--- a/view/template_test.go
+++ b/view/template_test.go
@@ -1,6 +1,7 @@
 package view
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -118,7 +119,7 @@ func TestTemplateRender_ParseError(t *testing.T) {
 	})
 
 	_, err := NewView().Make("broken.tmpl").Render()
-	assert.Error(t, err)
+	assert.ErrorContains(t, err, "broken.tmpl")
 }
 
 func TestTemplateRender_PointerFields(t *testing.T) {
@@ -215,6 +216,41 @@ func TestTemplateRender_Concurrent(t *testing.T) {
 	wg.Wait()
 }
 
+func TestTemplateRender_ConcurrentWithRegistration(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		"greeting.tmpl": `{{ define "greeting.tmpl" }}Hello, {{ .Name }}{{ end }}`,
+	})
+
+	view := NewView()
+
+	var wg sync.WaitGroup
+	for i := 0; i < 20; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			html, err := view.Make("greeting.tmpl", map[string]any{"Name": "Goravel"}).Render()
+			assert.NoError(t, err)
+			assert.Equal(t, "Hello, Goravel", html)
+		}()
+	}
+
+	// Registering a source drops the compiled set, which the renders above are reading.
+	for i := 0; i < 5; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			view.LoadViewsFromFS(fstest.MapFS{
+				fmt.Sprintf("views/pkg%d.tmpl", i): {Data: []byte(`package`)},
+			}, "views")
+		}(i)
+	}
+	wg.Wait()
+
+	html, err := view.Make("greeting.tmpl", map[string]any{"Name": "Goravel"}).Render()
+	require.NoError(t, err)
+	assert.Equal(t, "Hello, Goravel", html)
+}
+
 func TestTemplateWith(t *testing.T) {
 	setupAppViews(t, map[string]string{
 		"greeting.tmpl": `{{ define "greeting.tmpl" }}{{ .Greeting }}, {{ .Name }}{{ end }}`,
@@ -265,6 +301,171 @@ func TestFirst(t *testing.T) {
 	assert.ErrorIs(t, err, errors.ViewNoneExist)
 }
 
+func TestTemplateRender_DefineOnlyFileIsNotAView(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		"layouts/app.tmpl": `{{ define "layouts/app.tmpl" }}<html>{{ .Title }}</html>{{ end }}`,
+	})
+
+	view := NewView()
+
+	html, err := view.Make("layouts/app.tmpl", map[string]any{"Title": "Home"}).Render()
+	require.NoError(t, err)
+	assert.Equal(t, "<html>Home</html>", html)
+
+	// The file is parsed under its base name too, which leaves an empty template behind, and
+	// every template set carries an unnamed root. Neither is a view.
+	for _, name := range []string{"app.tmpl", ""} {
+		html, err = view.Make(name).Render()
+		assert.ErrorIs(t, err, errors.ViewTemplateNotExist, name)
+		assert.Empty(t, html)
+	}
+}
+
+func TestTemplateRender_NestedFileWithoutDefine(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		"pages/raw.tmpl": `raw {{ .Name }}`,
+	})
+
+	view := NewView()
+	data := map[string]any{"Name": "Goravel"}
+
+	// The path is what Exists answers for, the base name is what the route drivers address it
+	// by, and both have to render.
+	require.True(t, view.Exists("pages/raw.tmpl"))
+	for _, name := range []string{"pages/raw.tmpl", "raw.tmpl"} {
+		html, err := view.Make(name, data).Render()
+		require.NoError(t, err, name)
+		assert.Equal(t, "raw Goravel", html)
+	}
+}
+
+func TestTemplateRender_PackageDoesNotOverrideApplication(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		// The trim marker keeps the define out of the rendered output; it still names a template.
+		"primary.tmpl": `{{- define "primary.tmpl" -}}app primary{{- end -}}
+{{- define "shared.tmpl" -}}app shared{{- end -}}`,
+	})
+
+	pkg := fstest.MapFS{
+		"views/other.tmpl": {Data: []byte(`{{ define "other.tmpl" }}package other{{ end }}` +
+			`{{ define "shared.tmpl" }}package shared{{ end }}`)},
+	}
+
+	view := NewView()
+	view.LoadViewsFromFS(pkg, "views")
+
+	tests := map[string]string{
+		"primary.tmpl": "app primary",
+		"shared.tmpl":  "app shared",
+		// A name the application owns costs the package that name, not the rest of the file.
+		"other.tmpl": "package other",
+	}
+	for name, expect := range tests {
+		html, err := view.Make(name).Render()
+		require.NoError(t, err, name)
+		assert.Equal(t, expect, html, name)
+	}
+}
+
+func TestFirst_SkipsViewThatCannotRender(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		// The file exists under this path but names its template something else, so it is not
+		// addressable as "partials/menu.tmpl" and First has to carry on to the next candidate.
+		"partials/menu.tmpl": `{{ define "nav.tmpl" }}nav{{ end }}`,
+		"fallback.tmpl":      `{{ define "fallback.tmpl" }}fallback{{ end }}`,
+	})
+
+	view := NewView()
+	require.True(t, view.Exists("partials/menu.tmpl"))
+
+	template := view.First([]string{"partials/menu.tmpl", "fallback.tmpl"})
+	assert.Equal(t, "fallback.tmpl", template.Name())
+
+	html, err := template.Render()
+	require.NoError(t, err)
+	assert.Equal(t, "fallback", html)
+}
+
+func TestFirst_ReportsInvalidDataBeforeMissingViews(t *testing.T) {
+	setupAppViews(t, map[string]string{"admin.tmpl": `{{ define "admin.tmpl" }}admin{{ end }}`})
+
+	view := NewView()
+
+	_, err := view.First([]string{"missing.tmpl"}, map[int]string{1: "one"}).Render()
+	assert.ErrorIs(t, err, errors.ViewInvalidData)
+
+	_, err = view.First(nil).Render()
+	assert.ErrorIs(t, err, errors.ViewNoneExist)
+
+	// A template that matched nothing still collects data; it just cannot be rendered.
+	template := view.First([]string{"missing.tmpl"}).With("Name", "Goravel")
+	assert.Equal(t, map[string]any{"Name": "Goravel"}, template.Data())
+	_, err = template.Render()
+	assert.ErrorIs(t, err, errors.ViewNoneExist)
+}
+
+func TestTemplateData_IsACopy(t *testing.T) {
+	setupAppViews(t, map[string]string{"greet.tmpl": `{{ define "greet.tmpl" }}{{ .Name }}{{ end }}`})
+
+	view := NewView()
+	template := view.Make("greet.tmpl", map[string]any{"Name": "Goravel"})
+
+	data := template.Data()
+	data["Name"] = "changed"
+
+	assert.Equal(t, "Goravel", template.Data()["Name"])
+	html, err := template.Render()
+	require.NoError(t, err)
+	assert.Equal(t, "Goravel", html)
+}
+
+func TestTemplateRender_BlockPlaceholderDoesNotWinOverPage(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		// The page is walked first, so the layout's empty {{ block }} must not replace the
+		// content the page just filled in.
+		"page.tmpl":    `{{ define "page.tmpl" }}{{ template "zlayout.tmpl" . }}{{ end }}{{ define "content" }}page{{ end }}`,
+		"zlayout.tmpl": `{{ define "zlayout.tmpl" }}[{{ block "content" . }}{{ end }}]{{ end }}`,
+	})
+
+	html, err := NewView().Make("page.tmpl").Render()
+	require.NoError(t, err)
+	assert.Equal(t, "[page]", html)
+}
+
+func TestFirst_FallsBackToExistsWhenSourcesAreBroken(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		"broken.tmpl": `{{ define "broken.tmpl" }}{{ .Name }`,
+		"good.tmpl":   `{{ define "good.tmpl" }}good{{ end }}`,
+	})
+
+	// Nothing compiles, so First cannot tell which views are renderable. It has to pick the
+	// candidate that exists and let Render report the parse error, rather than claiming that
+	// none of the views exist.
+	_, err := NewView().First([]string{"good.tmpl"}).Render()
+	assert.ErrorContains(t, err, "broken.tmpl")
+}
+
+func TestTemplateRender_MapPointerData(t *testing.T) {
+	setupAppViews(t, map[string]string{"greet.tmpl": `{{ define "greet.tmpl" }}[{{ .Name }}]{{ end }}`})
+
+	view := NewView()
+
+	data := map[string]any{"Name": "Goravel"}
+	html, err := view.Make("greet.tmpl", &data).Render()
+	require.NoError(t, err)
+	assert.Equal(t, "[Goravel]", html)
+
+	// The copy is taken when the template is built, so a later change is not picked up.
+	data["Name"] = "changed"
+	html, err = view.Make("greet.tmpl", &data).With("Name", "With").Render()
+	require.NoError(t, err)
+	assert.Equal(t, "[With]", html)
+
+	html, err = view.Make("greet.tmpl", (*map[string]any)(nil)).Render()
+	require.NoError(t, err)
+	assert.Equal(t, "[]", html)
+}
+
 func BenchmarkTemplateRender(b *testing.B) {
 	var page strings.Builder
 	page.WriteString(`{{ define "page.tmpl" }}<html><body><h1>{{ .Title }}</h1><ul>`)
diff --git a/view/view.go b/view/view.go
index 31071bb91..aaa538efd 100644
--- a/view/view.go
+++ b/view/view.go
@@ -14,6 +14,8 @@ import (
 	"github.com/goravel/framework/support"
 )
 
+var _ contractsview.View = (*View)(nil)
+
 type View struct {
 	mu          sync.RWMutex
 	paths       []string
@@ -59,13 +61,18 @@ func (r *View) Exists(view string) bool {
 
 func (r *View) First(views []string, data ...any) contractsview.Template {
 	for _, view := range views {
-		if r.Exists(view) {
+		// Exists answers for the file, which is not the same question: a file that only holds
+		// define blocks exists without being addressable under its own name. Picking a candidate
+		// that cannot be rendered would stop First from falling through to the next one.
+		if r.renderable(view) {
 			return r.Make(view, data...)
 		}
 	}
 
 	template := NewTemplate(r, "", data...)
-	template.err = errors.ViewNoneExist.Args(views)
+	if template.err == nil {
+		template.err = errors.ViewNoneExist.Args(views)
+	}
 
 	return template
 }
diff --git a/view/view_test.go b/view/view_test.go
index ce95c5ecd..db06c0e4c 100644
--- a/view/view_test.go
+++ b/view/view_test.go
@@ -7,6 +7,7 @@ import (
 	"io/fs"
 	"os"
 	"path/filepath"
+	"regexp"
 	"testing"
 	"testing/fstest"
 
@@ -287,6 +288,10 @@ func setupAppViews(t testing.TB, files map[string]string) string {
 	return dir
 }
 
+// driverDefineRe mirrors the regular expression the route drivers scan views with. It is kept
+// here, rather than shared with the package, so parseAll stays an independent reference.
+var driverDefineRe = regexp.MustCompile(`\{\{\s*define\s+"([^"]+)"`)
+
 // parseAll mirrors a route driver: it parses every source into one template set, in precedence
 // order, skipping any file whose define name was already claimed by an earlier source.
 func parseAll(t *testing.T, appDir string, view *View) *template.Template {
@@ -313,7 +318,7 @@ func parseAll(t *testing.T, appDir string, view *View) *template.Template {
 				return err
 			}
 
-			name := defineRe.FindStringSubmatch(string(content))
+			name := driverDefineRe.FindStringSubmatch(string(content))
 			if len(name) > 1 {
 				if seen[name[1]] {
 					return nil

From 9c8e1e773f70922c82609c29a20de7c85f02b526 Mon Sep 17 00:00:00 2001
From: darakanoit <dara.kamaliev@gmail.com>
Date: Mon, 28 Sep 2026 04:12:49 +0500
Subject: [PATCH 5/5] fix: [#773] keep empty templates out of the renderable
 names

An empty define or a bare {{ block }} placeholder no longer counts as a
view, so Make reports it as missing and First falls through to the next
candidate. The name becomes renderable once a body for it is parsed,
whichever of the two is walked first.

When the sources fail to parse, First picks the first candidate so Render
reports the parse error, including for a candidate given by its base name.
A First that matched nothing names its candidates in a data error.
---
 contracts/view/view.go |  6 +++--
 view/render.go         | 33 +++++++++++++----------
 view/template.go       |  9 ++++---
 view/template_test.go  | 59 ++++++++++++++++++++++++++++++++++++++----
 view/view.go           | 13 +++++++---
 view/view_test.go      |  1 +
 6 files changed, 94 insertions(+), 27 deletions(-)

diff --git a/contracts/view/view.go b/contracts/view/view.go
index da70fb2ec..ba904b98d 100644
--- a/contracts/view/view.go
+++ b/contracts/view/view.go
@@ -5,8 +5,10 @@ import "io/fs"
 type View interface {
 	// Exists checks if a view with the specified name exists.
 	Exists(view string) bool
-	// First returns a template for the first view in the list that exists. If none of them
-	// exist, rendering the returned template fails.
+	// First returns a template for the first view in the list that can be rendered, which is
+	// not always a view that Exists: a file holding only define blocks under other names exists
+	// but cannot be rendered by its path. If none of them can be rendered, rendering the
+	// returned template fails.
 	First(views []string, data ...any) Template
 	// LoadViewsFrom registers a package view directory for template fallback.
 	// Templates from registered directories are loaded after app views; if a
diff --git a/view/render.go b/view/render.go
index 0339098fc..f6b9ada1e 100644
--- a/view/render.go
+++ b/view/render.go
@@ -4,7 +4,7 @@ import (
 	"html/template"
 	"io/fs"
 	"os"
-	stdpath "path"
+	"path"
 	"strings"
 	"sync/atomic"
 	"text/template/parse"
@@ -57,12 +57,12 @@ func (r *View) render(name string, values map[string]any) (string, error) {
 // renderable reports whether the view resolves to a template that can be rendered, which is
 // the question First has to ask: a file can exist without being addressable under its own
 // name, for example when it holds nothing but define blocks. When the sources cannot be
-// parsed it falls back to Exists, so Render reports the parse error rather than First
-// reporting that none of the views exist.
+// parsed there is no telling which names resolve, so every view counts as renderable and
+// Render reports the parse error rather than First reporting that none of the views exist.
 func (r *View) renderable(view string) bool {
 	c := r.compile()
 	if c.err != nil {
-		return r.Exists(view)
+		return true
 	}
 
 	_, ok := c.sizes[view]
@@ -122,15 +122,16 @@ func (r *View) sources() []fs.FS {
 }
 
 // parse loads every source into one template set and returns the names the set can be
-// rendered by. A file contributes each of its define blocks, and, when it has text of its own
-// around them, its path within the source plus, for a nested file, its base name, which is
-// what html/template.ParseFS and the route drivers address it by. Names are owned per source:
-// views in one directory override each other the way html/template behaves on its own, while
-// a later source is only used for the names no earlier source contributed. It returns a nil
-// template when no source contributes one.
+// rendered by. A file contributes each of its non-empty define blocks, and, when it has text
+// of its own around them, its path within the source plus, for a nested file, its base name,
+// which is what html/template.ParseFS and the route drivers address it by. Names are owned per
+// source: views in one directory override each other the way html/template behaves on its
+// own, while a later source is only used for the names no earlier source contributed. It
+// returns a nil template when no source contributes one.
 func (r *View) parse() (*template.Template, []string, error) {
 	tmpl := template.New("")
 	owned := make(map[string]bool)
+	renderable := make(map[string]bool)
 	var names []string
 	loaded := false
 
@@ -152,8 +153,14 @@ func (r *View) parse() (*template.Template, []string, error) {
 			if _, err := tmpl.AddParseTree(name, tree); err != nil {
 				return err
 			}
-			if !contributed[name] {
-				contributed[name] = true
+			contributed[name] = true
+
+			// An empty tree stays in the set, so {{ template }} and {{ block }} references to it
+			// resolve, but it is not a view: rendering it returns an empty string, which must
+			// not pass for a page. The name becomes renderable once a body for it turns up,
+			// whichever of the two is walked first.
+			if !renderable[name] && !parse.IsEmptyTree(tree.Root) {
+				renderable[name] = true
 				names = append(names, name)
 			}
 
@@ -201,7 +208,7 @@ func (r *View) parse() (*template.Template, []string, error) {
 			if err := claim(name, body.Tree, false); err != nil {
 				return err
 			}
-			if base := stdpath.Base(name); base != name {
+			if base := path.Base(name); base != name {
 				return claim(base, body.Tree.Copy(), true)
 			}
 
diff --git a/view/template.go b/view/template.go
index 0f433d5da..893737736 100644
--- a/view/template.go
+++ b/view/template.go
@@ -18,8 +18,10 @@ type Template struct {
 	err  error
 }
 
-// NewTemplate binds a view to its data. The data may be a map with string keys or a struct,
-// and is copied, so later changes to the caller's value are not picked up.
+// NewTemplate binds a view to its data. The data may be a map with string keys or a struct.
+// It is copied at the top level only: replacing a key in the caller's map is not picked up,
+// but nested maps, slices and pointers are still shared with the caller and must not be
+// changed while the template is in use.
 func NewTemplate(view *View, name string, data ...any) *Template {
 	values, err := toMap(name, data...)
 
@@ -67,7 +69,8 @@ func (r *Template) With(key string, value any) contractsview.Template {
 	return r
 }
 
-// toMap copies the given map or struct into a new map, leaving the caller's data untouched.
+// toMap copies the top level of the given map or struct into a new map, leaving the caller's
+// map untouched.
 func toMap(view string, data ...any) (map[string]any, error) {
 	if len(data) == 0 || data[0] == nil {
 		return make(map[string]any), nil
diff --git a/view/template_test.go b/view/template_test.go
index a3622dcdb..6961378e9 100644
--- a/view/template_test.go
+++ b/view/template_test.go
@@ -120,6 +120,7 @@ func TestTemplateRender_ParseError(t *testing.T) {
 
 	_, err := NewView().Make("broken.tmpl").Render()
 	assert.ErrorContains(t, err, "broken.tmpl")
+	assert.NotErrorIs(t, err, errors.ViewTemplateNotExist)
 }
 
 func TestTemplateRender_PointerFields(t *testing.T) {
@@ -394,6 +395,9 @@ func TestFirst_ReportsInvalidDataBeforeMissingViews(t *testing.T) {
 	_, err := view.First([]string{"missing.tmpl"}, map[int]string{1: "one"}).Render()
 	assert.ErrorIs(t, err, errors.ViewInvalidData)
 
+	// The template has no name, so the error names the candidates instead.
+	assert.ErrorContains(t, err, "[missing.tmpl]")
+
 	_, err = view.First(nil).Render()
 	assert.ErrorIs(t, err, errors.ViewNoneExist)
 
@@ -432,19 +436,63 @@ func TestTemplateRender_BlockPlaceholderDoesNotWinOverPage(t *testing.T) {
 	assert.Equal(t, "[page]", html)
 }
 
+func TestTemplateRender_EmptyTemplateIsNotAView(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		"empty.tmpl": `{{ define "empty.name" }}{{ end }}`,
+		// The layout is walked before the page here, so the empty block placeholder is claimed
+		// first and the page's content has to make the name renderable afterwards.
+		"a_layout.tmpl": `{{ define "a_layout.tmpl" }}[{{ block "content" . }}{{ end }}|{{ block "aside" . }}{{ end }}]{{ end }}`,
+		"b_page.tmpl":   `{{ define "b_page.tmpl" }}{{ template "a_layout.tmpl" . }}{{ end }}{{ define "content" }}page{{ end }}`,
+		"fallback.tmpl": `{{ define "fallback.tmpl" }}fallback{{ end }}`,
+	})
+
+	view := NewView()
+
+	for _, name := range []string{"empty.name", "aside"} {
+		html, err := view.Make(name).Render()
+		assert.ErrorIs(t, err, errors.ViewTemplateNotExist, name)
+		assert.Empty(t, html)
+	}
+
+	// Empty templates stay in the set, so a layout still resolves its placeholders.
+	html, err := view.Make("b_page.tmpl").Render()
+	require.NoError(t, err)
+	assert.Equal(t, "[page|]", html)
+
+	html, err = view.Make("content").Render()
+	require.NoError(t, err)
+	assert.Equal(t, "page", html)
+
+	template := view.First([]string{"empty.name", "aside", "fallback.tmpl"})
+	assert.Equal(t, "fallback.tmpl", template.Name())
+}
+
 func TestFirst_FallsBackToExistsWhenSourcesAreBroken(t *testing.T) {
 	setupAppViews(t, map[string]string{
 		"broken.tmpl": `{{ define "broken.tmpl" }}{{ .Name }`,
 		"good.tmpl":   `{{ define "good.tmpl" }}good{{ end }}`,
 	})
 
-	// Nothing compiles, so First cannot tell which views are renderable. It has to pick the
-	// candidate that exists and let Render report the parse error, rather than claiming that
-	// none of the views exist.
+	// Nothing compiles, so First cannot tell which views are renderable. It has to pick a
+	// candidate and let Render report the parse error, rather than claiming that none of the
+	// views exist.
 	_, err := NewView().First([]string{"good.tmpl"}).Render()
 	assert.ErrorContains(t, err, "broken.tmpl")
 }
 
+func TestFirst_BaseNameCandidateWhenSourcesAreBroken(t *testing.T) {
+	setupAppViews(t, map[string]string{
+		"broken.tmpl":    `{{ define "broken.tmpl" }}{{ .Name }`,
+		"pages/raw.tmpl": `raw`,
+	})
+
+	// raw.tmpl is only a base name, which Exists does not answer for. The parse error is still
+	// what the caller needs to see.
+	_, err := NewView().First([]string{"raw.tmpl"}).Render()
+	assert.ErrorContains(t, err, "broken.tmpl")
+	assert.NotErrorIs(t, err, errors.ViewNoneExist)
+}
+
 func TestTemplateRender_MapPointerData(t *testing.T) {
 	setupAppViews(t, map[string]string{"greet.tmpl": `{{ define "greet.tmpl" }}[{{ .Name }}]{{ end }}`})
 
@@ -456,10 +504,11 @@ func TestTemplateRender_MapPointerData(t *testing.T) {
 	assert.Equal(t, "[Goravel]", html)
 
 	// The copy is taken when the template is built, so a later change is not picked up.
+	template := view.Make("greet.tmpl", &data)
 	data["Name"] = "changed"
-	html, err = view.Make("greet.tmpl", &data).With("Name", "With").Render()
+	html, err = template.Render()
 	require.NoError(t, err)
-	assert.Equal(t, "[With]", html)
+	assert.Equal(t, "[Goravel]", html)
 
 	html, err = view.Make("greet.tmpl", (*map[string]any)(nil)).Render()
 	require.NoError(t, err)
diff --git a/view/view.go b/view/view.go
index aaa538efd..33ec8b0b6 100644
--- a/view/view.go
+++ b/view/view.go
@@ -1,6 +1,7 @@
 package view
 
 import (
+	"fmt"
 	"io/fs"
 	"os"
 	"path"
@@ -59,6 +60,7 @@ func (r *View) Exists(view string) bool {
 	return false
 }
 
+// First returns a template for the first view in the list that can be rendered.
 func (r *View) First(views []string, data ...any) contractsview.Template {
 	for _, view := range views {
 		// Exists answers for the file, which is not the same question: a file that only holds
@@ -69,12 +71,14 @@ func (r *View) First(views []string, data ...any) contractsview.Template {
 		}
 	}
 
-	template := NewTemplate(r, "", data...)
-	if template.err == nil {
-		template.err = errors.ViewNoneExist.Args(views)
+	// Nothing matched, so the template has no name, but a data error still names the views it
+	// was meant for.
+	values, err := toMap(fmt.Sprint(views), data...)
+	if err == nil {
+		err = errors.ViewNoneExist.Args(views)
 	}
 
-	return template
+	return &Template{view: r, data: values, err: err}
 }
 
 func (r *View) LoadViewsFrom(path string) {
@@ -116,6 +120,7 @@ func (r *View) LoadViewsFromFS(fsys fs.FS, root string) {
 	r.resetCompiled()
 }
 
+// Make returns a template for the view, bound to the given data.
 func (r *View) Make(view string, data ...any) contractsview.Template {
 	return NewTemplate(r, view, data...)
 }
diff --git a/view/view_test.go b/view/view_test.go
index db06c0e4c..6838dc741 100644
--- a/view/view_test.go
+++ b/view/view_test.go
@@ -265,6 +265,7 @@ func TestResolveTemplates(t *testing.T) {
 }
 
 // setupAppViews points the application resources path at a temp dir and writes the given views into it.
+// It changes package-wide globals, so tests that call it must not run in parallel.
 func setupAppViews(t testing.TB, files map[string]string) string {
 	t.Helper()