fix(deep-gen): stop emitting imports of internal/engine in generated code

cmd/deep-gen/main.go

@@ -487,7 +487,6 @@ import (
 {{- end}}
 {{- if .NeedsDeep}}
 	deep "github.com/brunoga/deep/v5"
-	_deepengine "github.com/brunoga/deep/v5/internal/engine"
 {{- end}}
 {{- if .NeedsCrdt}}
 	crdt "github.com/brunoga/deep/v5/crdt"
@@ -515,7 +514,7 @@ func (t *{{.TypeName}}) Patch(p {{.P}}Patch[{{.TypeName}}], logger *slog.Logger)
 		if err != nil {
 			errs = append(errs, err)
 		} else if !handled {
-			if err := _deepengine.ApplyOpReflection(t, op, logger); err != nil {
+			if err := {{.P}}ApplyOpReflection(t, op, logger); err != nil {
 				errs = append(errs, err)
 			}
 		}

cmd/deep-gen/main_test.go

@@ -1,9 +1,12 @@
 package main
 
 import (
+	"go/parser"
+	"go/token"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"testing"
 )
@@ -43,3 +46,44 @@ func TestGeneratorOutput(t *testing.T) {
 		t.Errorf("generator output does not match golden file\nwant:\n%s\n\ngot:\n%s", goldenStr, gotStr)
 	}
 }
+
+// TestGeneratedCodeHasNoInternalImports asserts that code emitted by deep-gen
+// never imports an internal/... package of this module. Such imports compile
+// inside the module but break for any downstream user — see the bug fixed by
+// exposing deep.ApplyOpReflection as a public wrapper around the engine's
+// reflection fallback.
+func TestGeneratedCodeHasNoInternalImports(t *testing.T) {
+	tmpDir := t.TempDir()
+	genBin := filepath.Join(tmpDir, "deep-gen")
+	if out, err := exec.Command("go", "build", "-o", genBin, ".").CombinedOutput(); err != nil {
+		t.Fatalf("build deep-gen: %v\n%s", err, out)
+	}
+
+	// internal/testmodels is rich enough to exercise the reflection fallback
+	// (which is what previously dragged the internal/engine import in).
+	outFile := filepath.Join(tmpDir, "user_deep.go")
+	if out, err := exec.Command(genBin, "-type=User,Detail", "-output", outFile, "../../internal/testmodels").CombinedOutput(); err != nil {
+		t.Fatalf("run deep-gen: %v\n%s", err, out)
+	}
+
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, outFile, nil, parser.ImportsOnly)
+	if err != nil {
+		t.Fatalf("parse generated file: %v", err)
+	}
+
+	const modulePrefix = "github.com/brunoga/deep/v5/"
+	for _, imp := range file.Imports {
+		path, err := strconv.Unquote(imp.Path.Value)
+		if err != nil {
+			t.Fatalf("unquote import %q: %v", imp.Path.Value, err)
+		}
+		if !strings.HasPrefix(path, modulePrefix) {
+			continue
+		}
+		rel := strings.TrimPrefix(path, modulePrefix)
+		if rel == "internal" || strings.HasPrefix(rel, "internal/") || strings.Contains(rel, "/internal/") {
+			t.Errorf("generated code imports internal package %q; expose a public wrapper instead", path)
+		}
+	}
+}

engine.go

@@ -31,6 +31,16 @@ func WithLogger(l *slog.Logger) ApplyOption {
 	return func(c *applyConfig) { c.logger = l }
 }
 
+// ApplyOpReflection applies a single Operation to target using reflection.
+//
+// This is intended for use by code generated by deep-gen as a fallback for
+// operations the generated fast-path does not handle (e.g. slice index or map
+// key paths). It is not part of the stable user-facing API; prefer [Apply]
+// for normal use.
+func ApplyOpReflection[T any](target *T, op Operation, logger *slog.Logger) error {
+	return engine.ApplyOpReflection(target, op, logger)
+}
+
 // Apply applies a Patch to a target pointer.
 // v5 prioritizes the generated Patch method but falls back to reflection if needed.
 //