chore(deps): update golang:1.27-alpine docker digest to f92b6ef (main) (#7)

Co-authored-by: renovate <renovate@hhhhh.dev>

README.md

@@ -25,11 +25,9 @@ A repository is identified by the hash of its root commit, so nothing is registe
 shared docs/agents
 shared CLAUDE.local.md
 branch .agent
-ignore vault/.obsidian/workspace*.json
-ignore .DS_Store
 ```
 
-`ignore` keeps matching files on the machine that has them: they are never pushed, pulled or watched. Its pattern is a glob over the whole path, or over any single name when it has no slash. Synced paths are hidden through `.git/info/exclude`; `.gitignore` is never touched, and files tracked by git are never synced. When two machines edit the same file, the later edit wins and the other version stays in history.
+Synced paths are hidden through `.git/info/exclude`; `.gitignore` is never touched, and files tracked by git are never synced. When two machines edit the same file, the later edit wins and the other version stays in history.
 
 ## Adding a machine
 
@@ -43,14 +41,6 @@ Running the returned `curl ... | sh` on a Mac or a Linux machine downloads the c
 
 `make -C backend dev` runs the server without Docker, `make -C backend client` builds the client into `backend/bin`.
 
-## Several servers
-
-A repository can live on another lodge server than the rest of the machine, for example a team's server during an event, while everything else stays on the personal one. Inside the repository, `lodge remote <url> <code>` claims a code from that server and binds the repository to it; further repositories on the same server need only `lodge remote <url>`. Outside a repository the same command only stores the server's token. The binding belongs to the repository key, so worktrees and later clones follow it, and the daemon listens to every server it holds a token for. `lodge remote` prints the server of the current repository, `lodge remote --default` sends it back to the default one. `lodge login` and `lodge update` only touch the default server, and a machine with no default server at all syncs just the repositories bound with `lodge remote`.
-
-On a machine that is logged in elsewhere, the code's `remote_command`, `curl -fsSL https://lodge.example.com/i/<code>/remote | sh`, installs or updates the client, connects the machine to that server without touching the default one, restarts a running daemon so it runs the new binary, and installs the daemon only if it is not there yet. Repositories are then bound with `lodge remote <url>`. Keep the servers a machine talks to on the same version: an older client ignores bindings and syncs every repository with the default server, and `lodge update` brings the default server's client.
-
-Where no service manager runs, in a container for example, `lodge install` says so and leaves it to `lodge daemon &`.
-
 ## The admin
 
 The server serves the admin from `frontend/build`. History is drawn as a borehole log: every revision is a bed, newest on top, hatched by the machine that wrote it and labelled with the branch and commit of the main repository. Dragging along the column, or the arrow keys, shows the notes as they were at that revision, and every depth, file and view is a link. A file can be compared with its previous version and put back on the surface; a repository can be deleted with its history, which leaves the files on the machines alone. Machines are listed with their hatch and can be revoked.

backend/.golangci.yml

@@ -44,7 +44,6 @@ linters:
         - (*github.com/fsnotify/fsnotify.Watcher).Close
         - os.Unsetenv
         - os.Remove
-        - os.RemoveAll
         - fmt.Fprint
         - fmt.Fprintf
         - fmt.Fprintln

backend/Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.27-alpine@sha256:4cb7ac979db5fcc41cae44b2227ba5ab8a51e8807f40d9ba4dee20a0ad960b5b AS build
+FROM golang:1.27-alpine@sha256:f92b6ef800e499660581efdabdf25d9d817a9d124eaf900924f0504e7e27e12d AS build
 
 WORKDIR /src
 
@@ -15,7 +15,7 @@ RUN for target in darwin/arm64 darwin/amd64 linux/arm64 linux/amd64; do \
 		GOOS=${target%/*} GOARCH=${target#*/} go build -trimpath -ldflags "-s -w" -o /out/dl/lodge-${target%/*}-${target#*/} ./cmd/lodge || exit 1; \
 	done
 
-FROM alpine:3.22@sha256:5291449c3df73caf6ed85e649dec1b9e818b39a5d8c871e97afc13e9cd5e8fa8
+FROM alpine:3.24@sha256:294b683cb724975bec92580e1e685676bd4b50bda910ddb8c51d4cabeaec77e6
 
 WORKDIR /app
 

backend/cmd/lodge/main.go

@@ -9,7 +9,6 @@ import (
 	"os"
 	"os/signal"
 	"path/filepath"
-	"slices"
 	"syscall"
 	"time"
 
@@ -21,11 +20,9 @@ import (
 const usage = `lodge keeps agent files out of git and in sync across machines
 
   lodge login <url> <code>      connect this machine using a code from the admin page
-  lodge remote <url> [code]     sync the current repository with another server
-  lodge remote [--default]      show that server, or go back to the default one
   lodge install                 start the daemon, install the git hook and the agent skill
   lodge uninstall               undo install
-  lodge update                  replace this binary with the one the default server ships
+  lodge update                  replace this binary with the one the server ships
   lodge add [dir]               start syncing a repository that was cloned before install
   lodge forget [dir]            stop syncing a repository
   lodge sync [dir]              sync once, for machines without a daemon
@@ -34,7 +31,7 @@ const usage = `lodge keeps agent files out of git and in sync across machines
   lodge show <rev|sha> <path>   a file as of a revision or a commit of the main repository
   lodge daemon                  run the sync daemon in the foreground
 
-status, log, sync and remote accept --json
+status, log and sync accept --json
 `
 
 var hookEnvironment = []string{"GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_PREFIX"}
@@ -42,18 +39,12 @@ var hookEnvironment = []string{"GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GI
 type status struct {
 	Root     string                       `json:"root"`
 	Key      string                       `json:"key"`
-	Server   string                       `json:"server"`
 	Branch   string                       `json:"branch"`
 	Rules    []client.Rule                `json:"rules"`
 	Revision int64                        `json:"revision"`
 	Spaces   map[string]protocol.Manifest `json:"spaces"`
 }
 
-type remoteStatus struct {
-	URL     string `json:"url"`
-	Default bool   `json:"default"`
-}
-
 func main() {
 	if len(os.Args) < 2 {
 		fmt.Print(usage)
@@ -76,15 +67,14 @@ func hook(ctx context.Context) {
 	for _, name := range hookEnvironment {
 		os.Unsetenv(name)
 	}
-	if cfg, err := client.Load(); err == nil {
-		_ = cfg.Hook(ctx, ".")
+	if c, err := client.Load(); err == nil {
+		_ = c.Hook(ctx, ".")
 	}
 }
 
 func run(ctx context.Context, name string, args []string) error {
 	flags := flag.NewFlagSet(name, flag.ExitOnError)
 	asJSON := flags.Bool("json", false, "machine-readable output")
-	toDefault := flags.Bool("default", false, "go back to the default server")
 	_ = flags.Parse(args)
 	args = flags.Args()
 	target := func(fallback string) string {
@@ -94,36 +84,45 @@ func run(ctx context.Context, name string, args []string) error {
 		return fallback
 	}
 
-	if slices.Contains([]string{"help", "-h", "--help"}, name) {
-		fmt.Print(usage)
-		return nil
-	}
-	cfg, err := client.Load()
-	if err != nil {
-		return err
-	}
 	switch name {
 	case "login":
 		if len(args) != 2 {
 			return errors.New("usage: lodge login <url> <code>")
 		}
-		return cfg.Login(ctx, args[0], args[1])
-	case "remote":
-		return remote(ctx, cfg, args, *toDefault, *asJSON)
+		return client.Login(ctx, args[0], args[1])
+	case "help", "-h", "--help":
+		fmt.Print(usage)
+		return nil
+	}
+
+	c, err := client.Load()
+	if err != nil {
+		return err
+	}
+	switch name {
 	case "install":
-		return cfg.Install()
+		return c.Install()
 	case "uninstall":
-		return cfg.Uninstall()
+		return c.Uninstall()
 	case "daemon":
-		return cfg.Daemon(ctx)
+		return c.Daemon(ctx)
 	case "update":
-		updated, err := cfg.Update(ctx)
+		updated, err := c.Update(ctx)
 		if err == nil && !updated {
 			fmt.Println("already up to date")
 		}
 		return err
 	case "add", "sync":
-		return syncRepo(ctx, cfg, target("."), *asJSON)
+		res, err := c.Sync(ctx, target("."), true)
+		if err != nil {
+			return err
+		}
+		return output(*asJSON, res, func() {
+			fmt.Printf("pushed %d, pulled %d\n", res.Pushed, res.Pulled)
+			for _, path := range res.Skipped {
+				fmt.Printf("skipped, over 5 MB: %s\n", path)
+			}
+		})
 	case "forget":
 		root, err := filepath.Abs(target("."))
 		if err != nil {
@@ -132,16 +131,16 @@ func run(ctx context.Context, name string, args []string) error {
 		if repo, err := gitrepo.Open(root); err == nil {
 			root = repo.Root
 		}
-		return cfg.Forget(root)
+		return c.Forget(root)
 	case "status":
-		return showStatus(ctx, cfg, target("."), *asJSON)
+		return showStatus(ctx, c, target("."), *asJSON)
 	case "log":
-		return showLog(ctx, cfg, target(""), *asJSON)
+		return showLog(ctx, c, target(""), *asJSON)
 	case "show":
 		if len(args) != 2 {
 			return errors.New("usage: lodge show <revision|commit-sha> <path>")
 		}
-		return showFile(ctx, cfg, args[0], args[1])
+		return showFile(ctx, c, args[0], args[1])
 	}
 	return fmt.Errorf("unknown command %q, see lodge help", name)
 }
@@ -156,86 +155,21 @@ func output(asJSON bool, value any, human func()) error {
 	return encoder.Encode(value)
 }
 
-func syncRepo(ctx context.Context, cfg *client.Config, dir string, asJSON bool) error {
-	res, err := cfg.Sync(ctx, dir, true)
-	if err != nil {
-		return err
-	}
-	return output(asJSON, res, func() {
-		fmt.Printf("pushed %d, pulled %d\n", res.Pushed, res.Pulled)
-		for _, path := range res.Skipped {
-			fmt.Printf("skipped, over 5 MB: %s\n", path)
-		}
-	})
-}
-
-func remote(ctx context.Context, cfg *client.Config, args []string, toDefault, asJSON bool) error {
-	if len(args) > 2 || toDefault && len(args) > 0 {
-		return errors.New("usage: lodge remote [<url> [code]] | lodge remote --default")
-	}
-	if len(args) == 2 {
-		if err := cfg.Connect(ctx, args[0], args[1]); err != nil {
-			return err
-		}
-	}
-	repo, err := gitrepo.Open(".")
-	if err != nil && len(args) == 2 {
-		fmt.Printf("connected to %s, run lodge remote %s inside a repository to sync it there\n", args[0], args[0])
-		return nil
-	}
-	if err != nil {
-		return err
-	}
-	if len(args) == 0 && !toDefault {
-		c, err := cfg.Server(repo.Key)
-		if err != nil {
-			return err
-		}
-		report := remoteStatus{URL: c.URL, Default: !cfg.Bound(repo.Key)}
-		return output(asJSON, report, func() {
-			if report.Default {
-				fmt.Printf("%s (default)\n", report.URL)
-			} else {
-				fmt.Println(report.URL)
-			}
-		})
-	}
-	server := ""
-	if len(args) > 0 {
-		server = args[0]
-	}
-	if err := cfg.Bind(repo.Key, server); err != nil {
-		return err
-	}
-	err = syncRepo(ctx, cfg, repo.Root, asJSON)
-	if toDefault && errors.Is(err, client.ErrNotLoggedIn) {
-		return nil
-	}
-	return err
-}
-
-func showStatus(ctx context.Context, cfg *client.Config, dir string, asJSON bool) error {
+func showStatus(ctx context.Context, c *client.Client, dir string, asJSON bool) error {
 	repo, err := gitrepo.Open(dir)
 	if err != nil {
 		return err
 	}
-	c, err := cfg.Server(repo.Key)
-	if err != nil {
-		return err
-	}
 	state, err := c.State(ctx, repo.Key, "")
 	if err != nil {
 		return err
 	}
-	report := status{Root: repo.Root, Key: repo.Key, Server: c.URL, Branch: repo.Branch(), Rules: client.LoadRules(repo.Root), Revision: state.Seq, Spaces: state.Spaces}
+	report := status{Root: repo.Root, Key: repo.Key, Branch: repo.Branch(), Rules: client.LoadRules(repo.Root), Revision: state.Seq, Spaces: state.Spaces}
 	return output(asJSON, report, func() {
-		fmt.Printf("%s\nkey %s, branch %s, revision %d\nserver %s\n\nrules:\n", report.Root, report.Key, report.Branch, report.Revision, report.Server)
+		fmt.Printf("%s\nkey %s, branch %s, revision %d\n\nrules:\n", report.Root, report.Key, report.Branch, report.Revision)
 		for _, rule := range report.Rules {
 			kind := "branch"
-			switch {
-			case rule.Ignore:
-				kind = "ignore"
-			case rule.Shared:
+			if rule.Shared {
 				kind = "shared"
 			}
 			fmt.Printf("  %s %s\n", kind, rule.Path)
@@ -249,15 +183,11 @@ func showStatus(ctx context.Context, cfg *client.Config, dir string, asJSON bool
 	})
 }
 
-func showLog(ctx context.Context, cfg *client.Config, path string, asJSON bool) error {
+func showLog(ctx context.Context, c *client.Client, path string, asJSON bool) error {
 	repo, err := gitrepo.Open(".")
 	if err != nil {
 		return err
 	}
-	c, err := cfg.Server(repo.Key)
-	if err != nil {
-		return err
-	}
 	revisions, err := c.Revisions(ctx, repo.Key, path)
 	if err != nil {
 		return err
@@ -265,11 +195,7 @@ func showLog(ctx context.Context, cfg *client.Config, path string, asJSON bool)
 	return output(asJSON, revisions, func() {
 		for _, rev := range revisions {
 			when := time.UnixMilli(rev.Time).Format("2006-01-02 15:04")
-			who := rev.Machine
-			if rev.Author != "" {
-				who = rev.Author + " via " + rev.Machine
-			}
-			fmt.Printf("%d  %s  %s  %s@%.10s\n", rev.Seq, when, who, rev.MainBranch, rev.MainSHA)
+			fmt.Printf("%d  %s  %s  %s@%.10s\n", rev.Seq, when, rev.Machine, rev.MainBranch, rev.MainSHA)
 			for _, change := range rev.Changes {
 				action := "M"
 				if change.Base == "" {
@@ -283,15 +209,11 @@ func showLog(ctx context.Context, cfg *client.Config, path string, asJSON bool)
 	})
 }
 
-func showFile(ctx context.Context, cfg *client.Config, at, path string) error {
+func showFile(ctx context.Context, c *client.Client, at, path string) error {
 	repo, err := gitrepo.Open(".")
 	if err != nil {
 		return err
 	}
-	c, err := cfg.Server(repo.Key)
-	if err != nil {
-		return err
-	}
 	state, err := c.State(ctx, repo.Key, at)
 	if err != nil {
 		return err

backend/go.mod

@@ -4,7 +4,7 @@ go 1.27.1
 
 require (
 	github.com/fsnotify/fsnotify v1.10.1
-	modernc.org/sqlite v1.60.1
+	modernc.org/sqlite v1.59.0
 )
 
 require (
@@ -13,8 +13,8 @@ require (
 	github.com/mattn/go-isatty v0.0.24 // indirect
 	github.com/ncruces/go-strftime v1.0.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
-	golang.org/x/sys v0.48.0 // indirect
-	modernc.org/libc v1.77.1 // indirect
+	golang.org/x/sys v0.47.0 // indirect
+	modernc.org/libc v1.75.7 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.12.1 // indirect
 )

backend/go.sum

@@ -20,8 +20,6 @@ golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
 golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
 golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
-golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
 golang.org/x/tools v0.48.0 h1:3+hClM1aLL5mjMKm5ovokw9epgRXPuu2tILgismM6RE=
 golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk=
 modernc.org/cc/v4 v4.29.2 h1:h6+9ciCnPKutf4I03CvheAvDLX7+IHlqR6Iy6J+cgd8=
@@ -38,8 +36,6 @@ modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks=
 modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
 modernc.org/libc v1.75.7 h1:o3DTP9/0p9pKmY2WCKQaySW6wIiZhNM7wc2lUoyhfew=
 modernc.org/libc v1.75.7/go.mod h1:bO5o2ztHxBb2rjz0PgdHN0sSMw57CgxGFLZ3Qd/QpVQ=
-modernc.org/libc v1.77.1 h1:Ct8j47QtiZ1Enj2DtFXQtUqrPCAjdCmPjtCuvrYQ0Hs=
-modernc.org/libc v1.77.1/go.mod h1:87/pZ4L6nD1zqW4nItuS12YO7hN1igAah34xjnQo/W0=
 modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
 modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
 modernc.org/memory v1.12.1 h1:nFMiWrpStgZczNl6XI9GnIk/rWhYIyHGUaR04pGbp9g=
@@ -50,8 +46,6 @@ modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
 modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
 modernc.org/sqlite v1.59.0 h1:X1es1GpqBlS/5T+vbM4HLUdaa8OtQx468DF2vrx+38A=
 modernc.org/sqlite v1.59.0/go.mod h1:+paeT2A3iPRHkQDwG7oA6Tk0zQd5woMEI8q7orfry8k=
-modernc.org/sqlite v1.60.1 h1:/blz53O951KWFOso4QQvEs/Fq6cDBKLtMVrYNSeJVKw=
-modernc.org/sqlite v1.60.1/go.mod h1:1dIoEagfDE72QytD5scH1lxARtaUgKgHC/NuApA27r0=
 modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
 modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
 modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=

backend/internal/client/client.go

@@ -10,7 +10,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"maps"
 	"net/http"
 	"net/url"
 	"os"
@@ -30,23 +29,14 @@ const (
 
 var (
 	httpClient     = &http.Client{Transport: newTransport()}
-	ErrNotLoggedIn = errors.New("not logged in: run the install command from the lodge admin page, or lodge remote <url> <code> inside the repository")
+	ErrNotLoggedIn = errors.New("not logged in: run the install command from the lodge admin page")
 	errConflict    = errors.New("server state changed")
 )
 
-type Config struct {
-	URL     string            `json:"url,omitempty"`
-	Token   string            `json:"token,omitempty"`
-	Servers map[string]string `json:"servers,omitempty"`
-	Repos   map[string]string `json:"repos,omitempty"`
-	DataDir string            `json:"-"`
-	path    string
-}
-
 type Client struct {
-	URL     string
-	Token   string
-	DataDir string
+	URL     string `json:"url"`
+	Token   string `json:"token"`
+	DataDir string `json:"-"`
 }
 
 func configPath() string {
@@ -59,128 +49,30 @@ func dataDir() string {
 	return filepath.Join(cmp.Or(os.Getenv("XDG_DATA_HOME"), filepath.Join(home, ".local", "share")), "lodge")
 }
 
-func serverURL(raw string) string {
-	return strings.TrimSuffix(raw, "/")
-}
-
-func Load() (*Config, error) {
-	return loadConfig(configPath(), dataDir())
-}
-
-func loadConfig(file, dir string) (*Config, error) {
-	cfg := &Config{DataDir: dir, path: file}
-	if data, err := os.ReadFile(file); err == nil {
-		if err := json.Unmarshal(data, cfg); err != nil {
+func Load() (*Client, error) {
+	c := &Client{DataDir: dataDir()}
+	if data, err := os.ReadFile(configPath()); err == nil {
+		if err := json.Unmarshal(data, c); err != nil {
 			return nil, err
 		}
 	}
-	cfg.URL = serverURL(cmp.Or(os.Getenv("LODGE_URL"), cfg.URL))
-	cfg.Token = cmp.Or(os.Getenv("LODGE_TOKEN"), cfg.Token)
-	return cfg, nil
-}
-
-func (cfg *Config) reload() (*Config, error) {
-	return loadConfig(cfg.path, cfg.DataDir)
-}
-
-func (cfg *Config) update(change func(*Config)) error {
-	unlock, err := flock(cfg.path + ".lock")
-	if err != nil {
-		return err
-	}
-	defer unlock()
-	saved := &Config{Servers: map[string]string{}, Repos: map[string]string{}}
-	if data, err := os.ReadFile(cfg.path); err == nil {
-		if err := json.Unmarshal(data, saved); err != nil {
-			return err
-		}
-	}
-	change(saved)
-	if err := writeJSONFile(cfg.path, saved); err != nil {
-		return err
-	}
-	fresh, err := cfg.reload()
-	if err == nil {
-		*cfg = *fresh
-	}
-	return err
-}
-
-func (cfg *Config) serverOf(key string) string {
-	return cmp.Or(cfg.Repos[key], cfg.URL)
-}
-
-func (cfg *Config) Bound(key string) bool {
-	return cfg.Repos[key] != ""
-}
-
-func (cfg *Config) Server(key string) (*Client, error) {
-	return cfg.client(cfg.serverOf(key))
-}
-
-func (cfg *Config) client(server string) (*Client, error) {
-	token := cfg.Servers[server]
-	if server == cfg.URL {
-		token = cmp.Or(cfg.Token, token)
-	}
-	switch {
-	case server == "":
+	c.URL = strings.TrimSuffix(cmp.Or(os.Getenv("LODGE_URL"), c.URL), "/")
+	c.Token = cmp.Or(os.Getenv("LODGE_TOKEN"), c.Token)
+	if c.URL == "" || c.Token == "" {
 		return nil, ErrNotLoggedIn
-	case token == "":
-		return nil, fmt.Errorf("no token for %s: run lodge remote %s <code> with a code from that server", server, server)
 	}
-	return &Client{URL: server, Token: token, DataDir: cfg.DataDir}, nil
+	return c, nil
 }
 
-func (cfg *Config) clients() map[Client]bool {
-	clients := map[Client]bool{}
-	for _, server := range append(slices.Collect(maps.Keys(cfg.Servers)), cfg.URL) {
-		if c, err := cfg.client(server); err == nil {
-			clients[*c] = true
-		}
-	}
-	return clients
-}
-
-func claim(ctx context.Context, server, code string) (string, error) {
+func Login(ctx context.Context, serverURL, code string) error {
 	name, _ := os.Hostname()
-	var res protocol.ClaimResponse
-	err := (&Client{URL: server}).call(ctx, http.MethodPost, "/api/claim", protocol.ClaimRequest{Code: code, Name: name}, &res)
-	return res.Token, err
-}
-
-func (cfg *Config) Login(ctx context.Context, server, code string) error {
-	server = serverURL(server)
-	token, err := claim(ctx, server, code)
-	if err != nil {
+	c := &Client{URL: strings.TrimSuffix(serverURL, "/")}
+	var claim protocol.ClaimResponse
+	if err := c.call(ctx, http.MethodPost, "/api/claim", protocol.ClaimRequest{Code: code, Name: name}, &claim); err != nil {
 		return err
 	}
-	return cfg.update(func(saved *Config) { saved.URL, saved.Token = server, token })
-}
-
-func (cfg *Config) Connect(ctx context.Context, server, code string) error {
-	server = serverURL(server)
-	token, err := claim(ctx, server, code)
-	if err != nil {
-		return err
-	}
-	return cfg.update(func(saved *Config) { saved.Servers[server] = token })
-}
-
-func (cfg *Config) Bind(key, server string) error {
-	server = serverURL(server)
-	if server != "" {
-		if _, err := cfg.client(server); err != nil {
-			return err
-		}
-	}
-	return cfg.update(func(saved *Config) {
-		if server == "" {
-			delete(saved.Repos, key)
-		} else {
-			saved.Repos[key] = server
-		}
-	})
+	c.Token = claim.Token
+	return writeJSONFile(configPath(), c)
 }
 
 func writeJSONFile(path string, value any) error {
@@ -313,20 +205,20 @@ func (c *Client) uploadBlob(ctx context.Context, hash string) error {
 	return res.Body.Close()
 }
 
-func (cfg *Config) registryPath() string {
-	return filepath.Join(cfg.DataDir, "worktrees.json")
+func (c *Client) registryPath() string {
+	return filepath.Join(c.DataDir, "worktrees.json")
 }
 
-func (cfg *Config) Worktrees() []string {
+func (c *Client) Worktrees() []string {
 	var roots []string
-	if data, err := os.ReadFile(cfg.registryPath()); err == nil {
+	if data, err := os.ReadFile(c.registryPath()); err == nil {
 		_ = json.Unmarshal(data, &roots)
 	}
 	return roots
 }
 
-func (cfg *Config) register(root string) error {
-	roots := cfg.Worktrees()
+func (c *Client) register(root string) error {
+	roots := c.Worktrees()
 	if slices.Contains(roots, root) {
 		return nil
 	}
@@ -334,10 +226,10 @@ func (cfg *Config) register(root string) error {
 		_, err := os.Stat(known)
 		return err != nil
 	})
-	return writeJSONFile(cfg.registryPath(), append(roots, root))
+	return writeJSONFile(c.registryPath(), append(roots, root))
 }
 
-func (cfg *Config) Forget(root string) error {
-	roots := slices.DeleteFunc(cfg.Worktrees(), func(known string) bool { return known == root })
-	return writeJSONFile(cfg.registryPath(), roots)
+func (c *Client) Forget(root string) error {
+	roots := slices.DeleteFunc(c.Worktrees(), func(known string) bool { return known == root })
+	return writeJSONFile(c.registryPath(), roots)
 }

backend/internal/client/daemon.go

@@ -36,46 +36,38 @@ type tree struct {
 }
 
 type daemon struct {
-	config  *Config
+	client  *Client
 	watcher *fsnotify.Watcher
 	queue   chan string
 
 	mu      sync.Mutex
-	current   *Config
-	listeners map[Client]context.CancelFunc
 	owners  map[string]string
 	trees   map[string]tree
 	pending map[string]*time.Timer
 }
 
-func (cfg *Config) Daemon(ctx context.Context) error {
+func (c *Client) Daemon(ctx context.Context) error {
 	watcher, err := fsnotify.NewWatcher()
 	if err != nil {
 		return err
 	}
 	defer watcher.Close()
-	for _, dir := range []string{cfg.DataDir, filepath.Dir(cfg.path)} {
-		if err := os.MkdirAll(dir, 0o755); err != nil {
+	if err := os.MkdirAll(c.DataDir, 0o755); err != nil {
 		return err
 	}
-		if err := watcher.Add(dir); err != nil {
+	if err := watcher.Add(c.DataDir); err != nil {
 		return err
 	}
-	}
 	d := &daemon{
-		config:    cfg,
+		client:  c,
 		watcher: watcher,
 		queue:   make(chan string, 256),
-		current:   cfg,
-		listeners: map[Client]context.CancelFunc{},
 		owners:  map[string]string{},
 		trees:   map[string]tree{},
 		pending: map[string]*time.Timer{},
 	}
-	d.connect(ctx)
-	var workers sync.WaitGroup
-	defer workers.Wait()
-	workers.Go(func() { d.work(ctx) })
+	go d.listen(ctx)
+	go d.work(ctx)
 	d.syncAll()
 
 	ticker := time.NewTicker(fullSyncEvery)
@@ -89,43 +81,13 @@ func (cfg *Config) Daemon(ctx context.Context) error {
 		case err := <-watcher.Errors:
 			log.Printf("watcher: %v", err)
 		case event := <-watcher.Events:
-			d.handle(ctx, event)
+			d.handle(event)
 		}
 	}
 }
 
-func (d *daemon) connect(ctx context.Context) {
-	current, err := d.config.reload()
-	if err != nil {
-		log.Printf("config: %v", err)
-		return
-	}
-	clients := current.clients()
-	d.mu.Lock()
-	defer d.mu.Unlock()
-	d.current = current
-	for c, stop := range d.listeners {
-		if !clients[c] {
-			stop()
-			delete(d.listeners, c)
-		}
-	}
-	for c := range clients {
-		if d.listeners[c] == nil {
-			listenCtx, stop := context.WithCancel(ctx)
-			d.listeners[c] = stop
-			go d.listen(listenCtx, c)
-		}
-	}
-}
-
-func (d *daemon) handle(ctx context.Context, event fsnotify.Event) {
-	switch event.Name {
-	case d.config.registryPath():
-		d.syncAll()
-		return
-	case d.config.path:
-		d.connect(ctx)
+func (d *daemon) handle(event fsnotify.Event) {
+	if event.Name == d.client.registryPath() {
 		d.syncAll()
 		return
 	}
@@ -150,8 +112,8 @@ func (t tree) relevant(root, name string) bool {
 		return false
 	}
 	rel = filepath.ToSlash(rel)
-	return !t.rules.ignored(rel) && slices.ContainsFunc(t.rules, func(rule Rule) bool {
-		return !rule.Ignore && (within(rel, rule.Path) || within(rule.Path, rel))
+	return slices.ContainsFunc(t.rules, func(rule Rule) bool {
+		return within(rel, rule.Path) || within(rule.Path, rel)
 	})
 }
 
@@ -171,7 +133,7 @@ func (d *daemon) schedule(root string) {
 }
 
 func (d *daemon) syncAll() {
-	for _, root := range d.config.Worktrees() {
+	for _, root := range d.client.Worktrees() {
 		if _, err := os.Stat(root); errors.Is(err, fs.ErrNotExist) {
 			d.forget(root)
 		} else {
@@ -181,7 +143,7 @@ func (d *daemon) syncAll() {
 }
 
 func (d *daemon) forget(root string) {
-	if err := d.config.Forget(root); err != nil {
+	if err := d.client.Forget(root); err != nil {
 		log.Printf("%s: %v", root, err)
 		return
 	}
@@ -198,13 +160,10 @@ func (d *daemon) work(ctx context.Context) {
 		case <-ctx.Done():
 			return
 		case root := <-d.queue:
-			res, err := d.config.Sync(ctx, root, true)
-			switch {
-			case errors.Is(err, ErrNotLoggedIn):
-				continue
-			case err != nil:
+			res, err := d.client.Sync(ctx, root, true)
+			if err != nil {
 				log.Printf("%s: %v", root, err)
-			case res.Pushed+res.Pulled > 0:
+			} else if res.Pushed+res.Pulled > 0 {
 				log.Printf("%s: pushed %d, pulled %d", root, res.Pushed, res.Pulled)
 			}
 			d.watch(root)
@@ -219,15 +178,14 @@ func (d *daemon) watch(root string) {
 	}
 	rules := LoadRules(repo.Root)
 	dirs := map[string]bool{repo.GitDir: true}
-	for _, rule := range rules.synced() {
+	for _, rule := range rules {
 		target := filepath.Join(repo.Root, filepath.FromSlash(rule.Path))
 		dirs[nearestDir(filepath.Dir(target), repo.Root)] = true
 		_ = filepath.WalkDir(target, func(path string, entry fs.DirEntry, err error) error {
 			if err != nil || !entry.IsDir() {
 				return nil
 			}
-			rel, _ := filepath.Rel(repo.Root, path)
-			if entry.Name() == ".git" || rules.ignored(filepath.ToSlash(rel)) {
+			if entry.Name() == ".git" {
 				return filepath.SkipDir
 			}
 			dirs[path] = true
@@ -266,29 +224,25 @@ func nearestDir(path, root string) string {
 	return root
 }
 
-func (d *daemon) listen(ctx context.Context, c Client) {
+func (d *daemon) listen(ctx context.Context) {
 	backoff := minBackoff
-	for {
+	for ctx.Err() == nil {
 		started := time.Now()
-		err := d.stream(ctx, c)
-		if ctx.Err() != nil {
-			return
-		}
+		err := d.stream(ctx)
 		if time.Since(started) > maxBackoff {
 			backoff = minBackoff
 		}
-		log.Printf("%s: event stream closed, retrying in %s: %v", c.URL, backoff, err)
+		log.Printf("event stream closed, retrying in %s: %v", backoff, err)
 		select {
 		case <-ctx.Done():
-			return
 		case <-time.After(backoff):
 		}
 		backoff = min(backoff*2, maxBackoff)
 	}
 }
 
-func (d *daemon) stream(ctx context.Context, c Client) error {
-	res, err := c.request(ctx, http.MethodGet, "/api/events", nil)
+func (d *daemon) stream(ctx context.Context) error {
+	res, err := d.client.request(ctx, http.MethodGet, "/api/events", nil)
 	if err != nil {
 		return err
 	}
@@ -303,13 +257,11 @@ func (d *daemon) stream(ctx context.Context, c Client) error {
 		}
 		d.mu.Lock()
 		var roots []string
-		if d.current.serverOf(event.Repo) == c.URL {
 		for root, tree := range d.trees {
 			if tree.key == event.Repo {
 				roots = append(roots, root)
 			}
 		}
-		}
 		d.mu.Unlock()
 		for _, root := range roots {
 			d.schedule(root)

backend/internal/client/daemon_test.go

@@ -17,7 +17,7 @@ func TestDaemonWatchesOnlyRulePaths(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(func() { watcher.Close() })
-	d := &daemon{config: m.config, watcher: watcher, owners: map[string]string{}, trees: map[string]tree{}}
+	d := &daemon{client: m.client, watcher: watcher, owners: map[string]string{}, trees: map[string]tree{}}
 	gitDir := filepath.Join(m.root, ".git")
 	expectWatched := func(want ...string) {
 		t.Helper()
@@ -55,43 +55,14 @@ func TestDaemonWatchesOnlyRulePaths(t *testing.T) {
 	}
 }
 
-func TestDaemonSkipsIgnoredPaths(t *testing.T) {
-	m, _ := setup(t)
-	watcher, err := fsnotify.NewWatcher()
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { watcher.Close() })
-	d := &daemon{config: m.config, watcher: watcher, owners: map[string]string{}, trees: map[string]tree{}}
-	write(t, m.root, RulesFile, "shared vault\nignore vault/.obsidian/workspace*.json\nignore .DS_Store\nignore vault/.trash\n")
-	write(t, m.root, "vault/.obsidian/app.json", "settings")
-	write(t, m.root, "vault/.trash/old.md", "old")
-	d.watch(m.root)
-	if _, watched := d.owners[filepath.Join(m.root, "vault/.trash")]; watched {
-		t.Fatal("ignored directory is watched")
-	}
-	for name, want := range map[string]bool{
-		"vault/note.md":                         true,
-		"vault/.obsidian/app.json":              true,
-		"vault/.obsidian/workspace.json":        false,
-		"vault/.obsidian/workspace-mobile.json": false,
-		"vault/.DS_Store":                       false,
-		"vault/.trash/old.md":                   false,
-	} {
-		if got := d.trees[m.root].relevant(m.root, filepath.Join(m.root, name)); got != want {
-			t.Errorf("relevant(%s) = %v, want %v", name, got, want)
-		}
-	}
-}
-
 func TestDaemonForgetsVanishedWorktrees(t *testing.T) {
-	cfg := &Config{DataDir: t.TempDir()}
-	if err := writeJSONFile(cfg.registryPath(), []string{filepath.Join(t.TempDir(), "gone")}); err != nil {
+	c := &Client{DataDir: t.TempDir()}
+	if err := writeJSONFile(c.registryPath(), []string{filepath.Join(t.TempDir(), "gone")}); err != nil {
 		t.Fatal(err)
 	}
-	d := &daemon{config: cfg, owners: map[string]string{}, trees: map[string]tree{}}
+	d := &daemon{client: c, owners: map[string]string{}, trees: map[string]tree{}}
 	d.syncAll()
-	if roots := cfg.Worktrees(); len(roots) != 0 {
+	if roots := c.Worktrees(); len(roots) != 0 {
 		t.Fatalf("registry still lists %v", roots)
 	}
 }

backend/internal/client/install.go

@@ -75,11 +75,11 @@ func unitPath(home string) string {
 	return filepath.Join(home, ".config", "systemd", "user", systemdUnit)
 }
 
-func (cfg *Config) templateDir() string {
-	return filepath.Join(cfg.DataDir, "git-template")
+func (c *Client) templateDir() string {
+	return filepath.Join(c.DataDir, "git-template")
 }
 
-func (cfg *Config) Install() error {
+func (c *Client) Install() error {
 	binary, err := os.Executable()
 	if err != nil {
 		return err
@@ -88,7 +88,7 @@ func (cfg *Config) Install() error {
 	if err != nil {
 		return err
 	}
-	if err := cfg.installHook(binary); err != nil {
+	if err := c.installHook(binary); err != nil {
 		return err
 	}
 	for _, dir := range skillDirs {
@@ -96,17 +96,14 @@ func (cfg *Config) Install() error {
 			return err
 		}
 	}
-	if err := startService(home, binary, filepath.Join(cfg.DataDir, "daemon.log")); err != nil {
-		fmt.Fprintf(os.Stderr, "lodge: the daemon could not be started as a service: %v\nrun `lodge daemon &` to keep this machine in sync\n", err)
-	}
-	return nil
+	return startService(home, binary, filepath.Join(c.DataDir, "daemon.log"))
 }
 
-func (cfg *Config) installHook(binary string) error {
+func (c *Client) installHook(binary string) error {
 	template, _ := exec.Command("git", "config", "--global", "--get", "init.templateDir").Output()
 	dir := strings.TrimSpace(string(template))
 	if dir == "" {
-		dir = cfg.templateDir()
+		dir = c.templateDir()
 		if err := command("git", "config", "--global", "init.templateDir", dir); err != nil {
 			return err
 		}
@@ -149,7 +146,7 @@ func restartService() error {
 	return command("systemctl", "--user", "restart", systemdUnit)
 }
 
-func (cfg *Config) Uninstall() error {
+func (c *Client) Uninstall() error {
 	home, err := os.UserHomeDir()
 	if err != nil {
 		return err
@@ -162,20 +159,16 @@ func (cfg *Config) Uninstall() error {
 		_ = os.Remove(unitPath(home))
 	}
 	template, _ := exec.Command("git", "config", "--global", "--get", "init.templateDir").Output()
-	if strings.TrimSpace(string(template)) == cfg.templateDir() {
+	if strings.TrimSpace(string(template)) == c.templateDir() {
 		_ = command("git", "config", "--global", "--unset", "init.templateDir")
 	}
 	for _, dir := range skillDirs {
 		_ = os.RemoveAll(filepath.Join(home, dir))
 	}
-	return os.RemoveAll(cfg.templateDir())
+	return os.RemoveAll(c.templateDir())
 }
 
-func (cfg *Config) Update(ctx context.Context) (bool, error) {
-	c, err := cfg.client(cfg.URL)
-	if err != nil {
-		return false, err
-	}
+func (c *Client) Update(ctx context.Context) (bool, error) {
 	binary, err := os.Executable()
 	if err != nil {
 		return false, err

backend/internal/client/remote_test.go

@@ -1,227 +0,0 @@
-package client
-
-import (
-	"context"
-	"errors"
-	"net/http"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"lodge/internal/gitrepo"
-	"lodge/internal/protocol"
-)
-
-func issueCode(t *testing.T, url string) string {
-	t.Helper()
-	var code protocol.CodeResponse
-	admin := &Client{URL: url, Token: adminToken}
-	if err := admin.call(context.Background(), http.MethodPost, "/api/codes", nil, &code); err != nil {
-		t.Fatal(err)
-	}
-	return code.Code
-}
-
-func (m *machine) remote(url, code string) {
-	m.t.Helper()
-	ctx := context.Background()
-	if code != "" {
-		if err := m.config.Connect(ctx, url, code); err != nil {
-			m.t.Fatal(err)
-		}
-	}
-	if err := m.config.Bind(repoKey(m.t, m), url); err != nil {
-		m.t.Fatal(err)
-	}
-	m.sync()
-}
-
-func revisionsOn(t *testing.T, url, key string) []protocol.Revision {
-	t.Helper()
-	revisions, err := (&Client{URL: url, Token: adminToken}).Revisions(context.Background(), key, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	return revisions
-}
-
-func TestBoundRepositoryNeverReachesTheDefaultServer(t *testing.T) {
-	personal, event, origin := newServer(t), newServer(t), newOrigin(t)
-	mac := newMachine(t, origin, personal, adminToken)
-	key := repoKey(t, mac)
-	ctx := context.Background()
-
-	if err := mac.config.Hook(ctx, mac.root); err != nil {
-		t.Fatal(err)
-	}
-	stale, err := mac.config.reload()
-	if err != nil {
-		t.Fatal(err)
-	}
-	mac.remote(event+"/", issueCode(t, event))
-	write(t, mac.root, "docs/agents/plan.md", "event plan")
-	if _, err := stale.Sync(ctx, mac.root, true); err != nil {
-		t.Fatal(err)
-	}
-
-	worktree := filepath.Join(t.TempDir(), "feature")
-	git(t, mac.root, "worktree", "add", "-b", "feature", worktree)
-	worktree, _ = filepath.EvalSymlinks(worktree)
-	if err := mac.config.Hook(ctx, worktree); err != nil {
-		t.Fatal(err)
-	}
-	if data, _ := os.ReadFile(filepath.Join(worktree, "docs/agents/plan.md")); string(data) != "event plan" {
-		t.Fatalf("new worktree of a bound repository got %q", data)
-	}
-
-	other := newMachine(t, newOrigin(t), personal, adminToken)
-	other.config = mac.config
-	write(t, other.root, "docs/agents/private.md", "personal")
-	other.sync()
-
-	if revisions := revisionsOn(t, personal, key); len(revisions) != 0 {
-		t.Fatalf("the default server received %d revisions of a bound repository", len(revisions))
-	}
-	if revisions := revisionsOn(t, event, key); len(revisions) != 1 {
-		t.Fatalf("the event server has %d revisions, want 1", len(revisions))
-	}
-	if revisions := revisionsOn(t, event, repoKey(t, other)); len(revisions) != 0 {
-		t.Fatal("an unbound repository reached the event server")
-	}
-	if revisions := revisionsOn(t, personal, repoKey(t, other)); len(revisions) != 1 {
-		t.Fatal("an unbound repository did not reach the default server")
-	}
-
-	if c, err := mac.config.Server(key); err != nil || c.URL != event {
-		t.Fatalf("server of the bound repository = %v (%v), want %s", c, err, event)
-	}
-}
-
-func TestMachineWithoutDefaultServer(t *testing.T) {
-	event, origin := newServer(t), newOrigin(t)
-	mac := newMachine(t, origin, event, adminToken)
-	write(t, mac.root, "docs/agents/plan.md", "plan")
-	mac.sync()
-
-	fresh := newMachine(t, origin, "", "")
-	if _, err := fresh.config.Sync(context.Background(), fresh.root, true); !errors.Is(err, ErrNotLoggedIn) {
-		t.Fatalf("sync without any server: %v", err)
-	}
-	if roots := fresh.config.Worktrees(); len(roots) != 0 {
-		t.Fatalf("a repository without a server was registered: %v", roots)
-	}
-	if err := fresh.config.Connect(context.Background(), event, issueCode(t, event)); err != nil {
-		t.Fatal(err)
-	}
-	fresh.remote(event, "")
-	fresh.expect("docs/agents/plan.md", "plan")
-	if fresh.config.URL != "" {
-		t.Fatalf("lodge remote set the default server to %q", fresh.config.URL)
-	}
-}
-
-func TestMovingBetweenServersKeepsLocalFiles(t *testing.T) {
-	personal, event, origin := newServer(t), newServer(t), newOrigin(t)
-	mac := newMachine(t, origin, personal, adminToken)
-	dell := newMachine(t, origin, "", "")
-	key := repoKey(t, mac)
-
-	write(t, mac.root, "docs/agents/mine.md", "mine")
-	mac.sync()
-	dell.remote(event, issueCode(t, event))
-	write(t, dell.root, "docs/agents/theirs.md", "theirs")
-	dell.sync()
-
-	mac.remote(event, issueCode(t, event))
-	mac.expect("docs/agents/mine.md", "mine")
-	mac.expect("docs/agents/theirs.md", "theirs")
-	dell.sync()
-	dell.expect("docs/agents/mine.md", "mine")
-
-	if err := mac.config.Bind(key, ""); err != nil {
-		t.Fatal(err)
-	}
-	mac.sync()
-	mac.expect("docs/agents/mine.md", "mine")
-	mac.expect("docs/agents/theirs.md", "theirs")
-	state, err := mac.client.State(context.Background(), key, "")
-	if err != nil || len(state.Spaces[protocol.SharedSpace]) != 2 {
-		t.Fatalf("back on the default server: %v (%v)", state.Spaces, err)
-	}
-}
-
-func TestStateFromBeforeServersIsAdopted(t *testing.T) {
-	mac, dell := setup(t)
-	write(t, mac.root, "docs/agents/plan.md", "plan")
-	mac.sync()
-	dell.sync()
-	repo := openRepo(t, mac)
-	if err := os.Rename(mac.client.statePath(repo), worktreePath(mac.config.DataDir, repo)+".json"); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Remove(filepath.Join(dell.root, "docs/agents/plan.md")); err != nil {
-		t.Fatal(err)
-	}
-	dell.sync()
-	mac.sync()
-	mac.expect("docs/agents/plan.md", "")
-}
-
-func TestDaemonFollowsServersAddedLater(t *testing.T) {
-	event, origin := newServer(t), newOrigin(t)
-	mac := newMachine(t, origin, event, adminToken)
-	fresh := newMachine(t, origin, "", "")
-	daemonConfig, err := fresh.config.reload()
-	if err != nil {
-		t.Fatal(err)
-	}
-	ctx, cancel := context.WithCancel(context.Background())
-	done := make(chan error)
-	go func() { done <- daemonConfig.Daemon(ctx) }()
-	t.Cleanup(func() {
-		cancel()
-		if err := <-done; err != nil {
-			t.Error(err)
-		}
-	})
-
-	fresh.remote(event, issueCode(t, event))
-	write(t, mac.root, "docs/agents/first.md", "first")
-	mac.sync()
-	fresh.waitFor("docs/agents/first.md", "first")
-	write(t, mac.root, "docs/agents/second.md", "second")
-	mac.sync()
-	fresh.waitFor("docs/agents/second.md", "second")
-
-	var machines []protocol.Machine
-	if err := (&Client{URL: event, Token: adminToken}).call(context.Background(), http.MethodGet, "/api/machines", nil, &machines); err != nil {
-		t.Fatal(err)
-	}
-	if len(machines) != 1 || !machines[0].Online {
-		t.Fatalf("the daemon is not online on the server it was bound to: %+v", machines)
-	}
-}
-
-func (m *machine) waitFor(path, content string) {
-	m.t.Helper()
-	deadline := time.Now().Add(15 * time.Second)
-	for {
-		if data, _ := os.ReadFile(filepath.Join(m.root, path)); string(data) == content {
-			return
-		}
-		if time.Now().After(deadline) {
-			m.t.Fatalf("the daemon did not bring %s", path)
-		}
-		time.Sleep(50 * time.Millisecond)
-	}
-}
-
-func openRepo(t *testing.T, m *machine) *gitrepo.Repo {
-	t.Helper()
-	repo, err := gitrepo.Open(m.root)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return repo
-}

backend/internal/client/rules.go

@@ -5,7 +5,6 @@ import (
 	"os"
 	"path"
 	"path/filepath"
-	"slices"
 	"strings"
 
 	"lodge/internal/gitrepo"
@@ -16,7 +15,6 @@ const (
 	RulesFile     = ".lodge"
 	sharedKeyword = "shared"
 	branchKeyword = "branch"
-	ignoreKeyword = "ignore"
 	excludeBegin  = "# lodge begin"
 	excludeEnd    = "# lodge end"
 	DefaultRules  = "shared docs/agents\nshared CLAUDE.local.md\nbranch .agent\n"
@@ -25,7 +23,6 @@ const (
 type Rule struct {
 	Path   string `json:"path"`
 	Shared bool   `json:"shared"`
-	Ignore bool   `json:"ignore,omitempty"`
 }
 
 type Rules []Rule
@@ -34,12 +31,12 @@ func parseRules(text string) Rules {
 	rules := Rules{{Path: RulesFile, Shared: true}}
 	for _, line := range strings.Split(text, "\n") {
 		fields := strings.Fields(line)
-		if len(fields) != 2 || !slices.Contains([]string{sharedKeyword, branchKeyword, ignoreKeyword}, fields[0]) {
+		if len(fields) != 2 || fields[0] != sharedKeyword && fields[0] != branchKeyword {
 			continue
 		}
 		rulePath := path.Clean(strings.Trim(filepath.ToSlash(fields[1]), "/"))
 		if protocol.SafePath(rulePath) {
-			rules = append(rules, Rule{Path: rulePath, Shared: fields[0] == sharedKeyword, Ignore: fields[0] == ignoreKeyword})
+			rules = append(rules, Rule{Path: rulePath, Shared: fields[0] == sharedKeyword})
 		}
 	}
 	return rules
@@ -53,14 +50,9 @@ func LoadRules(root string) Rules {
 	return parseRules(string(data))
 }
 
-func (rules Rules) synced() Rules {
-	return slices.DeleteFunc(slices.Clone(rules), func(rule Rule) bool { return rule.Ignore })
-}
-
 func (rules Rules) paths() []string {
-	synced := rules.synced()
-	paths := make([]string, len(synced))
-	for i, rule := range synced {
+	paths := make([]string, len(rules))
+	for i, rule := range rules {
 		paths[i] = rule.Path
 	}
 	return paths
@@ -68,29 +60,12 @@ func (rules Rules) paths() []string {
 
 func (rules Rules) covers(file string, shared bool) bool {
 	best := Rule{}
-	for _, rule := range rules.synced() {
+	for _, rule := range rules {
 		if within(file, rule.Path) && len(rule.Path) > len(best.Path) {
 			best = rule
 		}
 	}
-	return best.Path != "" && best.Shared == shared && !rules.ignored(file)
-}
-
-func (rules Rules) ignored(file string) bool {
-	return file != RulesFile && slices.ContainsFunc(rules, func(rule Rule) bool { return rule.Ignore && rule.matches(file) })
-}
-
-func (rule Rule) matches(file string) bool {
-	for name := file; name != "." && name != "/"; name = path.Dir(name) {
-		target := name
-		if !strings.Contains(rule.Path, "/") {
-			target = path.Base(name)
-		}
-		if matched, _ := path.Match(rule.Path, target); matched {
-			return true
-		}
-	}
-	return false
+	return best.Path != "" && best.Shared == shared
 }
 
 func within(path, dir string) bool {

backend/internal/client/skill.md

@@ -15,7 +15,7 @@ Run `lodge status` inside the repository to see the rules in effect. The default
 - `.agent/` holds what belongs to the current branch: the plan for the feature, what was tried, why something was reverted. It is swapped on `git checkout` together with the branch.
 - `CLAUDE.local.md` is shared across branches.
 
-The rules live in `.lodge` at the repository root, one per line, as `shared <path>`, `branch <path>` or `ignore <pattern>`. Paths are relative to the root. `ignore` keeps matching files local to each machine, for editor state and similar noise: the pattern is a glob over the whole path, or over any single name when it has no `/`, as in `ignore vault/.obsidian/workspace*.json` or `ignore .DS_Store`. The file itself is synced too.
+The rules live in `.lodge` at the repository root, one per line, as `shared <path>` or `branch <path>`. Paths are relative to the root, no globs. The file itself is synced too.
 
 ## Rules of conduct
 
@@ -23,7 +23,6 @@ The rules live in `.lodge` at the repository root, one per line, as `shared <pat
 - Files tracked by git are never touched by lodge, even under a synced path.
 - Files over 5 MB are not synced; `lodge status` lists them.
 - A deleted file is deleted on every machine. Its history stays on the server.
-- A repository may sync with another server than the rest of the machine; `lodge status` and `lodge remote` show which. Never run `lodge login`, `lodge remote` or `lodge update` unless asked: they change where files go.
 - Nothing needs to be run after writing a file: the daemon picks it up within seconds. Without a daemon (CI, cloud sandbox) run `lodge sync` at the start and at the end of the work.
 
 ## Reading history

backend/internal/client/sync.go

@@ -1,7 +1,6 @@
 package client
 
 import (
-	"bytes"
 	"cmp"
 	"context"
 	"encoding/json"
@@ -10,12 +9,10 @@ import (
 	"maps"
 	"net/http"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"slices"
 	"strings"
 	"syscall"
-	"unicode/utf8"
 
 	"lodge/internal/gitrepo"
 	"lodge/internal/protocol"
@@ -45,12 +42,8 @@ type diskFiles struct {
 	tracked map[string]bool
 }
 
-func worktreePath(dataDir string, repo *gitrepo.Repo) string {
-	return filepath.Join(dataDir, "repos", repo.Key, hashOf([]byte(repo.Root))[:16])
-}
-
 func (c *Client) statePath(repo *gitrepo.Repo) string {
-	return worktreePath(c.DataDir, repo) + "-" + hashOf([]byte(c.URL))[:16] + ".json"
+	return filepath.Join(c.DataDir, "repos", repo.Key, hashOf([]byte(repo.Root))[:16]+".json")
 }
 
 func (c *Client) loadState(repo *gitrepo.Repo) *worktreeState {
@@ -67,7 +60,8 @@ func (c *Client) loadState(repo *gitrepo.Repo) *worktreeState {
 	return st
 }
 
-func flock(path string) (func(), error) {
+func (c *Client) lock(repo *gitrepo.Repo) (func(), error) {
+	path := c.statePath(repo) + ".lock"
 	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
 		return nil, err
 	}
@@ -82,46 +76,31 @@ func flock(path string) (func(), error) {
 	return func() { file.Close() }, nil
 }
 
-func (cfg *Config) Hook(ctx context.Context, dir string) error {
+func (c *Client) Hook(ctx context.Context, dir string) error {
 	repo, err := gitrepo.Open(dir)
 	if err != nil {
 		return err
 	}
-	firstSight := !slices.Contains(cfg.Worktrees(), repo.Root)
-	_, err = cfg.Sync(ctx, repo.Root, firstSight)
+	firstSight := !slices.Contains(c.Worktrees(), repo.Root)
+	_, err = c.Sync(ctx, repo.Root, firstSight)
 	return err
 }
 
-func (cfg *Config) Sync(ctx context.Context, dir string, online bool) (Result, error) {
+func (c *Client) Sync(ctx context.Context, dir string, online bool) (Result, error) {
+	var res Result
 	repo, err := gitrepo.Open(dir)
 	if err != nil {
-		return Result{}, err
+		return res, err
 	}
-	worktree := worktreePath(cfg.DataDir, repo)
-	unlock, err := flock(worktree + ".lock")
+	if err := c.register(repo.Root); err != nil {
+		return res, err
+	}
+	unlock, err := c.lock(repo)
 	if err != nil {
-		return Result{}, err
+		return res, err
 	}
 	defer unlock()
-	current, err := cfg.reload()
-	if err != nil {
-		return Result{}, err
-	}
-	c, err := current.Server(repo.Key)
-	if err != nil {
-		return Result{}, err
-	}
-	if err := cfg.register(repo.Root); err != nil {
-		return Result{}, err
-	}
-	if c.URL == current.URL {
-		_ = os.Rename(worktree+".json", c.statePath(repo))
-	}
-	return c.sync(ctx, repo, online)
-}
 
-func (c *Client) sync(ctx context.Context, repo *gitrepo.Repo, online bool) (Result, error) {
-	var res Result
 	st := c.loadState(repo)
 	for range maxPasses {
 		again, err := c.pass(ctx, repo, st, online, &res)
@@ -135,20 +114,20 @@ func (c *Client) sync(ctx context.Context, repo *gitrepo.Repo, online bool) (Res
 
 func (c *Client) scan(repo *gitrepo.Repo, rules Rules) diskFiles {
 	found := diskFiles{shared: protocol.Manifest{}, branch: protocol.Manifest{}, tracked: repo.Tracked(rules.paths())}
-	for _, rule := range rules.synced() {
+	for _, rule := range rules {
 		start := filepath.Join(repo.Root, filepath.FromSlash(rule.Path))
 		_ = filepath.WalkDir(start, func(full string, entry fs.DirEntry, err error) error {
 			if err != nil {
 				return nil
 			}
-			rel, _ := filepath.Rel(repo.Root, full)
-			rel = filepath.ToSlash(rel)
-			if entry.IsDir() && (entry.Name() == ".git" || rules.ignored(rel)) {
+			if entry.IsDir() && entry.Name() == ".git" {
 				return filepath.SkipDir
 			}
 			if !entry.Type().IsRegular() || strings.HasSuffix(full, tempSuffix) {
 				return nil
 			}
+			rel, _ := filepath.Rel(repo.Root, full)
+			rel = filepath.ToSlash(rel)
 			if found.tracked[rel] || !rules.covers(rel, rule.Shared) {
 				return nil
 			}
@@ -179,9 +158,7 @@ func (c *Client) scan(repo *gitrepo.Repo, rules Rules) diskFiles {
 	return found
 }
 
-type mergeFunc func(local, base, remote protocol.File) (protocol.File, bool)
-
-func reconcile(space string, local, base, remote protocol.Manifest, relevant func(string) bool, merge mergeFunc) (first, second []protocol.Change, pull, next protocol.Manifest) {
+func reconcile(space string, local, base, remote protocol.Manifest, relevant func(string) bool) (first, second []protocol.Change, pull, next protocol.Manifest) {
 	pull, next = protocol.Manifest{}, maps.Clone(base)
 	if next == nil {
 		next = protocol.Manifest{}
@@ -197,14 +174,6 @@ func reconcile(space string, local, base, remote protocol.Manifest, relevant fun
 			continue
 		}
 		l, b, r := local[path], base[path], remote[path]
-		if l.Hash != b.Hash && r.Hash != b.Hash && l.Hash != r.Hash {
-			if merged, ok := merge(l, b, r); ok {
-				if merged.Hash != l.Hash {
-					pull[path] = merged
-				}
-				l, b = merged, r
-			}
-		}
 		mine := protocol.Change{Space: space, Path: path, Base: r.Hash, Hash: l.Hash}
 		settled := r
 		switch {
@@ -228,58 +197,6 @@ func reconcile(space string, local, base, remote protocol.Manifest, relevant fun
 	return first, second, pull, next
 }
 
-func (c *Client) merge(ctx context.Context, local, base, remote protocol.File) (protocol.File, bool) {
-	names := []string{"local", "base", "remote"}
-	versions := make([][]byte, len(names))
-	for i, file := range []protocol.File{local, base, remote} {
-		if file.Hash == "" {
-			return protocol.File{}, false
-		}
-		data, err := c.Blob(ctx, file.Hash)
-		if err != nil || !isText(data) {
-			return protocol.File{}, false
-		}
-		versions[i] = data
-	}
-	dir, err := os.MkdirTemp(c.DataDir, "merge-")
-	if err != nil {
-		return protocol.File{}, false
-	}
-	defer os.RemoveAll(dir)
-	for i, name := range names {
-		if err := os.WriteFile(filepath.Join(dir, name), versions[i], 0o600); err != nil {
-			return protocol.File{}, false
-		}
-	}
-	cmd := exec.CommandContext(ctx, "git", append([]string{"merge-file", "-p"}, names...)...)
-	cmd.Dir = dir
-	merged, err := cmd.Output()
-	clean := err == nil
-	if !clean {
-		merged, clean = appended(versions[0], versions[1], versions[2])
-	}
-	if !clean || len(merged) > protocol.MaxBlobSize {
-		return protocol.File{}, false
-	}
-	hash, err := c.cacheBlob(merged)
-	return protocol.File{Hash: hash, Time: max(local.Time, remote.Time)}, err == nil
-}
-
-func appended(local, base, remote []byte) ([]byte, bool) {
-	if !bytes.HasPrefix(local, base) || !bytes.HasPrefix(remote, base) {
-		return nil, false
-	}
-	tail, glue := local[len(base):], []byte{}
-	if !bytes.HasSuffix(remote, []byte("\n")) && !bytes.HasPrefix(tail, []byte("\n")) {
-		glue = []byte("\n")
-	}
-	return slices.Concat(remote, glue, tail), true
-}
-
-func isText(data []byte) bool {
-	return len(data) <= protocol.MaxBlobSize && utf8.Valid(data) && bytes.IndexByte(data, 0) == -1
-}
-
 func (c *Client) pass(ctx context.Context, repo *gitrepo.Repo, st *worktreeState, online bool, res *Result) (bool, error) {
 	rules := LoadRules(repo.Root)
 	if err := writeExclude(repo, rules); err != nil {
@@ -326,9 +243,6 @@ func (c *Client) pass(ctx context.Context, repo *gitrepo.Repo, st *worktreeState
 	var first, second []protocol.Change
 	pulls, bases := map[string]protocol.Manifest{}, map[string]protocol.Manifest{}
 	spaces := map[string]bool{}
-	merge := func(l, b, r protocol.File) (protocol.File, bool) {
-		return c.merge(ctx, l, b, r)
-	}
 	for _, group := range []map[string]protocol.Manifest{locals, st.Base, remote.Spaces} {
 		for space := range group {
 			spaces[space] = true
@@ -343,15 +257,13 @@ func (c *Client) pass(ctx context.Context, repo *gitrepo.Repo, st *worktreeState
 			}
 			continue
 		}
-		relevant := func(path string) bool {
-			return protocol.SafePath(path) && !rules.ignored(path)
-		}
+		relevant := protocol.SafePath
 		if active[space] != nil {
 			relevant = func(path string) bool {
 				return protocol.SafePath(path) && rules.covers(path, space == protocol.SharedSpace) && !found.tracked[path]
 			}
 		}
-		mine, theirs, pull, next := reconcile(space, local, st.Base[space], remote.Spaces[space], relevant, merge)
+		mine, theirs, pull, next := reconcile(space, local, st.Base[space], remote.Spaces[space], relevant)
 		first, second, pulls[space], bases[space] = append(first, mine...), append(second, theirs...), pull, next
 	}
 

backend/internal/client/sync_test.go

@@ -19,7 +19,6 @@ const adminToken = "admin"
 
 type machine struct {
 	t      *testing.T
-	config *Config
 	client *Client
 	root   string
 }
@@ -35,7 +34,7 @@ func git(t *testing.T, dir string, args ...string) string {
 	return string(out)
 }
 
-func newServer(t *testing.T) string {
+func setup(t *testing.T) (*machine, *machine) {
 	t.Helper()
 	store, err := server.OpenStore(filepath.Join(t.TempDir(), "lodge.db"))
 	if err != nil {
@@ -44,41 +43,22 @@ func newServer(t *testing.T) string {
 	t.Cleanup(func() { store.Close() })
 	api := httptest.NewServer(server.New(store, server.Config{AdminToken: adminToken}))
 	t.Cleanup(api.Close)
-	return api.URL
-}
 
-func newOrigin(t *testing.T) string {
-	t.Helper()
 	origin := t.TempDir()
 	git(t, origin, "init", "-b", "main")
 	write(t, origin, "README.md", "readme")
 	write(t, origin, "docs/agents/tracked.md", "in git")
 	git(t, origin, "add", ".")
-	git(t, origin, "commit", "-m", "root "+origin)
-	return origin
-}
+	git(t, origin, "commit", "-m", "root")
 
-func newMachine(t *testing.T, origin, url, token string) *machine {
-	t.Helper()
-	cfg := &Config{URL: url, Token: token, DataDir: t.TempDir(), path: filepath.Join(t.TempDir(), "config.json")}
-	if err := writeJSONFile(cfg.path, cfg); err != nil {
-		t.Fatal(err)
-	}
-	return &machine{t: t, config: cfg, client: &Client{URL: url, Token: token, DataDir: cfg.DataDir}, root: clone(t, origin)}
-}
-
-func clone(t *testing.T, origin string) string {
-	t.Helper()
+	machines := [2]*machine{}
+	for i := range machines {
 		root := filepath.Join(t.TempDir(), "clone")
 		git(t, origin, "clone", origin, root)
 		resolved, _ := filepath.EvalSymlinks(root)
-	return resolved
-}
-
-func setup(t *testing.T) (*machine, *machine) {
-	t.Helper()
-	url, origin := newServer(t), newOrigin(t)
-	return newMachine(t, origin, url, adminToken), newMachine(t, origin, url, adminToken)
+		machines[i] = &machine{t: t, root: resolved, client: &Client{URL: api.URL, Token: adminToken, DataDir: t.TempDir()}}
+	}
+	return machines[0], machines[1]
 }
 
 func write(t *testing.T, root, path, content string) {
@@ -90,7 +70,7 @@ func write(t *testing.T, root, path, content string) {
 
 func (m *machine) sync() Result {
 	m.t.Helper()
-	res, err := m.config.Sync(context.Background(), m.root, true)
+	res, err := m.client.Sync(context.Background(), m.root, true)
 	if err != nil {
 		m.t.Fatal(err)
 	}
@@ -150,7 +130,7 @@ func TestBranchNotesFollowTheBranchAndSharedStay(t *testing.T) {
 	mac.sync()
 
 	git(t, mac.root, "checkout", "main")
-	if _, err := mac.config.Sync(context.Background(), mac.root, false); err != nil {
+	if _, err := mac.client.Sync(context.Background(), mac.root, false); err != nil {
 		t.Fatal(err)
 	}
 	mac.expect(".agent/plan.md", "main plan")
@@ -203,86 +183,6 @@ func TestLaterEditWinsAndLoserStaysInHistory(t *testing.T) {
 	}
 }
 
-func TestConcurrentEditsMerge(t *testing.T) {
-	for name, versions := range map[string][4]string{
-		"different lines": {
-			"# plan\n\n## todo\n- a\n\n## notes\n- x\n",
-			"# plan\n\n## todo\n- a\n- from mac\n\n## notes\n- x\n",
-			"# plan\n\n## todo\n- a\n\n## notes\n- x\n- from dell\n",
-			"# plan\n\n## todo\n- a\n- from mac\n\n## notes\n- x\n- from dell\n",
-		},
-		"appends":                    {"# log\n- a\n", "# log\n- a\n- from mac\n", "# log\n- a\n- from dell\n", "# log\n- a\n- from dell\n- from mac\n"},
-		"appends without newline":    {"# log\n- a", "# log\n- a\n- from mac", "# log\n- a\n- from dell", "# log\n- a\n- from dell\n- from mac"},
-		"appends to unfinished line": {"# log\n- a", "# log\n- a b", "# log\n- a\n- from dell", "# log\n- a\n- from dell\n b"},
-	} {
-		t.Run(name, func(t *testing.T) {
-			mac, dell := setup(t)
-			path := "docs/agents/plan.md"
-			write(t, mac.root, path, versions[0])
-			mac.sync()
-			dell.sync()
-
-			write(t, mac.root, path, versions[1])
-			write(t, dell.root, path, versions[2])
-			dell.sync()
-			mac.sync()
-			dell.sync()
-
-			mac.expect(path, versions[3])
-			dell.expect(path, versions[3])
-			state, err := mac.client.State(context.Background(), repoKey(t, mac), "")
-			if err != nil {
-				t.Fatal(err)
-			}
-			if got, _ := mac.client.Blob(context.Background(), state.Spaces[protocol.SharedSpace][path].Hash); string(got) != versions[3] {
-				t.Fatalf("server has %q, want %q", got, versions[3])
-			}
-			for _, m := range []*machine{mac, dell, mac} {
-				if res := m.sync(); res.Pushed != 0 || res.Pulled != 0 {
-					t.Fatalf("merged file keeps syncing: %+v", res)
-				}
-			}
-			revisions, err := mac.client.Revisions(context.Background(), repoKey(t, mac), path)
-			if err != nil || len(revisions) != 3 {
-				t.Fatalf("want base, dell and one merged revision, got %d (%v)", len(revisions), err)
-			}
-		})
-	}
-}
-
-func TestConflictingOrBinaryEditsFallBackToLaterWins(t *testing.T) {
-	for name, versions := range map[string][3]string{
-		"same line":    {"1\n2\n3\n4\n5\n", "mac\n2\n3\n4\n5\n", "dell\n2\n3\n4\n5\n"},
-		"nul byte":     {"1\n2\n3\n4\n5\n\x00\n", "mac\n2\n3\n4\n5\n\x00\n", "1\n2\n3\n4\ndell\n\x00\n"},
-		"invalid utf8": {"1\n2\n3\n4\n5\n\xff\n", "mac\n2\n3\n4\n5\n\xff\n", "1\n2\n3\n4\ndell\n\xff\n"},
-	} {
-		t.Run(name, func(t *testing.T) {
-			mac, dell := setup(t)
-			path := "docs/agents/plan.md"
-			write(t, mac.root, path, versions[0])
-			mac.sync()
-			dell.sync()
-
-			write(t, mac.root, path, versions[1])
-			old := time.Now().Add(-time.Hour)
-			if err := os.Chtimes(filepath.Join(mac.root, path), old, old); err != nil {
-				t.Fatal(err)
-			}
-			write(t, dell.root, path, versions[2])
-			dell.sync()
-			mac.sync()
-			dell.sync()
-
-			mac.expect(path, versions[2])
-			dell.expect(path, versions[2])
-			revisions, err := mac.client.Revisions(context.Background(), repoKey(t, mac), path)
-			if err != nil || len(revisions) != 4 {
-				t.Fatalf("want base, dell, losing mac and restored dell revisions, got %d (%v)", len(revisions), err)
-			}
-		})
-	}
-}
-
 func TestRulesFileTravelsAndHostileServerPathsAreIgnored(t *testing.T) {
 	mac, dell := setup(t)
 	write(t, mac.root, RulesFile, "shared notes\n")
@@ -307,72 +207,6 @@ func TestRulesFileTravelsAndHostileServerPathsAreIgnored(t *testing.T) {
 	}
 }
 
-func TestIgnoredFilesNeverTravel(t *testing.T) {
-	mac, dell := setup(t)
-	rules := "shared vault\nignore vault/.obsidian/workspace*.json\nignore .DS_Store\nignore vault/cache\n"
-	write(t, mac.root, RulesFile, rules)
-	write(t, mac.root, "vault/note.md", "note")
-	write(t, mac.root, "vault/.obsidian/app.json", "settings")
-	write(t, mac.root, "vault/.obsidian/workspace.json", "mac layout")
-	write(t, mac.root, "vault/.obsidian/workspace-mobile.json", "mac mobile")
-	write(t, mac.root, "vault/deep/.DS_Store", "finder")
-	write(t, mac.root, "vault/cache/index.bin", "cache")
-	if res := mac.sync(); res.Pushed != 3 {
-		t.Fatalf("pushed %d files, want the rules, the note and app.json", res.Pushed)
-	}
-
-	write(t, dell.root, "vault/.obsidian/workspace.json", "dell layout")
-	dell.sync()
-	dell.expect("vault/note.md", "note")
-	dell.expect("vault/.obsidian/app.json", "settings")
-	dell.expect("vault/.obsidian/workspace.json", "dell layout")
-	dell.expect("vault/.obsidian/workspace-mobile.json", "")
-	dell.expect("vault/deep/.DS_Store", "")
-	dell.expect("vault/cache/index.bin", "")
-
-	hash, _ := mac.client.cacheBlob([]byte("pushed by an old client"))
-	if err := mac.client.uploadBlob(context.Background(), hash); err != nil {
-		t.Fatal(err)
-	}
-	push := protocol.Push{Changes: []protocol.Change{{Space: protocol.SharedSpace, Path: "vault/.obsidian/workspace.json", Hash: hash}}}
-	if err := mac.client.call(context.Background(), http.MethodPost, "/api/repos/"+repoKey(t, mac)+"/revisions", push, nil); err != nil {
-		t.Fatal(err)
-	}
-	mac.sync()
-	dell.sync()
-	mac.expect("vault/.obsidian/workspace.json", "mac layout")
-	dell.expect("vault/.obsidian/workspace.json", "dell layout")
-
-	exclude, _ := os.ReadFile(filepath.Join(dell.root, ".git/info/exclude"))
-	if strings.Contains(string(exclude), "workspace") || strings.Contains(string(exclude), "DS_Store") {
-		t.Fatalf("ignore rules leaked into exclude:\n%s", exclude)
-	}
-}
-
-func TestIgnoreRuleMatching(t *testing.T) {
-	rules := parseRules("shared vault\nbranch .agent\nignore vault/.obsidian/workspace*.json\nignore .DS_Store\nignore *.tmp\nignore .lodge\n")
-	for file, want := range map[string]bool{
-		"vault/note.md":                         true,
-		"vault/.obsidian/workspace.json":        false,
-		"vault/.obsidian/workspace-mobile.json": false,
-		"vault/.obsidian/workspaces.json":       false,
-		"vault/.obsidian/app.json":              true,
-		"vault/sub/.obsidian/workspace.json":    true,
-		"vault/.DS_Store":                       false,
-		"vault/a/b/.DS_Store":                   false,
-		"vault/.DS_Store/inside":                false,
-		"vault/draft.tmp":                       false,
-		RulesFile:                               true,
-	} {
-		if got := rules.covers(file, true); got != want {
-			t.Errorf("covers(%s) = %v, want %v", file, got, want)
-		}
-	}
-	if rules.covers(".agent/.DS_Store", false) || !rules.covers(".agent/plan.md", false) {
-		t.Error("ignore rules must apply to branch paths too")
-	}
-}
-
 func TestDeletingRepositoryOnServerKeepsFilesOnMachines(t *testing.T) {
 	mac, _ := setup(t)
 	write(t, mac.root, "docs/agents/plan.md", "v1")

backend/internal/protocol/protocol.go

@@ -32,7 +32,6 @@ type Change struct {
 
 type Push struct {
 	Name       string   `json:"name"`
-	Author     string   `json:"author,omitempty"`
 	MainSHA    string   `json:"main_sha"`
 	MainBranch string   `json:"main_branch"`
 	Changes    []Change `json:"changes"`
@@ -41,7 +40,6 @@ type Push struct {
 type Revision struct {
 	Seq        int64    `json:"seq"`
 	Machine    string   `json:"machine"`
-	Author     string   `json:"author"`
 	Time       int64    `json:"time"`
 	MainSHA    string   `json:"main_sha"`
 	MainBranch string   `json:"main_branch"`
@@ -60,8 +58,6 @@ type Machine struct {
 	Name      string `json:"name"`
 	CreatedAt int64  `json:"created_at"`
 	LastPush  int64  `json:"last_push"`
-	LastSeen  int64  `json:"last_seen"`
-	Online    bool   `json:"online"`
 	Revisions int64  `json:"revisions"`
 }
 
@@ -72,7 +68,6 @@ type Login struct {
 type Event struct {
 	Repo string `json:"repo"`
 	Seq  int64  `json:"seq"`
-	Author string `json:"author,omitempty"`
 }
 
 type ClaimRequest struct {
@@ -87,7 +82,6 @@ type ClaimResponse struct {
 type CodeResponse struct {
 	Code      string `json:"code"`
 	Command   string `json:"command"`
-	RemoteCommand string `json:"remote_command"`
 	ExpiresAt int64  `json:"expires_at"`
 }
 

backend/internal/server/install.sh

@@ -1,10 +1,6 @@
 #!/bin/sh
 set -eu
 
-url="{{URL}}"
-code="{{CODE}}"
-mode="{{MODE}}"
-
 os=$(uname -s | tr '[:upper:]' '[:lower:]')
 arch=$(uname -m)
 case "$arch" in
@@ -15,26 +11,12 @@ esac
 
 bin="$HOME/.local/bin"
 mkdir -p "$bin"
-curl -fsSL "$url/dl/lodge-$os-$arch" -o "$bin/lodge.new"
+curl -fsSL "{{URL}}/dl/lodge-$os-$arch" -o "$bin/lodge.new"
 chmod +x "$bin/lodge.new"
 mv "$bin/lodge.new" "$bin/lodge"
 
-if [ "$mode" = login ]; then
-	"$bin/lodge" login "$url" "$code"
-	"$bin/lodge" install
-else
-	plist="$HOME/Library/LaunchAgents/com.kotikot.lodge.plist"
-	unit="$HOME/.config/systemd/user/lodge.service"
-	restarted=yes
-	if [ -f "$plist" ]; then
-		launchctl kickstart -k "gui/$(id -u)/com.kotikot.lodge" || restarted=no
-	elif [ -f "$unit" ]; then
-		systemctl --user restart lodge.service || restarted=no
-	fi
-	[ "$restarted" = yes ] || echo "lodge: restart the running daemon so it runs the new binary" >&2
-	(cd / && "$bin/lodge" remote "$url" "$code")
-	[ -f "$plist" ] || [ -f "$unit" ] || "$bin/lodge" install
-fi
+"$bin/lodge" login "{{URL}}" "{{CODE}}"
+"$bin/lodge" install
 
 case ":$PATH:" in
 	*":$bin:"*) ;;

backend/internal/server/server.go

@@ -50,17 +50,14 @@ type Server struct {
 
 	mu          sync.Mutex
 	subscribers map[chan protocol.Event]struct{}
-	streams     map[int64]int
-	seen        map[int64]int64
 }
 
 type machineKey struct{}
 
 func New(store *Store, config Config) http.Handler {
-	s := &Server{config: config, store: store, subscribers: map[chan protocol.Event]struct{}{}, streams: map[int64]int{}, seen: map[int64]int64{}}
+	s := &Server{config: config, store: store, subscribers: map[chan protocol.Event]struct{}{}}
 	mux := http.NewServeMux()
-	mux.HandleFunc("GET /i/{code}", s.install("login"))
-	mux.HandleFunc("GET /i/{code}/remote", s.install("remote"))
+	mux.HandleFunc("GET /i/{code}", s.install)
 	mux.Handle("GET /dl/", http.StripPrefix("/dl/", http.FileServer(http.Dir(config.ClientsDir))))
 	mux.HandleFunc("POST /api/claim", s.claim)
 	mux.HandleFunc("POST /api/session", s.login)
@@ -139,7 +136,6 @@ func (s *Server) auth(next http.HandlerFunc) http.HandlerFunc {
 				return
 			}
 			machineID = id
-			s.track(id, 0)
 		}
 		if key := r.PathValue("key"); key != "" && !repoKeyPattern.MatchString(key) {
 			http.Error(w, "bad repository key", http.StatusBadRequest)
@@ -160,16 +156,14 @@ func (s *Server) publicURL(r *http.Request) string {
 	return scheme + "://" + r.Host
 }
 
-func (s *Server) install(mode string) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
+func (s *Server) install(w http.ResponseWriter, r *http.Request) {
 	code := r.PathValue("code")
 	if !codePattern.MatchString(code) || !s.store.CodeValid(r.Context(), code) {
 		http.Error(w, "echo 'lodge: this install link has expired, create a new one' >&2; exit 1", http.StatusNotFound)
 		return
 	}
 	w.Header().Set("Content-Type", "text/x-shellscript")
-		_, _ = strings.NewReplacer("{{URL}}", s.publicURL(r), "{{CODE}}", code, "{{MODE}}", mode).WriteString(w, installScript)
-	}
+	_, _ = strings.NewReplacer("{{URL}}", s.publicURL(r), "{{CODE}}", code).WriteString(w, installScript)
 }
 
 func (s *Server) setSession(w http.ResponseWriter, r *http.Request, token string, expires time.Time) {
@@ -212,25 +206,12 @@ func (s *Server) logout(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusNoContent)
 }
 
-func (s *Server) track(machineID int64, streams int) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.seen[machineID] = time.Now().UnixMilli()
-	s.streams[machineID] += streams
-}
-
 func (s *Server) machines(w http.ResponseWriter, r *http.Request) {
 	machines, err := s.store.Machines(r.Context())
 	if err != nil {
 		writeError(w, err)
 		return
 	}
-	s.mu.Lock()
-	for i, machine := range machines {
-		machines[i].Online = s.streams[machine.ID] > 0
-		machines[i].LastSeen = max(s.seen[machine.ID], machine.LastPush)
-	}
-	s.mu.Unlock()
 	writeJSON(w, http.StatusOK, machines)
 }
 
@@ -269,7 +250,6 @@ func (s *Server) createCode(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusCreated, protocol.CodeResponse{
 		Code:      code,
 		Command:   fmt.Sprintf("curl -fsSL %s/i/%s | sh", s.publicURL(r), code),
-		RemoteCommand: fmt.Sprintf("curl -fsSL %s/i/%s/remote | sh", s.publicURL(r), code),
 		ExpiresAt: expires.UnixMilli(),
 	})
 }
@@ -307,19 +287,7 @@ func (s *Server) state(w http.ResponseWriter, r *http.Request) {
 }
 
 func (s *Server) revisions(w http.ResponseWriter, r *http.Request) {
-	key, query := r.PathValue("key"), r.URL.Query()
-	var revisions []protocol.Revision
-	var err error
-	if query.Has("after") {
-		after, parseErr := strconv.ParseInt(query.Get("after"), 10, 64)
-		if parseErr != nil {
-			http.Error(w, "bad after", http.StatusBadRequest)
-			return
-		}
-		revisions, err = s.store.RevisionsAfter(r.Context(), key, query.Get("path"), after)
-	} else {
-		revisions, err = s.store.Revisions(r.Context(), key, query.Get("path"))
-	}
+	revisions, err := s.store.Revisions(r.Context(), r.PathValue("key"), r.URL.Query().Get("path"))
 	if err != nil {
 		writeError(w, err)
 		return
@@ -351,9 +319,8 @@ func (s *Server) push(w http.ResponseWriter, r *http.Request) {
 		writeError(w, err)
 		return
 	}
-	event := protocol.Event{Repo: key, Seq: seq, Author: push.Author}
-	s.publish(event)
-	writeJSON(w, http.StatusCreated, event)
+	s.publish(protocol.Event{Repo: key, Seq: seq})
+	writeJSON(w, http.StatusCreated, protocol.Event{Repo: key, Seq: seq})
 }
 
 func (s *Server) blob(w http.ResponseWriter, r *http.Request) {
@@ -403,17 +370,14 @@ func (s *Server) events(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "streaming unsupported", http.StatusInternalServerError)
 		return
 	}
-	machineID, _ := r.Context().Value(machineKey{}).(int64)
 	subscriber := make(chan protocol.Event, 16)
 	s.mu.Lock()
 	s.subscribers[subscriber] = struct{}{}
 	s.mu.Unlock()
-	s.track(machineID, 1)
 	defer func() {
 		s.mu.Lock()
 		delete(s.subscribers, subscriber)
 		s.mu.Unlock()
-		s.track(machineID, -1)
 	}()
 
 	w.Header().Set("Content-Type", "text/event-stream")
@@ -427,7 +391,6 @@ func (s *Server) events(w http.ResponseWriter, r *http.Request) {
 		case <-r.Context().Done():
 			return
 		case <-ticker.C:
-			s.track(machineID, 0)
 			fmt.Fprint(w, ": ping\n\n")
 		case event := <-subscriber:
 			data, _ := json.Marshal(event)

backend/internal/server/server_test.go

@@ -1,241 +0,0 @@
-package server
-
-import (
-	"bufio"
-	"bytes"
-	"context"
-	"crypto/sha256"
-	"database/sql"
-	"encoding/hex"
-	"encoding/json"
-	"errors"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-
-	"lodge/internal/protocol"
-)
-
-const (
-	adminToken = "admin"
-	repoKey    = "0123456789abcdef0123456789abcdef01234567"
-)
-
-func newServer(t *testing.T) string {
-	t.Helper()
-	store, err := OpenStore(filepath.Join(t.TempDir(), "lodge.db"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { store.Close() })
-	api := httptest.NewServer(New(store, Config{AdminToken: adminToken}))
-	t.Cleanup(api.Close)
-	return api.URL
-}
-
-func call(t *testing.T, method, url, token string, in, out any) {
-	t.Helper()
-	var body bytes.Buffer
-	if in != nil {
-		_ = json.NewEncoder(&body).Encode(in)
-	}
-	req, _ := http.NewRequest(method, url, &body)
-	req.Header.Set("Authorization", "Bearer "+token)
-	res, err := http.DefaultClient.Do(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer res.Body.Close()
-	if res.StatusCode >= http.StatusBadRequest {
-		t.Fatalf("%s %s: %s", method, url, res.Status)
-	}
-	if out != nil {
-		if err := json.NewDecoder(res.Body).Decode(out); err != nil {
-			t.Fatal(err)
-		}
-	}
-}
-
-func push(t *testing.T, url, author, path, base, content string) string {
-	t.Helper()
-	sum := sha256.Sum256([]byte(content))
-	hash := hex.EncodeToString(sum[:])
-	req, _ := http.NewRequest(http.MethodPut, url+"/api/blobs/"+hash, strings.NewReader(content))
-	req.Header.Set("Authorization", "Bearer "+adminToken)
-	res, err := http.DefaultClient.Do(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	res.Body.Close()
-	change := protocol.Change{Space: protocol.SharedSpace, Path: path, Base: base, Hash: hash}
-	call(t, http.MethodPost, url+"/api/repos/"+repoKey+"/revisions", adminToken, protocol.Push{Name: "vault", Author: author, Changes: []protocol.Change{change}}, nil)
-	return hash
-}
-
-func revisions(t *testing.T, url, query string) []protocol.Revision {
-	t.Helper()
-	var revisions []protocol.Revision
-	call(t, http.MethodGet, url+"/api/repos/"+repoKey+"/revisions"+query, adminToken, nil, &revisions)
-	return revisions
-}
-
-func seqs(revisions []protocol.Revision) []int64 {
-	seqs := make([]int64, len(revisions))
-	for i, rev := range revisions {
-		seqs[i] = rev.Seq
-	}
-	return seqs
-}
-
-func TestRevisionsCarryAuthorAndPageAfterSeq(t *testing.T) {
-	url := newServer(t)
-	events, err := http.NewRequest(http.MethodGet, url+"/api/events", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	events.Header.Set("Authorization", "Bearer "+adminToken)
-	stream, err := http.DefaultClient.Do(events)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer stream.Body.Close()
-
-	first := push(t, url, "", "a.md", "", "one")
-	push(t, url, "alice", "a.md", first, "two")
-	push(t, url, "bob", "b.md", "", "three")
-
-	if got := seqs(revisions(t, url, "")); len(got) != 3 || got[0] != 3 {
-		t.Fatalf("default order = %v, want newest first", got)
-	}
-	after := revisions(t, url, "?after=1")
-	if got := seqs(after); len(got) != 2 || got[0] != 2 || got[1] != 3 {
-		t.Fatalf("after=1 = %v, want [2 3]", got)
-	}
-	if after[0].Author != "alice" || after[0].Machine != "web" || revisions(t, url, "?after=0")[0].Author != "" {
-		t.Fatalf("authors = %+v", after)
-	}
-	if got := seqs(revisions(t, url, "?after=0&path=b.md")); len(got) != 1 || got[0] != 3 {
-		t.Fatalf("after with path = %v", got)
-	}
-	if got := revisions(t, url, "?after=3"); len(got) != 0 {
-		t.Fatalf("after the last revision = %v", got)
-	}
-
-	var authors []string
-	scanner := bufio.NewScanner(stream.Body)
-	for len(authors) < 3 && scanner.Scan() {
-		if data, ok := strings.CutPrefix(scanner.Text(), "data: "); ok {
-			var event protocol.Event
-			_ = json.Unmarshal([]byte(data), &event)
-			authors = append(authors, event.Author)
-		}
-	}
-	if strings.Join(authors, ",") != ",alice,bob" {
-		t.Fatalf("event authors = %q", authors)
-	}
-}
-
-func TestOldDatabaseGainsAuthorColumn(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "lodge.db")
-	db, err := sql.Open("sqlite", path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	_, err = db.Exec(`
-		create table revisions (repo text not null, seq integer not null, machine_id integer, time integer not null, main_sha text not null, main_branch text not null, primary key (repo, seq));
-		create table changes (repo text not null, seq integer not null, space text not null, path text not null, base text not null, hash text not null, primary key (repo, seq, space, path));
-		insert into revisions values ('` + repoKey + `', 1, null, 1, '', 'main');
-		insert into changes values ('` + repoKey + `', 1, 'shared', 'a.md', '', 'x');`)
-	if err := errors.Join(err, db.Close()); err != nil {
-		t.Fatal(err)
-	}
-	for range 2 {
-		store, err := OpenStore(path)
-		if err != nil {
-			t.Fatal(err)
-		}
-		revisions, err := store.Revisions(context.Background(), repoKey, "")
-		store.Close()
-		if err != nil || len(revisions) != 1 || revisions[0].Author != "" {
-			t.Fatalf("old revisions = %+v (%v)", revisions, err)
-		}
-	}
-}
-
-func TestMachinesShowWhoIsOnline(t *testing.T) {
-	url := newServer(t)
-	var code protocol.CodeResponse
-	call(t, http.MethodPost, url+"/api/codes", adminToken, nil, &code)
-	var claim protocol.ClaimResponse
-	call(t, http.MethodPost, url+"/api/claim", "", protocol.ClaimRequest{Code: code.Code, Name: "dell"}, &claim)
-	online := func() protocol.Machine {
-		t.Helper()
-		var machines []protocol.Machine
-		call(t, http.MethodGet, url+"/api/machines", adminToken, nil, &machines)
-		if len(machines) != 1 {
-			t.Fatalf("machines = %+v", machines)
-		}
-		return machines[0]
-	}
-	if machine := online(); machine.Online || machine.LastSeen != 0 {
-		t.Fatalf("a machine that never connected: %+v", machine)
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, url+"/api/events", nil)
-	req.Header.Set("Authorization", "Bearer "+claim.Token)
-	stream, err := http.DefaultClient.Do(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if machine := online(); !machine.Online || machine.LastSeen == 0 {
-		t.Fatalf("a machine listening for events: %+v", machine)
-	}
-	cancel()
-	stream.Body.Close()
-	deadline := time.Now().Add(5 * time.Second)
-	for online().Online {
-		if time.Now().After(deadline) {
-			t.Fatal("the machine stays online after its stream closed")
-		}
-		time.Sleep(20 * time.Millisecond)
-	}
-}
-
-func TestInstallScriptModes(t *testing.T) {
-	url := newServer(t)
-	var code protocol.CodeResponse
-	call(t, http.MethodPost, url+"/api/codes", adminToken, nil, &code)
-	if code.RemoteCommand != "curl -fsSL "+url+"/i/"+code.Code+"/remote | sh" {
-		t.Fatalf("remote command = %q", code.RemoteCommand)
-	}
-	for path, mode := range map[string]string{"/i/" + code.Code: "login", "/i/" + code.Code + "/remote": "remote"} {
-		res, err := http.Get(url + path)
-		if err != nil {
-			t.Fatal(err)
-		}
-		script, _ := io.ReadAll(res.Body)
-		res.Body.Close()
-		if res.StatusCode != http.StatusOK || !strings.Contains(string(script), `mode="`+mode+`"`) || !strings.Contains(string(script), `code="`+code.Code+`"`) {
-			t.Fatalf("%s: %d\n%s", path, res.StatusCode, script)
-		}
-		check := exec.Command("sh", "-n")
-		check.Stdin = bytes.NewReader(script)
-		if out, err := check.CombinedOutput(); err != nil {
-			t.Fatalf("%s is not valid sh: %v %s", path, err, out)
-		}
-	}
-	res, err := http.Get(url + "/i/abcdef/remote")
-	if err != nil {
-		t.Fatal(err)
-	}
-	res.Body.Close()
-	if res.StatusCode != http.StatusNotFound {
-		t.Fatalf("unknown code: %d", res.StatusCode)
-	}
-}

backend/internal/server/store.go

@@ -20,11 +20,6 @@ const (
 	codeLifetime    = 10 * time.Minute
 	sessionLifetime = 30 * 24 * time.Hour
 	revisionLimit   = 500
-	revisionRows    = `
-		select r.seq, coalesce(m.name, iif(r.machine_id is null, 'web', 'revoked')), r.author, r.time, r.main_sha, r.main_branch, c.space, c.path, c.base, c.hash
-		from revisions r
-		join changes c on c.repo = r.repo and c.seq = r.seq
-		left join machines m on m.id = r.machine_id`
 	schema          = `
 create table if not exists machines (
 	id integer primary key,
@@ -54,7 +49,6 @@ create table if not exists revisions (
 	repo text not null,
 	seq integer not null,
 	machine_id integer,
-	author text not null default '',
 	time integer not null,
 	main_sha text not null,
 	main_branch text not null,
@@ -92,21 +86,9 @@ func OpenStore(path string) (*Store, error) {
 	if _, err := db.Exec(schema); err != nil {
 		return nil, err
 	}
-	if err := addAuthor(db); err != nil {
-		return nil, err
-	}
 	return &Store{db: db}, nil
 }
 
-func addAuthor(db *sql.DB) error {
-	var found int
-	if err := db.QueryRow(`select count(*) from pragma_table_info('revisions') where name = 'author'`).Scan(&found); err != nil || found > 0 {
-		return err
-	}
-	_, err := db.Exec(`alter table revisions add column author text not null default ''`)
-	return err
-}
-
 func (s *Store) Close() error {
 	return s.db.Close()
 }
@@ -310,24 +292,14 @@ func (s *Store) State(ctx context.Context, repo, at string) (protocol.State, err
 }
 
 func (s *Store) Revisions(ctx context.Context, repo, path string) ([]protocol.Revision, error) {
-	return s.revisions(ctx, revisionRows+`
+	rows, err := s.db.QueryContext(ctx, `
+		select r.seq, coalesce(m.name, iif(r.machine_id is null, 'web', 'revoked')), r.time, r.main_sha, r.main_branch, c.space, c.path, c.base, c.hash
+		from revisions r
+		join changes c on c.repo = r.repo and c.seq = r.seq
+		left join machines m on m.id = r.machine_id
 		where r.repo = ?1 and (?2 = '' or c.path = ?2)
 		order by r.seq desc, c.path
 		limit ?3`, repo, path, revisionLimit)
-}
-
-func (s *Store) RevisionsAfter(ctx context.Context, repo, path string, after int64) ([]protocol.Revision, error) {
-	return s.revisions(ctx, revisionRows+`
-		where r.repo = ?1 and (?2 = '' or c.path = ?2) and r.seq in (
-			select distinct seq from changes
-			where repo = ?1 and (?2 = '' or path = ?2) and seq > ?4
-			order by seq limit ?3
-		)
-		order by r.seq, c.path`, repo, path, revisionLimit, after)
-}
-
-func (s *Store) revisions(ctx context.Context, query string, args ...any) ([]protocol.Revision, error) {
-	rows, err := s.db.QueryContext(ctx, query, args...)
 	if err != nil {
 		return nil, err
 	}
@@ -336,7 +308,7 @@ func (s *Store) revisions(ctx context.Context, query string, args ...any) ([]pro
 	for rows.Next() {
 		var rev protocol.Revision
 		var change protocol.Change
-		if err := rows.Scan(&rev.Seq, &rev.Machine, &rev.Author, &rev.Time, &rev.MainSHA, &rev.MainBranch, &change.Space, &change.Path, &change.Base, &change.Hash); err != nil {
+		if err := rows.Scan(&rev.Seq, &rev.Machine, &rev.Time, &rev.MainSHA, &rev.MainBranch, &change.Space, &change.Path, &change.Base, &change.Hash); err != nil {
 			return nil, err
 		}
 		if last := len(revisions) - 1; last >= 0 && revisions[last].Seq == rev.Seq {
@@ -384,7 +356,7 @@ func (s *Store) Push(ctx context.Context, repo string, machineID int64, push pro
 		return 0, err
 	}
 	machine := sql.NullInt64{Int64: machineID, Valid: machineID != 0}
-	if _, err := tx.ExecContext(ctx, `insert into revisions (repo, seq, machine_id, author, time, main_sha, main_branch) values (?, ?, ?, ?, ?, ?, ?)`, repo, seq, machine, push.Author, now, push.MainSHA, push.MainBranch); err != nil {
+	if _, err := tx.ExecContext(ctx, `insert into revisions (repo, seq, machine_id, time, main_sha, main_branch) values (?, ?, ?, ?, ?, ?)`, repo, seq, machine, now, push.MainSHA, push.MainBranch); err != nil {
 		return 0, err
 	}
 	for _, change := range push.Changes {

frontend/bun.lock

@@ -5,7 +5,7 @@
     "": {
       "name": "lodge",
       "devDependencies": {
-        "@biomejs/biome": "2.5.13",
+        "@biomejs/biome": "2.5.2",
         "@fontsource-variable/archivo": "^5.3.0",
         "@fontsource-variable/jetbrains-mono": "^5.3.0",
         "@internationalized/date": "^3.12.0",
@@ -30,42 +30,52 @@
         "tailwindcss": "^4.3.0",
         "tw-animate-css": "^1.4.0",
         "typescript": "^6.0.3",
-        "ultracite": "7.12.4",
+        "ultracite": "7.9.0",
         "vite": "^8.0.16",
       },
     },
   },
   "packages": {
-    "@babel/helper-string-parser": ["@babel/helper-string-parser@7.29.7", "", {}, "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw=="],
+    "@biomejs/biome": ["@biomejs/biome@2.5.2", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.5.2", "@biomejs/cli-darwin-x64": "2.5.2", "@biomejs/cli-linux-arm64": "2.5.2", "@biomejs/cli-linux-arm64-musl": "2.5.2", "@biomejs/cli-linux-x64": "2.5.2", "@biomejs/cli-linux-x64-musl": "2.5.2", "@biomejs/cli-win32-arm64": "2.5.2", "@biomejs/cli-win32-x64": "2.5.2" }, "bin": { "biome": "bin/biome" } }, "sha512-VQ3RCqr7JmDIX+w6stWYl+g/3bYofN3q2wDBHUKKc/c7i5QWrFKFBZYCYPWTE6agsUPMIZZe6/CMmVUfUAhkKA=="],
 
-    "@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.29.7", "", {}, "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg=="],
+    "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@2.5.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-e7P3P7EkwFc/KiX2AHw4YDLIBOMfG9CPCAwy52k5Bp0dfhkozx9hf6wCmIr2QeXy2XeccJ3V/Sg+hDmzYEqxSg=="],
 
-    "@babel/parser": ["@babel/parser@7.29.9", "", { "dependencies": { "@babel/types": "^7.29.8" }, "bin": "./bin/babel-parser.js" }, "sha512-CjXrNHTnvqBVqHgdBysY3vk2T8tpJHb5/RMeHJBTyVa9xgugCB0CJTx/3oO8RV2QRQP391RWpB7D6hLjm8V9uA=="],
+    "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@2.5.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-ymzMvjC1Jg0b9K0D26ZdARqFQXs7MocfLC5FOCGfkC0Ss+ACUJkX5364ZM5nT4NLZanHRZNVrZEy+Ibwcvux/g=="],
 
-    "@babel/types": ["@babel/types@7.29.8", "", { "dependencies": { "@babel/helper-string-parser": "^7.29.7", "@babel/helper-validator-identifier": "^7.29.7" } }, "sha512-Vj1jF3cPfxg7OAfoI7QnVKLoILlm2JF9pnVHrX8qx7AHMiYWT+NDAA7jChlNgRS4WTLc/fD1lXLmPixluj+3Gg=="],
+    "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@2.5.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-t7sseOmqND57uUWTwlawU6BYj+J06T/9EkydzBhkrgw/FK3QVhjU2wsJR0frljrKZ0/I8A/rYw7284QgqjQfIQ=="],
 
-    "@biomejs/biome": ["@biomejs/biome@2.5.13", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.5.13", "@biomejs/cli-darwin-x64": "2.5.13", "@biomejs/cli-linux-arm64": "2.5.13", "@biomejs/cli-linux-arm64-musl": "2.5.13", "@biomejs/cli-linux-x64": "2.5.13", "@biomejs/cli-linux-x64-musl": "2.5.13", "@biomejs/cli-win32-arm64": "2.5.13", "@biomejs/cli-win32-x64": "2.5.13" }, "bin": { "biome": "bin/biome" } }, "sha512-+SEC/mFk1a+5mvUANZgbZTaiZXs1nj4iMhL/PHiqDT5TPUEPFIlliEtkKKZB4N862yylHC3UI+/Sj2I0HJEqhA=="],
+    "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@2.5.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-w+ANG0ZvTu9IeEg9QnstoOnk6L0fpwJifW6aHR18+cb5Z39bkANItYjAfMrnvce5tmMK+IQ6nPX7/kQFdam5iw=="],
 
-    "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@2.5.13", "", { "os": "darwin", "cpu": "arm64" }, "sha512-nYSuDJ6zgVqZUkAkJkvhXxsF2PYIrUk/g638K4voCXz7foI9f7b6C2/7+oAihsHQlivZNMUrm/y8ywlcHQtZOw=="],
+    "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@2.5.2", "", { "os": "linux", "cpu": "x64" }, "sha512-M/lOZrewzTCRDINbjhQ1gYYru37KlD3kJBQwwKCG0ckz5E9IZwIoJ3X0wBwRXA+yBDIwWUuPBHS67HzJY4dTfA=="],
 
-    "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@2.5.13", "", { "os": "darwin", "cpu": "x64" }, "sha512-KVy1ceEDuJ3AzFxjT9kkxbVy+UANw1pjEMUS6lvKfxjJ+fmkRvc7sQn1Xo6ETgseEI7wUQoV03KSga3XfE8YRQ=="],
+    "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@2.5.2", "", { "os": "linux", "cpu": "x64" }, "sha512-VArNLAzND063tF+XY0yPyM+DyahpzOMzOAvb7qs259nhjJWRjvjZdssuA+Rfl+l07+NOesKZ0Xu2yFrXyBMtzw=="],
 
-    "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@2.5.13", "", { "os": "linux", "cpu": "arm64" }, "sha512-VlNMtoxOqs0dUR6drxxHr18SNUvI7xxAuHZlH4s/dstYSf3g6RaqVgo8JRnhcOhKz9afWrvtJTboNG1JuYlIDQ=="],
+    "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@2.5.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-kbjFFKyZlzYnAuw7sRy5qDoFG6zrP40UK08oPQsWK0ct3NMnGSt+Bs1iviEEyEIP57N5MrykGXdO/wRiaR4lww=="],
 
-    "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@2.5.13", "", { "os": "linux", "cpu": "arm64" }, "sha512-CH32xpep3dNS5EVJpAHlYchkBYznxyVZQrx0b6YYYlPL9u9ZeD2NtqiK/6s64+HFS2a7hGnryLlqqZAOh8ax5g=="],
+    "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@2.5.2", "", { "os": "win32", "cpu": "x64" }, "sha512-4InchVpdVmdkkkgjQqKpgvyu+VPnoF/7RPSw5YATgEVpt2j72wcCAeV5TwaE9ZGJUZWZn7v2CwSAj6CrMJEx8A=="],
 
-    "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@2.5.13", "", { "os": "linux", "cpu": "x64" }, "sha512-Fi6gIxbUaJ3ZCIXeG3ggIBPF76O2DjDN67WrPX/ODRv54GeXPm2gbEPC96Yb0yrJoiH0Eax1JLx1Pi0XbsNFZQ=="],
+    "@cacheable/memory": ["@cacheable/memory@2.2.0", "", { "dependencies": { "@cacheable/utils": "^2.5.0", "@keyv/bigmap": "^1.3.1", "hookified": "^1.15.1", "keyv": "^5.6.0" } }, "sha512-CTLKqLItRCEixEAewD3/j9DB3/o96gpTPD4eJ1v+DGOlxZRZncRQkGYqqnAGCscYd6RNeXfGeiuCphsPtqyIfQ=="],
 
-    "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@2.5.13", "", { "os": "linux", "cpu": "x64" }, "sha512-F3pmwl+VHoUuVJN/tbNLKeLt0SVK3EIyN1jXlMcNyQGYRQQTVqXF+GgkP0/CjGXFN87e/mv0sBfUnWqWza5PKQ=="],
-
-    "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@2.5.13", "", { "os": "win32", "cpu": "arm64" }, "sha512-+WD13qshXrr0Icv4BfsAdzm8Fs3TL+nZ59zEQxsYNd8lcgZJ0A5+OrlwsL1PipVCmWeRpxgIPD6DAcEd7smkCQ=="],
-
-    "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@2.5.13", "", { "os": "win32", "cpu": "x64" }, "sha512-VOofU/nW761XWzUeUNE8zzYNyPrxuMuNFMizL0qz7J75yeV8N7WFheUlk1/K6dOkaFpH9wJ+lDKlwjAbw0346w=="],
+    "@cacheable/utils": ["@cacheable/utils@2.5.0", "", { "dependencies": { "hashery": "^1.5.1", "keyv": "^5.6.0" } }, "sha512-buipgOVDkkPXNR5+xBpDw7Zk2n1EvU7qBJCNUcL7rhQ//kfpOXPAvQ511Os0vpLYJ1pZnvudNytkQt2hst3wqA=="],
 
     "@clack/core": ["@clack/core@1.5.1", "", { "dependencies": { "fast-wrap-ansi": "^0.2.0", "sisteransi": "^1.0.5" } }, "sha512-iHTrHA8MtVuLl2TfZySmcKv1qO2PoyC9Z7pfSDozEuV5vtY3/wcOPKJXlqJ5Oq2Cx5DDGQGAMVx6HZfRRoVEbQ=="],
 
     "@clack/prompts": ["@clack/prompts@1.8.1", "", { "dependencies": { "@clack/core": "1.5.1", "fast-string-width": "^3.0.2", "fast-wrap-ansi": "^0.2.0", "sisteransi": "^1.0.5" } }, "sha512-dlT1m5e/0yUL0kRNcQn7yGLVThkgbB0Ga/1AmfDDC/8ik6AIiSf2QLQO2zPYvefsHP0aFgxO93cVLCCfDp7kzQ=="],
 
+    "@eslint-community/eslint-utils": ["@eslint-community/eslint-utils@4.10.1", "", { "dependencies": { "eslint-visitor-keys": "^3.4.3" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" } }, "sha512-cuadcxVFE8sDK6iWJbs8Sn0av2Nrh2QSGQhVlBW9AaAHqHwjWsZHT8LJ4hFGPh7ASBV2deFdM7H/DPjulmh8rg=="],
+
+    "@eslint-community/regexpp": ["@eslint-community/regexpp@4.12.2", "", {}, "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew=="],
+
+    "@eslint/config-array": ["@eslint/config-array@0.23.5", "", { "dependencies": { "@eslint/object-schema": "^3.0.5", "debug": "^4.3.1", "minimatch": "^10.2.4" } }, "sha512-Y3kKLvC1dvTOT+oGlqNQ1XLqK6D1HU2YXPc52NmAlJZbMMWDzGYXMiPRJ8TYD39muD/OTjlZmNJ4ib7dvSrMBA=="],
+
+    "@eslint/config-helpers": ["@eslint/config-helpers@0.7.0", "", { "dependencies": { "@eslint/core": "^1.2.1" } }, "sha512-DObd/KKUsU+FaFv4PLxSRenpXfQWmPXXP3pPZ6/K1PCrMu2vQpMDMuQe/BqYeoLcz8ro0bVDF1RxOJgfVEdhUw=="],
+
+    "@eslint/core": ["@eslint/core@1.2.1", "", { "dependencies": { "@types/json-schema": "^7.0.15" } }, "sha512-MwcE1P+AZ4C6DWlpin/OmOA54mmIZ/+xZuJiQd4SyB29oAJjN30UW9wkKNptW2ctp4cEsvhlLY/CsQ1uoHDloQ=="],
+
+    "@eslint/object-schema": ["@eslint/object-schema@3.0.5", "", {}, "sha512-vqTaUEgxzm+YDSdElad6PiRoX4t8VGDjCtt05zn4nU810UIx/uNEV7/lZJ6KwFThKZOzOxzXy48da+No7HZaMw=="],
+
+    "@eslint/plugin-kit": ["@eslint/plugin-kit@0.7.3", "", { "dependencies": { "@eslint/core": "^1.2.1", "levn": "^0.4.1" } }, "sha512-IkO+/KEUvwbVpiURZg+P7zF74z5Jxe0UgJxVni+RtoHQ6IZieXaO02kmadomap/q+l6bc/jdPGGqTjhuZnuz1Q=="],
+
     "@floating-ui/core": ["@floating-ui/core@1.8.0", "", { "dependencies": { "@floating-ui/utils": "^0.2.12" } }, "sha512-0CIZ5itps/8x7BG8dEIhs53BvCUH2PCoogtakwRTut+Arm58sJooJ0AuZhLw2HJYIR5cMLNPBSS728sPho2khQ=="],
 
     "@floating-ui/dom": ["@floating-ui/dom@1.8.0", "", { "dependencies": { "@floating-ui/core": "^1.8.0", "@floating-ui/utils": "^0.2.12" } }, "sha512-yXSrzeHZBTZadLOlfyhCkJHNeLJnHRnRInwdZ40L7ZiaAtrBwoYlsDrX3v5zB1Utk7CLfzcOVnVVWoXEky7Ceg=="],
@@ -76,6 +86,16 @@
 
     "@fontsource-variable/jetbrains-mono": ["@fontsource-variable/jetbrains-mono@5.3.0", "", {}, "sha512-F32xpS2NsGYoQi2ADSkKTgpJj7ozajsGgDJ8woTnqjmIB+dxDIqImjl4pXZVEExu8UFZ2ndhmX18EBS/hdz3Lw=="],
 
+    "@humanfs/core": ["@humanfs/core@0.19.2", "", { "dependencies": { "@humanfs/types": "^0.15.0" } }, "sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA=="],
+
+    "@humanfs/node": ["@humanfs/node@0.16.8", "", { "dependencies": { "@humanfs/core": "^0.19.2", "@humanfs/types": "^0.15.0", "@humanwhocodes/retry": "^0.4.0" } }, "sha512-gE1eQNZ3R++kTzFUpdGlpmy8kDZD/MLyHqDwqjkVQI0JMdI1D51sy1H958PNXYkM2rAac7e5/CnIKZrHtPh3BQ=="],
+
+    "@humanfs/types": ["@humanfs/types@0.15.0", "", {}, "sha512-ZZ1w0aoQkwuUuC7Yf+7sdeaNfqQiiLcSRbfI08oAxqLtpXQr9AIVX7Ay7HLDuiLYAaFPu8oBYNq/QIi9URHJ3Q=="],
+
+    "@humanwhocodes/module-importer": ["@humanwhocodes/module-importer@1.0.1", "", {}, "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA=="],
+
+    "@humanwhocodes/retry": ["@humanwhocodes/retry@0.4.3", "", {}, "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ=="],
+
     "@internationalized/date": ["@internationalized/date@3.12.4", "", { "dependencies": { "@swc/helpers": "^0.5.0" } }, "sha512-M1dEn4c1U1HsSlaVR8upZtSqvXrTkHDfv18H01uCSJyjVLDxnBR38v/fMxecmlwXKR4i9HeZcmgQAPE6A+aGJQ=="],
 
     "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.13", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA=="],
@@ -88,14 +108,12 @@
 
     "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="],
 
+    "@keyv/bigmap": ["@keyv/bigmap@1.3.1", "", { "dependencies": { "hashery": "^1.4.0", "hookified": "^1.15.0" }, "peerDependencies": { "keyv": "^5.6.0" } }, "sha512-WbzE9sdmQtKy8vrNPa9BRnwZh5UF4s1KTmSK0KUVLo3eff5BlQNNWDnFOouNpKfPKDnms9xynJjsMYjMaT/aFQ=="],
+
+    "@keyv/serialize": ["@keyv/serialize@1.1.1", "", {}, "sha512-dXn3FZhPv0US+7dtJsIi2R+c7qWYiReoEh5zUntWCf4oSpMNib8FDhSoed6m3QyZdx5hK7iLFkYk3rNxwt8vTA=="],
+
     "@lucide/svelte": ["@lucide/svelte@1.47.0", "", { "peerDependencies": { "svelte": "^5" } }, "sha512-tpuE7JIK9FzYDWsJx6PxHj9ROyCpnDxZfvHu5q5yHGKS2CFNjzSyf1o9/Ypu2A27GLvkPGqZcIMrF6idM+eQZQ=="],
 
-    "@nodelib/fs.scandir": ["@nodelib/fs.scandir@2.1.5", "", { "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" } }, "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g=="],
-
-    "@nodelib/fs.stat": ["@nodelib/fs.stat@2.0.5", "", {}, "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A=="],
-
-    "@nodelib/fs.walk": ["@nodelib/fs.walk@1.2.8", "", { "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" } }, "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg=="],
-
     "@oxc-project/types": ["@oxc-project/types@0.150.0", "", {}, "sha512-rDS5/31E9HfPl/CIzGrn0DOlvBbXFseQ5URJ9sYMfstbKLD/c6Gm9vmRzRGDdAXyOIL4zmO37lc9RIwYqVruZw=="],
 
     "@polka/url": ["@polka/url@1.0.0-next.29", "", {}, "sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww=="],
@@ -132,10 +150,6 @@
 
     "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.1", "", {}, "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw=="],
 
-    "@sec-ant/readable-stream": ["@sec-ant/readable-stream@0.4.1", "", {}, "sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg=="],
-
-    "@sindresorhus/merge-streams": ["@sindresorhus/merge-streams@4.0.0", "", {}, "sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ=="],
-
     "@standard-schema/spec": ["@standard-schema/spec@1.1.0", "", {}, "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w=="],
 
     "@sveltejs/acorn-typescript": ["@sveltejs/acorn-typescript@1.0.13", "", { "peerDependencies": { "acorn": "^8.9.0" } }, "sha512-wgKggnhZVL9Bfx1OaKKTrYY9BFRk6C8UAkQNUcIv1+llzYrIqy+RZm5HPKzn0NpEBvTVhTqB4kQyllZywsRBRQ=="],
@@ -184,48 +198,68 @@
 
     "@types/cookie": ["@types/cookie@0.6.0", "", {}, "sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA=="],
 
+    "@types/esrecurse": ["@types/esrecurse@4.3.1", "", {}, "sha512-xJBAbDifo5hpffDBuHl0Y8ywswbiAp/Wi7Y/GtAgSlZyIABppyurxVueOPE8LUQOxdlgi6Zqce7uoEpqNTeiUw=="],
+
     "@types/estree": ["@types/estree@1.0.9", "", {}, "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg=="],
 
+    "@types/json-schema": ["@types/json-schema@7.0.15", "", {}, "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="],
+
     "@types/node": ["@types/node@26.6.2", "", { "dependencies": { "undici-types": "~8.9.0" } }, "sha512-X1P21scMv4zGKLYqjdGjaKa7COa0RKVYYZZN/NfvLQ1JegxFhdhpZG/Lyn8AXx6CDUavKAd11v6BvfpkDByK8g=="],
 
     "@types/trusted-types": ["@types/trusted-types@2.0.7", "", {}, "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw=="],
 
+    "@typescript-eslint/project-service": ["@typescript-eslint/project-service@8.70.0", "", { "dependencies": { "@typescript-eslint/tsconfig-utils": "^8.70.0", "@typescript-eslint/types": "^8.70.0", "debug": "^4.4.3" }, "peerDependencies": { "typescript": ">=4.8.4 <6.1.0" } }, "sha512-hFHbTNqhU9G+2eKFXCBVb1tjFT/LceiJ4+HfLO4pTpDI0KHi6iajpcFFkaSQ9gXmCh7n82A0PthaayEdN6mspQ=="],
+
+    "@typescript-eslint/scope-manager": ["@typescript-eslint/scope-manager@8.70.0", "", { "dependencies": { "@typescript-eslint/types": "8.70.0", "@typescript-eslint/visitor-keys": "8.70.0" } }, "sha512-8nP3Kwh5hlgZ4FicGvmznAmJe8UL4sdU8tLukrPaMuQmDuk4Y8xYfzu/aYZW4xT2JCgc7H/TpDI5cGlxcWJSqQ=="],
+
+    "@typescript-eslint/tsconfig-utils": ["@typescript-eslint/tsconfig-utils@8.70.0", "", { "peerDependencies": { "typescript": ">=4.8.4 <6.1.0" } }, "sha512-adnkeeNq9Sq1sUf4+FRVc0KdgYghzsgFpZSQVZVvY0LCuUuN0FnQgyGzCJeC4fW1cdXseBAjU2EOqUIjbNcZUw=="],
+
+    "@typescript-eslint/types": ["@typescript-eslint/types@8.70.0", "", {}, "sha512-asTOIYhDg4zdzOScCyaytrsV3cR6B4ecPQlXw/dJIm7J/MZTtCtfVII9JD8Geh4jTCrK/Xe6cg5UevoleMcoJQ=="],
+
+    "@typescript-eslint/typescript-estree": ["@typescript-eslint/typescript-estree@8.70.0", "", { "dependencies": { "@typescript-eslint/project-service": "8.70.0", "@typescript-eslint/tsconfig-utils": "8.70.0", "@typescript-eslint/types": "8.70.0", "@typescript-eslint/visitor-keys": "8.70.0", "debug": "^4.4.3", "minimatch": "^10.2.2", "semver": "^7.7.3", "tinyglobby": "^0.2.15", "ts-api-utils": "^2.5.0" }, "peerDependencies": { "typescript": ">=4.8.4 <6.1.0" } }, "sha512-d9NmHMPEKQ7QCLLm1jI3zmoQBwT5KwFYjXBJ9ymZfKCUU+5rmTRykKAFvH5Qn/ZCds3CEAFS9OC9M/jkl0X2bA=="],
+
+    "@typescript-eslint/utils": ["@typescript-eslint/utils@8.70.0", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.9.1", "@typescript-eslint/scope-manager": "8.70.0", "@typescript-eslint/types": "8.70.0", "@typescript-eslint/typescript-estree": "8.70.0" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", "typescript": ">=4.8.4 <6.1.0" } }, "sha512-oZmtKJz/4fufZ2p3+Cn3ijEojcdfR+1zYDH2xKYrEly0dR/Q/1xUPRCOlKGxod78nWlU2UnDe09GZ3TaknBFGA=="],
+
+    "@typescript-eslint/visitor-keys": ["@typescript-eslint/visitor-keys@8.70.0", "", { "dependencies": { "@typescript-eslint/types": "8.70.0", "eslint-visitor-keys": "^5.0.0" } }, "sha512-BoC8PiO4Hkdo0TVJh9Ntxr5MxPDI7/oFsrygN5ADelFSeXG/qgNuucIGA+L5Z6JpPTE/uRfcTWtscjbUaufepQ=="],
+
     "acorn": ["acorn@8.18.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-lGq+9yr1/GuAWaVYIHRjvvySG5/4VfKIvC8EWxStPdcDh/Ka7FG3twP6v4d5BkravUilhIAsG4Qj83t02LWUPQ=="],
 
-    "ansi-escapes": ["ansi-escapes@7.3.0", "", { "dependencies": { "environment": "^1.0.0" } }, "sha512-BvU8nYgGQBxcmMuEeUEmNTvrMVjJNSH7RgW24vXexN4Ven6qCvy4TntnvlnwnMLTVlcRQQdbRY8NKnaIoeWDNg=="],
+    "acorn-jsx": ["acorn-jsx@5.3.2", "", { "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ=="],
 
-    "ansi-regex": ["ansi-regex@6.4.0", "", {}, "sha512-KzTVk2tCWAHtYrvvvaP8bJKJq2pVinhLcGEQdtLIYPbmNGNyYe8QwNaTUYQp2J7/vIsUKt5QCqAfUkYyG9DkOw=="],
-
-    "ansi-styles": ["ansi-styles@6.2.3", "", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="],
+    "ajv": ["ajv@6.15.0", "", { "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", "json-schema-traverse": "^0.4.1", "uri-js": "^4.2.2" } }, "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw=="],
 
     "aria-query": ["aria-query@5.3.1", "", {}, "sha512-Z/ZeOgVl7bcSYZ/u/rh0fOpvEpq//LZmdbkXyc7syVzjPAhfOa9ebsdTSjEBDU4vs5nC98Kfduj1uFo0qyET3g=="],
 
     "axobject-query": ["axobject-query@4.1.0", "", {}, "sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ=="],
 
+    "balanced-match": ["balanced-match@4.0.4", "", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="],
+
     "bits-ui": ["bits-ui@2.19.2", "", { "dependencies": { "@floating-ui/core": "^1.7.1", "@floating-ui/dom": "^1.7.1", "esm-env": "^1.1.2", "runed": "^0.35.1", "svelte-toolbelt": "^0.10.6", "tabbable": "^6.2.0" }, "peerDependencies": { "@internationalized/date": "^3.8.1", "svelte": "^5.33.0" } }, "sha512-W9upilTmLTIWjuVAD6Ta7XoS6gxRflmCQnXamj+WN1eYxZecghqGENpuSMAKQmVENMLXhh85BZb04LCrBd2+Ng=="],
 
-    "braces": ["braces@3.0.3", "", { "dependencies": { "fill-range": "^7.1.1" } }, "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA=="],
+    "brace-expansion": ["brace-expansion@5.0.12", "", { "dependencies": { "balanced-match": "^4.0.2" } }, "sha512-YovQ3rzhaLMIrDjNDMkNS01tea93qhEhG5xy8f6+R0l+dw3Ki+5sCoIoI942iuLZTHWogWktgwVDhU09iNEimQ=="],
 
     "bun-types": ["bun-types@1.4.2", "", { "dependencies": { "@types/node": "*" } }, "sha512-bxV1FgK7yBIzjRe5zBozIM4Bem11ZJcCXSrjWRG3YWLt8yFDePu4cLjpebO8OvPeIE9trbyPF4fuj3Cia4Fj3w=="],
 
+    "cacheable": ["cacheable@2.5.0", "", { "dependencies": { "@cacheable/memory": "^2.2.0", "@cacheable/utils": "^2.5.0", "hookified": "^1.15.0", "keyv": "^5.6.0", "qified": "^0.10.1" } }, "sha512-60cyAOytib/OzBw1JNSoSV/boK1AtHryDIjvVBk7XbN4ugfkM3+Sry7fEjNgPMGgOjuaZPAp8ruZ0Cxafwyq9g=="],
+
     "chokidar": ["chokidar@4.0.3", "", { "dependencies": { "readdirp": "^4.0.1" } }, "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA=="],
 
     "citty": ["citty@0.2.2", "", {}, "sha512-+6vJA3L98yv+IdfKGZHBNiGW5KHn22e/JwID0Strsz8h4S/csAu/OuICwxrg44k5MRiZHWIo8XXuJgQTriRP4w=="],
 
-    "cli-cursor": ["cli-cursor@5.0.0", "", { "dependencies": { "restore-cursor": "^5.0.0" } }, "sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw=="],
-
-    "cli-truncate": ["cli-truncate@6.1.1", "", { "dependencies": { "slice-ansi": "^9.0.0", "string-width": "^8.2.0" } }, "sha512-06p9vyLahLa4zkGcgsGxU6iEkSOiuI4fhCH6Emhe2lPAcoUv73n72DnODsnHA+5wwXGnV0n9M9/qOQJSjYhFhw=="],
-
     "clsx": ["clsx@2.1.1", "", {}, "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="],
 
     "cn": ["cn@0.3.0", "", { "bin": { "cn": "bin/cn.mjs" } }, "sha512-qRoU0ARrZD3Bbj1wKFftEKxPjSnzTEdFkf22NVhW+zU9D/wajhoP+qUZ5DChhhSOBCH1onV12hrmGqfu1+5Z2Q=="],
 
     "commander": ["commander@14.0.3", "", {}, "sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw=="],
 
-    "confbox": ["confbox@0.1.8", "", {}, "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w=="],
-
     "cookie": ["cookie@0.6.0", "", {}, "sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw=="],
 
+    "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
+
+    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" }, "peerDependencies": { "supports-color": "*" }, "optionalPeers": ["supports-color"] }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+
+    "deep-is": ["deep-is@0.1.4", "", {}, "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="],
+
     "deepmerge": ["deepmerge@4.3.1", "", {}, "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A=="],
 
     "dequal": ["dequal@2.0.3", "", {}, "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA=="],
@@ -238,19 +272,35 @@
 
     "dompurify": ["dompurify@3.4.15", "", { "optionalDependencies": { "@types/trusted-types": "^2.0.7" } }, "sha512-EUBjM+B+lkDE41iE82DDSCfkoPGfXx8IxFxPMjNzm/Uk4xDet77rTN9wqlxlVg71kK7XGuUMv6wUxJUwwv+Xyw=="],
 
-    "empathic": ["empathic@2.1.0", "", {}, "sha512-AnfC1ATldl49/cvZdLPDjBfrRNwbDO05aibiOtzQu3qtlbJtomNLhF30HEtn/7iBz50dlMECqATo3fG0LrdEgw=="],
-
     "enhanced-resolve": ["enhanced-resolve@5.25.1", "", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.3.3" } }, "sha512-nGXts5znJzmWPu+mIE9izCOzdg63oJca2mDzGWWTth7sr4aCToKcoyFVBQwN75Ij5Pf6p510EwkTqViTRzDV+w=="],
 
-    "environment": ["environment@1.1.0", "", {}, "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q=="],
+    "escape-string-regexp": ["escape-string-regexp@4.0.0", "", {}, "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="],
+
+    "eslint": ["eslint@10.11.0", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.8.0", "@eslint-community/regexpp": "^4.12.2", "@eslint/config-array": "^0.23.5", "@eslint/config-helpers": "^0.7.0", "@eslint/core": "^1.2.1", "@eslint/plugin-kit": "^0.7.3", "@humanfs/node": "^0.16.6", "@humanwhocodes/module-importer": "^1.0.1", "@humanwhocodes/retry": "^0.4.2", "@types/estree": "^1.0.6", "ajv": "^6.14.0", "cross-spawn": "^7.0.6", "debug": "^4.3.2", "escape-string-regexp": "^4.0.0", "eslint-scope": "^9.1.2", "eslint-visitor-keys": "^5.0.1", "espree": "^11.2.0", "esquery": "^1.7.0", "esutils": "^2.0.2", "fast-deep-equal": "^3.1.3", "file-entry-cache": "11.1.5 || >11.1.6 <12", "find-up": "^5.0.0", "glob-parent": "^6.0.2", "ignore": "^5.2.0", "imurmurhash": "^0.1.4", "is-glob": "^4.0.0", "json-stable-stringify-without-jsonify": "^1.0.1", "minimatch": "^10.2.5", "natural-compare": "^1.4.0", "optionator": "^0.9.3" }, "peerDependencies": { "jiti": "*" }, "optionalPeers": ["jiti"], "bin": { "eslint": "bin/eslint.js" } }, "sha512-P7a6UEEqb9G95MYAtqkmsTbVXIYyzIfl6NGOIJk162PaahFxFyeGcrlXYFSiagECg4sEm8IseJdZBKR3rx6MsQ=="],
+
+    "eslint-scope": ["eslint-scope@9.1.2", "", { "dependencies": { "@types/esrecurse": "^4.3.1", "@types/estree": "^1.0.8", "esrecurse": "^4.3.0", "estraverse": "^5.2.0" } }, "sha512-xS90H51cKw0jltxmvmHy2Iai1LIqrfbw57b79w/J7MfvDfkIkFZ+kj6zC3BjtUwh150HsSSdxXZcsuv72miDFQ=="],
+
+    "eslint-visitor-keys": ["eslint-visitor-keys@3.4.3", "", {}, "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag=="],
 
     "esm-env": ["esm-env@1.2.2", "", {}, "sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA=="],
 
+    "espree": ["espree@11.2.0", "", { "dependencies": { "acorn": "^8.16.0", "acorn-jsx": "^5.3.2", "eslint-visitor-keys": "^5.0.1" } }, "sha512-7p3DrVEIopW1B1avAGLuCSh1jubc01H2JHc8B4qqGblmg5gI9yumBgACjWo4JlIc04ufug4xJ3SQI8HkS/Rgzw=="],
+
+    "esquery": ["esquery@1.7.0", "", { "dependencies": { "estraverse": "^5.1.0" } }, "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g=="],
+
     "esrap": ["esrap@2.3.7", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.4.15" }, "peerDependencies": { "@typescript-eslint/types": "^8.2.0" }, "optionalPeers": ["@typescript-eslint/types"] }, "sha512-n2nf7fZR3c9yXf0BPEuHuXqT+KW0SJVj4cN5FMEkpCZ3scLjOQWpiccyCxVzCC2q1wubTghuEGzngJY/7Ah0Ow=="],
 
-    "execa": ["execa@10.1.0", "", { "dependencies": { "@sindresorhus/merge-streams": "^4.0.0", "figures": "^6.1.0", "get-stream": "^9.0.1", "human-signals": "^8.0.1", "is-plain-obj": "^4.1.0", "is-stream": "^4.0.1", "npm-run-path": "^6.0.0", "pretty-ms": "^9.3.1", "signal-exit": "^4.1.0", "strip-final-newline": "^4.0.0", "which-command": "^0.1.0", "yoctocolors": "^2.2.0" } }, "sha512-5HT/600HqXEtmkb9mK/PkTWw+bQSCzPnWiZ4/87wD3Hi0wFzCapOuNT9p4M08PDd+KLHdHvFhKjOWmNx/npRNQ=="],
+    "esrecurse": ["esrecurse@4.3.0", "", { "dependencies": { "estraverse": "^5.2.0" } }, "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag=="],
 
-    "fast-glob": ["fast-glob@3.3.3", "", { "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", "glob-parent": "^5.1.2", "merge2": "^1.3.0", "micromatch": "^4.0.8" } }, "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg=="],
+    "estraverse": ["estraverse@5.3.0", "", {}, "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="],
+
+    "esutils": ["esutils@2.0.3", "", {}, "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g=="],
+
+    "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="],
+
+    "fast-json-stable-stringify": ["fast-json-stable-stringify@2.1.0", "", {}, "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="],
+
+    "fast-levenshtein": ["fast-levenshtein@2.0.6", "", {}, "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw=="],
 
     "fast-string-truncated-width": ["fast-string-truncated-width@3.0.3", "", {}, "sha512-0jjjIEL6+0jag3l2XWWizO64/aZVtpiGE3t0Zgqxv0DPuxiMjvB3M24fCyhZUO4KomJQPj3LTSUnDP3GpdwC0g=="],
 
@@ -258,52 +308,56 @@
 
     "fast-wrap-ansi": ["fast-wrap-ansi@0.2.2", "", { "dependencies": { "fast-string-width": "^3.0.2" } }, "sha512-7F2Fl+TjRSenLqlU3UjSH0iyqopqoZIu7eZVpEirP2g1GtWa2G/ecEmBdgz31+Mxr+ELclgg6sokpSFIQiZ02Q=="],
 
-    "fastq": ["fastq@1.20.3", "", { "dependencies": { "reusify": "^1.0.4" } }, "sha512-XKv5nnLs6nLF71NgiKJLIZFLkPyIEuOselLG7ujZnGrRfQK8HpvY+WqKhAJUAdLomwVHErVS4LfxFlPq0/FTAw=="],
-
     "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="],
 
-    "figures": ["figures@6.1.0", "", { "dependencies": { "is-unicode-supported": "^2.0.0" } }, "sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg=="],
+    "file-entry-cache": ["file-entry-cache@11.1.5", "", { "dependencies": { "flat-cache": "^6.1.23" } }, "sha512-+PFTHITI08JIGhnNpGNI8T8inUpgZfk3GNEqfT9R2zZV2iFXg3CvqzSl/uEhs7TSGujYRELEANyDvS8Fj7+S7Q=="],
 
-    "fill-range": ["fill-range@7.1.1", "", { "dependencies": { "to-regex-range": "^5.0.1" } }, "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg=="],
+    "find-up": ["find-up@5.0.0", "", { "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" } }, "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng=="],
 
-    "find-workspaces": ["find-workspaces@0.3.1", "", { "dependencies": { "fast-glob": "^3.3.2", "pkg-types": "^1.0.3", "yaml": "^2.3.4" } }, "sha512-UDkGILGJSA1LN5Aa7McxCid4sqW3/e+UYsVwyxki3dDT0F8+ym0rAfnCkEfkL0rO7M+8/mvkim4t/s3IPHmg+w=="],
+    "flat-cache": ["flat-cache@6.1.23", "", { "dependencies": { "cacheable": "^2.5.0", "flatted": "^3.4.2", "hookified": "^1.15.0" } }, "sha512-f++BY9pTk+983xK1FLzlLpmM0i0z+jHmx3QESGkURMXujQZz1k5wzwX6hjnQ8goaD0B+sYnDK1yZ6MTyZfUaqA=="],
+
+    "flatted": ["flatted@3.4.4", "", {}, "sha512-5+ybhBZANEJxaH3X5evAFatUxLfEHSr7n6kYJ+1Qd0mUqr4eu9gIf6GDbWHf8RJijHrjjO8G+la14SlL2SeS1Q=="],
 
     "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
 
-    "get-east-asian-width": ["get-east-asian-width@1.7.0", "", {}, "sha512-XjH1AECxf0giL2V1aU8vKyRR2ppRUb5c0EvT7zuJTokQ74bNo52zOtghqdWIqrhUD79fo3x0WfKZdOqxF6LG1Q=="],
+    "glob": ["glob@13.0.6", "", { "dependencies": { "minimatch": "^10.2.2", "minipass": "^7.1.3", "path-scurry": "^2.0.2" } }, "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw=="],
 
-    "get-stream": ["get-stream@9.0.1", "", { "dependencies": { "@sec-ant/readable-stream": "^0.4.1", "is-stream": "^4.0.1" } }, "sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA=="],
-
-    "glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="],
+    "glob-parent": ["glob-parent@6.0.2", "", { "dependencies": { "is-glob": "^4.0.3" } }, "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A=="],
 
     "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="],
 
-    "human-signals": ["human-signals@8.0.1", "", {}, "sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ=="],
+    "hashery": ["hashery@1.5.1", "", { "dependencies": { "hookified": "^1.15.0" } }, "sha512-iZyKG96/JwPz1N55vj2Ie2vXbhu440zfUfJvSwEqEbeLluk7NnapfGqa7LH0mOsnDxTF85Mx8/dyR6HfqcbmbQ=="],
+
+    "hookified": ["hookified@1.15.1", "", {}, "sha512-MvG/clsADq1GPM2KGo2nyfaWVyn9naPiXrqIe4jYjXNZQt238kWyOGrsyc/DmRAQ+Re6yeo6yX/yoNCG5KAEVg=="],
+
+    "ignore": ["ignore@5.3.2", "", {}, "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g=="],
+
+    "imurmurhash": ["imurmurhash@0.1.4", "", {}, "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA=="],
 
     "inline-style-parser": ["inline-style-parser@0.2.7", "", {}, "sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA=="],
 
     "is-extglob": ["is-extglob@2.1.1", "", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="],
 
-    "is-fullwidth-code-point": ["is-fullwidth-code-point@5.1.0", "", { "dependencies": { "get-east-asian-width": "^1.3.1" } }, "sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ=="],
-
     "is-glob": ["is-glob@4.0.3", "", { "dependencies": { "is-extglob": "^2.1.1" } }, "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="],
 
-    "is-number": ["is-number@7.0.0", "", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="],
-
-    "is-plain-obj": ["is-plain-obj@4.1.0", "", {}, "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg=="],
-
     "is-reference": ["is-reference@3.0.3", "", { "dependencies": { "@types/estree": "^1.0.6" } }, "sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw=="],
 
-    "is-stream": ["is-stream@4.0.1", "", {}, "sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A=="],
-
-    "is-unicode-supported": ["is-unicode-supported@2.1.0", "", {}, "sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ=="],
+    "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="],
 
     "jiti": ["jiti@2.7.0", "", { "bin": { "jiti": "lib/jiti-cli.mjs" } }, "sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ=="],
 
+    "json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="],
+
+    "json-stable-stringify-without-jsonify": ["json-stable-stringify-without-jsonify@1.0.1", "", {}, "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw=="],
+
     "jsonc-parser": ["jsonc-parser@3.3.1", "", {}, "sha512-HUgH65KyejrUFPvHFPbqOY0rsFip3Bo5wb4ngvdi1EpCYWUQDC5V+Y7mZws+DLkr4M//zQJoanu1SP+87Dv1oQ=="],
 
+    "keyv": ["keyv@5.6.0", "", { "dependencies": { "@keyv/serialize": "^1.1.1" } }, "sha512-CYDD3SOtsHtyXeEORYRx2qBtpDJFjRTGXUtmNEMGyzYOKj1TE3tycdlho7kA1Ufx9OYWZzg52QFBGALTirzDSw=="],
+
     "kleur": ["kleur@4.1.5", "", {}, "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ=="],
 
+    "levn": ["levn@0.4.1", "", { "dependencies": { "prelude-ls": "^1.2.1", "type-check": "~0.4.0" } }, "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ=="],
+
     "lightningcss": ["lightningcss@1.33.0", "", { "dependencies": { "detect-libc": "^2.0.3" }, "optionalDependencies": { "lightningcss-android-arm64": "1.33.0", "lightningcss-darwin-arm64": "1.33.0", "lightningcss-darwin-x64": "1.33.0", "lightningcss-freebsd-x64": "1.33.0", "lightningcss-linux-arm-gnueabihf": "1.33.0", "lightningcss-linux-arm64-gnu": "1.33.0", "lightningcss-linux-arm64-musl": "1.33.0", "lightningcss-linux-x64-gnu": "1.33.0", "lightningcss-linux-x64-musl": "1.33.0", "lightningcss-win32-arm64-msvc": "1.33.0", "lightningcss-win32-x64-msvc": "1.33.0" } }, "sha512-WkUDrojuJs0xkgGf2udWxa3yGBRxPtxUkB79i6aCZLRgc7PM8fZe9TosfPDcvEpQZbuFASnHYmRLBLUbmLOIIA=="],
 
     "lightningcss-android-arm64": ["lightningcss-android-arm64@1.33.0", "", { "os": "android", "cpu": "arm64" }, "sha512-gEpRTalKdosp4Bb8qWtc2iOgE5SeIHlpS1up9bFq2wAyYhl1UdTObYiHe98zEM9SQvSoqQZ1IQD0JNpg3Ml5pg=="],
@@ -330,23 +384,19 @@
 
     "locate-character": ["locate-character@3.0.0", "", {}, "sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA=="],
 
-    "log-update": ["log-update@8.0.0", "", { "dependencies": { "ansi-escapes": "^7.3.0", "cli-cursor": "^5.0.0", "slice-ansi": "^9.0.0", "string-width": "^8.2.0", "strip-ansi": "^7.2.0", "wrap-ansi": "^10.0.0" } }, "sha512-lddSgOt3bPASrylL54ZSpy8nBHns+vBVSoILlVOx+dei300pnLRN958rj/EdlVLKuWlSESU3qdnDZdAI7FXYGg=="],
+    "locate-path": ["locate-path@6.0.0", "", { "dependencies": { "p-locate": "^5.0.0" } }, "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw=="],
+
+    "lru-cache": ["lru-cache@11.5.3", "", {}, "sha512-U4N8FgzmWxc8k1VH8Kr6lQg18U7Fjvby6wXHVRX/ZZ7IwWbRMgrRbP0Wrb5q5NVinryp4SQampHKdvtecItxUg=="],
 
     "lz-string": ["lz-string@1.5.0", "", { "bin": { "lz-string": "bin/bin.js" } }, "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ=="],
 
     "magic-string": ["magic-string@0.30.21", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.5" } }, "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ=="],
 
-    "magicast": ["magicast@0.5.5", "", { "dependencies": { "@babel/parser": "^7.29.7", "@babel/types": "^7.29.7", "source-map-js": "^1.2.1" } }, "sha512-UicdXN8zQ3JHlxVq+28afMXPr1z7WNY6+7EJnzTdQWkTAlMLF5fNCCKxJHBQwGaNGR11581EiQmQzx73+MvszA=="],
-
     "marked": ["marked@18.0.13", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-xTxVzZsBFwunP6HDmtBkabUQEYArnP7/rMDGmPj9SlrKlQ4i8MdYVow+nJL0eOqwpUqhzBoTBRADGN6uYwPyOw=="],
 
-    "merge2": ["merge2@1.4.1", "", {}, "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="],
+    "minimatch": ["minimatch@10.2.6", "", { "dependencies": { "brace-expansion": "^5.0.8" } }, "sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A=="],
 
-    "micromatch": ["micromatch@4.0.8", "", { "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" } }, "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA=="],
-
-    "mimic-function": ["mimic-function@5.0.1", "", {}, "sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA=="],
-
-    "mlly": ["mlly@1.8.2", "", { "dependencies": { "acorn": "^8.16.0", "pathe": "^2.0.3", "pkg-types": "^1.3.1", "ufo": "^1.6.3" } }, "sha512-d+ObxMQFmbt10sretNDytwt85VrbkhhUA/JBGm1MPaWJ65Cl4wOgLaB1NYvJSZ0Ef03MMEU/0xpPMXUIQ29UfA=="],
+    "minipass": ["minipass@7.1.3", "", {}, "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A=="],
 
     "mode-watcher": ["mode-watcher@1.1.0", "", { "dependencies": { "runed": "^0.25.0", "svelte-toolbelt": "^0.7.1" }, "peerDependencies": { "svelte": "^5.27.0" } }, "sha512-mUT9RRGPDYenk59qJauN1rhsIMKBmWA3xMF+uRwE8MW/tjhaDSCCARqkSuDTq8vr4/2KcAxIGVjACxTjdk5C3g=="],
 
@@ -354,21 +404,29 @@
 
     "mrmime": ["mrmime@2.0.1", "", {}, "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ=="],
 
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
     "nanoid": ["nanoid@3.3.19", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-Y2tUNy4ouw6tq5oDSKeQYGOyhkUBhNOcGV/02KC+6kd9eDGqdZd++mjMiIDilrBYvjEnCYvVtsuHCuP+okSfug=="],
 
-    "node-fetch-native": ["node-fetch-native@1.6.7", "", {}, "sha512-g9yhqoedzIUm0nTnTqAQvueMPVOuIY16bqgAJJC8XOOubYFNwz6IER9qs0Gq2Xd0+CecCKFjtdDTMA4u4xG06Q=="],
+    "natural-compare": ["natural-compare@1.4.0", "", {}, "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw=="],
 
-    "npm-run-path": ["npm-run-path@6.0.0", "", { "dependencies": { "path-key": "^4.0.0", "unicorn-magic": "^0.3.0" } }, "sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA=="],
+    "node-fetch-native": ["node-fetch-native@1.6.7", "", {}, "sha512-g9yhqoedzIUm0nTnTqAQvueMPVOuIY16bqgAJJC8XOOubYFNwz6IER9qs0Gq2Xd0+CecCKFjtdDTMA4u4xG06Q=="],
 
     "nypm": ["nypm@0.6.10", "", { "dependencies": { "citty": "^0.2.2", "pathe": "^2.0.3", "tinyexec": "^1.3.1" }, "bin": { "nypm": "./dist/cli.mjs" } }, "sha512-W72Hrj1petq+b3Hk2aAC+9zswetlIFTnDW4s5djseZh2nYqBbyQLOtj472HwcbcWykPBUW1WpWpjOd4nK6gMRw=="],
 
     "obug": ["obug@2.2.1", "", {}, "sha512-XrsrhT5sybtKI6wakr2SPOlGZWWYbUXZ7a0jT8/QOeAPau+1X/bSegNe5YR75oJmEZQbKningirmGOEJCIk61Q=="],
 
-    "onetime": ["onetime@7.0.0", "", { "dependencies": { "mimic-function": "^5.0.0" } }, "sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ=="],
+    "optionator": ["optionator@0.9.4", "", { "dependencies": { "deep-is": "^0.1.3", "fast-levenshtein": "^2.0.6", "levn": "^0.4.1", "prelude-ls": "^1.2.1", "type-check": "^0.4.0", "word-wrap": "^1.2.5" } }, "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g=="],
 
-    "parse-ms": ["parse-ms@4.0.0", "", {}, "sha512-TXfryirbmq34y8QBwgqCVLi+8oA3oWx2eAnSn62ITyEhEYaWRlVZ2DvMM9eZbMs/RfxPu/PK/aBLyGj4IrqMHw=="],
+    "p-limit": ["p-limit@3.1.0", "", { "dependencies": { "yocto-queue": "^0.1.0" } }, "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ=="],
 
-    "path-key": ["path-key@4.0.0", "", {}, "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ=="],
+    "p-locate": ["p-locate@5.0.0", "", { "dependencies": { "p-limit": "^3.0.2" } }, "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw=="],
+
+    "path-exists": ["path-exists@4.0.0", "", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="],
+
+    "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="],
+
+    "path-scurry": ["path-scurry@2.0.2", "", { "dependencies": { "lru-cache": "^11.0.0", "minipass": "^7.1.2" } }, "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg=="],
 
     "pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
 
@@ -376,26 +434,18 @@
 
     "picomatch": ["picomatch@4.0.7", "", {}, "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA=="],
 
-    "pkg-types": ["pkg-types@1.3.1", "", { "dependencies": { "confbox": "^0.1.8", "mlly": "^1.7.4", "pathe": "^2.0.1" } }, "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ=="],
-
     "postcss": ["postcss@8.5.28", "", { "dependencies": { "nanoid": "^3.3.18", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-RRuzqDtt5Y9h3quz5hWhK+TPnsmVs6WwSU6LkJMeY4HstUEDuYTG8UJSdawMRzmzAtV+KEoG8N3Qg2qLy5vM/A=="],
 
-    "pretty-ms": ["pretty-ms@9.3.1", "", { "dependencies": { "parse-ms": "^4.0.0" } }, "sha512-HzMy3Geq23nVALD/M2LliU+F+M+gVNsvkQWWqeBZ8HDiCgzo6YPJ/Omrmtq24EFrIsk0a3EkQGEd7bDOo+IhGA=="],
+    "prelude-ls": ["prelude-ls@1.2.1", "", {}, "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g=="],
 
-    "queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="],
+    "punycode": ["punycode@2.3.1", "", {}, "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="],
+
+    "qified": ["qified@0.10.1", "", { "dependencies": { "hookified": "^2.1.1" } }, "sha512-+Owyggi9IxT1ePKGafcI87ubSmxol6smwJ+RAHDQlx9+9cPwFWDiKFFCPuWhr9ignlGpZ9vDQLw67N4dcTVFEA=="],
 
     "readdirp": ["readdirp@4.1.2", "", {}, "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg=="],
 
-    "resolve.exports": ["resolve.exports@2.0.3", "", {}, "sha512-OcXjMsGdhL4XnbShKpAcSqPMzQoYkYyhbEaeSko47MjRP9NfEQMhZkXL1DoFlt9LWQn4YttrdnV6X2OiyzBi+A=="],
-
-    "restore-cursor": ["restore-cursor@5.1.0", "", { "dependencies": { "onetime": "^7.0.0", "signal-exit": "^4.1.0" } }, "sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA=="],
-
-    "reusify": ["reusify@1.1.0", "", {}, "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="],
-
     "rolldown": ["rolldown@1.2.9", "", { "dependencies": { "@oxc-project/types": "=0.150.0", "@rolldown/pluginutils": "^1.0.0" }, "optionalDependencies": { "@rolldown/binding-android-arm-eabi": "1.2.9", "@rolldown/binding-android-arm64": "1.2.9", "@rolldown/binding-darwin-arm64": "1.2.9", "@rolldown/binding-darwin-x64": "1.2.9", "@rolldown/binding-freebsd-x64": "1.2.9", "@rolldown/binding-linux-arm-gnueabihf": "1.2.9", "@rolldown/binding-linux-arm64-gnu": "1.2.9", "@rolldown/binding-linux-arm64-musl": "1.2.9", "@rolldown/binding-linux-ppc64-gnu": "1.2.9", "@rolldown/binding-linux-s390x-gnu": "1.2.9", "@rolldown/binding-linux-x64-gnu": "1.2.9", "@rolldown/binding-linux-x64-musl": "1.2.9", "@rolldown/binding-openharmony-arm64": "1.2.9", "@rolldown/binding-win32-arm64-msvc": "1.2.9", "@rolldown/binding-win32-x64-msvc": "1.2.9" }, "bin": { "rolldown": "./bin/cli.mjs" } }, "sha512-hx/Pv0N1haXRb11qkfnK5MXB/iqr7i0yjWQqmO9uHqZpBgQSqzc8UsSnEpalsh+j1I8qQ2CkXAkJC8Br3dKSlg=="],
 
-    "run-parallel": ["run-parallel@1.2.0", "", { "dependencies": { "queue-microtask": "^1.2.2" } }, "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA=="],
-
     "runed": ["runed@0.35.1", "", { "dependencies": { "dequal": "^2.0.3", "esm-env": "^1.0.0", "lz-string": "^1.5.0" }, "peerDependencies": { "@sveltejs/kit": "^2.21.0", "svelte": "^5.7.0" }, "optionalPeers": ["@sveltejs/kit"] }, "sha512-2F4Q/FZzbeJTFdIS/PuOoPRSm92sA2LhzTnv6FXhCoENb3huf5+fDuNOg1LNvGOouy3u/225qxmuJvcV3IZK5Q=="],
 
     "sade": ["sade@1.8.1", "", { "dependencies": { "mri": "^1.1.0" } }, "sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A=="],
@@ -406,22 +456,16 @@
 
     "shadcn-svelte": ["shadcn-svelte@1.7.0", "", { "dependencies": { "cn": "^0.3.0", "commander": "^14.0.0", "node-fetch-native": "^1.6.4", "postcss": "^8.5.10" }, "peerDependencies": { "svelte": "^5.0.0" }, "bin": { "shadcn-svelte": "dist/index.mjs" } }, "sha512-AK3ZsYOL8PN/RxcEBCHGvQj2TrLfaaBsbw0QohyEb3nn/yPNDRC/+9iSjnTp/uKEe+tAi0tBxB/Yhzno0N7EEg=="],
 
-    "signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="],
+    "shebang-command": ["shebang-command@2.0.0", "", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="],
+
+    "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="],
 
     "sirv": ["sirv@3.0.2", "", { "dependencies": { "@polka/url": "^1.0.0-next.24", "mrmime": "^2.0.0", "totalist": "^3.0.0" } }, "sha512-2wcC/oGxHis/BoHkkPwldgiPSYcpZK3JU28WoMVv55yHJgcZ8rlXvuG9iZggz+sU1d4bRgIGASwyWqjxu3FM0g=="],
 
     "sisteransi": ["sisteransi@1.0.5", "", {}, "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg=="],
 
-    "slice-ansi": ["slice-ansi@9.0.1", "", { "dependencies": { "ansi-styles": "^6.2.3", "is-fullwidth-code-point": "^5.1.0" } }, "sha512-aBY19bn/XA+hKOKX0qL7Z0UfdBsbQvc9hn993U8ALUjzxCvDcuZqLoRXjGJrUARWAlwMnsRVD9sw2AFNOYvalA=="],
-
     "source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="],
 
-    "string-width": ["string-width@8.3.0", "", { "dependencies": { "get-east-asian-width": "^1.5.0", "strip-ansi": "^7.1.2" } }, "sha512-ZbmZM0JCihQN91dWnxoipT2KOEyHqEyfRXUyjuRhW8b/xnqPDoq4gWEVApTVa9db2wN8mmoikgFBbjh71+cGeQ=="],
-
-    "strip-ansi": ["strip-ansi@7.2.0", "", { "dependencies": { "ansi-regex": "^6.2.2" } }, "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w=="],
-
-    "strip-final-newline": ["strip-final-newline@4.0.0", "", {}, "sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw=="],
-
     "style-to-object": ["style-to-object@1.0.14", "", { "dependencies": { "inline-style-parser": "0.2.7" } }, "sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw=="],
 
     "svelte": ["svelte@5.57.1", "", { "dependencies": { "@jridgewell/remapping": "^2.3.5", "@jridgewell/sourcemap-codec": "^1.6.0", "@sveltejs/acorn-typescript": "^1.0.13", "@types/estree": "^1.0.9", "acorn": "^8.18.0", "aria-query": "5.3.1", "axobject-query": "^4.1.0", "clsx": "^2.1.1", "devalue": "^5.9.2", "esm-env": "^1.2.1", "esrap": "^2.3.6", "is-reference": "^3.0.3", "locate-character": "^3.0.0", "magic-string": "^0.30.11", "zimmerframe": "^1.1.2" } }, "sha512-Uqj49lWKB+iSSnneuwiYYJ7MZgkB+eXr0LXBhv4uDuAkXqnWmq65Sxflfvp0Lc6MdKjMUxGaeOKWJqz5SNiVIA=="],
@@ -446,35 +490,35 @@
 
     "tinyglobby": ["tinyglobby@0.2.17", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.4" } }, "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g=="],
 
-    "to-regex-range": ["to-regex-range@5.0.1", "", { "dependencies": { "is-number": "^7.0.0" } }, "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ=="],
-
     "totalist": ["totalist@3.0.1", "", {}, "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ=="],
 
+    "ts-api-utils": ["ts-api-utils@2.5.0", "", { "peerDependencies": { "typescript": ">=4.8.4" } }, "sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA=="],
+
     "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
 
     "tw-animate-css": ["tw-animate-css@1.4.0", "", {}, "sha512-7bziOlRqH0hJx80h/3mbicLW7o8qLsH5+RaLR2t+OHM3D0JlWGODQKQ4cxbK7WlvmUxpcj6Kgu6EKqjrGFe3QQ=="],
 
+    "type-check": ["type-check@0.4.0", "", { "dependencies": { "prelude-ls": "^1.2.1" } }, "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew=="],
+
     "typescript": ["typescript@6.0.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw=="],
 
-    "ufo": ["ufo@1.6.4", "", {}, "sha512-JFNbkD1Svwe0KvGi8GOeLcP4kAWQ609twvCdcHxq1oSL8svv39ZuSvajcD8B+5D0eL4+s1Is2D/O6KN3qcTeRA=="],
-
-    "ultracite": ["ultracite@7.12.4", "", { "dependencies": { "@clack/prompts": "^1.8.1", "cli-truncate": "^6.1.1", "commander": "^15.0.0", "deepmerge": "^4.3.1", "empathic": "^2.1.0", "execa": "^10.0.1", "fast-glob": "^3.3.3", "find-workspaces": "^0.3.1", "jsonc-parser": "^3.3.1", "log-update": "^8.0.0", "magicast": "^0.5.5", "npm-run-path": "^6.0.0", "nypm": "^0.6.10", "resolve.exports": "^2.0.3", "semver": "^7.8.5", "string-width": "^8.3.0", "which-command": "^0.1.0", "yaml": "^2.9.1", "zod": "^4.6.5" }, "peerDependencies": { "@biomejs/biome": "^2.5.0", "eslint": "^10.9.0", "oxfmt": ">=0.59.0", "oxlint": "^1.86.0", "prettier": "^3.0.0", "stylelint": "^17.0.0" }, "optionalPeers": ["@biomejs/biome", "eslint", "oxfmt", "oxlint", "prettier", "stylelint"], "bin": { "ultracite": "dist/index.js" } }, "sha512-6jVEwaZBaytFm6XRoI3WGS2ZydrkrNvHTD0qTf7983ti2FlEWL1YcxnPaMaYuS6PkXqMhIK2XGr0cbsL4x5pQA=="],
+    "ultracite": ["ultracite@7.9.0", "", { "dependencies": { "@clack/prompts": "^1.5.1", "@typescript-eslint/utils": "^8.62.1", "commander": "^15.0.0", "cross-spawn": "^7.0.6", "deepmerge": "^4.3.1", "glob": "^13.0.6", "jsonc-parser": "^3.3.1", "nypm": "^0.6.6", "yaml": "^2.9.0", "zod": "^4.4.3" }, "peerDependencies": { "oxfmt": ">=0.1.0", "oxlint": "^1.0.0" }, "optionalPeers": ["oxfmt", "oxlint"], "bin": { "ultracite": "dist/index.js" } }, "sha512-Lkh6MXuX/vI89jeDIaEiOifI1BVXEJmk6e+igKRGAzdp5jKzeFa5d5A0tpJmHGCxXzd42jVwNpcs7jqm87IfNg=="],
 
     "undici-types": ["undici-types@8.9.0", "", {}, "sha512-KTDyRTYX8sWmKXAikPHHSyc63CRPETMctyjKFupcC6OBLXT3xsN0e9aF7m+mIXutFWpUXuedtowG7iLOzp0kQg=="],
 
-    "unicorn-magic": ["unicorn-magic@0.3.0", "", {}, "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA=="],
+    "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="],
 
     "vite": ["vite@8.3.0", "", { "dependencies": { "lightningcss": "^1.33.0", "picomatch": "^4.0.7", "postcss": "^8.5.28", "rolldown": "~1.2.6", "tinyglobby": "^0.2.17" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "@vitejs/devtools": "^0.7.1", "esbuild": "^0.27.0 || ^0.28.0", "jiti": ">=1.21.0", "less": "^4.0.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "@vitejs/devtools", "esbuild", "jiti", "less", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-lhZBVvEHefgE+HQZC9O7EBJgCU/nVzFNl7vkS4RE0APtWLP02/8QVIkQtzBxPquh7lq5/78NHipTj7ODQ6XuyQ=="],
 
     "vitefu": ["vitefu@1.1.3", "", { "peerDependencies": { "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" }, "optionalPeers": ["vite"] }, "sha512-ub4okH7Z5KLjb6hDyjqrGXqWtWvoYdU3IGm/NorpgHncKoLTCfRIbvlhBm7r0YstIaQRYlp4yEbFqDcKSzXSSg=="],
 
-    "which-command": ["which-command@0.1.0", "", { "bin": { "which-command": "cli.js" } }, "sha512-XZyoF5/5hZtXitIwzrU4NKK+Wtbb9aB9CezUEw2Q0wlYK8NUYQxC1rRXgNueYLtBAJwXIb+/tFVk4dozciNJMA=="],
+    "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
 
-    "wrap-ansi": ["wrap-ansi@10.0.2", "", { "dependencies": { "ansi-styles": "^6.2.3", "string-width": "^8.2.0" } }, "sha512-6OLRNZqRntVGBm26ghZ5eZhCuWWyOkRCSn8XsOIuq5stpCE/tjLbdozd93naILZig0lmD8ANfRwnhn0DLeXGlg=="],
+    "word-wrap": ["word-wrap@1.2.5", "", {}, "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA=="],
 
     "yaml": ["yaml@2.9.1", "", { "bin": { "yaml": "bin.mjs" } }, "sha512-3NxN8+78OdzbT7C/WjGsyfPAtJaN3FNDsWxv7Y7mcDsT/oOmgW8BpyQQFFBnvZE3j9Y2Sdz1ULFLezL7Eb2yFw=="],
 
-    "yoctocolors": ["yoctocolors@2.2.0", "", {}, "sha512-xYqdZFUK/VYazNl/oCDYN+3WloWQwMfZxBoiNt6qNyk+xfOdi598muWE42rNZFp1kNOiqW936q5RhUdnpqElSg=="],
+    "yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="],
 
     "zimmerframe": ["zimmerframe@1.1.5", "", {}, "sha512-msJxIvYDYcoNL+PJsu+7qmpDWsYmAxTY+2TNYXXF0hzBzBk0BMecOqDOG/EckUoKCuKwObfbugIl8QpqHDXeFA=="],
 
@@ -496,12 +540,18 @@
 
     "@tailwindcss/oxide-wasm32-wasi/tslib": ["tslib@2.8.1", "", { "bundled": true }, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
 
-    "micromatch/picomatch": ["picomatch@2.3.2", "", {}, "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA=="],
+    "@typescript-eslint/visitor-keys/eslint-visitor-keys": ["eslint-visitor-keys@5.0.1", "", {}, "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA=="],
+
+    "eslint/eslint-visitor-keys": ["eslint-visitor-keys@5.0.1", "", {}, "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA=="],
+
+    "espree/eslint-visitor-keys": ["eslint-visitor-keys@5.0.1", "", {}, "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA=="],
 
     "mode-watcher/runed": ["runed@0.25.0", "", { "dependencies": { "esm-env": "^1.0.0" }, "peerDependencies": { "svelte": "^5.7.0" } }, "sha512-7+ma4AG9FT2sWQEA0Egf6mb7PBT2vHyuHail1ie8ropfSjvZGtEAx8YTmUjv/APCsdRRxEVvArNjALk9zFSOrg=="],
 
     "mode-watcher/svelte-toolbelt": ["svelte-toolbelt@0.7.1", "", { "dependencies": { "clsx": "^2.1.1", "runed": "^0.23.2", "style-to-object": "^1.0.8" }, "peerDependencies": { "svelte": "^5.0.0" } }, "sha512-HcBOcR17Vx9bjaOceUvxkY3nGmbBmCBBbuWLLEWO6jtmWH8f/QoWmbyUfQZrpDINH39en1b8mptfPQT9VKQ1xQ=="],
 
+    "qified/hookified": ["hookified@2.2.0", "", {}, "sha512-p/LgFzRN5FeoD3DLS6bkUapeye6E4SI6yJs6KetENd18S+FBthqYq2amJUWpt5z0EQwwHemidjY5OqJGEKm5uA=="],
+
     "svelte-sonner/runed": ["runed@0.28.0", "", { "dependencies": { "esm-env": "^1.0.0" }, "peerDependencies": { "svelte": "^5.7.0" } }, "sha512-k2xx7RuO9hWcdd9f+8JoBeqWtYrm5CALfgpkg2YDB80ds/QE4w0qqu34A7fqiAwiBBSBQOid7TLxwxVC27ymWQ=="],
 
     "ultracite/commander": ["commander@15.0.0", "", {}, "sha512-z67u4ZhzCL/Tydu1lJARtEZYWbWaN7oYLHbsuzocr6y4N6WZAagG3RQ4FW61V1/0+jImpj293XfrcYnd1qxtPg=="],

frontend/docker-compose.yml

@@ -1,6 +1,6 @@
 services:
   frontend-dev:
-    image: oven/bun:alpine
+    image: oven/bun:alpine@sha256:d888c0ae6c86d7866ff10c5aafdd9077b36aee6455b33dd270fb93c0dd5cef6f
     profiles: [frontend-dev]
     restart: unless-stopped
     working_dir: /app

frontend/package.json

@@ -14,7 +14,7 @@
     "fix": "ultracite fix"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.5.13",
+    "@biomejs/biome": "2.5.2",
     "@fontsource-variable/archivo": "^5.3.0",
     "@fontsource-variable/jetbrains-mono": "^5.3.0",
     "@internationalized/date": "^3.12.0",
@@ -39,7 +39,7 @@
     "tailwindcss": "^4.3.0",
     "tw-animate-css": "^1.4.0",
     "typescript": "^6.0.3",
-    "ultracite": "7.12.4",
+    "ultracite": "7.9.0",
     "vite": "^8.0.16"
   }
 }