@machinal/scenes 0.0.0-stage → 0.1.0

package/renderer/browser_test.go

@@ -0,0 +1,307 @@
+package sceneengine
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"image/png"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func browserFixture(t *testing.T, progress func(Progress)) (*Renderer, Request) {
+	t.Helper()
+	browser, ffmpeg, directory := os.Getenv("SCENE_BROWSER"), os.Getenv("SCENE_FFMPEG"), os.Getenv("SCENE_FIXTURE_DIR")
+	if browser == "" || ffmpeg == "" || directory == "" {
+		t.Skip("configure SCENE_BROWSER, SCENE_FFMPEG and SCENE_FIXTURE_DIR for native tests")
+	}
+	server := httptest.NewServer(http.FileServer(http.Dir(directory)))
+	t.Cleanup(server.Close)
+	ctx, cancel := context.WithTimeout(context.Background(), 90*time.Second)
+	t.Cleanup(cancel)
+	renderer, err := New(ctx, Options{BrowserExecutable: browser, FFmpegExecutable: ffmpeg, Concurrency: 2, FrameTimeout: 10 * time.Second, Progress: progress})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(renderer.Close)
+	request := fixtureRequest()
+	request.URL = server.URL + "/scene.html"
+	request.Seed = "native-test"
+	request.Config.FPS = 12
+	request.Config.DurationInFrames = 24
+	return renderer, request
+}
+
+func TestBrowserDeterministicFrames(t *testing.T) {
+	renderer, request := browserFixture(t, nil)
+	worker, err := renderer.newWorker(context.Background(), request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer worker.close()
+	first, err := worker.capture(context.Background(), 18)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := worker.capture(context.Background(), 3); err != nil {
+		t.Fatal(err)
+	}
+	repeated, err := worker.capture(context.Background(), 18)
+	if err != nil {
+		t.Fatal(err)
+	}
+	assertCapturePixelsEqual(t, first, repeated)
+	second, err := renderer.newWorker(context.Background(), request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer second.close()
+	parallel, err := second.capture(context.Background(), 18)
+	if err != nil {
+		t.Fatal(err)
+	}
+	assertCapturePixelsEqual(t, first, parallel)
+}
+
+func assertCapturePixelsEqual(t *testing.T, first, second []byte) {
+	t.Helper()
+	a, err := png.Decode(bytes.NewReader(first))
+	if err != nil {
+		t.Fatal(err)
+	}
+	b, err := png.Decode(bytes.NewReader(second))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if a.Bounds() != b.Bounds() {
+		t.Fatal("capture dimensions differ")
+	}
+	for y := a.Bounds().Min.Y; y < a.Bounds().Max.Y; y++ {
+		for x := a.Bounds().Min.X; x < a.Bounds().Max.X; x++ {
+			ar, ag, ab, aa := a.At(x, y).RGBA()
+			br, bg, bb, ba := b.At(x, y).RGBA()
+			if ar != br || ag != bg || ab != bb || aa != ba {
+				t.Fatalf("capture pixels differ at %d,%d: %d,%d,%d,%d vs %d,%d,%d,%d", x, y, ar, ag, ab, aa, br, bg, bb, ba)
+			}
+		}
+	}
+}
+
+func TestBrowserRenderVideoAndAudio(t *testing.T) {
+	renderer, request := browserFixture(t, nil)
+	root := t.TempDir()
+	audio := filepath.Join(root, "tone.wav")
+	generate := exec.Command(renderer.options.FFmpegExecutable, "-hide_banner", "-loglevel", "error", "-f", "lavfi", "-i", "sine=frequency=440:duration=2", "-y", audio)
+	if data, err := generate.CombinedOutput(); err != nil {
+		t.Fatalf("create audio fixture: %v: %s", err, data)
+	}
+	request.Audio = []AudioTrack{{File: audio, Start: 0.5, Duration: 1}}
+	output := filepath.Join(root, "scene.mp4")
+	result, err := renderer.Render(context.Background(), request, output)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.HasAudio || result.Frames != 24 || result.Duration != 2 {
+		t.Fatalf("invalid result: %+v", result)
+	}
+	hash, size, err := fingerprint(output)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if hash != result.SHA256 || size != result.Size {
+		t.Fatal("manifest fingerprint does not match encoded bytes")
+	}
+	if _, err := os.Stat(output + ".scene.json"); err != nil {
+		t.Fatal(err)
+	}
+	streams := probeStreams(t, output)
+	if len(streams) != 2 || streams[0].CodecName != "h264" || streams[0].Width != 640 || streams[0].Height != 360 || streams[0].Frames != "24" || streams[1].CodecName != "aac" {
+		t.Fatalf("unexpected encoded streams: %+v", streams)
+	}
+	if _, err := renderer.Render(context.Background(), request, output); err == nil {
+		t.Fatal("overwrote an existing output")
+	}
+}
+
+func TestBrowserLosslessRGBMatchesCapturedPixels(t *testing.T) {
+	renderer, request := browserFixture(t, nil)
+	renderer.options.Lossless = true
+	renderer.options.X264Preset = "ultrafast"
+	renderer.options.EncoderThreads = 2
+	request.Config.DurationInFrames = 6
+	worker, err := renderer.newWorker(context.Background(), request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	capture, err := worker.capture(context.Background(), 3)
+	worker.close()
+	if err != nil {
+		t.Fatal(err)
+	}
+	image, err := png.Decode(bytes.NewReader(capture))
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := make([]byte, 0, request.Config.Width*request.Config.Height*3)
+	for y := 0; y < request.Config.Height; y++ {
+		for x := 0; x < request.Config.Width; x++ {
+			r, g, b, _ := image.At(x, y).RGBA()
+			want = append(want, byte(r>>8), byte(g>>8), byte(b>>8))
+		}
+	}
+	output := filepath.Join(t.TempDir(), "lossless.mp4")
+	result, err := renderer.Render(context.Background(), request, output)
+	if err != nil {
+		t.Fatal(err)
+	}
+	got, err := exec.Command(renderer.options.FFmpegExecutable, "-v", "error", "-i", output, "-vf", `select=eq(n\,3)`, "-frames:v", "1", "-pix_fmt", "rgb24", "-f", "rawvideo", "pipe:1").Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(want, got) {
+		if len(want) != len(got) {
+			t.Fatalf("lossless RGB byte count: want %d, got %d", len(want), len(got))
+		}
+		for i := range want {
+			if want[i] != got[i] {
+				t.Fatalf("lossless scene RGB differs at pixel %d,%d channel %d: want %d, got %d", i/3%request.Config.Width, i/3/request.Config.Width, i%3, want[i], got[i])
+			}
+		}
+	}
+	if result.Metrics.Workers != 2 || result.Metrics.CaptureAndEncode <= 0 || result.Metrics.SeekWorkerTime <= 0 {
+		t.Fatalf("missing stage measurements: %+v", result.Metrics)
+	}
+}
+
+func TestBrowserAlpha(t *testing.T) {
+	renderer, request := browserFixture(t, nil)
+	request.Config.Transparent = true
+	request.Config.DurationInFrames = 6
+	worker, err := renderer.newWorker(context.Background(), request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	buffer, err := worker.capture(context.Background(), 3)
+	worker.close()
+	if err != nil {
+		t.Fatal(err)
+	}
+	assertTransparentCorner(t, buffer)
+	output := filepath.Join(t.TempDir(), "overlay.webm")
+	result, err := renderer.Render(context.Background(), request, output)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Transparent || result.Codec != VP9 {
+		t.Fatalf("invalid transparent result: %+v", result)
+	}
+	decoded, err := exec.Command(renderer.options.FFmpegExecutable, "-hide_banner", "-loglevel", "error", "-c:v", "libvpx-vp9", "-i", output, "-frames:v", "1", "-f", "image2pipe", "-vcodec", "png", "pipe:1").Output()
+	if err != nil {
+		t.Fatalf("decode transparent video: %v", err)
+	}
+	assertTransparentCorner(t, decoded)
+}
+
+func TestBrowserCancellationAndReuse(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	cancelled := false
+	renderer, request := browserFixture(t, func(progress Progress) {
+		if progress.WrittenFrames == 2 && !cancelled {
+			cancelled = true
+			cancel()
+		}
+	})
+	output := filepath.Join(t.TempDir(), "cancelled.mp4")
+	_, err := renderer.Render(ctx, request, output)
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("expected cancellation, got %v", err)
+	}
+	for _, path := range []string{output, output + ".scene.json"} {
+		if _, err := os.Stat(path); !os.IsNotExist(err) {
+			t.Fatalf("cancelled job published %s", path)
+		}
+	}
+	request.Config.DurationInFrames = 6
+	if _, err := renderer.Render(context.Background(), request, output); err != nil {
+		t.Fatalf("browser could not be reused after cancellation: %v", err)
+	}
+}
+
+func TestBrowserReportsSceneFailure(t *testing.T) {
+	renderer, request := browserFixture(t, nil)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/html")
+		w.Write([]byte(`<script>window.__scene = { version: 1, ready: async () => { throw new Error('missing scene resource'); } };</script>`))
+	}))
+	defer server.Close()
+	request.URL = server.URL
+	_, err := renderer.Render(context.Background(), request, filepath.Join(t.TempDir(), "failed.mp4"))
+	if err == nil || !strings.Contains(err.Error(), "missing scene resource") {
+		t.Fatalf("lost scene error: %v", err)
+	}
+}
+
+func TestBrowserFrameTimeoutDoesNotPublishOutput(t *testing.T) {
+	renderer, request := browserFixture(t, nil)
+	renderer.options.FrameTimeout = time.Second
+	request.Config.DurationInFrames = 1
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/html")
+		w.Write([]byte(`<script>window.__scene = { version: 1, manifest: window.__sceneRequest, ready: async () => {}, seek: () => new Promise(() => {}) };</script>`))
+	}))
+	defer server.Close()
+	request.URL = server.URL
+	output := filepath.Join(t.TempDir(), "timed-out.mp4")
+	_, err := renderer.Render(context.Background(), request, output)
+	if !errors.Is(err, context.DeadlineExceeded) {
+		t.Fatalf("expected frame deadline, got %v", err)
+	}
+	if _, err := os.Stat(output); !os.IsNotExist(err) {
+		t.Fatal("timed-out frame published an asset")
+	}
+}
+
+func assertTransparentCorner(t *testing.T, data []byte) {
+	t.Helper()
+	image, err := png.Decode(bytes.NewReader(data))
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, _, _, alpha := image.At(0, 0).RGBA()
+	if alpha != 0 {
+		t.Fatalf("expected alpha zero at empty corner, got %d", alpha)
+	}
+}
+
+type probeStream struct {
+	CodecName string `json:"codec_name"`
+	Width     int    `json:"width"`
+	Height    int    `json:"height"`
+	Frames    string `json:"nb_frames"`
+}
+
+func probeStreams(t *testing.T, path string) []probeStream {
+	t.Helper()
+	executable := os.Getenv("SCENE_FFPROBE")
+	if executable == "" {
+		t.Fatal("SCENE_FFPROBE is required for native verification")
+	}
+	data, err := exec.Command(executable, "-v", "error", "-show_streams", "-of", "json", path).Output()
+	if err != nil {
+		t.Fatalf("probe rendered output: %v", err)
+	}
+	var result struct {
+		Streams []probeStream `json:"streams"`
+	}
+	if err := json.Unmarshal(data, &result); err != nil {
+		t.Fatal(err)
+	}
+	return result.Streams
+}

package/renderer/cmd/scene-render/main.go

@@ -0,0 +1,118 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"time"
+
+	sceneengine "github.com/catalinfl/viral-server/scene-engine/renderer"
+)
+
+type cliOptions struct {
+	requestFile    string
+	output         string
+	serveDirectory string
+	renderer       sceneengine.Options
+}
+
+func main() {
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+	options := parseFlags()
+	if err := run(ctx, options, os.Stdout, os.Stderr); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func parseFlags() cliOptions {
+	var options cliOptions
+	var allowedOrigins string
+	flag.StringVar(&options.requestFile, "request", "", "JSON/YAML job file (required)")
+	flag.StringVar(&options.output, "output", "", "new .mp4 or .webm output file (required)")
+	flag.StringVar(&options.serveDirectory, "serve", "", "serve a built scene directory on an ephemeral loopback port")
+	flag.StringVar(&options.renderer.BrowserExecutable, "browser", os.Getenv("SCENE_BROWSER"), "pinned Chrome Headless Shell executable")
+	flag.StringVar(&options.renderer.FFmpegExecutable, "ffmpeg", "ffmpeg", "FFmpeg executable")
+	flag.IntVar(&options.renderer.Concurrency, "workers", 2, "concurrent pages (1–16)")
+	flag.IntVar(&options.renderer.EncoderThreads, "encoder-threads", 0, "encoder threads (0 = automatic, at most 32)")
+	flag.StringVar(&options.renderer.X264Preset, "x264-preset", "medium", "x264 speed/compression preset (does not select quality)")
+	flag.BoolVar(&options.renderer.Lossless, "lossless", false, "lossless intermediate encoding; MP4 retains RGB, WebM retains alpha")
+	flag.BoolVar(&options.renderer.EnableGPU, "gpu", false, "allow hardware GPU rendering (requires working device access)")
+	flag.DurationVar(&options.renderer.FrameTimeout, "frame-timeout", 30*time.Second, "timeout for page preparation or one frame")
+	flag.BoolVar(&options.renderer.NoSandbox, "no-sandbox", false, "disable Chromium sandbox for an externally isolated container")
+	flag.StringVar(&allowedOrigins, "allow-origins", "", "comma-separated additional resource origins")
+	flag.Parse()
+	if allowedOrigins != "" {
+		for _, origin := range strings.Split(allowedOrigins, ",") {
+			options.renderer.AllowedOrigins = append(options.renderer.AllowedOrigins, strings.TrimSpace(origin))
+		}
+	}
+	return options
+}
+
+func run(ctx context.Context, options cliOptions, stdout, stderr io.Writer) error {
+	if options.requestFile == "" || options.output == "" {
+		return fmt.Errorf("-request and -output are required")
+	}
+	request, err := loadRequest(options.requestFile)
+	if err != nil {
+		return err
+	}
+	if options.serveDirectory != "" {
+		resolvedURL, closeServer, err := serveScene(options.serveDirectory, request.URL)
+		if err != nil {
+			return err
+		}
+		defer closeServer()
+		request.URL = resolvedURL
+	}
+	options.renderer.Progress = func(progress sceneengine.Progress) {
+		if progress.WrittenFrames == 1 || progress.WrittenFrames%30 == 0 || progress.WrittenFrames == progress.TotalFrames {
+			fmt.Fprintf(stderr, "frames %d/%d · %s\n", progress.WrittenFrames, progress.TotalFrames, progress.Elapsed.Round(time.Millisecond))
+		}
+	}
+	renderer, err := sceneengine.New(ctx, options.renderer)
+	if err != nil {
+		return err
+	}
+	defer renderer.Close()
+	result, err := renderer.Render(ctx, request, options.output)
+	if err != nil {
+		return err
+	}
+	if err := json.NewEncoder(stdout).Encode(result); err != nil {
+		return fmt.Errorf("write result JSON: %w", err)
+	}
+	return nil
+}
+
+func loadRequest(path string) (sceneengine.Request, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return sceneengine.Request{}, fmt.Errorf("open request: %w", err)
+	}
+	defer file.Close()
+	request, err := sceneengine.DecodeRequest(file)
+	if err != nil {
+		return request, err
+	}
+	for index := range request.Audio {
+		source := &request.Audio[index]
+		if !filepath.IsAbs(source.File) {
+			source.File = filepath.Join(filepath.Dir(path), source.File)
+		}
+		source.File, err = filepath.Abs(source.File)
+		if err != nil {
+			return request, fmt.Errorf("resolve audio[%d]: %w", index, err)
+		}
+	}
+	return request, nil
+}

package/renderer/cmd/scene-render/server.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"time"
+)
+
+func serveScene(directory, sceneURL string) (string, func(), error) {
+	info, err := os.Stat(directory)
+	if err != nil || !info.IsDir() {
+		return "", nil, fmt.Errorf("scene build directory is unavailable: %s", directory)
+	}
+	relative, err := url.Parse(sceneURL)
+	if err != nil || relative.IsAbs() || relative.Host != "" {
+		return "", nil, fmt.Errorf("with -serve, request URL must be a relative scene path")
+	}
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		return "", nil, fmt.Errorf("listen for scene files: %w", err)
+	}
+	server := &http.Server{Handler: http.FileServer(http.Dir(directory)), ReadHeaderTimeout: 5 * time.Second}
+	go func() {
+		// Shutdown below is the expected termination path for this private file server.
+		if err := server.Serve(listener); err != nil && err != http.ErrServerClosed {
+			server.Close()
+		}
+	}()
+	base := &url.URL{Scheme: "http", Host: listener.Addr().String(), Path: "/"}
+	closeServer := func() {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		if err := server.Shutdown(ctx); err != nil {
+			server.Close()
+		}
+	}
+	return base.ResolveReference(relative).String(), closeServer, nil
+}

package/renderer/encoder.go

@@ -0,0 +1,116 @@
+package sceneengine
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+const maxEncoderLogBytes = 32 << 10
+
+type encoder struct {
+	command *exec.Cmd
+	input   io.WriteCloser
+	log     tailLog
+}
+
+type tailLog struct{ buffer []byte }
+
+func (l *tailLog) Write(data []byte) (int, error) {
+	count := len(data)
+	l.buffer = append(l.buffer, data...)
+	if len(l.buffer) > maxEncoderLogBytes {
+		l.buffer = bytes.Clone(l.buffer[len(l.buffer)-maxEncoderLogBytes:])
+	}
+	return count, nil
+}
+
+func startEncoder(ctx context.Context, options Options, request Request, codec Codec, output string) (*encoder, error) {
+	args := encoderArgs(request, codec, output, options)
+	process := &encoder{command: exec.CommandContext(ctx, options.FFmpegExecutable, args...)}
+	process.command.Stderr = &process.log
+	input, err := process.command.StdinPipe()
+	if err != nil {
+		return nil, fmt.Errorf("open encoder stdin: %w", err)
+	}
+	process.input = input
+	if err := process.command.Start(); err != nil {
+		input.Close()
+		return nil, fmt.Errorf("start FFmpeg: %w", err)
+	}
+	return process, nil
+}
+
+func (e *encoder) finish() error {
+	closeErr := e.input.Close()
+	if err := e.command.Wait(); err != nil {
+		return fmt.Errorf("FFmpeg encoding failed: %w\n%s", err, string(e.log.buffer))
+	}
+	if closeErr != nil {
+		return fmt.Errorf("close encoder input: %w", closeErr)
+	}
+	return nil
+}
+
+func encoderArgs(request Request, codec Codec, output string, options Options) []string {
+	args := []string{"-hide_banner", "-loglevel", "error", "-y", "-f", "image2pipe", "-framerate", decimal(request.Config.FPS), "-vcodec", "png", "-i", "pipe:0"}
+	for _, audio := range request.Audio {
+		args = append(args, "-i", audio.File)
+	}
+	if len(request.Audio) > 0 {
+		args = append(args, "-filter_complex", audioFilter(request), "-map", "0:v:0", "-map", "[audio]")
+		if codec == H264 {
+			args = append(args, "-c:a", "aac", "-b:a", "192k")
+		} else {
+			args = append(args, "-c:a", "libopus", "-b:a", "192k")
+		}
+	} else {
+		args = append(args, "-map", "0:v:0", "-an")
+	}
+	if codec == H264 {
+		encoder, crf, pixelFormat := "libx264", "18", "yuv420p"
+		if options.Lossless {
+			encoder, crf, pixelFormat = "libx264rgb", "0", "rgb24"
+		}
+		args = append(args, "-c:v", encoder, "-preset", options.X264Preset, "-crf", crf, "-pix_fmt", pixelFormat, "-movflags", "+faststart")
+	} else {
+		pixelFormat := "yuv420p"
+		if request.Config.Transparent {
+			pixelFormat = "yuva420p"
+		}
+		crf := "30"
+		if options.Lossless {
+			crf = "0"
+		}
+		args = append(args, "-c:v", "libvpx-vp9", "-crf", crf, "-b:v", "0", "-pix_fmt", pixelFormat, "-auto-alt-ref", "0")
+		if options.Lossless {
+			args = append(args, "-lossless", "1", "-deadline", "good", "-cpu-used", "4", "-row-mt", "1")
+		}
+	}
+	if options.EncoderThreads > 0 {
+		args = append(args, "-threads", strconv.Itoa(options.EncoderThreads))
+	}
+	return append(args, "-t", decimal(request.Config.Duration()), output)
+}
+
+func audioFilter(request Request) string {
+	filters := make([]string, 0, len(request.Audio)+1)
+	labels := make([]string, 0, len(request.Audio))
+	for index, track := range request.Audio {
+		volume := 1.0
+		if track.Volume != nil {
+			volume = *track.Volume
+		}
+		label := fmt.Sprintf("[a%d]", index)
+		filters = append(filters, fmt.Sprintf("[%d:a:0]atrim=start=%s:duration=%s,asetpts=PTS-STARTPTS,volume=%s,adelay=%d:all=1%s", index+1, decimal(track.From), decimal(track.Duration), decimal(volume), int64(track.Start*1000+0.5), label))
+		labels = append(labels, label)
+	}
+	filters = append(filters, fmt.Sprintf("%samix=inputs=%d:normalize=0,apad,atrim=duration=%s[audio]", strings.Join(labels, ""), len(labels), decimal(request.Config.Duration())))
+	return strings.Join(filters, ";")
+}
+
+func decimal(value float64) string { return strconv.FormatFloat(value, 'f', -1, 64) }

package/renderer/encoder_test.go

@@ -0,0 +1,22 @@
+package sceneengine
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestLosslessEncodingRetainsCaptureDetail(t *testing.T) {
+	request := fixtureRequest()
+	options := Options{Lossless: true, X264Preset: "ultrafast", EncoderThreads: 2}
+	args := strings.Join(encoderArgs(request, H264, "scene.mp4", options), " ")
+	for _, want := range []string{"-vcodec png", "-c:v libx264rgb", "-preset ultrafast", "-crf 0", "-pix_fmt rgb24", "-threads 2"} {
+		if !strings.Contains(args, want) {
+			t.Fatalf("missing %s in %s", want, args)
+		}
+	}
+	request.Config.Transparent = true
+	args = strings.Join(encoderArgs(request, VP9, "scene.webm", options), " ")
+	if !strings.Contains(args, "-lossless 1") || !strings.Contains(args, "-pix_fmt yuva420p") {
+		t.Fatal(args)
+	}
+}

package/renderer/go.mod

@@ -0,0 +1,11 @@
+module github.com/catalinfl/viral-server/scene-engine/renderer
+
+go 1.27.2
+
+require (
+	github.com/chromedp/cdproto v0.157.8
+	github.com/chromedp/chromedp v0.20.1
+	gopkg.in/yaml.v3 v3.0.1
+)
+
+require github.com/go-json-experiment/json v0.0.0-20260213210345-44df1a37e875 // indirect

package/renderer/go.sum

@@ -0,0 +1,10 @@
+github.com/chromedp/cdproto v0.157.8 h1:Tkq0AjsUlC3Z4sJfHBzV/uAAxnTF/AZyuSTjfV/1gvk=
+github.com/chromedp/cdproto v0.157.8/go.mod h1:h68JaIuFr9o3yiayxEYhBdvaxgYO3shDrPSYhNlyfu0=
+github.com/chromedp/chromedp v0.20.1 h1:983T9wmyM09JtROWlxhLQwljKOQovqt8CVE89W3U0NA=
+github.com/chromedp/chromedp v0.20.1/go.mod h1:6z1Y5FdKUxRzxx2qcC5h1xjaBJrSWrZp1mjgITfNZig=
+github.com/go-json-experiment/json v0.0.0-20260213210345-44df1a37e875 h1:XGPtjxqp0FS8jj1Z7QGcSOSgyq1fUPjNyJXvi3KfI4A=
+github.com/go-json-experiment/json v0.0.0-20260213210345-44df1a37e875/go.mod h1:uNVvRXArCGbZ508SxYYTC5v1JWoz2voff5pm25jU1Ok=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

package/renderer/network.go

@@ -0,0 +1,50 @@
+package sceneengine
+
+import (
+	"context"
+	"strings"
+
+	"github.com/chromedp/cdproto/cdp"
+	"github.com/chromedp/cdproto/fetch"
+	"github.com/chromedp/cdproto/network"
+	"github.com/chromedp/chromedp"
+)
+
+func allowRequest(raw string, allowed map[string]bool) bool {
+	if strings.HasPrefix(raw, "data:") || strings.HasPrefix(raw, "blob:") || raw == "about:blank" {
+		return true
+	}
+	origin, err := parseOrigin(raw)
+	return err == nil && allowed[origin]
+}
+
+func restrictNetwork(owner context.Context, requestURL string, extraOrigins []string, cancel context.CancelFunc) chromedp.Action[chromedp.Void] {
+	allowed := make(map[string]bool)
+	origin, _ := parseOrigin(requestURL)
+	allowed[origin] = true
+	for _, raw := range extraOrigins {
+		origin, _ := parseOrigin(raw)
+		allowed[origin] = true
+	}
+	return chromedp.Func(func(ctx context.Context, target *chromedp.Target) error {
+		events := cdp.Events(owner, target, fetch.RequestPaused)
+		go func() {
+			for request, err := range events {
+				if err != nil {
+					return
+				}
+				if allowRequest(request.Request.URL, allowed) {
+					_, err = cdp.Call(owner, target, fetch.ContinueRequest, fetch.ContinueRequestParams{RequestID: request.RequestID})
+				} else {
+					_, err = cdp.Call(owner, target, fetch.FailRequest, fetch.FailRequestParams{RequestID: request.RequestID, ErrorReason: network.ErrorReasonBlockedByClient})
+				}
+				if err != nil {
+					cancel()
+					return
+				}
+			}
+		}()
+		_, err := cdp.Call(ctx, target, fetch.Enable, fetch.EnableParams{})
+		return err
+	})
+}