+ );
+}
diff --git a/src/components/react/index.ts b/src/components/react/index.ts
index fa7a369..ae317dd 100644
--- a/src/components/react/index.ts
+++ b/src/components/react/index.ts
@@ -34,4 +34,5 @@ export { PricingRates } from './PricingRates';
export { SearchDialog } from './SearchDialog';
export { SearchDialogWrapper } from './SearchDialogWrapper';
export { StatusBadge, StatusCodes } from './StatusCodes';
+export { StatusIcon } from './StatusIcon';
export { ThemeSwitcher } from './ThemeSwitcher';
diff --git a/src/content/docs/working-with-sprites.mdx b/src/content/docs/working-with-sprites.mdx
index ec1ef61..c675b4e 100644
--- a/src/content/docs/working-with-sprites.mdx
+++ b/src/content/docs/working-with-sprites.mdx
@@ -1,758 +1,250 @@
---
title: Working with Sprites
-description: Beyond the basics, sessions, ports, persistence, checkpoints
+description: Beyond the basics—sessions, ports, persistence, and everything you need to build real stuff
---
-import { Tabs, TabItem } from '@astrojs/starlight/components';
-import { Callout, LinkCard, CardGrid } from '@/components/react';
+import { Callout, StatusIcon } from '@/components/react';
-After you've made it through the Quickstart, you've got a working Sprite and a sense of how to use it. This page covers what comes next: how Sprites behave over time, how to run persistent processes, how networking works, and how to shape the environment to fit your stack. Use it as a reference as you start building more with Sprites.
+After you've made it through the [Quickstart](/quickstart), you've got a working Sprite and a basic idea of how to use it. This guide picks up from there: how to run commands, manage sessions, keep processes alive, and make sure your environment stays consistent over time. The first half covers everything you need to build and deploy real stuff. The rest is there when you're ready to go deeper.
-## Lifecycle
-
-### Automatic Hibernation
-
-Sprites automatically hibernate when inactive, with no compute charges while idle. When you execute a command or make a request to a Sprite's URL, it automatically wakes up with all your data intact.
-
-### Timeouts
-
-Sprites currently hibernate after **30 seconds** of inactivity. This timeout is not configurable yet.
-
-### Idle Detection
-
-A Sprite is considered active if any of the following are true:
+---
-1. It has an active command running (via `exec`)
-2. Its stdin is being written to
-3. It has an open TCP connection over its URL
-4. A detachable session is running
+## Running Commands and Sessions
----
+Sprites give you three main ways to interact:
-## Configuration
+### `sprite exec` – One-off commands and automation
-### Resource Allocation
+Run a single command, wait for it to finish, get the output. Perfect for scripts, package installs, or quick checks.
-Sprites currently run on machines with a fixed resource cap: 8 vCPUs, 8192 MB RAM, and 100 GB storage. These limits are not configurable yet. The SDK accepts config fields, but the API ignores them.
+```bash
+sprite exec "ls -la"
+sprite exec "npm install express"
+sprite exec -tty vim
+```
-Keep in mind, Sprites are not billed based on those limits. You are only charged for the resources your Sprite actually uses. The fixed config defines the current **maximum** resources each Sprite can consume, not a flat rate.
+- Blocks until the command completes
+- Returns stdout/stderr
+- Use for automation or scripting
-### Working Directory
+### `sprite console` – Interactive shell (like SSH)
-Set the working directory for command execution:
+Opens a full terminal session so you can explore, debug, or run multiple commands.
-
-
```bash
-sprite exec -dir /home/sprite/project npm test
-```
-
-
-
-```javascript
-const result = await sprite.exec('npm test', {
- cwd: '/home/sprite/project',
-});
+sprite console
+# Inside:
+# $ cd /home/sprite && ls -la && vim myfile.txt
```
-
-
-```go
-cmd := sprite.Command("npm", "test")
-cmd.Dir = "/home/sprite/project"
-output, err := cmd.Output()
-```
-
+- TTY enabled
+- Stays open until you exit
+- Use for manual work or debugging
-
-```elixir
-{output, 0} = Sprites.cmd(sprite, "npm", ["test"],
- dir: "/home/sprite/project"
-)
-```
-
-
+### `exec -detachable` + attach – Keep things running
-### Environment Variables
+Start a command that keeps running even after you disconnect. Great for dev servers, long builds, or background processes.
-
-
```bash
-sprite exec -env MY_SECRET=hello bash -c 'echo $MY_SECRET'
-```
-
-
-
-```javascript
-const result = await sprite.execFile('bash', ['-lc', 'echo $MY_SECRET'], {
- env: { MY_SECRET: 'hello' },
-});
-console.log(result.stdout); // hello
-```
-
-
-
-```go
-cmd := sprite.Command("bash", "-c", "echo $MY_SECRET")
-cmd.Env = []string{"MY_SECRET=hello"}
-output, _ := cmd.Output()
-fmt.Println(string(output)) // hello
-```
-
-
-
-```elixir
-{output, 0} = Sprites.cmd(sprite, "bash", ["-c", "echo $MY_SECRET"],
- env: [{"MY_SECRET", "hello"}]
-)
-IO.puts(output) # hello
+sprite exec -detachable "npm run dev"
+sprite exec # list sessions
+sprite exec -id # attach to session
+sprite exec -id -kill # kill session
```
-
-
---
-## Environment
+## Sprite Lifecycle: Hibernation and Persistence
-### Pre-installed Tools
+Sprites automatically hibernate after 30 seconds of inactivity. That means:
-The default Sprite environment includes:
+### What Persists (and What Doesn't)
-- **Languages**: Node.js, Python, Go, Ruby, Rust, Elixir/Erlang, Java, Bun, Deno
-- **AI Tools**: Claude CLI, Gemini CLI, OpenAI Codex, Cursor
-- **Utilities**: Git, curl, wget, vim, and common development tools
+**Filesystem persists**: All files, installed packages, git repos, databases—everything on disk stays intact
+**RAM doesn't persist**: Running processes stop, in-memory data is lost
+**Network config persists**: Open ports, URL settings, SSH access all remain configured
-### Custom Setup
+This means you can install dependencies once and they're there forever. But if you're running a web server, it'll need to restart when the Sprite wakes up—that's what detachable sessions are for.
-Run setup commands after creating a Sprite:
+### Wake-up Behavior
-
-
-```javascript
-const sprite = await client.createSprite('my-sprite');
+Wake-up is fast:
-// Install custom dependencies
-await sprite.exec('pip install pandas numpy matplotlib');
-await sprite.exec('npm install -g typescript');
+- ~100–500ms for normal wakes
+- 1–2s on cold starts
-// Clone a repository
-await sprite.exec('git clone https://github.com/your/repo.git /home/sprite/project');
-```
-
-
-
-```go
-sprite, _ := client.CreateSprite(ctx, "my-sprite", nil)
+Use detachable sessions to keep things running without hibernating. You can reattach later and see all the output.
-// Install custom dependencies
-sprite.Command("pip", "install", "pandas", "numpy", "matplotlib").Run()
-sprite.Command("npm", "install", "-g", "typescript").Run()
-
-// Clone a repository
-sprite.Command("git", "clone", "https://github.com/your/repo.git", "/home/sprite/project").Run()
+```bash
+sprite exec -detachable "rails server"
```
-
-
-```elixir
-{:ok, sprite} = Sprites.create(client, "my-sprite")
+### Idle Detection
-# Install custom dependencies
-Sprites.cmd(sprite, "pip", ["install", "pandas", "numpy", "matplotlib"])
-Sprites.cmd(sprite, "npm", ["install", "-g", "typescript"])
+If something's running, your Sprite stays awake. Otherwise, it sleeps. That includes:
-# Clone a repository
-Sprites.cmd(sprite, "git", ["clone", "https://github.com/your/repo.git", "/home/sprite/project"])
-```
-
-
+- Active exec/console commands
+- Open TCP connections (like your app's URL)
+- Running detachable sessions
---
-## Interactive Sessions
+## Networking: URLs and Port Forwarding
-### TTY Mode
+Every Sprite gets a URL: `https://.sprites.app`
-For interactive applications, enable TTY mode:
+### HTTP Access
-
-
```bash
-# Open interactive shell (TTY enabled by default)
-sprite console
-
-# Or with exec
-sprite exec -tty bash
+sprite url # see URL
+sprite url update --auth public # make public
+sprite url update --auth default # make private again
```
-
-
-
-```javascript
-const cmd = sprite.spawn('bash', [], {
- tty: true,
- rows: 24,
- cols: 80,
-});
-
-// Write to stdin
-cmd.stdin.write('echo hello\n');
-
-// Read from stdout
-cmd.stdout.on('data', (data) => {
- process.stdout.write(data);
-});
-
-// Resize terminal
-cmd.resize(30, 100);
-```
-
-
-
-```go
-cmd := sprite.Command("bash")
-cmd.SetTTY(true)
-cmd.SetTTYSize(24, 80)
-
-cmd.Stdin = os.Stdin
-cmd.Stdout = os.Stdout
-cmd.Stderr = os.Stderr
-cmd.Start()
+- Routes to port 8080 by default (or first HTTP port opened)
+- Wakes the Sprite on request
+- Private by default (auth token required)
-// Resize later
-cmd.Resize(30, 100)
+
+**Security note**: Public URLs expose your Sprite to the internet. Only use public mode for demos, webhooks, or non-sensitive work.
+
-cmd.Wait()
-```
-
-
-
-```elixir
-{:ok, cmd} = Sprites.spawn(sprite, "bash", [],
- tty: true,
- tty_rows: 24,
- tty_cols: 80
-)
-
-# Write to stdin
-Sprites.write(cmd, "echo hello\n")
-
-# Receive output
-receive do
- {:stdout, ^cmd, data} -> IO.write(data)
-end
-
-# Resize terminal
-Sprites.resize(cmd, 30, 100)
-```
-
-
-
-### Detachable Sessions
-
-Create sessions that persist even after disconnecting:
+### Port Forwarding
-
-
```bash
-# Create a detachable session
-sprite exec -detachable "npm run dev"
-
-# List active sessions
-sprite exec
-
-# Attach to a session
-sprite exec -id
-```
-
-
-
-```javascript
-// Create a detachable session
-const sessionCmd = sprite.createSession('npm', ['run', 'dev']);
-let sessionId;
-
-sessionCmd.on('message', (msg) => {
- if (msg && msg.type === 'session_info') {
- sessionId = msg.session_id;
- }
-});
-
-// ... later, attach to it
-const cmd = sprite.attachSession(sessionId);
-cmd.stdout.pipe(process.stdout);
+sprite proxy 5432 # access Sprite's port 5432 at localhost:5432
+sprite proxy 3001:3000 # map local 3001 to remote 3000
+sprite proxy 3000 8080 5432 # forward multiple ports
```
-
-
-
-```go
-// Create a detachable session
-cmd := sprite.CreateDetachableSession("npm", "run", "dev")
-cmd.Start()
-
-// List sessions to get the session ID
-sessions, _ := client.ListSessions(ctx, "my-sprite")
-sessionID := sessions[0].ID
-
-// ... later, attach to it
-cmd = sprite.AttachSessionContext(ctx, sessionID)
-cmd.Stdout = os.Stdout
-cmd.Run()
-```
-
-
-
-```elixir
-# Create a detachable session
-{:ok, cmd} = Sprites.spawn(sprite, "npm", ["run", "dev"],
- detachable: true
-)
-
-# Get the session ID from the message
-session_id = receive do
- {:session_info, ^cmd, %{session_id: id}} -> id
-end
-
-# ... later, attach to it
-{:ok, cmd} = Sprites.attach_session(sprite, session_id)
-
-receive do
- {:stdout, ^cmd, data} -> IO.write(data)
-end
-```
-
-
-### Listing Sessions
+Use for database access, dev tools, or private ports. Press `Ctrl+C` to stop forwarding.
-
-
-```bash
-sprite exec
-```
-
+### Port Conflicts
-
-```javascript
-const sessions = await sprite.listSessions();
-for (const session of sessions) {
- console.log(`${session.id}: ${session.command}`);
-}
-```
-
+If a local port is already in use, you'll get an error. Solutions:
-
-```go
-sessions, _ := client.ListSessions(ctx, "my-sprite")
-for _, session := range sessions {
- fmt.Printf("%s: %s\n", session.ID, session.Command)
-}
-```
-
-
-
-```elixir
-{:ok, sessions} = Sprites.list_sessions(sprite)
-for session <- sessions do
- IO.puts("#{session.id}: #{session.command}")
-end
-```
-
-
+1. **Choose a different local port**: `sprite proxy 3001:3000` forwards local 3001 to remote 3000
+2. **Stop the conflicting process**: Find what's using the port with `lsof -i :3000` (macOS/Linux)
+3. **Kill the old proxy session**: If you have an old proxy still running, stop it first
---
-## Managing Sprites
-
-### Referencing by Name
+## Your Environment
-
-
-```bash
-# Set active sprite for current directory
-sprite use my-sprite
+Sprites run Ubuntu 24.04 LTS with common tools preinstalled:
-# Commands now use this sprite
-sprite exec echo "hello"
-```
-
+- **Languages**: Node.js, Python, Go, Ruby, Rust, Elixir, Java, Bun, Deno
+- **AI/CLI Tools**: Claude CLI, Gemini CLI, OpenAI Codex, Cursor
+- **Utilities**: Git, curl, wget, vim, and common dev tools
-
-```javascript
-// Get sprite by name (doesn't verify it exists)
-const sprite = client.sprite('my-sprite');
+### Filesystem Basics
-// Get sprite and verify it exists
-const sprite = await client.getSprite('my-sprite');
-```
-
+- **`/home/sprite/`** — your home directory, put your stuff here
+- **`/home/sprite/.local/`** — for local binaries and user-installed tools
+- **`/opt/`** — good for standalone applications
+- **`/var/`** — for databases and application state
-
-```go
-// Get sprite by name (doesn't verify it exists)
-sprite := client.Sprite("my-sprite")
+Install packages like you would locally:
-// Get sprite and verify it exists
-sprite, err := client.GetSprite(ctx, "my-sprite")
-```
-
-
-
-```elixir
-# Get sprite by name (doesn't verify it exists)
-sprite = Sprites.sprite(client, "my-sprite")
-
-# Get sprite and verify it exists
-{:ok, sprite} = Sprites.get_sprite(client, "my-sprite")
-```
-
-
-
-### Listing Sprites
-
-
-
```bash
-# List all sprites
-sprite list
-
-# List with prefix filter
-sprite list --prefix "dev-"
-```
-
-
-
-```javascript
-// List all sprites
-const sprites = await client.listAllSprites();
-
-// List with prefix filter
-const devSprites = await client.listAllSprites('dev-');
-
-// Paginated listing
-const page = await client.listSprites({ maxResults: 50 });
-console.log(page.sprites);
-if (page.hasMore) {
- const nextPage = await client.listSprites({
- continuationToken: page.nextContinuationToken,
- });
-}
-```
-
-
-
-```go
-// List all sprites
-sprites, _ := client.ListAllSprites(ctx, "")
-
-// List with prefix filter
-devSprites, _ := client.ListAllSprites(ctx, "dev-")
-
-// Paginated listing
-page, _ := client.ListSprites(ctx, &sprites.ListOptions{MaxResults: 50})
-fmt.Println(page.Sprites)
-if page.HasMore {
- nextPage, _ := client.ListSprites(ctx, &sprites.ListOptions{
- ContinuationToken: page.NextContinuationToken,
- })
-}
+sprite exec "pip install pandas numpy"
+sprite exec "npm install -g typescript"
+sprite exec "cargo install ripgrep"
```
-
-
-```elixir
-# List all sprites
-{:ok, sprites} = Sprites.list(client)
+They persist across hibernation. No rebuilds needed.
-# List with prefix filter
-{:ok, dev_sprites} = Sprites.list(client, prefix: "dev-")
+
+**Storage space**: Each Sprite has 100 GB of persistent storage. Check usage with:
-# Iterate through sprites
-for sprite <- sprites do
- IO.puts(sprite.name)
-end
+```bash
+sprite exec "df -h"
```
-
-
+
---
-## HTTP Access
+## Managing Sprites
-Every Sprite has a unique URL for HTTP access:
+### Set Active Sprite
-
-
```bash
-# Get sprite URL
-sprite url
-
-# Make URL public (no auth required)
-sprite url update --auth public
-
-# Make URL require sprite auth (default)
-sprite url update --auth default
-```
-
-
-
-```javascript
-// Get sprite info including URL
-const info = await client.getSprite('my-sprite');
-console.log(info.url);
-```
-
-
-
-```go
-// Get sprite info including URL
-info, _ := client.GetSprite(ctx, "my-sprite")
-fmt.Println(info.URL)
-```
-
-
-
-```elixir
-# Get sprite info including URL
-{:ok, info} = Sprites.get_sprite(client, "my-sprite")
-IO.puts(info.url)
-
-# Update URL settings
-Sprites.update_url_settings(sprite, public: true)
+sprite use my-sprite
+# Now all commands target this sprite
+sprite exec "echo hello"
```
-
-
-
-Updating URL settings is available via the CLI, Go SDK, Elixir SDK, or REST API (the JS SDK does not expose a helper yet).
-
----
-## Port Forwarding
+### List and Filter
-Forward local ports to your Sprite:
-
-
-
```bash
-# Forward local port 3000 to sprite port 3000
-sprite proxy 3000
-
-# Forward multiple ports
-sprite proxy 3000 8080 5432
-```
-
-
-
-```go
-// Forward single port
-session, _ := client.ProxyPort(ctx, "my-sprite", 3000, 3000)
-defer session.Close()
-// localhost:3000 now forwards to sprite:3000
-
-// Forward multiple ports
-sessions, _ := client.ProxyPorts(ctx, "my-sprite", []sprites.PortMapping{
- {LocalPort: 3000, RemotePort: 3000},
- {LocalPort: 8080, RemotePort: 80},
-})
-```
-
-
-
-```elixir
-# Forward single port
-{:ok, session} = Sprites.proxy_port(sprite, 3000, 3000)
-# localhost:3000 now forwards to sprite:3000
-
-# Forward multiple ports
-mappings = [
- %Sprites.Proxy.PortMapping{local_port: 3000, remote_port: 3000},
- %Sprites.Proxy.PortMapping{local_port: 8080, remote_port: 80}
-]
-{:ok, sessions} = Sprites.proxy_ports(sprite, mappings)
-
-# Stop proxy when done
-Sprites.Proxy.Session.stop(session)
+sprite list
+sprite list --prefix "dev-"
```
-
-
-
-### Port Notifications
-
-Get notified when ports open in your Sprite:
-
-
-```javascript
-const cmd = sprite.spawn('npm', ['run', 'dev']);
+### Destroy
-cmd.on('message', (msg) => {
- if (msg.type === 'port_opened') {
- console.log(`Port ${msg.port} opened on ${msg.address} by PID ${msg.pid}`);
- // Auto-forward or notify user
- }
-});
-```
-
-
-
-```go
-cmd := sprite.Command("npm", "run", "dev")
-cmd.TextMessageHandler = func(data []byte) {
- var notification sprites.PortNotificationMessage
- json.Unmarshal(data, ¬ification)
-
- if notification.Type == "port_opened" {
- fmt.Printf("Port %d opened on %s by PID %d\n", notification.Port, notification.Address, notification.PID)
- }
-}
-cmd.Run()
+```bash
+sprite destroy my-sprite
```
-
-
-
-```elixir
-{:ok, cmd} = Sprites.spawn(sprite, "npm", ["run", "dev"])
-# Handle port notifications in receive loop
-receive do
- {:port_opened, ^cmd, %{port: port, address: addr, pid: pid}} ->
- IO.puts("Port #{port} opened on #{addr} by PID #{pid}")
-
- {:stdout, ^cmd, data} ->
- IO.write(data)
-end
-```
-
-
+
+**Destruction is irreversible!** All data is permanently deleted: files, packages, checkpoints. No undo.
+
---
## Checkpoints
-Save and restore Sprite state:
+Snapshot your Sprite's filesystem so you can roll back later.
-
-
```bash
-# Create a checkpoint
sprite checkpoint create
-
-# List checkpoints
+sprite checkpoint create --comment "before upgrade"
sprite checkpoint list
-
-# Restore from checkpoint
-sprite restore
+sprite restore
```
-
-
-```elixir
-# Create a checkpoint
-{:ok, checkpoint} = Sprites.create_checkpoint(sprite, comment: "before deploy")
+Use before risky changes, upgrades, or experiments.
-# List checkpoints
-{:ok, checkpoints} = Sprites.list_checkpoints(sprite)
+**What gets saved:**
-# Restore from checkpoint
-{:ok, _} = Sprites.restore_checkpoint(sprite, checkpoint.id)
-```
-
-
+Entire filesystem (all files, installed packages, databases)
+File permissions and ownership
+Running processes (they stop during checkpoint creation)
+In-memory state
-See [Checkpoints and Restore](/concepts/checkpoints) for more details.
+**Good to know:**
+- Checkpoints count against your storage quota
+- Restoring replaces the entire filesystem—changes since the checkpoint are lost
+- Creation takes 10–30 seconds depending on data size
---
-## Error Handling
-
-
-
-```javascript
-import { ExecError } from '@fly/sprites';
-
-try {
- await sprite.execFile('bash', ['-lc', 'exit 1']);
-} catch (error) {
- if (error instanceof ExecError) {
- console.log('Exit code:', error.exitCode);
- console.log('Stdout:', error.stdout);
- console.log('Stderr:', error.stderr);
- }
-}
-```
-
-
-
-```go
-cmd := sprite.Command("bash", "-lc", "exit 1")
-err := cmd.Run()
+## Optional: Going Deeper
-if err != nil {
- if exitErr, ok := err.(*sprites.ExitError); ok {
- fmt.Printf("Exit code: %d\n", exitErr.ExitCode())
- }
-}
-```
-
-
-
-```elixir
-case Sprites.cmd(sprite, "bash", ["-lc", "exit 1"]) do
- {_output, 0} ->
- IO.puts("Success")
-
- {output, exit_code} ->
- IO.puts("Exit code: #{exit_code}")
- IO.puts("Output: #{output}")
-end
-```
-
-
+These features are useful once you're comfortable.
----
+### Mounting Filesystem Locally
-## Cleanup
+Use SSHFS to mount your Sprite and edit files with your local tools.
-Always clean up Sprites when you're done:
+**Install SSHFS first:**
-
-
```bash
-sprite destroy my-sprite
-```
-
+# macOS
+brew install macfuse sshfs
-
-```javascript
-await sprite.delete();
-// or
-await client.deleteSprite('my-sprite');
-```
-
-
-
-```go
-err := client.DeleteSprite(ctx, "my-sprite")
-```
-
+# Ubuntu/Debian
+sudo apt-get install sshfs
-
-```elixir
-:ok = Sprites.destroy(sprite)
-# or
-:ok = Sprites.destroy(client, "my-sprite")
+# Fedora/RHEL
+sudo dnf install fuse-sshfs
```
-
-
-
----
-
-## Optional: Mount Sprite Filesystem Locally
-Add this helper function to your `.zshrc` or `.bashrc` to mount your Sprite's home directory locally:
+**Add this helper to your shell config:**
```bash
-# Add to ~/.zshrc
+# Add to ~/.zshrc or ~/.bashrc
sc() {
local sprite_name="${1:-$(sprite use)}"
local mount_point="/tmp/sprite-${sprite_name}"
@@ -763,57 +255,42 @@ sc() {
}
```
-Then use it with:
+**Unmount when done:**
+
+```bash
+umount /tmp/sprite-my-sprite
+# macOS may need: diskutil umount /tmp/sprite-my-sprite
+```
+
+### Common Error Scenarios
+
+**Connection errors:**
+- Check auth: `sprite org auth`
+- Verify Sprite exists: `sprite list`
+- Wait a moment and retry
+
+**Timeout errors:**
+- Be patient on first wake-up (1–2 seconds)
+- Check if command actually needs that long
+
+**Sprite won't wake up:**
+- Verify it exists with `sprite list`
+- Wait 30 seconds and retry
+- [Contact support](https://fly.io/dashboard/support) if persistent
+
+**Storage full:**
+- Clean up files: `sprite exec "du -sh /home/sprite/*"`
+- Delete old checkpoints
+- Create a new Sprite for additional workloads
+
+**Quick debugging:**
```bash
-sc my-sprite # Mounts and cd's to the sprite's filesystem
+sprite exec "ps aux" # running processes
+sprite exec "df -h" # disk space
+sprite exec "free -h" # memory usage
```
---
-## Next Steps
-
-
-
-
-
-
-
-
-
+Sprites are meant to feel like your own Linux box in the sky—fast to wake, persistent when you need it, and flexible enough to run whatever weird stack you're building. As you get more comfortable, the advanced features are there when you need them.
diff --git a/styles/config/vocabularies/fly-terms/accept.txt b/styles/config/vocabularies/fly-terms/accept.txt
index 1073acc..8079c0c 100644
--- a/styles/config/vocabularies/fly-terms/accept.txt
+++ b/styles/config/vocabularies/fly-terms/accept.txt
@@ -76,6 +76,7 @@ DDoS
Deno
dev
devSprites
+df
dnsutils
dotfiles
deployable
@@ -359,6 +360,7 @@ UIs
unicast
unix
Unix
+Unmount
Unprocessable
unreproducible
Untrusted