Try it: scene keys in the hint, J label on Health and Hurtbox, faster Respawn, sound starts with the Try click; lighter web audio pump; release notes from tools/release/notes

.dockerignore

@@ -5,3 +5,4 @@ site
 exports
 **/.aego
 *.test
+.claude

.github/workflows/ci.yml

@@ -3,6 +3,7 @@ name: ci
 on:
   push:
     branches: [master]
+    tags: ["v*"]
   pull_request:
 
 permissions:
@@ -36,6 +37,10 @@ jobs:
       - run: go vet ./platform/sdl
       - run: make lint
       - run: make depcheck
+      - name: packaging tools
+        run: sudo apt-get install -y nsis squashfs-tools
+      - name: installer dry run
+        run: make nsis-check
 
   build:
     strategy:
@@ -111,4 +116,39 @@ jobs:
       - name: example project
         run: |
           /tmp/aego check examples/native-rotator
-          /tmp/aego run examples/native-rotator --headless --frames 60
+          /tmp/aego run examples/native-rotator --headless --frames 60
+
+  release:
+    needs: [checks, build]
+    if: github.event_name == 'push'
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: write
+    env:
+      CGO_ENABLED: "1"
+      GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      GITEA_API: ${{ github.server_url }}/api/v1/repos/${{ github.repository }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+      - name: linux packages
+        run: sudo apt-get update && sudo apt-get install -y $LINUX_PKGS
+      - uses: actions/cache@v4
+        continue-on-error: true
+        with:
+          path: .cache/native
+          key: native-linux_amd64-${{ hashFiles('third_party/sdl/version.txt', 'tools/bootstrap-native.sh') }}
+      - run: bash tools/bootstrap-native.sh
+      - name: windows tools
+        run: sudo apt-get install -y mingw-w64 nsis zip
+      - name: publish
+        env:
+          REQUIRE_WINDOWS: "1"
+          GITEA_RESOLVE: git.akarpov.ru:443:79.142.92.250
+        run: |
+          case "$GITHUB_REF" in
+          refs/tags/v*) sh tools/release/release.sh "$GITHUB_REF_NAME" ;;
+          refs/heads/master) sh tools/release/release.sh nightly ;;
+          esac

README.md

@@ -0,0 +1,8 @@
+# Aego
+
+A 2D and 3D game engine with an editor, a scripting language and a web export, written in Go.
+
+- Documentation and the playground: <https://aego.akarpov.ru>
+- Installing and building from source: [engine/res/docs/install.md](engine/res/docs/install.md)
+- Contributing, check levels and rules for engine code: [docs/contributing.md](docs/contributing.md)
+- Architecture and decisions: [ARCHITECTURE.md](ARCHITECTURE.md)

app/agent/cli_test.go

@@ -0,0 +1,85 @@
+package agent
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+)
+
+func mustFind(t *testing.T, name string) *Command {
+	t.Helper()
+	c, ok := Find(name)
+	if !ok {
+		t.Fatalf("no command %s", name)
+	}
+	return c
+}
+
+func TestParseArgs(t *testing.T) {
+	set := mustFind(t, "scene.set")
+	a, f, err := parseArgs(set, []string{"s.aescene", "--json", "Player", "--dry-run", "Body2D.mass", "-3"})
+	if err != nil || !f.json || a.Str("value") != "-3" || a.Str("node") != "Player" || !a.Bool("dry-run") {
+		t.Fatalf("flags after positionals: %v %+v %v", a, f, err)
+	}
+	add := mustFind(t, "scene.add-node")
+	for _, toks := range [][]string{{"s", "N", "--index=1"}, {"s", "N", "--index", "1"}} {
+		a, _, err := parseArgs(add, toks)
+		if n, _ := a.Int("index", -1); err != nil || n != 1 {
+			t.Fatalf("%v: %v %v", toks, a, err)
+		}
+	}
+	a, _, err = parseArgs(set, []string{"s", "--", "Player", "Body2D.mass", "--odd"})
+	if err != nil || a.Str("value") != "--odd" {
+		t.Fatalf("after --: %v %v", a, err)
+	}
+	if _, _, err := parseArgs(set, []string{"s", "--nope"}); err == nil {
+		t.Fatal("an unknown flag was accepted")
+	}
+	if _, _, err := parseArgs(set, []string{"s", "a", "b", "c", "d"}); err == nil {
+		t.Fatal("an extra positional was accepted")
+	}
+	var out, errw bytes.Buffer
+	if code := Main(nil, []string{"scene", "set", "s", "--nope"}, &out, &errw, Options{}); code != 2 {
+		t.Fatalf("unknown flag exit %d", code)
+	}
+	if code := Main(nil, []string{"scene", "set", "a", "b", "c", "d", "e"}, &out, &errw, Options{}); code != 2 {
+		t.Fatalf("extra positional exit %d", code)
+	}
+	if code := Main(nil, []string{"scene", "help"}, &out, &errw, Options{}); code != 0 {
+		t.Fatalf("help exit %d", code)
+	}
+}
+
+func TestSchemasAndToolNames(t *testing.T) {
+	seen := map[string]bool{}
+	for _, c := range Commands() {
+		if seen[c.Tool()] {
+			t.Fatalf("tool name %s is used twice", c.Tool())
+		}
+		seen[c.Tool()] = true
+		b, err := json.Marshal(c.Schema())
+		if err != nil {
+			t.Fatal(err)
+		}
+		var sch struct {
+			Type       string                    `json:"type"`
+			Properties map[string]map[string]any `json:"properties"`
+			Required   []string                  `json:"required"`
+		}
+		if err := json.Unmarshal(b, &sch); err != nil || sch.Type != "object" {
+			t.Fatalf("%s: %s", c.Name, b)
+		}
+		var want []string
+		for _, x := range c.AllArgs() {
+			if x.Required {
+				want = append(want, x.Name)
+			}
+			if _, ok := sch.Properties[x.Name]; !ok {
+				t.Fatalf("%s: no property %s", c.Name, x.Name)
+			}
+		}
+		if len(want) != len(sch.Required) {
+			t.Fatalf("%s: required %v, want %v", c.Name, sch.Required, want)
+		}
+	}
+}

app/agent/project.go

@@ -0,0 +1,66 @@
+package agent
+
+import (
+	"strconv"
+
+	"aego/asset"
+	"aego/project/refs"
+	"aego/scene/mutate"
+)
+
+func projectCommands() []*Command {
+	return []*Command{
+		{Name: "project.validate", Doc: "missing assets and nodes, import errors, prefabs and scenes that do not load", Run: (*Session).projectValidate},
+	}
+}
+
+func (s *Session) projectValidate(Args) (*Output, error) {
+	out := &Output{}
+	add := func(err bool, node, msg string) {
+		out.Problems = append(out.Problems, mutate.Problem{Error: err, Node: node, Message: msg})
+	}
+	for _, m := range refs.MissingAssets(s.Project, s.Pipeline) {
+		add(true, "", "missing asset "+m.Label())
+	}
+	for _, m := range refs.MissingNodes(s.Pipeline) {
+		add(true, m.Scene+" "+m.Path, m.Owner+"."+m.Field+" references a node that is not in the scene")
+	}
+	if s.scriptErr != nil {
+		add(true, "", "script types: "+s.scriptErr.Error())
+	}
+	for _, e := range s.libErrs {
+		add(true, "", e.Error())
+	}
+	for _, x := range s.Pipeline.Assets() {
+		if x.Error != "" {
+			add(true, x.Path, x.Error)
+			continue
+		}
+		if x.Kind != asset.ArtScene && x.Kind != asset.ArtPrefab {
+			continue
+		}
+		src, err := s.read(x.Path)
+		if err != nil {
+			add(true, x.Path, err.Error())
+			continue
+		}
+		doc, err := mutate.Load(src, x.Path, s.env())
+		if err != nil {
+			add(true, x.Path, err.Error())
+			continue
+		}
+		for _, p := range doc.Problems {
+			add(p.Error, x.Path+" "+p.Node, p.Message)
+		}
+	}
+	errs, warns := 0, 0
+	for _, p := range out.Problems {
+		if p.Error {
+			errs++
+		} else {
+			warns++
+		}
+	}
+	out.Notes = []string{"project: " + strconv.Itoa(errs) + " error(s), " + strconv.Itoa(warns) + " warning(s)"}
+	return out, nil
+}

app/assembly/builtin/builtin.go

@@ -6,9 +6,11 @@ import (
 	"aego/engine/module"
 	"aego/modules/accessibility"
 	"aego/modules/audio"
+	"aego/modules/camera"
 	"aego/modules/dataasset"
 	"aego/modules/debug"
 	"aego/modules/display"
+	"aego/modules/gameplay"
 	inputmod "aego/modules/input"
 	"aego/modules/physics"
 	"aego/modules/render2d"
@@ -71,6 +73,14 @@ func tweenEntry() assembly.Entry {
 	return assembly.Entry{ID: tween.ID, Requires: []string{scripting.ID}, New: func(assembly.Options) module.Module { return tween.New() }}
 }
 
+func cameraEntry() assembly.Entry {
+	return assembly.Entry{ID: camera.ID, Requires: []string{scripting.ID}, New: func(assembly.Options) module.Module { return camera.New() }}
+}
+
+func gameplayEntry() assembly.Entry {
+	return assembly.Entry{ID: gameplay.ID, Requires: []string{physics.ID, scripting.ID}, New: func(assembly.Options) module.Module { return gameplay.New() }}
+}
+
 func dataEntry() assembly.Entry {
 	return assembly.Entry{ID: dataasset.ID, New: func(assembly.Options) module.Module { return dataasset.New() }}
 }
@@ -85,5 +95,5 @@ func savegameEntry() assembly.Entry {
 
 func Default() assembly.Catalog {
 	return assembly.Catalog{core(), dataEntry(), inputEntry(), render2dEntry(), render3dEntry(), scriptEntry(), physicsEntry(), debugEntry(),
-		displayEntry(), audioEntry(), accessibilityEntry(), settingsEntry(), tweenEntry(), spawnEntry(), savegameEntry()}
+		displayEntry(), audioEntry(), accessibilityEntry(), settingsEntry(), tweenEntry(), cameraEntry(), gameplayEntry(), spawnEntry(), savegameEntry()}
 }

app/assembly/builtin/headless.go

@@ -3,5 +3,5 @@ package builtin
 import "aego/app/assembly"
 
 func Headless() assembly.Catalog {
-	return assembly.Catalog{core(), dataEntry(), inputEntry(), scriptEntry(), physicsEntry(), debugEntry(), displayEntry(), audioEntry(), accessibilityEntry(), settingsEntry(), tweenEntry(), spawnEntry(), savegameEntry()}
+	return assembly.Catalog{core(), dataEntry(), inputEntry(), scriptEntry(), physicsEntry(), debugEntry(), displayEntry(), audioEntry(), accessibilityEntry(), settingsEntry(), tweenEntry(), cameraEntry(), spawnEntry(), savegameEntry()}
 }

app/assembly/editors/editors.go

@@ -2,8 +2,14 @@ package editors
 
 import (
 	"aego/app/assembly"
+	"aego/modules/audio"
+	audioeditor "aego/modules/audio/editor"
+	"aego/modules/camera"
+	cameraeditor "aego/modules/camera/editor"
 	"aego/modules/debug"
 	debugeditor "aego/modules/debug/editor"
+	"aego/modules/gameplay"
+	gameplayeditor "aego/modules/gameplay/editor"
 	inputmod "aego/modules/input"
 	inputeditor "aego/modules/input/editor"
 	"aego/modules/physics"
@@ -20,5 +26,8 @@ func With(c assembly.Catalog) assembly.Catalog {
 		With(render2d.ID, render2deditor.Hook).
 		With(render3d.ID, render3deditor.Hook).
 		With(physics.ID, physicseditor.Hook).
+		With(camera.ID, cameraeditor.Hook).
+		With(gameplay.ID, gameplayeditor.Hook).
+		With(audio.ID, audioeditor.Hook).
 		With(debug.ID, debugeditor.Hook)
 }

app/assembly/playground/playground.go

@@ -4,12 +4,20 @@ import (
 	"aego/app/assembly"
 	"aego/engine/base"
 	"aego/engine/module"
+	"aego/modules/audio"
+	"aego/modules/camera"
 	"aego/modules/debug"
+	"aego/modules/gameplay"
 	inputmod "aego/modules/input"
 	"aego/modules/physics"
 	"aego/modules/render2d"
+	"aego/modules/render3d"
+	"aego/modules/savegame"
 	"aego/modules/scripting"
+	"aego/modules/spawn"
+	"aego/modules/tween"
 	"aego/script/stdlib"
+	"aego/script/vm"
 )
 
 func Catalog() assembly.Catalog {
@@ -22,5 +30,22 @@ func Catalog() assembly.Catalog {
 		}},
 		{ID: physics.ID, New: func(assembly.Options) module.Module { return physics.New() }},
 		{ID: debug.ID, New: func(assembly.Options) module.Module { return debug.New() }},
+		{ID: tween.ID, Requires: []string{scripting.ID}, New: func(assembly.Options) module.Module { return tween.New() }},
+		{ID: camera.ID, Requires: []string{scripting.ID}, New: func(assembly.Options) module.Module { return camera.New() }},
+		{ID: gameplay.ID, Requires: []string{physics.ID, scripting.ID}, New: func(assembly.Options) module.Module { return gameplay.New() }},
+		{ID: render3d.ID, New: func(assembly.Options) module.Module { return render3d.New() }},
+		{ID: spawn.ID, New: func(assembly.Options) module.Module { return spawn.New() }},
+		{ID: savegame.ID, Requires: []string{scripting.ID, spawn.ID}, New: func(assembly.Options) module.Module { return savegame.New() }},
+		{ID: audio.ID, New: func(assembly.Options) module.Module { return audio.New() }},
 	}
 }
+
+const (
+	SandboxBudget = 2_000_000
+	SandboxHeap   = 64 << 20
+	SandboxNodes  = 10_000
+)
+
+func SandboxVM() vm.Options {
+	return vm.Options{Budget: SandboxBudget, MaxHeap: SandboxHeap}
+}

app/assembly/playground/saves.go

@@ -0,0 +1,61 @@
+package playground
+
+import (
+	"io/fs"
+	"path"
+	"sort"
+	"strings"
+	"time"
+
+	"aego/contracts/persistence"
+	"aego/engine"
+	"aego/platform"
+	"aego/save"
+)
+
+// UseMemorySaves gives e a save store kept in memory, for runs in a browser page that must not touch the visitor's storage.
+func UseMemorySaves(e *engine.Engine) {
+	e.SetService(persistence.StoreID, save.NewStoreFS("saves", &memUser{files: map[string][]byte{}}))
+}
+
+type memUser struct {
+	files map[string][]byte
+}
+
+func (m *memUser) ReadFile(p string) ([]byte, error) {
+	data, ok := m.files[path.Clean(p)]
+	if !ok {
+		return nil, fs.ErrNotExist
+	}
+	return append([]byte(nil), data...), nil
+}
+
+func (m *memUser) WriteFile(p string, data []byte) error {
+	m.files[path.Clean(p)] = append([]byte(nil), data...)
+	return nil
+}
+
+func (m *memUser) Remove(p string) error {
+	delete(m.files, path.Clean(p))
+	return nil
+}
+
+func (m *memUser) Stat(p string) (platform.UserEntry, error) {
+	data, ok := m.files[path.Clean(p)]
+	if !ok {
+		return platform.UserEntry{}, fs.ErrNotExist
+	}
+	return platform.UserEntry{Name: path.Base(p), Size: int64(len(data)), Mod: time.Time{}}, nil
+}
+
+func (m *memUser) List(dir string) ([]platform.UserEntry, error) {
+	prefix := path.Clean(dir) + "/"
+	var out []platform.UserEntry
+	for p, data := range m.files {
+		if rest, ok := strings.CutPrefix(p, prefix); ok && !strings.Contains(rest, "/") {
+			out = append(out, platform.UserEntry{Name: rest, Size: int64(len(data))})
+		}
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name })
+	return out, nil
+}

app/assembly/playground/try.go

@@ -0,0 +1,62 @@
+package playground
+
+import (
+	"encoding/base64"
+	"strings"
+
+	"aego/asset"
+	"aego/asset/loader"
+	"aego/core/ids"
+	"aego/script/bytecode"
+	"aego/vfs"
+	"aego/vfs/memfs"
+)
+
+// EncodeTry packs the compiled script of a try scene for a docs page: base64 modules joined by commas.
+func EncodeTry(mods []*bytecode.Module) string {
+	parts := make([]string, len(mods))
+	for i, m := range mods {
+		parts[i] = base64.StdEncoding.EncodeToString(bytecode.Encode(m))
+	}
+	return strings.Join(parts, ",")
+}
+
+func DecodeTry(code string) ([]*bytecode.Module, error) {
+	if code == "" {
+		return nil, nil
+	}
+	var mods []*bytecode.Module
+	for _, part := range strings.Split(code, ",") {
+		b, err := base64.StdEncoding.DecodeString(part)
+		if err != nil {
+			return nil, err
+		}
+		m, err := bytecode.Decode(b)
+		if err != nil {
+			return nil, err
+		}
+		mods = append(mods, m)
+	}
+	return mods, nil
+}
+
+// MountTry gives the loader the prefabs of a try scene, keyed by asset id; none unmounts them.
+func MountTry(l *loader.Loader, prefabs map[string]string) error {
+	idx := asset.NewIndex()
+	files := map[string][]byte{}
+	for key, text := range prefabs {
+		id, err := ids.ParseAssetID(key)
+		if err != nil {
+			return err
+		}
+		p := id.String() + ".aeprefab"
+		files[p] = []byte(text)
+		idx.Put(asset.Entry{ID: id, Kind: asset.ArtPrefab, Name: p, Source: p,
+			Artifacts: []asset.Artifact{{Kind: asset.ArtPrefab, Path: "try://" + p}}})
+	}
+	fs, err := vfs.New(vfs.Mount{Scheme: "try", ReadOnly: true, Source: memfs.New(files)})
+	if err != nil {
+		return err
+	}
+	return l.Mount(idx, fs)
+}

app/bootstrap/bootstrap.go

@@ -9,6 +9,7 @@ import (
 	"sort"
 	"strings"
 
+	"aego/app/proc"
 	"aego/core/errs"
 	"aego/core/log"
 	"aego/project"
@@ -169,6 +170,7 @@ func Build(p *project.Project, t Target, mode Mode, engineVersion string, lg *lo
 	cmd := exec.Command("go", args...)
 	cmd.Dir = p.Root
 	cmd.Env = append(os.Environ(), "GOOS="+t.OS, "GOARCH="+t.Arch)
+	proc.Hide(cmd)
 	output, err := cmd.CombinedOutput()
 	if err != nil {
 		os.RemoveAll(outDir)

app/bootstrap/icons.go

@@ -8,6 +8,7 @@ import (
 	"path/filepath"
 	"strings"
 
+	"aego/app/proc"
 	"aego/core/errs"
 	"aego/core/log"
 	"aego/project"
@@ -32,12 +33,14 @@ func RunIcons(p *project.Project, engineVersion string, out io.Writer) (int, err
 	defer os.Remove(bin)
 	build := exec.Command("go", "build", "-tags", strings.Join(t.Tags, ","), "-o", bin, "./.aego/generated/icons")
 	build.Dir = p.Root
+	proc.Hide(build)
 	if output, err := build.CombinedOutput(); err != nil {
 		return 2, errs.New(errs.BuildFailed, "native icons helper does not compile",
 			log.F("output", strings.TrimSpace(string(output))))
 	}
 	run := exec.Command(bin)
 	run.Dir, run.Stdout, run.Stderr = p.Root, out, out
+	proc.Hide(run)
 	err = run.Run()
 	var ee *exec.ExitError
 	if errors.As(err, &ee) {

app/bootstrap/manifest.go

@@ -6,6 +6,7 @@ import (
 	"path/filepath"
 	"strings"
 
+	"aego/app/proc"
 	"aego/core/errs"
 	"aego/core/log"
 	"aego/project"
@@ -52,6 +53,7 @@ func BuildManifest(p *project.Project, engineVersion string, lg *log.Logger) (st
 	defer os.Remove(bin)
 	build := exec.Command("go", "build", "-tags", strings.Join(t.Tags, ","), "-o", bin, "./.aego/generated/manifest")
 	build.Dir = p.Root
+	proc.Hide(build)
 	if output, err := build.CombinedOutput(); err != nil {
 		return "", errs.New(errs.BuildFailed, "native bindings helper does not compile",
 			log.F("output", strings.TrimSpace(string(output))))
@@ -59,6 +61,7 @@ func BuildManifest(p *project.Project, engineVersion string, lg *log.Logger) (st
 	tmp := out + ".tmp"
 	run := exec.Command(bin, tmp)
 	run.Dir = p.Root
+	proc.Hide(run)
 	if output, err := run.CombinedOutput(); err != nil {
 		os.Remove(tmp)
 		return "", errs.New(errs.BuildFailed, "native module Register failed",

app/brand/brand.go

@@ -0,0 +1,33 @@
+package brand
+
+import (
+	"bytes"
+	"embed"
+	"image"
+	"image/png"
+	"strconv"
+)
+
+//go:embed png/aego-*.png
+var files embed.FS
+
+var windowSizes = []int{16, 24, 32, 48, 64, 128, 256}
+
+func PNG(n int) ([]byte, bool) {
+	data, err := files.ReadFile("png/aego-" + strconv.Itoa(n) + ".png")
+	return data, err == nil
+}
+
+func Window() []image.Image {
+	out := make([]image.Image, 0, len(windowSizes))
+	for _, n := range windowSizes {
+		data, ok := PNG(n)
+		if !ok {
+			continue
+		}
+		if img, err := png.Decode(bytes.NewReader(data)); err == nil {
+			out = append(out, img)
+		}
+	}
+	return out
+}

app/build.go

@@ -41,6 +41,7 @@ type Config struct {
 	Editor             bool
 	FailOnScriptErrors bool
 	Catalog            assembly.Catalog
+	Platform           platform.Platform
 	Profile            string
 	NoProfile          bool
 }
@@ -98,6 +99,9 @@ func (h *Host) build(cfg Config, mods []module.Module) error {
 		ecfg.LoopScope = cfg.LoopScope
 	}
 	builder := engine.NewBuilder(ecfg).WithLogger(lg).Use(rmod)
+	if cfg.Platform != nil {
+		builder.WithPlatform(cfg.Platform)
+	}
 	if h.Types, err = assembly.NewTypes(); err != nil {
 		return err
 	}
@@ -187,6 +191,7 @@ func (h *Host) build(cfg Config, mods []module.Module) error {
 	}
 	h.Settings.SetNames(h.Sections.Names)
 	h.Engine.SetService(settings.ServiceID, h.Settings)
+	h.Engine.OnClose(h.Modules.Shutdown)
 	if err = h.Modules.Init(&module.InitContext{Engine: h.Engine, Assets: h.Loader, Log: lg, Editor: cfg.Editor, Sections: h.Sections, Problems: h.Problems, Settings: h.Settings}); err != nil {
 		return err
 	}
@@ -227,9 +232,6 @@ func (h *Host) Close() {
 		return
 	}
 	h.closed = true
-	if h.Modules != nil {
-		h.Modules.Shutdown()
-	}
 	if h.Engine != nil {
 		h.Engine.Close()
 	}

app/docstool/diagnostics.go

@@ -0,0 +1,33 @@
+package docstool
+
+import (
+	"aego/app/playground"
+	"aego/engine/docs"
+	"aego/script/diag"
+)
+
+func diagnoser(pg *playground.Playground) func(string, *docs.DiagInfo) {
+	return func(code string, d *docs.DiagInfo) {
+		got, err := pg.Reproduce(code)
+		if err != nil || got.Code == "" {
+			return
+		}
+		d.Severity, d.At, d.Message = got.Severity, got.File, got.Message
+		d.Line, d.Col, d.EndLine, d.EndCol = got.Line, got.Col, got.EndLine, got.EndCol
+	}
+}
+
+// DiagnosticProblems lists codes whose example is missing or no longer produces the code.
+func DiagnosticProblems() []docs.Problem {
+	pg, err := playground.New()
+	if err != nil {
+		return []docs.Problem{{ID: docs.DiagnosticsID, Error: true, Message: "cannot start the docs runtime: " + err.Error()}}
+	}
+	var out []docs.Problem
+	for _, c := range diag.Codes() {
+		if _, err := pg.Reproduce(c); err != nil {
+			out = append(out, docs.Problem{ID: c, Error: true, Message: err.Error()})
+		}
+	}
+	return out
+}

app/docstool/docstool_test.go

@@ -138,7 +138,7 @@ func TestF1Refs(t *testing.T) {
 	if err := os.WriteFile(path, []byte(probe), 0o644); err != nil {
 		t.Fatal(err)
 	}
-	reg, ws, err := build(p, nil)
+	reg, ws, err := build(p, nil, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -169,3 +169,17 @@ func TestF1Refs(t *testing.T) {
 		}
 	}
 }
+
+func TestDiagnosticExamplesExported(t *testing.T) {
+	if ps := DiagnosticProblems(); len(ps) > 0 {
+		t.Fatalf("diagnostics examples: %v", ps)
+	}
+	reg, err := ExportRegistry(nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	e, ok := reg.Get("AES2001")
+	if !ok || e.Diag == nil || e.Diag.Line == 0 || e.Diag.Severity != "error" || !strings.Contains(e.Diag.Message, "heigth") {
+		t.Fatalf("AES2001 example was not diagnosed: %+v", e.Diag)
+	}
+}

app/docstool/examples.go

@@ -0,0 +1,70 @@
+package docstool
+
+import (
+	"fmt"
+	"io"
+	"strings"
+
+	"aego/app/playground"
+	"aego/engine/docs"
+	"aego/engine/module"
+)
+
+// CheckExamples loads the example scene of every module code, validates it and runs it headless; the code must be among the problems it reports (D146).
+func CheckExamples(reg *docs.Registry, w io.Writer) int {
+	pg, err := playground.New()
+	if err != nil {
+		fmt.Fprintln(w, "examples: cannot start the docs runtime:", err)
+		return 1
+	}
+	pg.SetGame(playground.GameConfig{Headless: true, FrameTime: 1.0 / 60})
+	defer func() {
+		if g := pg.Game(); g != nil {
+			g.Close()
+		}
+	}()
+	bad := 0
+	for _, e := range reg.All() {
+		if e.Kind != docs.Code || e.Diag == nil || e.Diag.Example == "" {
+			continue
+		}
+		found, why := false, ""
+		code := ""
+		if e.Diag.ExampleScript != "" {
+			c, err := pg.TryCode(e.Diag.ExampleScript)
+			if err != nil {
+				fmt.Fprintf(w, "%s: error: example script does not compile: %v\n", e.ID, err)
+				bad++
+				continue
+			}
+			code = c
+		}
+		if res := pg.PlayScene("example-"+e.ID, []byte(e.Diag.Example), code, nil); !res.Started {
+			why = "does not load: " + res.Error
+		} else {
+			for _, d := range module.ValidateScene(pg.Game().Scene(), nil) {
+				found = found || d.Code == e.ID
+			}
+			if err := pg.Game().Step(tryFrames); err != nil {
+				why = "stops the engine: " + err.Error()
+			}
+		}
+		poll := pg.Poll()
+		for _, f := range poll.Faults {
+			found = found || f.Code == e.ID
+		}
+		for _, l := range poll.Log {
+			found = found || strings.Contains(l.Text, e.ID)
+		}
+		switch {
+		case why != "":
+			fmt.Fprintf(w, "%s: error: example %s %s\n", e.ID, e.Diag.ExampleFile, why)
+			bad++
+		case !found:
+			fmt.Fprintf(w, "%s: error: example of %s does not produce %s\n", e.ID, e.ID, e.ID)
+			bad++
+		}
+	}
+	pg.Stop()
+	return bad
+}

app/docstool/registry.go

@@ -9,6 +9,7 @@ import (
 
 	"aego/app/assembly"
 	"aego/app/assembly/builtin"
+	"aego/app/playground"
 	"aego/engine/docs"
 	"aego/engine/module"
 	scriptsystems "aego/modules/scripting/systems"
@@ -20,7 +21,8 @@ import (
 	"aego/script/workspace"
 )
 
-func build(p *project.Project, mods []module.Module) (*docs.Registry, *workspace.Workspace, error) {
+// build assembles the registry; with pg it also compiles the diagnostics examples and the try scripts.
+func build(p *project.Project, mods []module.Module, pg *playground.Playground) (*docs.Registry, *workspace.Workspace, error) {
 	types, err := assembly.NewTypes()
 	if err != nil {
 		return nil, nil, err
@@ -41,6 +43,10 @@ func build(p *project.Project, mods []module.Module) (*docs.Registry, *workspace
 		return nil, nil, err
 	}
 	src := docs.SourcesOf(bm, types.Schema(), man)
+	if pg != nil {
+		src.Diagnose = diagnoser(pg)
+		src.CompileTry = pg.TryCode
+	}
 	var ws *workspace.Workspace
 	if p != nil {
 		ws, err = workspace.Open(workspace.Config{Root: p.Root, Module: p.Module, Scripts: p.ScriptsDir(), Bindings: reg.Table(), Docs: bm})
@@ -61,7 +67,17 @@ func build(p *project.Project, mods []module.Module) (*docs.Registry, *workspace
 }
 
 func Registry(p *project.Project, mods []module.Module) (*docs.Registry, error) {
-	r, _, err := build(p, mods)
+	r, _, err := build(p, mods, nil)
+	return r, err
+}
+
+// ExportRegistry is Registry with the diagnostics examples compiled for their messages and positions, and the try scripts compiled.
+func ExportRegistry(p *project.Project, mods []module.Module) (*docs.Registry, error) {
+	pg, err := playground.New()
+	if err != nil {
+		return nil, err
+	}
+	r, _, err := build(p, mods, pg)
 	return r, err
 }
 
@@ -84,9 +100,9 @@ func WriteExport(reg *docs.Registry, title, path string, w io.Writer) error {
 	return os.WriteFile(path, data, 0o644)
 }
 
-func Check(reg *docs.Registry, strict bool, w io.Writer) int {
+func Check(reg *docs.Registry, strict bool, w io.Writer, extra ...docs.Problem) int {
 	errs, warns := 0, 0
-	for _, p := range reg.Check(strict) {
+	for _, p := range append(reg.Check(strict), extra...) {
 		level := "warn "
 		if p.Error {
 			level = "error"

app/docstool/tool.go

@@ -21,7 +21,11 @@ func Tool(p *project.Project, args []string, stdout, stderr io.Writer, mods ...m
 	if err := fs.Parse(args[1:]); err != nil {
 		return 2
 	}
-	reg, err := Registry(p, mods)
+	build := Registry
+	if args[0] == "export" {
+		build = ExportRegistry
+	}
+	reg, err := build(p, mods)
 	if err != nil {
 		fmt.Fprintln(stderr, "aego:", err)
 		return 1
@@ -34,7 +38,7 @@ func Tool(p *project.Project, args []string, stdout, stderr io.Writer, mods ...m
 		}
 		return 0
 	case "check":
-		return Check(reg, *strict, stdout)
+		return Check(reg, *strict, stdout, DiagnosticProblems()...)
 	}
 	fmt.Fprintf(stderr, "unknown docs command %q\n", args[0])
 	return 2

app/docstool/try.go

@@ -0,0 +1,77 @@
+package docstool
+
+import (
+	"fmt"
+	"io"
+	"strings"
+
+	"aego/app/playground"
+	"aego/engine/docs"
+)
+
+const tryFrames = 60
+
+func CheckTry(reg *docs.Registry, w io.Writer) int {
+	pg, err := playground.New()
+	if err != nil {
+		fmt.Fprintln(w, "try: cannot start the docs runtime:", err)
+		return 1
+	}
+	pg.SetGame(playground.GameConfig{Headless: true, FrameTime: 1.0 / 60})
+	defer func() {
+		if g := pg.Game(); g != nil {
+			g.Close()
+		}
+	}()
+	sandbox := map[string]bool{}
+	for _, e := range pg.TryScenes() {
+		sandbox[e.ID] = true
+	}
+	bad := 0
+	for _, e := range reg.All() {
+		if e.Try == "" {
+			continue
+		}
+		var msgs []string
+		add := func(msg string) {
+			for _, m := range msgs {
+				if m == msg || strings.Contains(m, msg) || strings.Contains(msg, m) {
+					return
+				}
+			}
+			msgs = append(msgs, msg)
+		}
+		var code string
+		var err error
+		if e.TryScript != "" {
+			code, err = pg.TryCode(e.TryScript)
+		}
+		switch res := pg.PlayScene(e.ID, []byte(e.Try), code, e.TryPrefabs); {
+		case !sandbox[e.ID]:
+			add("belongs to a module the docs runtime does not include")
+		case err != nil:
+			add("script does not compile: " + err.Error())
+		case !res.Started:
+			add("does not load: " + res.Error)
+		default:
+			if err := pg.Game().Step(tryFrames); err != nil {
+				add("stops the engine: " + err.Error())
+			}
+		}
+		poll := pg.Poll()
+		for _, l := range poll.Log {
+			if l.Level != "INFO" && l.Level != "DEBUG" {
+				add(l.Text)
+			}
+		}
+		for _, f := range poll.Faults {
+			add(f.Code + " " + f.Message)
+		}
+		for _, m := range msgs {
+			fmt.Fprintf(w, "%s: error: try scene %s\n", e.ID, m)
+		}
+		bad += len(msgs)
+	}
+	pg.Stop()
+	return bad
+}

app/docsview/scripts.go

@@ -0,0 +1,79 @@
+//go:build aego_editor
+
+package docsview
+
+import (
+	playmods "aego/app/assembly/playground"
+	"aego/core/log"
+	"aego/editor/core/context"
+	"aego/engine"
+	"aego/engine/module"
+	"aego/scene"
+	"aego/script/bind"
+	"aego/script/bytecode"
+	scriptruntime "aego/script/runtime"
+)
+
+type scriptHost struct {
+	reg   *bind.Registry
+	types *scene.Types
+	man   *module.Manifest
+	log   *log.Logger
+	mods  []*bytecode.Module
+}
+
+// use makes mods the scripts of the next scene and publishes their types, so the scene keeps their fields.
+func (h *scriptHost) use(mods []*bytecode.Module) error {
+	if err := scriptruntime.Publish(h.types.Schema(), mods, h.reg.Surface()); err != nil {
+		return err
+	}
+	h.mods = mods
+	return nil
+}
+
+func (h *scriptHost) Errors() int {
+	return 0
+}
+
+func (h *scriptHost) Attach(w *engine.World, s *scene.Scene) (func(), error) {
+	rt := scriptruntime.New(scriptruntime.Options{Bindings: h.reg, Schema: h.types.Schema(), Log: h.log, VM: playmods.SandboxVM()})
+	if err := rt.Link(h.mods); err != nil {
+		rt.Close()
+		return nil, err
+	}
+	w.SetService(scriptruntime.ServiceID, rt)
+	if err := rt.Instantiate(s); err != nil {
+		w.RemoveService(scriptruntime.ServiceID)
+		rt.Close()
+		return nil, err
+	}
+	detach, err := h.man.Attach(&module.AttachContext{World: w, Scene: s, Log: h.log, Editor: true, Play: true})
+	if err != nil {
+		w.RemoveService(scriptruntime.ServiceID)
+		rt.Close()
+		return nil, err
+	}
+	return func() {
+		detach()
+		w.RemoveService(scriptruntime.ServiceID)
+		rt.Close()
+	}, nil
+}
+
+func (h *scriptHost) Problems() ([]context.ScriptProblem, uint64) {
+	return nil, 0
+}
+
+func (h *scriptHost) Stats() (context.ScriptStats, bool) {
+	return context.ScriptStats{}, false
+}
+
+func (h *scriptHost) Status() (uint64, bool) {
+	return 0, false
+}
+
+func (h *scriptHost) Watch(*engine.World, scene.NodeHandle, string, string, int) (string, float64, bool, bool) {
+	return "", 0, false, false
+}
+
+var _ context.ScriptHost = (*scriptHost)(nil)

app/edit/boot.go

@@ -0,0 +1,27 @@
+package edit
+
+import (
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+
+	"aego/engine"
+	"aego/platform"
+)
+
+func startBoot(verb string) {
+	wd, _ := os.Getwd()
+	exe, _ := os.Executable()
+	gobin, err := exec.LookPath("go")
+	if err != nil {
+		gobin = "not on PATH"
+	}
+	_ = platform.StartBoot(platform.DefaultBootPath(),
+		"aego "+engine.Version+" "+runtime.GOOS+"/"+runtime.GOARCH+" "+verb,
+		"exe "+exe,
+		"args "+strings.Join(os.Args[1:], " "),
+		"cwd "+wd,
+		"go "+gobin,
+	)
+}