local-preview 0.1.0__py3-none-any.whl

cmd/server/cli.go

@@ -0,0 +1,31 @@
+package server
+
+import (
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+// addClientCommands attaches the user-facing CLI subcommand groups to root.
+// They're thin wrappers over the HTTP API, useful for scripting and remote
+// control of a running `preview serve`.
+func addClientCommands(root *cobra.Command) {
+	root.AddCommand(repoCmd(), deployCmd(), installHookCmd())
+}
+
+// resolveURL returns the effective server URL for a leaf command. PREVIEW_URL
+// wins only when the user didn't explicitly pass --server.
+func resolveURL(cmd *cobra.Command, serverURL string) string {
+	if env := os.Getenv("PREVIEW_URL"); env != "" && !cmd.Flags().Changed("server") {
+		return env
+	}
+	return serverURL
+}
+
+// addServerFlag registers --server as a persistent flag on the parent group
+// so every leaf inherits it. The same string variable is reused across the
+// group's subcommands.
+func addServerFlag(parent *cobra.Command, dst *string) {
+	parent.PersistentFlags().StringVar(dst, "server", "http://localhost:8080",
+		"Base URL of the HTTP server")
+}

cmd/server/cli_test.go

@@ -0,0 +1,53 @@
+package server
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+)
+
+// runLeaf executes a parent command with an inherited --server flag and
+// returns what resolveURL reports inside the leaf's RunE — the same shape as
+// the real CLI subcommands.
+func runLeaf(t *testing.T, args ...string) string {
+	t.Helper()
+	var serverURL string
+	var got string
+	parent := &cobra.Command{Use: "root"}
+	addServerFlag(parent, &serverURL)
+	leaf := &cobra.Command{
+		Use: "leaf",
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			got = resolveURL(cmd, serverURL)
+			return nil
+		},
+	}
+	parent.AddCommand(leaf)
+	parent.SetArgs(append([]string{"leaf"}, args...))
+	if err := parent.Execute(); err != nil {
+		t.Fatal(err)
+	}
+	return got
+}
+
+func TestResolveURL(t *testing.T) {
+	t.Run("default", func(t *testing.T) {
+		if got := runLeaf(t); got != "http://localhost:8080" {
+			t.Errorf("resolveURL = %q, want default", got)
+		}
+	})
+
+	t.Run("env wins over default", func(t *testing.T) {
+		t.Setenv("PREVIEW_URL", "http://env:1234")
+		if got := runLeaf(t); got != "http://env:1234" {
+			t.Errorf("resolveURL = %q, want env value", got)
+		}
+	})
+
+	t.Run("explicit flag wins over env", func(t *testing.T) {
+		t.Setenv("PREVIEW_URL", "http://env:1234")
+		if got := runLeaf(t, "--server", "http://flag:5678"); got != "http://flag:5678" {
+			t.Errorf("resolveURL = %q, want flag value", got)
+		}
+	})
+}

cmd/server/deploy.go

@@ -0,0 +1,222 @@
+package server
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"text/tabwriter"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/jmelahman/local-preview/internal/client"
+)
+
+func deployCmd() *cobra.Command {
+	var serverURL string
+	var repoFlag string
+	var rebuild, noWait, asJSON bool
+
+	parent := &cobra.Command{
+		Use:   "deploy [ref]",
+		Short: "Deploy a commit as a preview",
+		Long: "Deploy a commit (default: HEAD of the current repo) and print its\n" +
+			"preview URL. The repo is auto-detected from the working directory\n" +
+			"unless --repo is given.",
+		Args: cobra.MaximumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ref := ""
+			if len(args) == 1 {
+				ref = args[0]
+			}
+			return runDeploy(cmd.Context(), resolveURL(cmd, serverURL), cmd.OutOrStdout(),
+				repoFlag, ref, rebuild, noWait, asJSON)
+		},
+	}
+	addServerFlag(parent, &serverURL)
+	parent.Flags().StringVar(&repoFlag, "repo", "", "Registered repo name (default: auto-detect from cwd)")
+	parent.Flags().BoolVar(&rebuild, "rebuild", false, "Rebuild artifacts even if cached (needs a restart to affect a live backend)")
+	parent.Flags().BoolVar(&noWait, "no-wait", false, "Return immediately instead of waiting for the build")
+	parent.Flags().BoolVar(&asJSON, "json", false, "Print the deploy as JSON")
+
+	list := &cobra.Command{
+		Use:   "list",
+		Short: "List deploys",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runDeployList(cmd.Context(), resolveURL(cmd, serverURL), cmd.OutOrStdout(), repoFlag)
+		},
+	}
+
+	show := &cobra.Command{
+		Use:   "show <id>",
+		Short: "Show one deploy",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			id, err := parseInt64(args[0], "deploy id")
+			if err != nil {
+				return err
+			}
+			d, err := client.New(resolveURL(cmd, serverURL), nil).GetDeploy(cmd.Context(), id)
+			if err != nil {
+				return err
+			}
+			return printDeployJSON(cmd.OutOrStdout(), d)
+		},
+	}
+
+	logs := &cobra.Command{
+		Use:   "logs <id>",
+		Short: "Print a deploy's build logs",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			id, err := parseInt64(args[0], "deploy id")
+			if err != nil {
+				return err
+			}
+			text, err := client.New(resolveURL(cmd, serverURL), nil).GetDeployLogs(cmd.Context(), id)
+			if err != nil {
+				return err
+			}
+			fmt.Fprint(cmd.OutOrStdout(), text)
+			return nil
+		},
+	}
+
+	parent.AddCommand(list, show, logs)
+	return parent
+}
+
+func runDeploy(ctx context.Context, url string, out io.Writer, repoName, ref string, rebuild, noWait, asJSON bool) error {
+	c := client.New(url, nil)
+
+	if ref == "" {
+		sha, err := gitOutput(ctx, "rev-parse", "HEAD")
+		if err != nil {
+			return fmt.Errorf("no ref given and no commit found in the current directory: %w", err)
+		}
+		ref = sha
+	}
+	if repoName == "" {
+		var err error
+		repoName, err = detectRepo(ctx, c)
+		if err != nil {
+			return err
+		}
+	}
+
+	d, err := c.CreateDeploy(ctx, repoName, ref, rebuild)
+	if err != nil {
+		return err
+	}
+	if noWait {
+		if asJSON {
+			return printDeployJSON(out, d)
+		}
+		fmt.Fprintf(out, "deploy %d (%s@%s) %s\n", d.ID, d.Repo, d.ShortSHA, d.Status)
+		return nil
+	}
+
+	for d.Status == "queued" || d.Status == "building" {
+		time.Sleep(500 * time.Millisecond)
+		d, err = c.GetDeploy(ctx, d.ID)
+		if err != nil {
+			return err
+		}
+	}
+	if asJSON {
+		return printDeployJSON(out, d)
+	}
+	switch d.Status {
+	case "ready":
+		fmt.Fprintf(out, "ready: %s\n", d.PreviewURL)
+		if rebuild {
+			fmt.Fprintf(out, "note: --rebuild replaced the artifacts on disk; a running backend keeps its old binary until restarted\n")
+		}
+		return nil
+	default:
+		fmt.Fprintf(out, "deploy %d %s: %s\n", d.ID, d.Status, d.Error)
+		fmt.Fprintf(out, "full logs: preview deploy logs %d\n", d.ID)
+		return fmt.Errorf("deploy did not become ready")
+	}
+}
+
+// detectRepo matches the cwd's git toplevel or origin URL against the
+// server's registered repos.
+func detectRepo(ctx context.Context, c *client.Client) (string, error) {
+	repos, err := c.ListRepos(ctx)
+	if err != nil {
+		return "", err
+	}
+	if top, err := gitOutput(ctx, "rev-parse", "--show-toplevel"); err == nil {
+		absTop, _ := filepath.Abs(top)
+		for _, r := range repos {
+			if absSource, err := filepath.Abs(r.Source); err == nil && absSource == absTop {
+				return r.Name, nil
+			}
+		}
+	}
+	if origin, err := gitOutput(ctx, "config", "--get", "remote.origin.url"); err == nil && origin != "" {
+		for _, r := range repos {
+			if r.Source == origin {
+				return r.Name, nil
+			}
+		}
+	}
+	return "", fmt.Errorf("could not match the current directory to a registered repo; pass --repo (registered: %s)", repoNames(repos))
+}
+
+func repoNames(repos []client.Repo) string {
+	if len(repos) == 0 {
+		return "none"
+	}
+	names := make([]string, len(repos))
+	for i, r := range repos {
+		names[i] = r.Name
+	}
+	return strings.Join(names, ", ")
+}
+
+func gitOutput(ctx context.Context, args ...string) (string, error) {
+	out, err := exec.CommandContext(ctx, "git", args...).Output()
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(string(out)), nil
+}
+
+func runDeployList(ctx context.Context, url string, out io.Writer, repoName string) error {
+	deploys, err := client.New(url, nil).ListDeploys(ctx, repoName)
+	if err != nil {
+		return err
+	}
+	tw := tabwriter.NewWriter(out, 0, 0, 2, ' ', 0)
+	fmt.Fprintln(tw, "ID\tREPO\tSHA\tSTATUS\tURL")
+	for _, d := range deploys {
+		url := d.PreviewURL
+		if url == "" {
+			url = "-"
+		}
+		fmt.Fprintf(tw, "%d\t%s\t%s\t%s\t%s\n", d.ID, d.Repo, d.ShortSHA, d.Status, url)
+	}
+	return tw.Flush()
+}
+
+func printDeployJSON(out io.Writer, d client.Deploy) error {
+	enc := json.NewEncoder(out)
+	enc.SetIndent("", "  ")
+	return enc.Encode(d)
+}
+
+// parseInt64 wraps strconv.ParseInt with a descriptive error.
+func parseInt64(s, label string) (int64, error) {
+	id, err := strconv.ParseInt(s, 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("invalid %s %q: %w", label, s, err)
+	}
+	return id, nil
+}

cmd/server/hook.go

@@ -0,0 +1,92 @@
+package server
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+// hookMarker identifies hooks we generated, so install-hook never clobbers a
+// hand-written one.
+const hookMarker = "# generated by local-preview (preview install-hook)"
+
+const hookScript = `#!/bin/sh
+` + hookMarker + `
+preview deploy "$(git rev-parse HEAD)" --no-wait >/dev/null 2>&1 || true
+`
+
+// preCommitStanza is printed (never auto-applied — silently mutating a file
+// the pre-commit framework re-parses is riskier than asking the user to
+// paste) when the target repo already uses the pre-commit framework.
+const preCommitStanza = `  - repo: local
+    hooks:
+      - id: local-preview
+        name: local-preview deploy
+        entry: sh -c 'preview deploy "$(git rev-parse HEAD)" --no-wait'
+        language: system
+        stages: [post-commit]
+        always_run: true
+        pass_filenames: false
+`
+
+func installHookCmd() *cobra.Command {
+	var dryRun bool
+	cmd := &cobra.Command{
+		Use:   "install-hook",
+		Short: "Install a post-commit hook that deploys every commit",
+		Long: "Run from inside a target repository's working tree. Installs a git\n" +
+			"post-commit hook that requests a preview deploy of each new commit.\n" +
+			"If the repo uses the pre-commit framework, the equivalent stanza is\n" +
+			"printed for .pre-commit-config.yaml instead.",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runInstallHook(cmd.Context(), cmd.OutOrStdout(), dryRun)
+		},
+	}
+	cmd.Flags().BoolVar(&dryRun, "dry-run", false, "Print what would be written without writing it")
+	return cmd
+}
+
+func runInstallHook(ctx context.Context, out io.Writer, dryRun bool) error {
+	top, err := gitOutput(ctx, "rev-parse", "--show-toplevel")
+	if err != nil {
+		return fmt.Errorf("not inside a git working tree: %w", err)
+	}
+
+	if _, err := os.Stat(filepath.Join(top, ".pre-commit-config.yaml")); err == nil {
+		fmt.Fprintf(out, "This repo uses the pre-commit framework. Add this hook to .pre-commit-config.yaml\n")
+		fmt.Fprintf(out, "(and install the post-commit stage with `pre-commit install --hook-type post-commit`):\n\n")
+		fmt.Fprint(out, preCommitStanza)
+		return nil
+	}
+
+	gitDir, err := gitOutput(ctx, "rev-parse", "--git-dir")
+	if err != nil {
+		return err
+	}
+	if !filepath.IsAbs(gitDir) {
+		gitDir = filepath.Join(top, gitDir)
+	}
+	hookPath := filepath.Join(gitDir, "hooks", "post-commit")
+
+	if existing, err := os.ReadFile(hookPath); err == nil && !strings.Contains(string(existing), hookMarker) {
+		return fmt.Errorf("%s already exists and wasn't generated by local-preview — add this line to it yourself:\n  preview deploy \"$(git rev-parse HEAD)\" --no-wait || true", hookPath)
+	}
+
+	if dryRun {
+		fmt.Fprintf(out, "would write %s:\n\n%s", hookPath, hookScript)
+		return nil
+	}
+	if err := os.MkdirAll(filepath.Dir(hookPath), 0o755); err != nil {
+		return err
+	}
+	if err := os.WriteFile(hookPath, []byte(hookScript), 0o755); err != nil {
+		return err
+	}
+	fmt.Fprintf(out, "installed %s — every commit now deploys a preview\n", hookPath)
+	return nil
+}

cmd/server/main.go

@@ -0,0 +1,204 @@
+package server
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"runtime/debug"
+	"syscall"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/jmelahman/local-preview/internal/api"
+	"github.com/jmelahman/local-preview/internal/build"
+	"github.com/jmelahman/local-preview/internal/config"
+	"github.com/jmelahman/local-preview/internal/db"
+	"github.com/jmelahman/local-preview/internal/gitrepo"
+	"github.com/jmelahman/local-preview/internal/proxy"
+	"github.com/jmelahman/local-preview/internal/store"
+	"github.com/jmelahman/local-preview/internal/supervise"
+)
+
+// version is populated at build time via -ldflags -X (see Dockerfile /
+// .goreleaser.yaml). Use `git describe --tags --always --dirty` so a single
+// string carries tag, distance, short sha, and dirty marker. Falls back to
+// runtime/debug VCS info for dev builds without ldflags.
+var version = ""
+
+// BuildInfo describes the running binary.
+type BuildInfo struct {
+	Version string `json:"version"`
+}
+
+// Build returns the build metadata for the running binary, falling back to
+// runtime/debug VCS info when ldflags weren't set.
+func Build() BuildInfo {
+	if version != "" {
+		return BuildInfo{Version: version}
+	}
+	if info, ok := debug.ReadBuildInfo(); ok {
+		var rev string
+		var modified bool
+		for _, s := range info.Settings {
+			switch s.Key {
+			case "vcs.revision":
+				rev = s.Value
+			case "vcs.modified":
+				modified = s.Value == "true"
+			}
+		}
+		if rev != "" {
+			short := rev
+			if len(short) > 7 {
+				short = short[:7]
+			}
+			if modified {
+				short += "-dirty"
+			}
+			return BuildInfo{Version: short}
+		}
+	}
+	return BuildInfo{Version: "dev"}
+}
+
+func Root() *cobra.Command {
+	var addr string
+	var dataDir string
+	var inMemory bool
+	var previewDomain string
+	var buildConcurrency int
+
+	cmd := &cobra.Command{
+		Use:     "preview",
+		Short:   "Local preview-deployment orchestrator",
+		Version: Build().Version,
+	}
+
+	serve := &cobra.Command{
+		Use:   "serve",
+		Short: "Start the HTTP server",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return run(addr, dataDir, inMemory, previewDomain, buildConcurrency)
+		},
+	}
+	serve.Flags().StringVar(&addr, "addr", ":8080", "HTTP listen address")
+	serve.Flags().StringVar(&dataDir, "data-dir", "", "Override data directory (default: $PREVIEW_DATA_DIR or XDG)")
+	serve.Flags().BoolVar(&inMemory, "in-memory", false, "Use an ephemeral in-memory SQLite database; all data is discarded on shutdown")
+	serve.Flags().StringVar(&previewDomain, "preview-domain", "", "Base domain previews are served under (default: $PREVIEW_DOMAIN or preview.localhost)")
+	serve.Flags().IntVar(&buildConcurrency, "build-concurrency", 2, "Number of deploys built in parallel")
+	cmd.AddCommand(serve)
+
+	addClientCommands(cmd)
+
+	return cmd
+}
+
+func run(addr, dataDirOverride string, inMemory bool, previewDomain string, buildConcurrency int) error {
+	cfg, err := config.Load(dataDirOverride, previewDomain)
+	if err != nil {
+		return fmt.Errorf("load config: %w", err)
+	}
+	workCtx, stopWork := context.WithCancel(context.Background())
+	defer stopWork()
+	if err := gitrepo.CheckGit(workCtx); err != nil {
+		return err
+	}
+
+	dbPath := cfg.DBPath()
+	if inMemory {
+		log.Printf("WARNING: --in-memory set; using ephemeral SQLite, all data is lost on shutdown")
+		dbPath = ":memory:"
+	}
+	database, err := db.Open(dbPath)
+	if err != nil {
+		return fmt.Errorf("open db: %w", err)
+	}
+	defer database.Close()
+
+	files := store.New(cfg.ArtifactsDir(), cfg.StateDir(), cfg.TmpDir())
+	if err := files.SweepTmp(24 * time.Hour); err != nil {
+		log.Printf("sweep tmp: %v", err)
+	}
+	gitMgr := gitrepo.NewManager(cfg.ReposDir())
+	super := supervise.New(database, files, cfg.LogsDir())
+	super.ReclaimOrphans()
+	queue := build.NewQueue(database, gitMgr, files, super, cfg.LogsDir(), nil)
+	queue.Start(workCtx, buildConcurrency)
+
+	apex := api.NewMux(api.Deps{
+		Store:  database,
+		Build:  api.BuildInfo(Build()),
+		Config: cfg,
+		Git:    gitMgr,
+		Queue:  queue,
+		Super:  super,
+		Addr:   addr,
+	})
+	router := proxy.New(database, files, super, cfg.PreviewDomain, apex)
+
+	srv := &http.Server{
+		Addr:              addr,
+		Handler:           recoverPanics(logRequests(router)),
+		ReadHeaderTimeout: 10 * time.Second,
+	}
+
+	go func() {
+		log.Printf("listening on %s (previews at *.%s)", addr, cfg.PreviewDomain)
+		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
+			log.Fatalf("listen: %v", err)
+		}
+	}()
+
+	stop := make(chan os.Signal, 1)
+	signal.Notify(stop, os.Interrupt, syscall.SIGTERM)
+	<-stop
+	log.Println("shutting down")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	err = srv.Shutdown(ctx)
+	stopWork()
+	super.StopAll()
+	return err
+}
+
+type statusRecorder struct {
+	http.ResponseWriter
+	status int
+}
+
+func (s *statusRecorder) WriteHeader(code int) {
+	s.status = code
+	s.ResponseWriter.WriteHeader(code)
+}
+
+// recoverPanics is the outermost middleware. It catches panics from any
+// downstream handler so the process survives, logs the trace, and writes a
+// 500 response.
+func recoverPanics(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		defer func() {
+			rec := recover()
+			if rec == nil {
+				return
+			}
+			log.Printf("panic recovered: %v\n%s", rec, debug.Stack())
+			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+		}()
+		next.ServeHTTP(w, r)
+	})
+}
+
+func logRequests(h http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		start := time.Now()
+		rec := &statusRecorder{ResponseWriter: w, status: 200}
+		h.ServeHTTP(rec, r)
+		log.Printf("%s %s %d %s", r.Method, r.URL.Path, rec.status, time.Since(start))
+	})
+}

cmd/server/repo.go

@@ -0,0 +1,68 @@
+package server
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"text/tabwriter"
+
+	"github.com/spf13/cobra"
+
+	"github.com/jmelahman/local-preview/internal/client"
+)
+
+func repoCmd() *cobra.Command {
+	var serverURL string
+	parent := &cobra.Command{
+		Use:   "repo",
+		Short: "Manage registered repositories",
+	}
+	addServerFlag(parent, &serverURL)
+
+	var source string
+	create := &cobra.Command{
+		Use:   "create <name>",
+		Short: "Register a repository for previews",
+		Long: "Register a repository: the server keeps a mirror clone of --source\n" +
+			"(a local path or clone URL) and serves previews at <sha>.<name>.<domain>.",
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runRepoCreate(cmd.Context(), resolveURL(cmd, serverURL), cmd.OutOrStdout(), args[0], source)
+		},
+	}
+	create.Flags().StringVar(&source, "source", "", "Local path or clone URL of the repository (required)")
+	_ = create.MarkFlagRequired("source")
+
+	list := &cobra.Command{
+		Use:   "list",
+		Short: "List registered repositories",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runRepoList(cmd.Context(), resolveURL(cmd, serverURL), cmd.OutOrStdout())
+		},
+	}
+
+	parent.AddCommand(create, list)
+	return parent
+}
+
+func runRepoCreate(ctx context.Context, url string, out io.Writer, name, source string) error {
+	repo, err := client.New(url, nil).CreateRepo(ctx, name, source)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(out, "registered %s (source %s)\n", repo.Name, repo.Source)
+	return nil
+}
+
+func runRepoList(ctx context.Context, url string, out io.Writer) error {
+	repos, err := client.New(url, nil).ListRepos(ctx)
+	if err != nil {
+		return err
+	}
+	tw := tabwriter.NewWriter(out, 0, 0, 2, ' ', 0)
+	fmt.Fprintln(tw, "NAME\tSOURCE\tCREATED")
+	for _, r := range repos {
+		fmt.Fprintf(tw, "%s\t%s\t%s\n", r.Name, r.Source, r.CreatedAt)
+	}
+	return tw.Flush()
+}

go.mod

@@ -0,0 +1,24 @@
+module github.com/jmelahman/local-preview
+
+go 1.26.5
+
+require (
+	github.com/BurntSushi/toml v1.6.0
+	github.com/spf13/cobra v1.10.2
+	golang.org/x/sync v0.22.0
+	modernc.org/sqlite v1.55.0
+)
+
+require (
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/ncruces/go-strftime v1.0.0 // indirect
+	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/spf13/pflag v1.0.9 // indirect
+	golang.org/x/sys v0.46.0 // indirect
+	modernc.org/libc v1.74.1 // indirect
+	modernc.org/mathutil v1.7.1 // indirect
+	modernc.org/memory v1.11.0 // indirect
+)