# What Builders Should Notice

> The surprising density of the shadcn-style UI kit versus sparse editor logic, generated route trees, Bun CI, and the real constraints: architecture still in design, classic vs rewrite split, and what is worth watching as the Rust core and plugin surface appear.

- Repository: OpenCut-app/OpenCut
- GitHub: https://github.com/OpenCut-app/OpenCut
- Human wiki: https://grok-wiki.com/public/wiki/opencut-app-opencut-2bfee888b2cd
- Complete Markdown: https://grok-wiki.com/public/wiki/opencut-app-opencut-2bfee888b2cd/llms-full.txt

## Source Files

- `apps/web/src/lib/utils.ts`
- `apps/web/components.json`
- `apps/web/src/routeTree.gen.ts`
- `.github/workflows/bun-ci.yml`
- `apps/web/moon.yml`
- `.moon/toolchains.yml`

---

<details>
<summary>Relevant source files</summary>

The following files were used as context for generating this wiki page:

- [.github/workflows/bun-ci.yml](.github/workflows/bun-ci.yml)
- [.moon/toolchains.yml](.moon/toolchains.yml)
- [apps/web/components.json](apps/web/components.json)
- [apps/web/moon.yml](apps/web/moon.yml)
- [apps/web/src/lib/utils.ts](apps/web/src/lib/utils.ts)
- [apps/web/src/routeTree.gen.ts](apps/web/src/routeTree.gen.ts)

</details>

# What Builders Should Notice

OpenCut’s web surface looks product-ready at the edges and thin in the middle. The repo already wires a full shadcn-style UI kit, TanStack-generated routing, Bun under moon, multi-OS CI, and a declared Rust toolchain—yet the generated route tree still only exposes `/`. That contrast is the useful signal: tooling and design system density are ahead of application surface area.

This page is for builders skimming the repo for leverage points. It separates what is already concrete (UI kit config, route generation, CI, toolchains) from what is only scaffolded or absent in the evidence (editor depth, multi-page product routes, a visible Rust core). The goal is accurate expectations, not a roadmap claim.

## The density mismatch: UI kit vs app surface

### A complete shadcn-style kit configuration

`apps/web/components.json` is not a stub. It pins style (`base-mira`), TSX, Tailwind CSS variables on neutral, Hugeicons, path aliases for components/utils/ui/lib/hooks, and menu accent settings. That is the full shadcn registry shape: enough structure to grow a large component library without re-deciding layout conventions.

```json
{
  "style": "base-mira",
  "rsc": false,
  "tsx": true,
  "tailwind": {
    "css": "src/styles.css",
    "baseColor": "neutral",
    "cssVariables": true
  },
  "iconLibrary": "hugeicons",
  "aliases": {
    "components": "#/components",
    "utils": "#/lib/utils",
    "ui": "#/components/ui",
    "lib": "#/lib",
    "hooks": "#/hooks"
  }
}
```

Sources: [apps/web/components.json:1-25]()

The classic `cn` helper is present—`clsx` + `tailwind-merge`—the standard glue for conditional Tailwind class composition in this stack.

Sources: [apps/web/src/lib/utils.ts:1-6]()

### Sparse product routing

By contrast, TanStack Router’s generated tree is minimal. `routeTree.gen.ts` is machine-owned (“you should NOT make any changes”) and currently wires only the index route under root:

| Route id | Path | Role in generated tree |
| --- | --- | --- |
| `__root__` | (parent) | Root route import |
| `/` | `/` | Sole file child |

`FileRoutesByFullPath`, `fullPaths`, and `to` all resolve to `'/'` only. The module also registers SSR and the app router with `@tanstack/react-start` (`ssr: true`). That is real stack commitment; it is not a multi-screen editor shell in the generated graph.

Sources: [apps/web/src/routeTree.gen.ts:7-18](), [apps/web/src/routeTree.gen.ts:20-37](), [apps/web/src/routeTree.gen.ts:57-68]()

```text
UI kit config (components.json + cn)
        dense: style, aliases, icons, CSS vars
                    │
                    ▼
        apps/web application layer
                    │
        routeTree.gen.ts ── only '/' + __root__
                    │
        (editor / multi-route product logic:
         not shown in this evidence set)
```

**Builder takeaway:** do not equate “shadcn + TanStack Start wired” with “editor architecture is settled.” The kit can absorb many components while the route graph stays a single page.

## Tooling that is already production-shaped

### Bun + moon as the web project contract

`apps/web` is a TypeScript **application** layer project under moon. Tasks map straight to Bun scripts:

| Task | Command | CI / cache notes |
| --- | --- | --- |
| `dev` | `bun run dev` | `runInCI: false` — skipped in CI, not cached as a server |
| `build` | `bun run build` | Inputs: `src/**/*`, `public/**/*`, Vite/TS configs; output `dist` |
| `test` | `bun run test` | Inputs: `src/**/*`, `tsconfig.json` |
| `deploy` | `bun run deploy` | Depends on `~:build` |

Sources: [apps/web/moon.yml:1-32]()

### Repo-level toolchains

Moon enables JavaScript alongside Bun (version **1.3.11**, auto-install deps on lockfile/manifest change) and declares an empty Rust toolchain block whose version is inherited from `.prototools` (referenced in comment only; that file is not in this evidence).

Sources: [.moon/toolchains.yml:1-12]()

### Bun CI matrix

GitHub Actions workflow **Bun CI** runs on `main` pushes and PRs, ignores `*.md` path changes, uses a concurrency group per ref with cancel-in-progress, checks out with full history (`fetch-depth: 0`), sets up moonrepo’s toolchain installer, and runs `moon ci` on **ubuntu-latest**, **windows-latest**, and **macos-latest**.

Sources: [.github/workflows/bun-ci.yml:1-37]()

```text
push/PR → main (ignore *.md)
              │
              ▼
     matrix: Linux / Windows / macOS
              │
     moonrepo/setup-toolchain
              │
           moon ci
              │
     (web tasks per moon.yml; rust toolchain declared)
```

**Builder takeaway:** CI and package-manager story are not experimental side scripts. Cross-OS `moon ci` is the gate; Markdown-only changes skip it.

## What the evidence does *not* settle

Stay honest about absences. In this evidence set you **cannot** verify:

- A multi-route product or editor workspace layout (generated routes stop at `/`)
- Implementation of a Rust media/editor core (only `rust: {}` in toolchains)
- A classic-vs-rewrite code split, plugin API, or architecture decision docs
- Security, performance, or shipping status of deploy beyond the task wiring

Those may exist elsewhere in the monorepo; they are simply not part of the record used for this page. Treat “architecture still in design” as a reading of **sparsity in app surface relative to tooling**, not as a quoted project status.

## What is worth watching next

| Signal | Why it matters | Where it would show up first |
| --- | --- | --- |
| Route tree growth | Product surface expanding beyond a single index | New entries in `routeTree.gen.ts` / `routes/*` |
| UI components under aliases | Kit filling out vs remaining config-only | `#/components/ui` and related paths from `components.json` |
| Rust projects in moon | Core leaving “toolchain declared” | moon projects + non-empty Rust tasks (not in this evidence) |
| CI task composition | What `moon ci` actually enforces as the app grows | Workflow stays thin; project `moon.yml` tasks are the real surface |
| Deploy dependency chain | Ship path remains build-then-deploy | `deploy` → `~:build` in `apps/web/moon.yml` |

For integration work (e.g. wiki or agent skill packs against this repo), keep the design **provider-neutral**: treat skill packs and docs as portable file/repo/catalog inputs; use repository code (`moon.yml`, toolchains, generated routes, UI config) as the source of truth for implementation claims.

## Summary

Builders should notice the **asymmetric maturity**: shadcn-style kit config and `cn` utility, TanStack Start SSR registration, Bun 1.3.11 under moon, and three-OS Bun CI are already in place, while the generated route tree remains a single `/` and Rust appears only as a toolchain declaration. Read density in tooling and UI conventions as readiness to grow a frontend; do not read it as proof of a finished editor core or multi-surface product graph until those show up in code the same way the kit and CI already do.