Please address the comments from this code review:

## Overall Comments
- The `mdiSubset` plugin currently runs on every `buildStart`, including `vite dev`; consider gating it behind `command === 'build'` in `defineConfig` or an env check so you don't pay the subsetting cost (and noisy logs) during development server startup.
- In `subset-mdi-font.mjs`, you use `import.meta.dirname` which is not part of the standard Node ESM API; to avoid runtime issues across Node versions, you may want to derive `ROOT` via `fileURLToPath(new URL('..', import.meta.url))` instead.

## Individual Comments

### Comment 1
<location path="dashboard/scripts/subset-mdi-font.mjs" line_range="18" />
<code_context>
+import { readFileSync, writeFileSync, copyFileSync, readdirSync, statSync, existsSync, mkdirSync } from "fs";
+import { join, resolve, extname } from "path";
+
+const ROOT = resolve(import.meta.dirname, "..");
+const SRC = join(ROOT, "src");
+const MDI_CSS_PATH = join(ROOT, "node_modules/@mdi/font/css/materialdesignicons.css");
</code_context>
<issue_to_address>
**issue (bug_risk):** Using `import.meta.dirname` may not be portable across Node versions; prefer deriving `__dirname` from `import.meta.url`.

`import.meta.dirname` isn’t part of Node’s stable ESM API and may be undefined in some Node versions or other runtimes, causing runtime failures. To make this portable, derive the directory from `import.meta.url` instead:

```js
import { fileURLToPath } from 'url';
const __dirname = fileURLToPath(new URL('.', import.meta.url));
const ROOT = resolve(__dirname, '..');
```

This keeps the script working across Node versions and toolchains.
</issue_to_address>

### Comment 2
<location path="dashboard/scripts/subset-mdi-font.mjs" line_range="55" />
<code_context>
+    console.warn(`⚠️  Fallback complete: using full font (${(size / 1024).toFixed(1)} KB woff2)`);
+}
+
+try {
+    // ── Pre-checks ────────────────────────────────────────────────────────────
+    if (!existsSync(MDI_CSS_PATH)) {
</code_context>
<issue_to_address>
**issue (complexity):** Consider extracting the main flow and key parsing/transform steps into small, named helper functions (and a thin main/try block) to make this script easier to follow and maintain without changing behavior.

One way to reduce the perceived complexity without changing behavior is to tease apart a few responsibilities into small, named helpers. You don’t need a full rewrite; even a couple of extra functions and a thinner `try` block will make this easier to follow and maintain.

### 1. Extract `main()` and keep the top-level `try/catch` thin

Right now the `try` block mixes everything. You can keep the “fallback on any error” behavior but move the main flow into a function:

```js
async function main() {
  // Pre-checks
  // dynamic import subset-font
  // scan icons
  // parse mdi CSS
  // resolve codepoints
  // subset fonts
  // generate CSS
  // report
}

try {
  await main();
} catch (err) {
  try {
    fallbackToFullFont(err.message);
  } catch (fallbackErr) {
    console.error(`❌ Fallback also failed: ${fallbackErr.message}`);
    console.error(`❌ Please ensure @mdi/font is installed: pnpm install`);
    process.exit(1);
  }
}
```

This keeps the global scope and error handling simple while keeping identical behavior.

### 2. Move `collectFiles` out of `main` and make it reusable

The recursive directory walk is fine but inlined in the main flow. Pulling it out clarifies intent and allows reuse/tests.

```js
function collectFiles(dir, exts) {
  let files = [];
  for (const entry of readdirSync(dir, { withFileTypes: true })) {
    const full = join(dir, entry.name);
    if (entry.isDirectory() && entry.name !== "node_modules") {
      files = files.concat(collectFiles(full, exts));
    } else if (exts.includes(extname(entry.name))) {
      files.push(full);
    }
  }
  return files;
}

// in main():
const sourceFiles = collectFiles(SRC, [".vue", ".ts", ".js"]);
```

Same behavior, simpler top-level.

### 3. Isolate CSS parsing logic

The regex + marker logic is currently mixed into the main script. Pulling these into named functions makes the logic easier to reason about and change if @mdi/font updates.

```js
function parseIconCodepoints(mdiCSS) {
  const classPattern = /\.(mdi-[a-z][a-z0-9-]*)::before\s*\{\s*content:\s*"\\([0-9A-Fa-f]+)"/g;
  const iconMap = new Map();
  for (const match of mdiCSS.matchAll(classPattern)) {
    iconMap.set(match[1], match[2]);
  }
  return iconMap;
}

function extractUtilityCss(mdiCSS) {
  const utilityStartMarker = ".mdi-18px.mdi-set"; // first utility rule in @mdi/font
  const idx = mdiCSS.indexOf(utilityStartMarker);
  if (idx === -1) return "";
  return mdiCSS
    .slice(idx)
    .replace(/\/\*# sourceMappingURL=.*\*\//, "")
    .trim();
}
```

Then in `main()`:

```js
const mdiCSS = readFileSync(MDI_CSS_PATH, "utf-8");
const iconMap = parseIconCodepoints(mdiCSS);

let css = /* font-face + base .mdi rules */;
for (const icon of resolvedIcons.sort()) {
  const cp = iconMap.get(icon);
  css += `.${icon}::before {\n  content: "\\${cp}";\n}\n\n`;
}

const utilityCss = extractUtilityCss(mdiCSS);
if (utilityCss) {
  css += `/* Utility classes (extracted from @mdi/font) */\n${utilityCss}\n`;
} else {
  console.warn("⚠️  Could not find MDI utility classes in original CSS, skipping");
}
```

Same output, but all CSS parsing is clearly grouped and documented.

### 4. Make the “used → resolved/missing/subset” step a data transform

Instead of mutating three collections inline, return the grouped result from a helper:

```js
function resolveUsedIcons(usedIcons, iconMap) {
  const resolvedIcons = [];
  const missingIcons = [];
  const subsetChars = [];

  for (const icon of usedIcons) {
    const cp = iconMap.get(icon);
    if (cp) {
      resolvedIcons.push(icon);
      subsetChars.push(String.fromCodePoint(parseInt(cp, 16)));
    } else {
      missingIcons.push(icon);
    }
  }

  return { resolvedIcons, missingIcons, subsetChars };
}

// in main():
const { resolvedIcons, missingIcons, subsetChars } = resolveUsedIcons(usedIcons, iconMap);
```

This keeps the data flow explicit without changing any semantics.

### 5. Optional: clarify `fallbackToFullFont` transformations

You can keep the same regexes but make the intent clearer:

```js
function rewriteFontUrlsToSubset(mdiCSS) {
  return mdiCSS
    .replace(/url\("\.\.\/fonts\/materialdesignicons-webfont\.(woff2?)\?[^"]*"\)/g,
      (_, ext) => `url("./materialdesignicons-webfont-subset.${ext}")`);
}

function removeLegacySources(mdiCSS) {
  return mdiCSS
    .replace(/url\("\.\.\/fonts\/materialdesignicons-webfont\.(eot|ttf)\?[^"]*"\)[^,]*/g, "");
}

function normalizeSrcSeparators(mdiCSS) {
  return mdiCSS
    .replace(/src:\s*,/g, "src:")
    .replace(/,\s*;/g, ";");
}

function buildFallbackCss() {
  const mdiCSS = readFileSync(MDI_CSS_PATH, "utf-8");
  let css = rewriteFontUrlsToSubset(mdiCSS);
  css = removeLegacySources(css);
  css = normalizeSrcSeparators(css);
  return css;
}

// in fallbackToFullFont():
const fallbackCSS = buildFallbackCss();
writeFileSync(join(OUT_DIR, "materialdesignicons-subset.css"), fallbackCSS);
```

Behavior is identical; the nested `.replace()` chain becomes a sequence of named steps, which makes it easier to audit and adjust later.
</issue_to_address>