diff --git a/.agents/skills/chrome-trace/SKILL.md b/.agents/skills/chrome-trace/SKILL.md
index 3476843f..62f03183 100644
--- a/.agents/skills/chrome-trace/SKILL.md
+++ b/.agents/skills/chrome-trace/SKILL.md
@@ -20,7 +20,7 @@ Use Playwright with Chromium and the Chrome DevTools Protocol `Tracing` domain t
 
 Do not draw conclusions from FPS alone. Use FPS/frame-time summaries only as the symptom; use trace groups and top events as the explanation.
 
-## Polycss Trace Runners
+## PolyCSS Trace Runners
 
 Use `scripts/trace.mjs` as the front door:
 
@@ -46,7 +46,7 @@ Use `trace.mjs drag` for real `PolyOrbitControls` pointer-drag traces on `nonvox
 
 Use `trace.mjs generic` for arbitrary pages and interactions that are not covered by a polycss bench page.
 
-When interpreting polycss traces, map the result back to the render model:
+When interpreting PolyCSS traces, map the result back to the render model:
 
 - `FunctionCall`, `EventDispatch`, `FireAnimationFrame`: JS/input work. Unexpected sustained per-frame work is suspicious outside imported skeletal animation.
 - `UpdateLayoutTree`, `RecalculateStyles`: style recalculation, often CSS variable or selector invalidation cost.
diff --git a/.agents/skills/compat-hunter/SKILL.md b/.agents/skills/compat-hunter/SKILL.md
new file mode 100644
index 00000000..f46cc9e3
--- /dev/null
+++ b/.agents/skills/compat-hunter/SKILL.md
@@ -0,0 +1,97 @@
+---
+name: compat-hunter
+description: Use when hunting for OBJ/GLB/glTF/VOX parser compatibility issues by streaming candidate models, parsing each immediately, deleting clean files, and retaining only actionable failures, unknown warnings, or unexplained zero-polygon outputs. Especially useful in the polycss repo with scripts/compat-hunter.mjs.
+---
+
+# Compat Hunter
+
+Use this skill when the user wants to keep digging for parser compatibility issues without building a fixed local corpus.
+
+## Workflow
+
+1. In the repo, prefer the reusable script:
+
+   ```bash
+   pnpm compat-hunter -- --max-models 2000
+   ```
+
+   Equivalent explicit form:
+
+   ```bash
+   pnpm --filter @layoutit/polycss-core build
+   node .agents/skills/compat-hunter/scripts/compat-hunter.mjs --max-models 2000
+   ```
+
+2. Let the script stream remote OBJ/GLB/glTF/VOX candidates, parse each model, and discard clean files. Reports are written under `bench/results/`, which is ignored by git.
+
+3. Treat these as known non-actionable unless the user asks to support them:
+   - glTF POINTS/LINES/LINE_LOOP/LINE_STRIP primitives.
+   - Required Draco or meshopt compressed primitives skipped with a warning.
+
+4. Stop and inspect anything classified as:
+   - `throw`
+   - `unknown-warning`
+   - `obj-zero-no-warning`
+   - `glb-zero-no-warning`
+
+5. If an actionable parser issue is found, keep the saved file under the report's `interesting/` directory, add a focused parser test using that behavior, implement the smallest fix, and rerun the focused parser tests plus the hunter on the saved file or source class.
+
+## Useful Commands
+
+Fresh Objaverse and expanded GitHub stream:
+
+```bash
+pnpm compat-hunter -- --max-models 5000 --max-bytes 10mb --timeout-ms 30000
+```
+
+Objaverse only, later shards:
+
+```bash
+pnpm compat-hunter -- --sources objaverse --objaverse-shards 120:220 --max-models 5000
+```
+
+GitHub only:
+
+```bash
+pnpm compat-hunter -- --sources github --max-models 500
+```
+
+Poly Haven only:
+
+```bash
+pnpm compat-hunter -- --sources polyhaven --polyhaven-limit 250 --max-models 200
+```
+
+VOX-heavy GitHub sources:
+
+```bash
+pnpm compat-hunter -- --sources github --github-repos ephtracy/voxel-model@master:vox/,mikelovesrobots/mmmm@master:vox/ --max-models 1000
+```
+
+Local directory:
+
+```bash
+pnpm compat-hunter -- --sources local --local-root /tmp/models --max-models 1000
+```
+
+Keep known-warning files too:
+
+```bash
+pnpm compat-hunter -- --keep-known --max-models 500
+```
+
+Continue after interesting cases:
+
+```bash
+pnpm compat-hunter -- --no-stop-on-interesting --max-models 2000
+```
+
+## Reporting
+
+Summarize the final `report.json` with:
+
+```bash
+pnpm compat-hunter -- --report bench/results/<run>/report.json
+```
+
+In the final response, state the attempted/parsed counts, whether any interesting files were retained, and whether the findings are actionable. Do not imply a clean stream proves full compatibility; it only means this pass found no new actionable parser issue.
diff --git a/.agents/skills/compat-hunter/agents/openai.yaml b/.agents/skills/compat-hunter/agents/openai.yaml
new file mode 100644
index 00000000..6e53a709
--- /dev/null
+++ b/.agents/skills/compat-hunter/agents/openai.yaml
@@ -0,0 +1,4 @@
+interface:
+  display_name: "Compat Hunter"
+  short_description: "Stream model parser compatibility hunts"
+  default_prompt: "Use $compat-hunter to stream OBJ/GLB/glTF/VOX models until a parser compatibility issue appears."
diff --git a/.agents/skills/compat-hunter/scripts/compat-hunter.mjs b/.agents/skills/compat-hunter/scripts/compat-hunter.mjs
new file mode 100755
index 00000000..a7ccc480
--- /dev/null
+++ b/.agents/skills/compat-hunter/scripts/compat-hunter.mjs
@@ -0,0 +1,734 @@
+#!/usr/bin/env node
+/**
+ * Stream OBJ/GLB/glTF/VOX files through the core parser and keep only compatibility
+ * cases worth inspecting. Clean models are never written to disk.
+ *
+ * Usage:
+ *   pnpm --filter @layoutit/polycss-core build
+ *   node .agents/skills/compat-hunter/scripts/compat-hunter.mjs
+ *   node .agents/skills/compat-hunter/scripts/compat-hunter.mjs --sources objaverse --max-models 5000
+ *   node .agents/skills/compat-hunter/scripts/compat-hunter.mjs --sources github --max-models 500
+ *   node .agents/skills/compat-hunter/scripts/compat-hunter.mjs --sources polyhaven --max-models 200
+ *   node .agents/skills/compat-hunter/scripts/compat-hunter.mjs --sources github --github-repos ephtracy/voxel-model@master:vox/
+ *   node .agents/skills/compat-hunter/scripts/compat-hunter.mjs --local-root /tmp/models --out bench/results/local-hunt
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, extname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { performance } from "node:perf_hooks";
+import { parseGltf, parseObj, parseVox } from "../../../../packages/core/dist/index.js";
+
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../../../..");
+const argv = process.argv.slice(2).filter((arg) => arg !== "--");
+const VALID_SOURCES = new Set(["objaverse", "github", "polyhaven", "local"]);
+const textEncoder = new TextEncoder();
+
+function fail(message) {
+  console.error(`compat-hunter: ${message}`);
+  process.exit(1);
+}
+
+function flag(name) {
+  return argv.indexOf(`--${name}`);
+}
+
+function hasFlag(name) {
+  return flag(name) >= 0;
+}
+
+function optStr(name, dflt = "") {
+  const index = flag(name);
+  if (index < 0) return dflt;
+  const value = argv[index + 1];
+  if (!value || value.startsWith("--")) fail(`--${name} requires a value`);
+  return value;
+}
+
+function optNum(name, dflt) {
+  const raw = optStr(name, "");
+  if (!raw) return dflt;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : dflt;
+}
+
+function parseByteLimit(raw) {
+  const text = String(raw).trim().toLowerCase();
+  const match = /^(\d+(?:\.\d+)?)(b|kb|mb|gb)?$/.exec(text);
+  if (!match) return Number(raw) || 0;
+  const value = Number(match[1]);
+  const unit = match[2] ?? "b";
+  const multiplier = unit === "gb" ? 1024 ** 3 : unit === "mb" ? 1024 ** 2 : unit === "kb" ? 1024 : 1;
+  return Math.floor(value * multiplier);
+}
+
+function usage() {
+  console.log(`Usage: node .agents/skills/compat-hunter/scripts/compat-hunter.mjs [options]
+
+Options:
+  --sources <list>          Comma-separated sources: objaverse,github,polyhaven,local. Default: objaverse,github
+  --max-models <n>          Stop after this many attempted models. Default: 2000
+  --max-bytes <n|10mb>      Skip remote files above this size. Default: 10mb
+  --concurrency <n>         Parallel remote downloads/parses. Default: 8
+  --timeout-ms <n>          Fetch timeout for API/file downloads. Default: 30000
+  --out <dir>               Report directory. Default: bench/results/compat-hunter-<timestamp>
+  --progress <n>            Print progress every n attempts. Default: 100
+  --report <file>           Print a compact summary for an existing report and exit.
+  --stop-on-interesting     Stop after first actionable case. Default: true
+  --no-stop-on-interesting  Continue after actionable cases until --max-models
+  --keep-known              Save files that only hit known non-actionable warnings.
+  --local-root <dir>        Local OBJ/GLB/glTF/VOX tree when --sources includes local.
+  --objaverse-shards <a:b>  Objaverse shard range, inclusive. Default: 20:120
+  --github-repos <list>     repo specs owner/repo@branch[:prefix], comma-separated.
+  --polyhaven-limit <n>     Max Poly Haven asset metadata records to inspect. Default: 250
+  --skip-manifest <file>    Manifest with selected[].path to skip. Default: previous 5k manifest if present
+`);
+}
+
+if (hasFlag("help")) {
+  usage();
+  process.exit(0);
+}
+
+if (hasFlag("report")) {
+  summarizeReport(resolve(repoRoot, optStr("report")));
+  process.exit(0);
+}
+
+const sources = optStr("sources", "objaverse,github")
+  .split(",")
+  .map((source) => source.trim())
+  .filter(Boolean);
+for (const source of sources) {
+  if (!VALID_SOURCES.has(source)) {
+    fail(`unknown source "${source}" (expected one of ${[...VALID_SOURCES].join(", ")})`);
+  }
+}
+const maxModels = Math.max(1, optNum("max-models", 2000));
+const maxBytes = parseByteLimit(optStr("max-bytes", "10mb"));
+const concurrency = Math.max(1, optNum("concurrency", 8));
+const timeoutMs = Math.max(0, optNum("timeout-ms", 30000));
+const progressEvery = Math.max(0, optNum("progress", 100));
+const stopOnInteresting = !hasFlag("no-stop-on-interesting");
+const keepKnown = hasFlag("keep-known");
+const startedAt = new Date().toISOString();
+const outRoot = resolve(repoRoot, optStr(
+  "out",
+  `bench/results/compat-hunter-${startedAt.replace(/[:.]/g, "-")}`,
+));
+const interestingRoot = join(outRoot, "interesting");
+const knownRoot = join(outRoot, "known");
+const reportPath = join(outRoot, "report.json");
+mkdirSync(interestingRoot, { recursive: true });
+if (keepKnown) mkdirSync(knownRoot, { recursive: true });
+
+const defaultSkipManifest = resolve(repoRoot, "bench/results/parser-corpus-5000-objaverse/manifest.json");
+const skipManifestPath = optStr("skip-manifest", existsSync(defaultSkipManifest) ? defaultSkipManifest : "");
+const skippedSourcePaths = new Set();
+if (skipManifestPath && existsSync(resolve(repoRoot, skipManifestPath))) {
+  const manifest = JSON.parse(readFileSync(resolve(repoRoot, skipManifestPath), "utf8"));
+  for (const item of manifest.selected ?? []) {
+    if (item.path) skippedSourcePaths.add(item.path);
+  }
+}
+
+const knownWarningCounts = new Map();
+const knownErrorCounts = new Map();
+const failureCounts = new Map();
+const sourceCounts = new Map();
+const cleanSamples = [];
+const knownSamples = [];
+const interesting = [];
+const failedDownloads = [];
+let cleanCount = 0;
+let knownCount = 0;
+let attempted = 0;
+let parsed = 0;
+let totalPolygons = 0;
+let stop = false;
+let nextQueueIndex = 0;
+
+function stableShuffle(items, seed) {
+  let state = seed >>> 0;
+  const next = () => {
+    state = (Math.imul(1664525, state) + 1013904223) >>> 0;
+    return state / 0x100000000;
+  };
+  const out = [...items];
+  for (let i = out.length - 1; i > 0; i--) {
+    const j = Math.floor(next() * (i + 1));
+    [out[i], out[j]] = [out[j], out[i]];
+  }
+  return out;
+}
+
+function bump(map, key) {
+  map.set(key, (map.get(key) ?? 0) + 1);
+}
+
+function counterObject(map) {
+  return Object.fromEntries([...map.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])));
+}
+
+function sourceStats(source) {
+  if (!sourceCounts.has(source)) {
+    sourceCounts.set(source, {
+      queued: 0,
+      attempted: 0,
+      parsed: 0,
+      clean: 0,
+      known: 0,
+      interesting: 0,
+      failedDownloads: 0,
+      totalPolygons: 0,
+    });
+  }
+  return sourceCounts.get(source);
+}
+
+function bumpSource(source, field, amount = 1) {
+  const stats = sourceStats(source);
+  stats[field] = (stats[field] ?? 0) + amount;
+}
+
+function sourceCountsObject() {
+  return Object.fromEntries([...sourceCounts.entries()].sort((a, b) => a[0].localeCompare(b[0])));
+}
+
+function summarizeReport(file) {
+  const report = JSON.parse(readFileSync(file, "utf8"));
+  console.log(JSON.stringify({
+    counts: report.counts,
+    sourceCounts: report.sourceCounts,
+    knownWarningsByMessage: report.knownWarningsByMessage,
+    knownErrorsByMessage: report.knownErrorsByMessage,
+    failuresByMessage: report.failuresByMessage,
+    interesting: report.interesting,
+  }, null, 2));
+}
+
+function isKnownWarning(warning) {
+  return /^Skipped primitives with unsupported mode \d+ \((POINTS|LINES|LINE_LOOP|LINE_STRIP)\)$/.test(warning)
+    || warning === "Skipped primitives with unsupported required extension KHR_draco_mesh_compression"
+    || warning === "Skipped primitives with unsupported required extension EXT_meshopt_compression";
+}
+
+function isKnownError(message) {
+  return /^parseGltf: only glTF v2 supported/.test(message)
+    || /^parseGltf: only glTF asset v2 supported/.test(message)
+    || /^parseGltf: glTF asset requires minVersion/.test(message);
+}
+
+function toArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+
+function classify(parsed, ext) {
+  const warnings = parsed.warnings ?? [];
+  const unknownWarnings = warnings.filter((warning) => !isKnownWarning(warning));
+  if (unknownWarnings.length > 0) return { kind: "unknown-warning", unknownWarnings };
+  if (parsed.polygons.length === 0 && warnings.length === 0) return { kind: `${ext}-zero-no-warning`, unknownWarnings };
+  if (parsed.polygons.length === 0 && warnings.some(isKnownWarning)) return { kind: "known-zero", unknownWarnings };
+  if (warnings.length > 0) return { kind: "known-warning", unknownWarnings };
+  return { kind: "clean", unknownWarnings };
+}
+
+function rowForItem(item, testedIndex, extra = {}) {
+  return {
+    testedIndex,
+    source: item.source,
+    sourcePath: item.sourcePath,
+    ext: item.ext,
+    size: item.size,
+    url: item.url,
+    ...extra,
+  };
+}
+
+function writeReport(done = false) {
+  const report = {
+    startedAt,
+    updatedAt: new Date().toISOString(),
+    done,
+    policy: {
+      sources,
+      maxModels,
+      maxBytes,
+      concurrency,
+      timeoutMs,
+      stopOnInteresting,
+      keepKnown,
+      cleanFilesDeleted: true,
+      skippedSourcePaths: skippedSourcePaths.size,
+    },
+    counts: {
+      queued: queue.length,
+      attempted,
+      parsed,
+      clean: cleanCount,
+      known: knownCount,
+      interesting: interesting.length,
+      failedDownloads: failedDownloads.length,
+      totalPolygons,
+    },
+    sourceCounts: sourceCountsObject(),
+    knownWarningsByMessage: counterObject(knownWarningCounts),
+    knownErrorsByMessage: counterObject(knownErrorCounts),
+    failuresByMessage: counterObject(failureCounts),
+    interesting,
+    knownSamples: knownSamples.slice(-100),
+    cleanSamples: cleanSamples.slice(-25),
+    failedDownloads: failedDownloads.slice(-100),
+  };
+  writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`);
+}
+
+async function fetchWithTimeout(url) {
+  const response = await fetch(url, {
+    headers: { "User-Agent": "polycss-compat-hunter" },
+    signal: timeoutMs > 0 ? AbortSignal.timeout(timeoutMs) : undefined,
+  });
+  if (!response.ok) throw new Error(`${response.status} ${response.statusText}`);
+  return response;
+}
+
+async function fetchJson(url) {
+  const response = await fetchWithTimeout(url);
+  return response.json();
+}
+
+async function fetchBytes(url) {
+  const response = await fetchWithTimeout(url);
+  return new Uint8Array(await response.arrayBuffer());
+}
+
+async function fetchText(url) {
+  const response = await fetchWithTimeout(url);
+  return response.text();
+}
+
+async function listObjaverse() {
+  const [startRaw, endRaw] = optStr("objaverse-shards", "20:120").split(":");
+  const start = Number(startRaw);
+  const end = Number(endRaw);
+  const out = [];
+  for (let shard = start; shard <= end && out.length < maxModels * 3; shard++) {
+    const shardName = `000-${String(shard).padStart(3, "0")}`;
+    const api = `https://huggingface.co/api/datasets/allenai/objaverse/tree/main/glbs/${shardName}?recursive=false&expand=false`;
+    try {
+      const entries = await fetchJson(api);
+      const files = entries
+        .filter((entry) =>
+          entry.type === "file"
+          && entry.path?.endsWith(".glb")
+          && entry.size > 0
+          && entry.size <= maxBytes
+          && !skippedSourcePaths.has(entry.path)
+        )
+        .map((entry) => ({
+          source: "allenai/objaverse@main",
+          sourcePath: entry.path,
+          ext: "glb",
+          size: entry.size,
+          url: `https://huggingface.co/datasets/allenai/objaverse/resolve/main/${entry.path}`,
+        }));
+      out.push(...stableShuffle(files, 0x509c + shard));
+      console.log(`listed objaverse ${shardName}: +${files.length}, queue=${out.length}`);
+    } catch (error) {
+      const source = "allenai/objaverse@main";
+      failedDownloads.push({
+        source,
+        sourcePath: shardName,
+        stage: "list",
+        error: error instanceof Error ? error.message : String(error),
+      });
+      bumpSource(source, "failedDownloads");
+    }
+  }
+  return out;
+}
+
+function parseRepoSpec(spec) {
+  const [repoAndBranch, prefix = ""] = spec.split(":");
+  const [repoName, branch = "main"] = repoAndBranch.split("@");
+  const [owner, repo] = repoName.split("/");
+  if (!owner || !repo || !branch) fail(`bad GitHub repo spec "${spec}" (expected owner/repo@branch[:prefix])`);
+  return { owner, repo, branch, prefix };
+}
+
+async function listGithub() {
+  const defaultRepos = [
+    "alecjacobson/common-3d-test-models@master",
+    "mrdoob/three.js@dev:examples/models/",
+    "KhronosGroup/glTF-Sample-Assets@main:Models/",
+    "KhronosGroup/glTF-Sample-Models@main:2.0/",
+    "google/draco@main:testdata/",
+    "google/model-viewer@master",
+    "assimp/assimp@master:test/models/",
+    "ephtracy/voxel-model@master:vox/",
+    "mikelovesrobots/mmmm@master:vox/",
+  ];
+  const specs = optStr("github-repos", defaultRepos.join(","))
+    .split(",")
+    .map((spec) => spec.trim())
+    .filter(Boolean)
+    .map(parseRepoSpec);
+  const out = [];
+  for (const spec of specs) {
+    const source = `${spec.owner}/${spec.repo}@${spec.branch}`;
+    const api = `https://api.github.com/repos/${spec.owner}/${spec.repo}/git/trees/${spec.branch}?recursive=1`;
+    try {
+      const json = await fetchJson(api);
+      const files = (json.tree ?? [])
+        .filter((entry) =>
+          entry.type === "blob"
+          && (!spec.prefix || entry.path.startsWith(spec.prefix))
+          && /\.(obj|glb|gltf|vox)$/i.test(entry.path)
+          && entry.size > 0
+          && entry.size <= maxBytes
+        )
+        .map((entry) => ({
+          source,
+          sourcePath: entry.path,
+          ext: extname(entry.path).slice(1).toLowerCase(),
+          size: entry.size,
+          url: `https://raw.githubusercontent.com/${spec.owner}/${spec.repo}/${spec.branch}/${entry.path}`,
+          baseUrl: `https://raw.githubusercontent.com/${spec.owner}/${spec.repo}/${spec.branch}/${entry.path}`,
+        }));
+      out.push(...files);
+      console.log(`listed github ${source}: +${files.length}, queue=${out.length}`);
+    } catch (error) {
+      failedDownloads.push({
+        source,
+        sourcePath: spec.prefix || ".",
+        stage: "list",
+        error: error instanceof Error ? error.message : String(error),
+      });
+      bumpSource(source, "failedDownloads");
+    }
+  }
+  return stableShuffle(out, 0xc017);
+}
+
+function selectPolyhavenGltf(assetId, files) {
+  const variants = [];
+  for (const [resolution, formats] of Object.entries(files.gltf ?? {})) {
+    const gltf = formats?.gltf;
+    if (!gltf?.url) continue;
+    const includeUrls = {};
+    let size = gltf.size ?? 0;
+    for (const [uri, include] of Object.entries(gltf.include ?? {})) {
+      if (!uri.toLowerCase().endsWith(".bin") || !include?.url) continue;
+      includeUrls[uri] = include.url;
+      size += include.size ?? 0;
+    }
+    variants.push({
+      resolution,
+      size,
+      url: gltf.url,
+      includeUrls,
+    });
+  }
+  return variants
+    .filter((variant) => variant.size > 0 && variant.size <= maxBytes)
+    .sort((a, b) => a.size - b.size || a.resolution.localeCompare(b.resolution))[0] ?? null;
+}
+
+async function listPolyhaven() {
+  const limit = Math.max(1, optNum("polyhaven-limit", 250));
+  const source = "polyhaven@models";
+  const out = [];
+  try {
+    const assets = await fetchJson("https://api.polyhaven.com/assets?t=models");
+    const ids = stableShuffle(Object.keys(assets), 0x9017).slice(0, limit);
+    for (const assetId of ids) {
+      if (out.length >= maxModels * 2) break;
+      try {
+        const files = await fetchJson(`https://api.polyhaven.com/files/${encodeURIComponent(assetId)}`);
+        const selected = selectPolyhavenGltf(assetId, files);
+        if (!selected) continue;
+        out.push({
+          source,
+          sourcePath: `${assetId}/${selected.resolution}`,
+          ext: "gltf",
+          size: selected.size,
+          url: selected.url,
+          baseUrl: selected.url,
+          includeUrls: selected.includeUrls,
+        });
+      } catch (error) {
+        failedDownloads.push({
+          source,
+          sourcePath: assetId,
+          stage: "list",
+          error: error instanceof Error ? error.message : String(error),
+        });
+        bumpSource(source, "failedDownloads");
+      }
+    }
+    console.log(`listed polyhaven models: +${out.length}, inspected=${ids.length}`);
+  } catch (error) {
+    failedDownloads.push({
+      source,
+      sourcePath: ".",
+      stage: "list",
+      error: error instanceof Error ? error.message : String(error),
+    });
+    bumpSource(source, "failedDownloads");
+  }
+  return stableShuffle(out, 0x9a11);
+}
+
+function walkLocal(dir) {
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...walkLocal(full));
+      continue;
+    }
+    const ext = extname(entry.name).slice(1).toLowerCase();
+    if (ext === "obj" || ext === "glb" || ext === "gltf" || ext === "vox") out.push(full);
+  }
+  return out;
+}
+
+function listLocal() {
+  const rootArg = optStr("local-root", "");
+  if (!rootArg) return [];
+  const root = resolve(repoRoot, rootArg);
+  const files = walkLocal(root)
+    .map((file) => ({
+      source: `local:${root}`,
+      sourcePath: relative(root, file),
+      ext: extname(file).slice(1).toLowerCase(),
+      size: readFileSync(file).byteLength,
+      url: file,
+      baseUrl: file,
+    }))
+    .filter((item) => item.size <= maxBytes);
+  console.log(`listed local ${root}: +${files.length}`);
+  return stableShuffle(files, 0x10ca1);
+}
+
+async function downloadItem(item) {
+  if (item.source.startsWith("local:")) {
+    return item.ext === "obj" || item.ext === "gltf" ? readFileSync(item.url, "utf8") : readFileSync(item.url);
+  }
+  return item.ext === "obj" || item.ext === "gltf" ? fetchText(item.url) : fetchBytes(item.url);
+}
+
+async function loadExternalGltfBuffers(item, text) {
+  const doc = JSON.parse(text);
+  const buffers = new Map();
+  const expectedBytes = (doc.buffers ?? [])
+    .filter((buffer) => buffer.uri && !buffer.uri.startsWith("data:"))
+    .reduce((sum, buffer) => sum + (buffer.byteLength ?? 0), textEncoder.encode(text).byteLength);
+  if (expectedBytes > maxBytes) {
+    throw new Error(`external glTF buffers exceed --max-bytes (${expectedBytes} > ${maxBytes})`);
+  }
+  for (const buffer of doc.buffers ?? []) {
+    const uri = buffer.uri;
+    if (!uri || uri.startsWith("data:")) continue;
+    if (item.source.startsWith("local:")) {
+      buffers.set(uri, new Uint8Array(readFileSync(resolve(dirname(item.url), uri))));
+      continue;
+    }
+    const url = item.includeUrls?.[uri] ?? new URL(uri, item.baseUrl ?? item.url).href;
+    buffers.set(uri, await fetchBytes(url));
+  }
+  return buffers;
+}
+
+async function prepareItem(item) {
+  const data = await downloadItem(item);
+  if (item.ext !== "gltf") return { data, keepData: data, parseOptions: undefined, externalBuffers: new Map() };
+  const externalBuffers = await loadExternalGltfBuffers(item, data);
+  return {
+    data: textEncoder.encode(data),
+    keepData: data,
+    externalBuffers,
+    parseOptions: {
+      baseUrl: item.baseUrl ?? item.url,
+      resolveBuffer: (uri) => {
+        const bytes = externalBuffers.get(uri);
+        if (!bytes) throw new Error(`compat-hunter: missing prefetched glTF buffer ${uri}`);
+        return bytes;
+      },
+    },
+  };
+}
+
+function parseItem(item, prepared) {
+  if (item.ext === "obj") return parseObj(prepared.data);
+  if (item.ext === "vox") return parseVox(toArrayBuffer(prepared.data));
+  return parseGltf(prepared.data, prepared.parseOptions);
+}
+
+function keepPathFor(item, testedIndex, root) {
+  return join(root, `${String(testedIndex).padStart(5, "0")}-${item.sourcePath.replace(/[^A-Za-z0-9._-]+/g, "-")}`);
+}
+
+function writeKeptItem(item, testedIndex, root, prepared) {
+  const keptPath = keepPathFor(item, testedIndex, root);
+  if (item.ext !== "gltf") {
+    writeFileSync(keptPath, prepared.keepData);
+    return keptPath;
+  }
+  mkdirSync(keptPath, { recursive: true });
+  writeFileSync(join(keptPath, "model.gltf"), prepared.keepData);
+  const buffersDir = join(keptPath, "buffers");
+  mkdirSync(buffersDir, { recursive: true });
+  const buffers = [];
+  for (const [uri, bytes] of prepared.externalBuffers.entries()) {
+    const fileName = uri.replace(/[^A-Za-z0-9._-]+/g, "-");
+    writeFileSync(join(buffersDir, fileName), bytes);
+    buffers.push({ uri, fileName, bytes: bytes.byteLength });
+  }
+  writeFileSync(join(keptPath, "external-buffers.json"), `${JSON.stringify(buffers, null, 2)}\n`);
+  return keptPath;
+}
+
+async function handleItem(item, testedIndex) {
+  const started = performance.now();
+  let prepared;
+  try {
+    prepared = await prepareItem(item);
+  } catch (error) {
+    failedDownloads.push(rowForItem(item, testedIndex, {
+      stage: "download",
+      error: error instanceof Error ? error.message : String(error),
+      ms: Math.round((performance.now() - started) * 100) / 100,
+    }));
+    bumpSource(item.source, "failedDownloads");
+    return;
+  }
+
+  try {
+    const parsedResult = parseItem(item, prepared);
+    const ms = Math.round((performance.now() - started) * 100) / 100;
+    const classification = classify(parsedResult, item.ext);
+    const warnings = parsedResult.warnings ?? [];
+    const row = rowForItem(item, testedIndex, {
+      kind: classification.kind,
+      polygonCount: parsedResult.polygons.length,
+      warningCount: warnings.length,
+      warnings,
+      triangleCount: parsedResult.metadata?.triangleCount,
+      unknownWarnings: classification.unknownWarnings,
+      ms,
+    });
+    parsed++;
+    bumpSource(item.source, "parsed");
+    totalPolygons += parsedResult.polygons.length;
+    bumpSource(item.source, "totalPolygons", parsedResult.polygons.length);
+    parsedResult.dispose?.();
+
+    if (classification.kind === "clean") {
+      cleanCount++;
+      bumpSource(item.source, "clean");
+      if (cleanSamples.length < 25 || testedIndex % progressEvery === 0) {
+        cleanSamples.push({
+          testedIndex,
+          source: item.source,
+          sourcePath: item.sourcePath,
+          polygonCount: row.polygonCount,
+          ms,
+        });
+      }
+      return;
+    }
+
+    if (classification.kind === "known-warning" || classification.kind === "known-zero") {
+      knownCount++;
+      bumpSource(item.source, "known");
+      for (const warning of warnings) bump(knownWarningCounts, warning);
+      if (keepKnown) {
+        const keptPath = writeKeptItem(item, testedIndex, knownRoot, prepared);
+        row.keptPath = keptPath;
+      }
+      knownSamples.push(row);
+      return;
+    }
+
+    const keptPath = writeKeptItem(item, testedIndex, interestingRoot, prepared);
+    interesting.push({ ...row, keptPath });
+    bumpSource(item.source, "interesting");
+    console.log(`FOUND ${classification.kind} at ${testedIndex}: ${item.source} ${item.sourcePath}`);
+    if (stopOnInteresting) stop = true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const knownError = isKnownError(message);
+    if (knownError) {
+      knownCount++;
+      bumpSource(item.source, "known");
+      bump(knownErrorCounts, message);
+      const row = rowForItem(item, testedIndex, {
+        kind: "known-error",
+        error: message,
+        ms: Math.round((performance.now() - started) * 100) / 100,
+      });
+      if (keepKnown) row.keptPath = writeKeptItem(item, testedIndex, knownRoot, prepared);
+      knownSamples.push(row);
+      return;
+    }
+    bump(failureCounts, message);
+    const keptPath = writeKeptItem(item, testedIndex, interestingRoot, prepared);
+    interesting.push(rowForItem(item, testedIndex, {
+      kind: "throw",
+      error: message,
+      keptPath,
+      ms: Math.round((performance.now() - started) * 100) / 100,
+    }));
+    bumpSource(item.source, "interesting");
+    console.log(`FOUND throw at ${testedIndex}: ${item.source} ${item.sourcePath}: ${message}`);
+    if (stopOnInteresting) stop = true;
+  }
+}
+
+async function buildQueue() {
+  const chunks = [];
+  if (sources.includes("objaverse")) chunks.push(await listObjaverse());
+  if (sources.includes("github")) chunks.push(await listGithub());
+  if (sources.includes("polyhaven")) chunks.push(await listPolyhaven());
+  if (sources.includes("local")) chunks.push(listLocal());
+  return stableShuffle(chunks.flat(), 0x705e);
+}
+
+const queue = await buildQueue();
+for (const item of queue) bumpSource(item.source, "queued");
+if (queue.length === 0) {
+  writeReport(true);
+  throw new Error("compat-hunter: no OBJ/GLB/glTF/VOX candidates were listed");
+}
+
+async function worker() {
+  while (!stop) {
+    if (attempted >= maxModels) return;
+    const item = queue[nextQueueIndex++];
+    if (!item) return;
+    const testedIndex = ++attempted;
+    bumpSource(item.source, "attempted");
+    await handleItem(item, testedIndex);
+    if (progressEvery > 0 && (attempted % progressEvery === 0 || stop)) {
+      console.log(
+        `attempted=${attempted} parsed=${parsed} clean=${cleanCount} known=${knownCount} `
+        + `interesting=${interesting.length} failedDownloads=${failedDownloads.length}`,
+      );
+      writeReport(stop);
+    }
+  }
+}
+
+writeReport(false);
+await Promise.all(Array.from({ length: concurrency }, () => worker()));
+writeReport(true);
+console.log(JSON.stringify({
+  reportPath,
+  attempted,
+  parsed,
+  clean: cleanCount,
+  known: knownCount,
+  interesting: interesting.length,
+  failedDownloads: failedDownloads.length,
+  totalPolygons,
+}, null, 2));
diff --git a/AGENTS.md b/AGENTS.md
index 270cc098..98740cc5 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,10 +1,10 @@
-# Polycss — agent guide
+# PolyCSS — agent guide
 
 This file is the single source of truth for AI coding agents (Claude Code, Cursor, etc.). `CLAUDE.md` is a symlink to this file — **always edit `AGENTS.md`, never `CLAUDE.md`**. The constraints below describe the current design and the rules we work under; if a request conflicts with one of them, push back before doing it.
 
 ## What this repo is
 
-`polycss` is a CSS-based polygon mesh rendering engine. It paints 3D meshes by emitting one DOM element per polygon, transforming it with `matrix3d`, and letting the browser composite the result. No WebGL, no canvas-per-frame. Rasterisation only happens once, into a texture atlas; everything after that is pure DOM + CSS.
+PolyCSS is a CSS-based polygon mesh rendering engine. It paints 3D meshes by emitting one DOM element per polygon, transforming it with `matrix3d`, and letting the browser composite the result. No WebGL, no canvas-per-frame. Rasterisation only happens once, into a texture atlas; everything after that is pure DOM + CSS.
 
 Monorepo layout (pnpm workspaces):
 
@@ -81,6 +81,7 @@ If you find yourself wanting a `requestAnimationFrame` loop to update many DOM n
 
 ## Naming (three.js parity)
 
+- Brand text is **PolyCSS**. Keep lowercase `polycss` only for literal package names, import paths, CSS classes, domains, and other code identifiers.
 - Every public export gets a `Poly` prefix. Exceptions are generic math types: `Vec2`, `Vec3`, `Polygon`, `PolyMaterial` (already prefixed).
 - **Hooks/composables:** `usePolyCamera`, `usePolyMesh`, `usePolySceneContext`, `usePolySelect`, `usePolySelectionApi`, `usePolyAnimation`.
 - **Components:** `PolyPerspectiveCamera`, `PolyOrthographicCamera`, `PolyOrbitControls`, `PolyMapControls`, `PolyTransformControls`, `PolySelect`, `PolyAxesHelper`, `PolyDirectionalLightHelper`.
@@ -89,15 +90,15 @@ If you find yourself wanting a `requestAnimationFrame` loop to update many DOM n
 - **Vanilla factories:** `create*` names stay as-is (`createPolyScene`, `createTransformControls`, `createSelect`).
 - **HTML custom elements:** `poly-` prefix + kebab-case. Existing tags: `<poly-scene>`, `<poly-mesh>`, `<poly-polygon>`, `<poly-perspective-camera>`, `<poly-orthographic-camera>`, `<poly-axes-helper>`, `<poly-directional-light-helper>`. Any new element follows the same shape (e.g. `<poly-transform-controls>`, `<poly-select>`).
 - **Leaf DOM tags (`<b>`, `<i>`, `<s>`, `<u>`):** internal render-strategy tags. Not part of the public API and not user-facing — do not document them as such.
-- `PolyCamera` is a kept alias for `PolyOrthographicCamera` — the ergonomic default, optimised for iso/voxel/diagrammatic scenes which is polycss's structural strength. **Not deprecated.**
+- `PolyCamera` is a kept alias for `PolyOrthographicCamera` — the ergonomic default, optimised for iso/voxel/diagrammatic scenes which is PolyCSS's structural strength. **Not deprecated.**
 
 ## Cross-package discipline
 
 The React and Vue packages are mirror images. **Any public API change in one must land in the other in the same PR.** Same names, same arguments, same defaults, same return shapes (allowing for idiomatic differences — refs vs reactives, `useEffect` vs `watchEffect`).
 
-When you change `packages/polycss` or `packages/core` in a way that affects the public surface (new option, renamed export, changed default), the React and Vue bindings update in the same PR. Don't ship a polycss change that leaves the bindings stale.
+When you change `packages/polycss` or `packages/core` in a way that affects the public surface (new option, renamed export, changed default), the React and Vue bindings update in the same PR. Don't ship a PolyCSS change that leaves the bindings stale.
 
-**Renderer-owned browser glue.** The canvas atlas pipeline (`buildAtlasPages` + helpers), browser-feature detection (`isBorderShapeSupported`, `isSolidTriangleSupported`, `resolveSolidTrianglePrimitive`), direct voxel renderer (`voxelRenderer.ts`), and injected `.polycss-scene` / `.polycss-camera` base styles exist as **independent copies** across the three renderers. This includes `packages/polycss/src/render/atlas/`, `packages/react/src/scene/atlas/`, `packages/vue/src/scene/atlas/`, the three renderer-local `voxelRenderer.ts` files, and the three sibling `styles.ts` files. This is deliberate — each renderer is self-contained on its dep graph (React/Vue do not import from polycss). The trade-off is that a bug fix in any of these files MUST be mirrored into the other two. Coverage is pinned per copy by the co-located test files.
+**Renderer-owned browser glue.** The canvas atlas pipeline (`buildAtlasPages` + helpers), browser-feature detection (`isBorderShapeSupported`, `isSolidTriangleSupported`, `resolveSolidTrianglePrimitive`), direct voxel renderer (`voxelRenderer.ts`), and injected `.polycss-scene` / `.polycss-camera` base styles exist as **independent copies** across the three renderers. This includes `packages/polycss/src/render/atlas/`, `packages/react/src/scene/atlas/`, `packages/vue/src/scene/atlas/`, the three renderer-local `voxelRenderer.ts` files, and the three sibling `styles.ts` files. This is deliberate — each renderer is self-contained on its dep graph (React/Vue do not import from the `polycss` package). The trade-off is that a bug fix in any of these files MUST be mirrored into the other two. Coverage is pinned per copy by the co-located test files.
 
 Before opening a PR:
 
@@ -105,7 +106,7 @@ Before opening a PR:
 - [ ] If I touched a Vue component/composable, the React component/hook matches.
 - [ ] If I added an option to a `polycss` factory, both bindings expose it.
 - [ ] If I renamed a `core` export, every package that imports it is updated.
-- [ ] If I touched the canvas atlas pipeline (`rasterise.ts` / `buildAtlasPages.ts`), browser-feature detection, or direct voxel renderer in ONE renderer, the same fix lands in the other two renderers (polycss + react + vue) in this PR.
+- [ ] If I touched the canvas atlas pipeline (`rasterise.ts` / `buildAtlasPages.ts`), browser-feature detection, or direct voxel renderer in ONE renderer, the same fix lands in the other two renderers (`polycss` + react + vue) in this PR.
 - [ ] If I touched any of the three `styles.ts` (`packages/polycss/src/styles/styles.ts`, `packages/react/src/styles/styles.ts`, `packages/vue/src/styles/styles.ts`), the other two are consistent — CSS rules cover every emitted tag for both lighting modes, and shared properties like `will-change: transform` on `.polycss-scene` exist in all three.
 - [ ] Website docs (`website/src/content/docs/**`) and READMEs reflect any user-visible change.
 - [ ] If I changed a render strategy, lighting mode, naming convention, or the JS-in-render-loop rules, `AGENTS.md` reflects the new state in this same PR.
diff --git a/README.md b/README.md
index 0b012ea1..2a6fb249 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@ A CSS polygon mesh library. A 3D engine for the DOM. Renders OBJ/MTL, GLB and VO
 
 Visit [polycss.com](https://polycss.com) for docs and model examples.
 
-<img width="1600" height="300" alt="polycss-primitives-banner" src="https://github.com/user-attachments/assets/b05e2204-9323-4f83-8d1b-01ea0dd000db" />
+<img width="1600" height="300" alt="PolyCSS primitives banner" src="https://github.com/user-attachments/assets/b05e2204-9323-4f83-8d1b-01ea0dd000db" />
 
 ## Installation
 
@@ -35,7 +35,7 @@ You can also load PolyCSS directly from a CDN. Here is a minimal custom-element
 </poly-camera>
 ```
 
-<img width="2500" height="1145" alt="polycss-intro" src="https://github.com/user-attachments/assets/0e5df0d8-04a8-4e50-8e3a-1097a96ce42f" />
+<img width="2500" height="1145" alt="PolyCSS intro" src="https://github.com/user-attachments/assets/0e5df0d8-04a8-4e50-8e3a-1097a96ce42f" />
 
 ## Framework Components
 
diff --git a/examples/html/baked-shapes/index.html b/examples/html/baked-shapes/index.html
index db16d2eb..a4ed444a 100644
--- a/examples/html/baked-shapes/index.html
+++ b/examples/html/baked-shapes/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>baked-shapes — polycss HTML</title>
+  <title>baked-shapes — PolyCSS HTML</title>
   <script type="module">import "@layoutit/polycss/elements";</script>
   <style>
     html, body { margin: 0; height: 100%; background: #111; } poly-scene { display: block; width: 100%; height: 100%; }
diff --git a/examples/html/index.html b/examples/html/index.html
index 4344efb2..30f869cc 100644
--- a/examples/html/index.html
+++ b/examples/html/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>polycss — HTML examples</title>
+  <title>PolyCSS — HTML examples</title>
   <style>
     body { background: #111; color: #eee; font-family: sans-serif; padding: 2rem; }
     h1 { margin-bottom: 1rem; }
@@ -14,7 +14,7 @@
   </style>
 </head>
 <body>
-  <h1>polycss — HTML (custom elements)</h1>
+  <h1>PolyCSS — HTML (custom elements)</h1>
   <ul>
     <li><a href="baked-shapes/">baked-shapes</a></li>
     <li><a href="multi-mesh/">multi-mesh</a></li>
diff --git a/examples/html/multi-mesh/index.html b/examples/html/multi-mesh/index.html
index e08d2394..a2495c1f 100644
--- a/examples/html/multi-mesh/index.html
+++ b/examples/html/multi-mesh/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>multi-mesh — polycss HTML</title>
+  <title>multi-mesh — PolyCSS HTML</title>
   <script type="module">import "@layoutit/polycss/elements";</script>
   <style>
     html, body { margin: 0; height: 100%; background: #111; } poly-scene { display: block; width: 100%; height: 100%; }
diff --git a/examples/html/solid-glb/index.html b/examples/html/solid-glb/index.html
index 0843919b..68c638f7 100644
--- a/examples/html/solid-glb/index.html
+++ b/examples/html/solid-glb/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>solid-glb — polycss HTML</title>
+  <title>solid-glb — PolyCSS HTML</title>
   <script type="module">import "@layoutit/polycss/elements";</script>
   <style>
     html, body { margin: 0; height: 100%; background: #111; } poly-scene { display: block; width: 100%; height: 100%; }
diff --git a/examples/html/textured-glb/index.html b/examples/html/textured-glb/index.html
index ff115f53..e8be6a48 100644
--- a/examples/html/textured-glb/index.html
+++ b/examples/html/textured-glb/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>textured-glb — polycss HTML</title>
+  <title>textured-glb — PolyCSS HTML</title>
   <script type="module">import "@layoutit/polycss/elements";</script>
   <style>
     html, body { margin: 0; height: 100%; background: #111; } poly-scene { display: block; width: 100%; height: 100%; }
diff --git a/examples/html/voxel/index.html b/examples/html/voxel/index.html
index 01ac3c5a..0cb519cf 100644
--- a/examples/html/voxel/index.html
+++ b/examples/html/voxel/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>voxel — polycss HTML</title>
+  <title>voxel — PolyCSS HTML</title>
   <script type="module">import "@layoutit/polycss/elements";</script>
   <style>
     html, body { margin: 0; height: 100%; background: #111; } poly-scene { display: block; width: 100%; height: 100%; }
diff --git a/examples/react/animated/index.html b/examples/react/animated/index.html
index bb88aa55..429d1171 100644
--- a/examples/react/animated/index.html
+++ b/examples/react/animated/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>animated — polycss React</title>
+  <title>animated — PolyCSS React</title>
   <style>html, body { margin: 0; height: 100%; background: #111; }</style>
 </head>
 <body>
diff --git a/examples/react/baked-shapes/index.html b/examples/react/baked-shapes/index.html
index 5021bfe6..589cba71 100644
--- a/examples/react/baked-shapes/index.html
+++ b/examples/react/baked-shapes/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>baked-shapes — polycss React</title>
+  <title>baked-shapes — PolyCSS React</title>
   <style>html, body { margin: 0; height: 100%; background: #111; }</style>
 </head>
 <body>
diff --git a/examples/react/index.html b/examples/react/index.html
index a3949ebc..2a6f9fef 100644
--- a/examples/react/index.html
+++ b/examples/react/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>polycss — React examples</title>
+  <title>PolyCSS — React examples</title>
   <style>
     body { background: #111; color: #eee; font-family: sans-serif; padding: 2rem; }
     h1 { margin-bottom: 1rem; }
@@ -14,7 +14,7 @@
   </style>
 </head>
 <body>
-  <h1>polycss — React examples</h1>
+  <h1>PolyCSS — React examples</h1>
   <ul>
     <li><a href="baked-shapes/">baked-shapes</a></li>
     <li><a href="multi-mesh/">multi-mesh</a></li>
diff --git a/examples/react/multi-mesh/index.html b/examples/react/multi-mesh/index.html
index f01e852d..384bcab4 100644
--- a/examples/react/multi-mesh/index.html
+++ b/examples/react/multi-mesh/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>multi-mesh — polycss React</title>
+  <title>multi-mesh — PolyCSS React</title>
   <style>html, body { margin: 0; height: 100%; background: #111; }</style>
 </head>
 <body>
diff --git a/examples/react/solid-glb/index.html b/examples/react/solid-glb/index.html
index b3e1e336..77a1e560 100644
--- a/examples/react/solid-glb/index.html
+++ b/examples/react/solid-glb/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>solid-glb — polycss React</title>
+  <title>solid-glb — PolyCSS React</title>
   <style>html, body { margin: 0; height: 100%; background: #111; }</style>
 </head>
 <body>
diff --git a/examples/react/textured-glb/index.html b/examples/react/textured-glb/index.html
index cd59b0f4..754f4a80 100644
--- a/examples/react/textured-glb/index.html
+++ b/examples/react/textured-glb/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>textured-glb — polycss React</title>
+  <title>textured-glb — PolyCSS React</title>
   <style>html, body { margin: 0; height: 100%; background: #111; }</style>
 </head>
 <body>
diff --git a/examples/react/voxel/index.html b/examples/react/voxel/index.html
index 7cfdb3b9..69262d4e 100644
--- a/examples/react/voxel/index.html
+++ b/examples/react/voxel/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>voxel — polycss React</title>
+  <title>voxel — PolyCSS React</title>
   <style>html, body { margin: 0; height: 100%; background: #111; }</style>
 </head>
 <body>
diff --git a/examples/vanilla/animated/index.html b/examples/vanilla/animated/index.html
index 88603149..2afc97eb 100644
--- a/examples/vanilla/animated/index.html
+++ b/examples/vanilla/animated/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>animated — polycss vanilla</title>
+  <title>animated — PolyCSS vanilla</title>
   <style>
     html, body { margin: 0; height: 100%; background: #111; }
     #host { width: 100%; height: 100vh; }
diff --git a/examples/vanilla/baked-shapes/index.html b/examples/vanilla/baked-shapes/index.html
index 07c55f14..ca9aa740 100644
--- a/examples/vanilla/baked-shapes/index.html
+++ b/examples/vanilla/baked-shapes/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>baked-shapes — polycss vanilla</title>
+  <title>baked-shapes — PolyCSS vanilla</title>
   <style>
     html, body { margin: 0; height: 100%; background: #111; }
     #host { width: 100%; height: 100vh; }
diff --git a/examples/vanilla/index.html b/examples/vanilla/index.html
index 7ecd3b30..800574b3 100644
--- a/examples/vanilla/index.html
+++ b/examples/vanilla/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>polycss — vanilla examples</title>
+  <title>PolyCSS — vanilla examples</title>
   <style>
     body { background: #111; color: #eee; font-family: sans-serif; padding: 2rem; }
     h1 { margin-bottom: 1rem; }
@@ -14,7 +14,7 @@
   </style>
 </head>
 <body>
-  <h1>polycss — vanilla (imperative API)</h1>
+  <h1>PolyCSS — vanilla (imperative API)</h1>
   <ul>
     <li><a href="baked-shapes/">baked-shapes</a></li>
     <li><a href="multi-mesh/">multi-mesh</a></li>
diff --git a/examples/vanilla/multi-mesh/index.html b/examples/vanilla/multi-mesh/index.html
index d1f31d93..07d88fe1 100644
--- a/examples/vanilla/multi-mesh/index.html
+++ b/examples/vanilla/multi-mesh/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>multi-mesh — polycss vanilla</title>
+  <title>multi-mesh — PolyCSS vanilla</title>
   <style>
     html, body { margin: 0; height: 100%; background: #111; }
     #host { width: 100%; height: 100vh; }
diff --git a/examples/vanilla/solid-glb/index.html b/examples/vanilla/solid-glb/index.html
index 344ab744..f1bad0e4 100644
--- a/examples/vanilla/solid-glb/index.html
+++ b/examples/vanilla/solid-glb/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>solid-glb — polycss vanilla</title>
+  <title>solid-glb — PolyCSS vanilla</title>
   <style>
     html, body { margin: 0; height: 100%; background: #111; }
     #host { width: 100%; height: 100vh; }
diff --git a/examples/vanilla/textured-glb/index.html b/examples/vanilla/textured-glb/index.html
index 9169c84d..15f538ba 100644
--- a/examples/vanilla/textured-glb/index.html
+++ b/examples/vanilla/textured-glb/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>textured-glb — polycss vanilla</title>
+  <title>textured-glb — PolyCSS vanilla</title>
   <style>
     html, body { margin: 0; height: 100%; background: #111; }
     #host { width: 100%; height: 100vh; }
diff --git a/examples/vanilla/voxel/index.html b/examples/vanilla/voxel/index.html
index da9a1690..e102be9e 100644
--- a/examples/vanilla/voxel/index.html
+++ b/examples/vanilla/voxel/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>voxel — polycss vanilla</title>
+  <title>voxel — PolyCSS vanilla</title>
   <style>
     html, body { margin: 0; height: 100%; background: #111; }
     #host { width: 100%; height: 100vh; }
diff --git a/examples/vue/animated/index.html b/examples/vue/animated/index.html
index 3a8759d4..a2131142 100644
--- a/examples/vue/animated/index.html
+++ b/examples/vue/animated/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>animated — polycss Vue</title>
+  <title>animated — PolyCSS Vue</title>
   <style>html, body { margin: 0; height: 100%; background: #111; }</style>
 </head>
 <body>
diff --git a/examples/vue/baked-shapes/index.html b/examples/vue/baked-shapes/index.html
index 950e0fa7..f4608ed0 100644
--- a/examples/vue/baked-shapes/index.html
+++ b/examples/vue/baked-shapes/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>baked-shapes — polycss Vue</title>
+  <title>baked-shapes — PolyCSS Vue</title>
   <style>html, body { margin: 0; height: 100%; background: #111; }</style>
 </head>
 <body>
diff --git a/examples/vue/index.html b/examples/vue/index.html
index 4a07226f..c298d2a4 100644
--- a/examples/vue/index.html
+++ b/examples/vue/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>polycss — Vue examples</title>
+  <title>PolyCSS — Vue examples</title>
   <style>
     body { background: #111; color: #eee; font-family: sans-serif; padding: 2rem; }
     h1 { margin-bottom: 1rem; }
@@ -14,7 +14,7 @@
   </style>
 </head>
 <body>
-  <h1>polycss — Vue examples</h1>
+  <h1>PolyCSS — Vue examples</h1>
   <ul>
     <li><a href="baked-shapes/">baked-shapes</a></li>
     <li><a href="multi-mesh/">multi-mesh</a></li>
diff --git a/examples/vue/multi-mesh/index.html b/examples/vue/multi-mesh/index.html
index f3805e7e..1b27e673 100644
--- a/examples/vue/multi-mesh/index.html
+++ b/examples/vue/multi-mesh/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>multi-mesh — polycss Vue</title>
+  <title>multi-mesh — PolyCSS Vue</title>
   <style>html, body { margin: 0; height: 100%; background: #111; }</style>
 </head>
 <body>
diff --git a/examples/vue/solid-glb/index.html b/examples/vue/solid-glb/index.html
index 9b2720f3..f5e5f9b7 100644
--- a/examples/vue/solid-glb/index.html
+++ b/examples/vue/solid-glb/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>solid-glb — polycss Vue</title>
+  <title>solid-glb — PolyCSS Vue</title>
   <style>html, body { margin: 0; height: 100%; background: #111; }</style>
 </head>
 <body>
diff --git a/examples/vue/textured-glb/index.html b/examples/vue/textured-glb/index.html
index 7ce4ea41..4add433e 100644
--- a/examples/vue/textured-glb/index.html
+++ b/examples/vue/textured-glb/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>textured-glb — polycss Vue</title>
+  <title>textured-glb — PolyCSS Vue</title>
   <style>html, body { margin: 0; height: 100%; background: #111; }</style>
 </head>
 <body>
diff --git a/examples/vue/voxel/index.html b/examples/vue/voxel/index.html
index 65d356aa..a525cd85 100644
--- a/examples/vue/voxel/index.html
+++ b/examples/vue/voxel/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>voxel — polycss Vue</title>
+  <title>voxel — PolyCSS Vue</title>
   <style>html, body { margin: 0; height: 100%; background: #111; }</style>
 </head>
 <body>
diff --git a/package.json b/package.json
index 00aeb4e2..096c9140 100644
--- a/package.json
+++ b/package.json
@@ -38,6 +38,7 @@
     "bench:minecraft-movement": "pnpm --filter @layoutit/polycss-examples-vanilla build && node bench/minecraft-movement-bench.mjs",
     "bench:lossy": "pnpm --filter @layoutit/polycss-core build && node bench/lossy-optimizer-bench.mjs",
     "bench:lossy:corpus": "pnpm --filter @layoutit/polycss-core build && node bench/lossy-corpus-bench.mjs",
+    "compat-hunter": "pnpm --filter @layoutit/polycss-core build && node .agents/skills/compat-hunter/scripts/compat-hunter.mjs",
     "bench:seams": "pnpm --filter @layoutit/polycss-core build && node bench/seam-gap-bench.mjs",
     "bench:seams:render": "pnpm --filter @layoutit/polycss-core build && node bench/seam-gap-bench.mjs --render",
     "bench:visual": "node bench/build.mjs && node bench/perf-visual.mjs"
diff --git a/packages/core/README.md b/packages/core/README.md
index dfee357d..5d571c90 100644
--- a/packages/core/README.md
+++ b/packages/core/README.md
@@ -1,14 +1,14 @@
 <p align="center">
-  <img src="https://polycss.com/voxisologo.png" alt="polycss" width="300" />
+  <img src="https://polycss.com/voxisologo.png" alt="PolyCSS" width="300" />
 </p>
 
-# polycss
+# PolyCSS
 
 A CSS polygon mesh engine. A 3D renderer for the DOM. Renders OBJ, glTF, GLB, MagicaVoxel `.vox`, and generated primitives as real HTML elements transformed with CSS `matrix3d(...)`. Supports colors, textures, lighting, shadows, controls, selection, animation, and per-polygon interaction. Works with React, Vue, custom elements, or plain JavaScript.
 
 Visit [polycss.com](https://polycss.com) for docs and model examples.
 
-<img width="1915" height="900" alt="polycss scene" src="https://polycss.com/voxcss-intro.png" />
+<img width="1915" height="900" alt="PolyCSS scene" src="https://polycss.com/voxcss-intro.png" />
 
 ## Installation
 
@@ -23,7 +23,7 @@ npm install @layoutit/polycss-vue
 npm install @layoutit/polycss
 ```
 
-You can also load polycss directly from a CDN. Here is a minimal custom-element scene:
+You can also load PolyCSS directly from a CDN. Here is a minimal custom-element scene:
 
 ```html
 <script type="module" src="https://esm.sh/@layoutit/polycss/elements"></script>
@@ -171,7 +171,7 @@ Supported formats:
 
 ## Performance
 
-polycss renders in the DOM, so performance is mostly determined by how many polygons are mounted and how much texture atlas area they consume. The renderer uses several CSS strategies so simple surfaces stay cheap and textured or irregular surfaces fall back to atlas slices.
+PolyCSS renders in the DOM, so performance is mostly determined by how many polygons are mounted and how much texture atlas area they consume. The renderer uses several CSS strategies so simple surfaces stay cheap and textured or irregular surfaces fall back to atlas slices.
 
 - One visible polygon becomes one leaf DOM element.
 - Flat rectangles and stable quads use solid CSS leaves.
@@ -200,7 +200,7 @@ For diagnostics, all renderer packages export `collectPolyRenderStats(root)`, wh
 | `@layoutit/polycss-react` | React components, hooks, controls, and core re-exports. |
 | `@layoutit/polycss-vue` | Vue 3 components, composables, controls, and core re-exports. |
 
-## Made with polycss
+## Made with PolyCSS
 
 [Layoutit Voxels](https://voxels.layoutit.com)
 -> A CSS Voxel editor
diff --git a/packages/core/src/atlas/solidTrianglePlan.ts b/packages/core/src/atlas/solidTrianglePlan.ts
index bc9b01a1..4f417d73 100644
--- a/packages/core/src/atlas/solidTrianglePlan.ts
+++ b/packages/core/src/atlas/solidTrianglePlan.ts
@@ -434,7 +434,7 @@ export function computeSolidTrianglePlanFromCssPoints(
     ? basisHint
     : { a, b, c };
   // Use the pre-resolved primitive from computeOptions — the browser-global
-  // resolution that formerly happened here now happens in the polycss wrapper.
+  // resolution that formerly happened here now happens in the PolyCSS wrapper.
   const primitive = computeOptions.primitive ?? computeOptions.resolvedPrimitive ?? "border";
   return {
     index,
diff --git a/packages/core/src/camera/camera.ts b/packages/core/src/camera/camera.ts
index ccc52423..a470d5d4 100644
--- a/packages/core/src/camera/camera.ts
+++ b/packages/core/src/camera/camera.ts
@@ -2,7 +2,7 @@
 import type { Vec3 } from "../types";
 
 /**
- * Base tile size in CSS pixels. One polycss world unit = BASE_TILE CSS
+ * Base tile size in CSS pixels. One PolyCSS world unit = BASE_TILE CSS
  * pixels (pre-scale). Used to convert world-coordinate target values to
  * CSS translations in the transform string.
  */
@@ -20,7 +20,7 @@ export type AutoRotateOption = boolean | number | AutoRotateConfig;
  * World-coordinate camera state (Three.js-style).
  *
  * `target` is the world point that should appear at the viewport centre.
- * Polycss world axes: [0]=X (rows/south), [1]=Y (cols/east), [2]=Z (up).
+ * PolyCSS world axes: [0]=X (rows/south), [1]=Y (cols/east), [2]=Z (up).
  *
  * `pan`, `tilt`, and `depthOffset` are gone. Translations now live inside
  * `target` so they happen BEFORE rotations — enabling correct world-space
@@ -114,7 +114,7 @@ export function createIsometricCamera(initial: Partial<CameraState> = {}): Camer
     const height = (input.rows ?? 0) * tileSize;
 
     // Convert world target to CSS-space translation.
-    // Polycss world→CSS mapping: world[0]→CSS Y, world[1]→CSS X, world[2]→CSS Z.
+    // PolyCSS world→CSS mapping: world[0]→CSS Y, world[1]→CSS X, world[2]→CSS Z.
     // Negate so that the world moves such that `target` ends up at scene origin.
     const [tx, ty, tz] = state.target;
     const cssX = ty * tileSize;  // world Y → CSS X
diff --git a/packages/core/src/helpers/arrowPolygons.ts b/packages/core/src/helpers/arrowPolygons.ts
index f5a983ea..913e8e99 100644
--- a/packages/core/src/helpers/arrowPolygons.ts
+++ b/packages/core/src/helpers/arrowPolygons.ts
@@ -5,7 +5,7 @@
  * drag handle for `<TransformControls>` — same primitive recipe as
  * `axesHelperPolygons`, plus an arrowhead.
  *
- * Returned polygons are in standard polycss world space and intended
+ * Returned polygons are in standard PolyCSS world space and intended
  * to be wrapped in the framework's PolyMesh equivalent for rendering.
  */
 import type { Polygon, Vec3 } from "../types";
@@ -51,7 +51,7 @@ function shaftPolygons(
     makeAxisVec(axis, along, sideA, sideB);
   // Vertex layout matches axesHelperPolygons' axisBox: 4 corners at
   // each end of the box, 6 quad faces. Same winding so the cuboid
-  // renders front-faces-out under polycss's backface-visibility:hidden.
+  // renders front-faces-out under PolyCSS's backface-visibility:hidden.
   const c0 = m(from, -half, -half);
   const c1 = m(from,  half, -half);
   const c2 = m(from,  half,  half);
diff --git a/packages/core/src/helpers/axesPolygons.ts b/packages/core/src/helpers/axesPolygons.ts
index 571cf0da..a435a7bb 100644
--- a/packages/core/src/helpers/axesPolygons.ts
+++ b/packages/core/src/helpers/axesPolygons.ts
@@ -3,7 +3,7 @@
  * cuboids stretching along world-X, world-Y and world-Z. Mirrors the
  * convention `red=X, green=Y, blue=Z`.
  *
- * Returned polygons are in the standard polycss world-space convention
+ * Returned polygons are in the standard PolyCSS world-space convention
  * (`+X right, +Y forward, +Z up`). Wrap with the framework's PolyMesh /
  * PolyScene equivalent to render.
  */
diff --git a/packages/core/src/helpers/boxPolygons.ts b/packages/core/src/helpers/boxPolygons.ts
index 58464773..c12398b1 100644
--- a/packages/core/src/helpers/boxPolygons.ts
+++ b/packages/core/src/helpers/boxPolygons.ts
@@ -1,7 +1,7 @@
 /**
  * Axis-aligned box/cuboid geometry as six quad polygons.
  *
- * Returned polygons are in standard polycss world space:
+ * Returned polygons are in standard PolyCSS world space:
  * +X = right, +Y = front/forward, +Z = top/up.
  */
 import type { Polygon, Vec2, Vec3 } from "../types";
diff --git a/packages/core/src/helpers/conePolygons.ts b/packages/core/src/helpers/conePolygons.ts
index 18f60f52..61b5d45b 100644
--- a/packages/core/src/helpers/conePolygons.ts
+++ b/packages/core/src/helpers/conePolygons.ts
@@ -5,7 +5,7 @@
  * to zero. The top cap is omitted (no area at the tip), and side faces are
  * emitted as triangles.
  *
- * Polycss world space: +X right, +Y forward, +Z up. Cone axis is Z; the apex
+ * PolyCSS world space: +X right, +Y forward, +Z up. Cone axis is Z; the apex
  * is at Z = +height/2 and the base at Z = -height/2.
  */
 import type { Polygon } from "../types";
diff --git a/packages/core/src/helpers/cylinderPolygons.ts b/packages/core/src/helpers/cylinderPolygons.ts
index 415e2d88..7f7f730f 100644
--- a/packages/core/src/helpers/cylinderPolygons.ts
+++ b/packages/core/src/helpers/cylinderPolygons.ts
@@ -12,7 +12,7 @@
  * Z = +height/2. Side quads are axis-aligned in the cylinder's own local
  * frame, which maximises the chance of hitting the <b> quad fast-path.
  *
- * Polycss world space: +X right, +Y forward, +Z up. The cylinder axis is
+ * PolyCSS world space: +X right, +Y forward, +Z up. The cylinder axis is
  * the Z axis so a typical upright pillar stands without any extra rotation.
  */
 import type { Polygon, Vec3 } from "../types";
diff --git a/packages/core/src/helpers/dodecahedronPolygons.ts b/packages/core/src/helpers/dodecahedronPolygons.ts
index 52d3995c..cc8cb314 100644
--- a/packages/core/src/helpers/dodecahedronPolygons.ts
+++ b/packages/core/src/helpers/dodecahedronPolygons.ts
@@ -8,7 +8,7 @@
  * lies on a single tangent plane. No triangulation is needed. The renderer
  * uses <i> (border-shape) on Chromium and <s> elsewhere for non-quad polygons.
  *
- * Polycss world space: +X right, +Y forward, +Z up.
+ * PolyCSS world space: +X right, +Y forward, +Z up.
  */
 import type { Polygon, Vec3 } from "../types";
 
diff --git a/packages/core/src/helpers/icosahedronPolygons.ts b/packages/core/src/helpers/icosahedronPolygons.ts
index 43981fc7..ad5599d9 100644
--- a/packages/core/src/helpers/icosahedronPolygons.ts
+++ b/packages/core/src/helpers/icosahedronPolygons.ts
@@ -4,7 +4,7 @@
  * Vertices are placed on a sphere of radius `size` centered at the origin.
  * Faces wind CCW from the outside.
  *
- * Polycss world space: +X right, +Y forward, +Z up.
+ * PolyCSS world space: +X right, +Y forward, +Z up.
  */
 import type { Polygon, Vec3 } from "../types";
 
diff --git a/packages/core/src/helpers/planePolygons.ts b/packages/core/src/helpers/planePolygons.ts
index 0ff48b03..976a0cc1 100644
--- a/packages/core/src/helpers/planePolygons.ts
+++ b/packages/core/src/helpers/planePolygons.ts
@@ -5,7 +5,7 @@
  * attached mesh along two axes simultaneously (XY, XZ, or YZ), instead of
  * the single-axis motion the arrow shafts provide.
  *
- * The polygon lives in standard polycss world space; wrap it in the
+ * The polygon lives in standard PolyCSS world space; wrap it in the
  * framework's PolyMesh equivalent for rendering.
  */
 import type { Polygon, Vec3 } from "../types";
diff --git a/packages/core/src/helpers/ringPolygons.ts b/packages/core/src/helpers/ringPolygons.ts
index 9a9e496e..ef5d1351 100644
--- a/packages/core/src/helpers/ringPolygons.ts
+++ b/packages/core/src/helpers/ringPolygons.ts
@@ -9,7 +9,7 @@
  * "rotation circle" and keeps the polygon count proportional to the
  * `segments` knob.
  *
- * Returned polygons are in standard polycss world space and intended
+ * Returned polygons are in standard PolyCSS world space and intended
  * to be wrapped in the framework's PolyMesh equivalent for rendering.
  */
 import type { Polygon, Vec3 } from "../types";
diff --git a/packages/core/src/helpers/spherePolygons.ts b/packages/core/src/helpers/spherePolygons.ts
index 9a3af40e..9e0094c9 100644
--- a/packages/core/src/helpers/spherePolygons.ts
+++ b/packages/core/src/helpers/spherePolygons.ts
@@ -3,7 +3,7 @@
  * triangular faces. Each subdivision step quadruples the face count:
  *   subdivisions 0 → 20, 1 → 80, 2 → 320, 3 → 1280 (capped).
  *
- * Vertex coordinates use polycss world space: +X right, +Y forward, +Z up.
+ * Vertex coordinates use PolyCSS world space: +X right, +Y forward, +Z up.
  * The sphere is centered at the origin; all vertices sit at distance `radius`.
  * Faces wind CCW from the outside (outward normal = away from origin).
  */
diff --git a/packages/core/src/helpers/tetrahedronPolygons.ts b/packages/core/src/helpers/tetrahedronPolygons.ts
index caafb686..f5e33e47 100644
--- a/packages/core/src/helpers/tetrahedronPolygons.ts
+++ b/packages/core/src/helpers/tetrahedronPolygons.ts
@@ -4,7 +4,7 @@
  * Vertices are placed so the tetrahedron is centered at the origin.
  * Faces wind CCW from the outside.
  *
- * Polycss world space: +X right, +Y forward, +Z up.
+ * PolyCSS world space: +X right, +Y forward, +Z up.
  */
 import type { Polygon, Vec3 } from "../types";
 
diff --git a/packages/core/src/helpers/torusPolygons.ts b/packages/core/src/helpers/torusPolygons.ts
index 4db18230..50dcd40f 100644
--- a/packages/core/src/helpers/torusPolygons.ts
+++ b/packages/core/src/helpers/torusPolygons.ts
@@ -2,7 +2,7 @@
  * Torus geometry — Z-axis ring plane.
  *
  * The torus is centered at the origin. The ring lies in the XY plane (the
- * ground plane in polycss world space, where Z is up). The donut hole points
+ * ground plane in PolyCSS world space, where Z is up). The donut hole points
  * along the Z axis.
  *
  * Geometry: `radialSegments × tubularSegments` quads on the surface.
@@ -11,7 +11,7 @@
  * heaviest of the built-in primitives. Reduce radialSegments / tubularSegments
  * if render budget is tight.
  *
- * Polycss world space: +X right, +Y forward, +Z up.
+ * PolyCSS world space: +X right, +Y forward, +Z up.
  */
 import type { Polygon, Vec3 } from "../types";
 
diff --git a/packages/core/src/math/rotation.ts b/packages/core/src/math/rotation.ts
index da97a3fd..0d58c7c1 100644
--- a/packages/core/src/math/rotation.ts
+++ b/packages/core/src/math/rotation.ts
@@ -2,7 +2,7 @@ import type { Vec3 } from "../types";
 
 /**
  * Apply CSS-style chained `rotateX(rx) rotateY(ry) rotateZ(rz)` rotation
- * to a 3D vector. Matches the matrix composition used by polycss mesh
+ * to a 3D vector. Matches the matrix composition used by PolyCSS mesh
  * wrapper transforms (see `buildTransform` in each PolyMesh implementation).
  *
  * CSS composes `transform: rotateX(rx) rotateY(ry) rotateZ(rz)` as the
diff --git a/packages/core/src/parser/parseGltf.test.ts b/packages/core/src/parser/parseGltf.test.ts
index 3d430913..da04f869 100644
--- a/packages/core/src/parser/parseGltf.test.ts
+++ b/packages/core/src/parser/parseGltf.test.ts
@@ -757,6 +757,52 @@ describe("parseGltf", () => {
         [0, 5, 0],
       ]);
     });
+
+    it("treats byteStride: 0 as tightly packed data", () => {
+      const positions = [
+        0, 0, 0,
+        2, 0, 0,
+        0, 1, 0,
+      ];
+      const bin = new Uint8Array(positions.length * 4);
+      const view = new DataView(bin.buffer);
+      for (let i = 0; i < positions.length; i++) {
+        view.setFloat32(i * 4, positions[i], true);
+      }
+      const doc = {
+        asset: { version: "2.0" },
+        scene: 0,
+        scenes: [{ nodes: [0] }],
+        nodes: [{ mesh: 0 }],
+        meshes: [{ primitives: [{ attributes: { POSITION: 0 }, mode: 4 }] }],
+        accessors: [{
+          bufferView: 0,
+          byteOffset: 0,
+          componentType: 5126,
+          count: 3,
+          type: "VEC3",
+        }],
+        bufferViews: [{
+          buffer: 0,
+          byteOffset: 0,
+          byteLength: bin.length,
+          byteStride: 0,
+        }],
+        buffers: [{ byteLength: bin.length }],
+      };
+      const result = parseGltf(buildGlb({ doc, binData: bin }), {
+        upAxis: "z",
+        targetSize: 10,
+        gridShift: 0,
+      });
+
+      expect(result.polygons).toHaveLength(1);
+      expect(result.polygons[0].vertices).toEqual([
+        [0, 0, 0],
+        [10, 0, 0],
+        [0, 5, 0],
+      ]);
+    });
   });
 
   describe("sparse accessors", () => {
@@ -806,7 +852,7 @@ describe("parseGltf", () => {
   });
 
   describe("triangle topology modes", () => {
-    function buildFourVertexModeGlb(mode: 5 | 6): ArrayBuffer {
+    function buildFourVertexModeGlb(mode: number): ArrayBuffer {
       const positions = [
         0, 0, 0,
         1, 0, 0,
@@ -840,6 +886,18 @@ describe("parseGltf", () => {
       const result = parseGltf(buildFourVertexModeGlb(6));
       expect(result.polygons).toHaveLength(2);
     });
+
+    it.each([
+      [0, "POINTS"],
+      [1, "LINES"],
+    ])("mode=%i (%s) is skipped with a warning", (mode, modeName) => {
+      const result = parseGltf(buildFourVertexModeGlb(mode));
+
+      expect(result.polygons).toEqual([]);
+      expect(result.warnings).toEqual([
+        `Skipped primitives with unsupported mode ${mode} (${modeName})`,
+      ]);
+    });
   });
 
   describe("unsupported extensions", () => {
@@ -872,6 +930,72 @@ describe("parseGltf", () => {
       expect(result.polygons).toEqual([]);
       expect(result.warnings.some((warning) => warning.includes("KHR_draco_mesh_compression"))).toBe(true);
     });
+
+    it("skips required meshopt-compressed bufferView primitives before reading extension fallback buffers", () => {
+      const doc = {
+        asset: { version: "2.0" },
+        extensionsRequired: ["EXT_meshopt_compression"],
+        scene: 0,
+        scenes: [{ nodes: [0] }],
+        nodes: [{ mesh: 0 }],
+        meshes: [{
+          name: "MeshoptCompressed",
+          primitives: [{
+            attributes: { POSITION: 0 },
+            indices: 1,
+            mode: 4,
+          }],
+        }],
+        accessors: [
+          { bufferView: 0, componentType: 5126, count: 3, type: "VEC3" },
+          { bufferView: 1, componentType: 5123, count: 3, type: "SCALAR" },
+        ],
+        bufferViews: [
+          {
+            buffer: 1,
+            byteOffset: 0,
+            byteLength: 36,
+            byteStride: 12,
+            extensions: {
+              EXT_meshopt_compression: {
+                buffer: 0,
+                byteOffset: 0,
+                byteLength: 4,
+                byteStride: 12,
+                mode: "ATTRIBUTES",
+                count: 3,
+              },
+            },
+          },
+          {
+            buffer: 1,
+            byteOffset: 36,
+            byteLength: 6,
+            extensions: {
+              EXT_meshopt_compression: {
+                buffer: 0,
+                byteOffset: 0,
+                byteLength: 4,
+                byteStride: 2,
+                mode: "TRIANGLES",
+                count: 3,
+              },
+            },
+          },
+        ],
+        buffers: [
+          { byteLength: 4 },
+          {
+            byteLength: 42,
+            extensions: { EXT_meshopt_compression: { fallback: true } },
+          },
+        ],
+      };
+      const result = parseGltf(buildGlb({ doc, binData: new Uint8Array(4) }));
+
+      expect(result.polygons).toEqual([]);
+      expect(result.warnings.some((warning) => warning.includes("EXT_meshopt_compression"))).toBe(true);
+    });
   });
 
   describe("material color", () => {
diff --git a/packages/core/src/parser/parseGltf.ts b/packages/core/src/parser/parseGltf.ts
index 70998dfb..e0196f40 100644
--- a/packages/core/src/parser/parseGltf.ts
+++ b/packages/core/src/parser/parseGltf.ts
@@ -18,7 +18,7 @@
  *
  * After parsing, the mesh is uniformly scaled to fit `targetSize` units
  * and the y/z axes are cyclically permuted (so glTF's +Y-up becomes
- * polycss's +Z-up without inverting handedness — a single y↔z swap would
+ * PolyCSS's +Z-up without inverting handedness — a single y↔z swap would
  * flip every triangle's winding and break backface culling).
  */
 import type {
@@ -52,7 +52,7 @@ export interface GltfParseOptions {
   /**
    * Which axis is "up" in the source mesh.
    *  - "y" (default, glTF spec): cyclic permutation (x,y,z) → (z,x,y) so
-   *    +Y ends up on polycss's +Z (elevation).
+   *    +Y ends up on PolyCSS's +Z (elevation).
    *  - "z" (Blender-style, FBX2glTF often emits this): identity, no swap.
    * Pick "z" if the model lands on its side / lies down instead of
    * standing.
@@ -90,6 +90,16 @@ const TYPE_COUNT: Record<string, number> = {
   SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4, MAT2: 4, MAT3: 9, MAT4: 16,
 };
 
+const PRIMITIVE_MODE_NAMES: Record<number, string> = {
+  0: "POINTS",
+  1: "LINES",
+  2: "LINE_LOOP",
+  3: "LINE_STRIP",
+  4: "TRIANGLES",
+  5: "TRIANGLE_STRIP",
+  6: "TRIANGLE_FAN",
+};
+
 interface GltfAccessor {
   bufferView?: number;
   byteOffset?: number;
@@ -115,6 +125,12 @@ interface GltfBufferView {
   byteOffset?: number;
   byteLength: number;
   byteStride?: number;
+  extensions?: Record<string, unknown>;
+}
+interface GltfBuffer {
+  byteLength: number;
+  uri?: string;
+  extensions?: Record<string, unknown>;
 }
 interface GltfTextureInfo {
   index: number; // index into doc.textures[]
@@ -159,7 +175,7 @@ interface GltfNode {
   mesh?: number;
   skin?: number;
   children?: number[];
-  /** TRS — polycss reads either matrix or these three components. */
+  /** TRS — PolyCSS reads either matrix or these three components. */
   matrix?: number[];
   translation?: number[];
   rotation?: number[]; // quaternion (x, y, z, w)
@@ -205,7 +221,7 @@ interface GltfDoc {
   materials?: GltfMaterial[];
   accessors?: GltfAccessor[];
   bufferViews?: GltfBufferView[];
-  buffers?: { byteLength: number; uri?: string }[];
+  buffers?: GltfBuffer[];
   images?: GltfImage[];
   textures?: GltfTexture[];
   samplers?: GltfSampler[];
@@ -288,6 +304,7 @@ function resolveBuffers(
   resolveBuffer?: (uri: string) => Uint8Array | Promise<Uint8Array>,
 ): Uint8Array[] {
   const specs = doc.buffers ?? [];
+  const canSkipMeshoptFallbackBuffers = (doc.extensionsRequired ?? []).includes("EXT_meshopt_compression");
   return specs.map((buffer, index) => {
     const uri = buffer.uri;
     if (uri) {
@@ -300,6 +317,9 @@ function resolveBuffers(
       throw new Error(`parseGltf: external buffer URI "${uri}" — provide options.resolveBuffer`);
     }
     if (index === 0 && glbBin) return glbBin;
+    if (canSkipMeshoptFallbackBuffers && buffer.extensions?.EXT_meshopt_compression) {
+      return new Uint8Array(0);
+    }
     throw new Error(`parseGltf: buffer[${index}] has no uri and no GLB BIN chunk`);
   });
 }
@@ -328,6 +348,10 @@ function assertAccessorFits(acc: GltfAccessor, view: GltfBufferView, stride: num
   }
 }
 
+function resolveAccessorStride(view: GltfBufferView, packedBytes: number): number {
+  return view.byteStride !== undefined && view.byteStride > 0 ? view.byteStride : packedBytes;
+}
+
 type AccessorArray = Float32Array | Uint16Array | Uint32Array | Uint8Array | Int8Array | Int16Array;
 
 function typedArrayFromValues(componentType: number, values: number[], normalized: boolean | undefined): AccessorArray {
@@ -362,7 +386,7 @@ function readAccessor(doc: GltfDoc, buffers: Uint8Array[], accessorIdx: number):
   const offset = (view.byteOffset ?? 0) + (acc.byteOffset ?? 0);
   const elements = acc.count * componentCount;
   const packedBytes = bytesPerComponent * componentCount;
-  const stride = view.byteStride ?? packedBytes;
+  const stride = resolveAccessorStride(view, packedBytes);
   assertAccessorFits(acc, view, stride, packedBytes);
 
   if (stride === packedBytes) {
@@ -449,7 +473,7 @@ function readAccessorComponents(doc: GltfDoc, buffers: Uint8Array[], accessorIdx
   if (acc.bufferView !== undefined) {
     const { buffer, view } = resolveBufferView(doc, buffers, acc.bufferView);
     const start = buffer.byteOffset + (view.byteOffset ?? 0) + (acc.byteOffset ?? 0);
-    const stride = view.byteStride ?? packedBytes;
+    const stride = resolveAccessorStride(view, packedBytes);
     assertAccessorFits(acc, view, stride, packedBytes);
     const data = new DataView(buffer.buffer);
     let write = 0;
@@ -1353,6 +1377,29 @@ export function parseGltf(input: ArrayBuffer | Uint8Array, options?: GltfParseOp
     warnings.push(warning);
   }
 
+  function accessorUsesBufferViewExtension(accessorIdx: number | undefined, extensionName: string): boolean {
+    if (accessorIdx === undefined) return false;
+    const acc = doc.accessors?.[accessorIdx];
+    if (!acc) return false;
+    const bufferViewHasExtension = (bufferViewIdx: number): boolean =>
+      doc.bufferViews?.[bufferViewIdx]?.extensions?.[extensionName] !== undefined;
+    if (acc.bufferView !== undefined && bufferViewHasExtension(acc.bufferView)) return true;
+    if (acc.sparse) {
+      if (bufferViewHasExtension(acc.sparse.indices.bufferView)) return true;
+      if (bufferViewHasExtension(acc.sparse.values.bufferView)) return true;
+    }
+    return false;
+  }
+
+  function primitiveUsesRequiredMeshopt(prim: GltfPrimitive): boolean {
+    if (!requiredExtensions.has("EXT_meshopt_compression")) return false;
+    if (prim.extensions?.EXT_meshopt_compression) return true;
+    if (accessorUsesBufferViewExtension(prim.indices, "EXT_meshopt_compression")) return true;
+    return Object.values(prim.attributes ?? {}).some((accessorIdx) =>
+      accessorUsesBufferViewExtension(accessorIdx, "EXT_meshopt_compression")
+    );
+  }
+
   interface RawTri {
     v0: Vec3;
     v1: Vec3;
@@ -1404,7 +1451,14 @@ export function parseGltf(input: ArrayBuffer | Uint8Array, options?: GltfParseOp
     if (!mesh) return;
     for (const prim of mesh.primitives) {
       const mode = prim.mode ?? 4;
-      if (mode !== 4 && mode !== 5 && mode !== 6) continue;
+      if (mode !== 4 && mode !== 5 && mode !== 6) {
+        const modeName = PRIMITIVE_MODE_NAMES[mode] ?? `mode ${mode}`;
+        pushWarningOnce(
+          `unsupported-mode:${mode}`,
+          `Skipped primitives with unsupported mode ${mode} (${modeName})`,
+        );
+        continue;
+      }
       if (prim.extensions?.KHR_draco_mesh_compression && requiredExtensions.has("KHR_draco_mesh_compression")) {
         pushWarningOnce(
           "KHR_draco_mesh_compression",
@@ -1412,6 +1466,13 @@ export function parseGltf(input: ArrayBuffer | Uint8Array, options?: GltfParseOp
         );
         continue;
       }
+      if (primitiveUsesRequiredMeshopt(prim)) {
+        pushWarningOnce(
+          "EXT_meshopt_compression",
+          "Skipped primitives with unsupported required extension EXT_meshopt_compression",
+        );
+        continue;
+      }
       if (prim.attributes.POSITION === undefined) {
         pushWarningOnce(
           `missing-position:${meshIdx}`,
diff --git a/packages/core/src/parser/parseObj.test.ts b/packages/core/src/parser/parseObj.test.ts
index 638c8411..305f7d63 100644
--- a/packages/core/src/parser/parseObj.test.ts
+++ b/packages/core/src/parser/parseObj.test.ts
@@ -209,6 +209,24 @@ describe("parseObj — face index formats (v, v/vt, v/vt/vn, v//vn)", () => {
     expect(r.polygons).toHaveLength(1);
     expect(r.polygons[0].uvs).toBeUndefined();
   });
+
+  it("negative vertex and texture indices resolve relative to the current OBJ lists", () => {
+    const obj = [
+      "v 0 0 0",
+      "v 1 0 0",
+      "v 0 1 0",
+      "vt 0 0",
+      "vt 1 0",
+      "vt 0 1",
+      "usemtl Tex",
+      "f -3/-3 -2/-2 -1/-1",
+    ].join("\n");
+    const r = parseObj(obj, { materialTextures: { Tex: "img.png" } });
+
+    expect(r.polygons).toHaveLength(1);
+    expect(r.polygons[0].texture).toBe("img.png");
+    expect(r.polygons[0].uvs).toEqual([[0, 0], [1, 0], [0, 1]]);
+  });
 });
 
 describe("parseObj — usemtl color resolution", () => {
diff --git a/packages/core/src/parser/parseObj.ts b/packages/core/src/parser/parseObj.ts
index c174959b..3e3fab6e 100644
--- a/packages/core/src/parser/parseObj.ts
+++ b/packages/core/src/parser/parseObj.ts
@@ -16,7 +16,7 @@
  *    `Plane` next to the actual model) that shouldn't render.
  *
  * The mesh is fit to `targetSize` units and remapped from OBJ's +Y-up
- * convention to polycss's +Z-up via the cyclic permutation (x,y,z) → (z,x,y),
+ * convention to PolyCSS's +Z-up via the cyclic permutation (x,y,z) → (z,x,y),
  * which preserves handedness so triangle winding stays consistent.
  *
  * Vertex coords are kept as floats; bbox is NOT computed per-polygon
@@ -115,6 +115,12 @@ export function parseObj(text: string, options?: ObjParseOptions): ParseResult {
     return materialColor.get(name)!;
   };
 
+  const resolveIndex = (rawIndex: string, length: number): number => {
+    const index = parseInt(rawIndex, 10);
+    if (!Number.isFinite(index)) return NaN;
+    return index < 0 ? length + index : index - 1;
+  };
+
   const lines = text.split("\n");
   for (const raw of lines) {
     if (raw.length === 0 || raw.charCodeAt(0) === 35) continue; // skip "" and "#"
@@ -137,10 +143,10 @@ export function parseObj(text: string, options?: ObjParseOptions): ParseResult {
       const uvIdx: (number | null)[] = [];
       for (const p of parts) {
         const slash = p.split("/");
-        idx.push(parseInt(slash[0], 10) - 1);
+        idx.push(resolveIndex(slash[0], verts.length));
         const vtRaw = slash[1];
         if (vtRaw && vtRaw.length > 0) {
-          const v = parseInt(vtRaw, 10) - 1;
+          const v = resolveIndex(vtRaw, uvs.length);
           uvIdx.push(Number.isFinite(v) ? v : null);
         } else {
           uvIdx.push(null);
@@ -173,7 +179,7 @@ export function parseObj(text: string, options?: ObjParseOptions): ParseResult {
   const scale = maxDim > 0 ? targetSize / maxDim : 1;
 
   // Cyclic axis permutation (x,y,z) → (z,x,y) puts OBJ's +Y up axis into
-  // polycss's +Z (elevation). Single axis swaps invert handedness; a cyclic
+  // PolyCSS's +Z (elevation). Single axis swaps invert handedness; a cyclic
   // shift doesn't, so triangle CCW-from-outside winding survives.
   const round = (n: number) => Math.round(n * 1000) / 1000;
   const grid: Vec3[] = verts.map(([x, y, z]) => [
diff --git a/packages/core/src/parser/parseVox.ts b/packages/core/src/parser/parseVox.ts
index 588acf74..a9b4efdf 100644
--- a/packages/core/src/parser/parseVox.ts
+++ b/packages/core/src/parser/parseVox.ts
@@ -14,10 +14,10 @@
  * Face culling: for each voxel, each of its 6 neighbours is checked. When a
  * neighbour cell is empty (or out of grid bounds) the shared face is visible
  * and emitted as a quad polygon.
- * Winding follows CCW-from-outside convention, consistent with polycss's
+ * Winding follows CCW-from-outside convention, consistent with PolyCSS's
  * backface culling.
  *
- * Coordinate system: MagicaVoxel is Z-up — same as polycss — so no axis
+ * Coordinate system: MagicaVoxel is Z-up — same as PolyCSS — so no axis
  * permutation is needed (unlike OBJ/glTF which are Y-up and need a cyclic
  * swap). Voxel coordinates are always non-negative (origin at 0), so no
  * shift is required by default.
diff --git a/packages/core/src/shadow/projection.ts b/packages/core/src/shadow/projection.ts
index 12296028..1da5a6ad 100644
--- a/packages/core/src/shadow/projection.ts
+++ b/packages/core/src/shadow/projection.ts
@@ -32,7 +32,7 @@ export const BAKED_SHADOW_MIN_UP = 0.01;
  * shadow leaf.
  *
  * `lightDir` is the direction the light TRAVELS (e.g. `[0, 0, -1]` is
- * straight down). Polycss world Z is up, and the world→CSS axis swap
+ * straight down). PolyCSS world Z is up, and the world→CSS axis swap
  * leaves Z alone — see styles.ts for the full convention.
  *
  * `groundCssZ` is the receiver plane in CSS-Z (= world-Z) coordinates,
diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
index e57b83fd..ff036809 100644
--- a/packages/core/src/types.ts
+++ b/packages/core/src/types.ts
@@ -29,7 +29,7 @@ export type MeshResolution = "lossless" | "lossy";
  * and the difference adds up. Destructure with `const [x, y, z] = v` when
  * you need named axes.
  *
- * Polycss world space convention: +X right, +Y forward, +Z up.
+ * PolyCSS world space convention: +X right, +Y forward, +Z up.
  */
 export type Vec3 = [number, number, number];
 
@@ -88,7 +88,7 @@ export interface PolyAmbientLight {
  *
  * In CSS terms, a material bundles the `background-image` source plus paint
  * config. When a polygon references a material AND its UVs form an
- * axis-aligned rectangle, polycss renders the polygon as an <i> with
+ * axis-aligned rectangle, PolyCSS renders the polygon as an <i> with
  * `background-image: url(material.texture)` directly — no per-polygon canvas
  * rasterization, browser-cached texture, mounting / unmounting one polygon
  * does not affect any other.
@@ -100,7 +100,7 @@ export interface PolyAmbientLight {
 export interface PolyMaterial {
   /** Image source. Anything `background-image: url(...)` can use. */
   texture: string;
-  /** Optional unique key (used by polycss to dedupe / cache). Caller can
+  /** Optional unique key (used by PolyCSS to dedupe / cache). Caller can
    *  pass a stable string; if omitted, the material's identity is its object
    *  reference. */
   key?: string;
@@ -143,7 +143,7 @@ export interface Polygon {
   /**
    * Shared material. When set, `material.texture` takes precedence over the
    * inline `texture` field. If the polygon's UVs form an axis-aligned
-   * rectangle, polycss uses the direct CSS background-image path (no per-
+   * rectangle, PolyCSS uses the direct CSS background-image path (no per-
    * polygon canvas rasterization). Falls back to the atlas path otherwise.
    */
   material?: PolyMaterial;
diff --git a/packages/polycss/README.md b/packages/polycss/README.md
index dfee357d..5d571c90 100644
--- a/packages/polycss/README.md
+++ b/packages/polycss/README.md
@@ -1,14 +1,14 @@
 <p align="center">
-  <img src="https://polycss.com/voxisologo.png" alt="polycss" width="300" />
+  <img src="https://polycss.com/voxisologo.png" alt="PolyCSS" width="300" />
 </p>
 
-# polycss
+# PolyCSS
 
 A CSS polygon mesh engine. A 3D renderer for the DOM. Renders OBJ, glTF, GLB, MagicaVoxel `.vox`, and generated primitives as real HTML elements transformed with CSS `matrix3d(...)`. Supports colors, textures, lighting, shadows, controls, selection, animation, and per-polygon interaction. Works with React, Vue, custom elements, or plain JavaScript.
 
 Visit [polycss.com](https://polycss.com) for docs and model examples.
 
-<img width="1915" height="900" alt="polycss scene" src="https://polycss.com/voxcss-intro.png" />
+<img width="1915" height="900" alt="PolyCSS scene" src="https://polycss.com/voxcss-intro.png" />
 
 ## Installation
 
@@ -23,7 +23,7 @@ npm install @layoutit/polycss-vue
 npm install @layoutit/polycss
 ```
 
-You can also load polycss directly from a CDN. Here is a minimal custom-element scene:
+You can also load PolyCSS directly from a CDN. Here is a minimal custom-element scene:
 
 ```html
 <script type="module" src="https://esm.sh/@layoutit/polycss/elements"></script>
@@ -171,7 +171,7 @@ Supported formats:
 
 ## Performance
 
-polycss renders in the DOM, so performance is mostly determined by how many polygons are mounted and how much texture atlas area they consume. The renderer uses several CSS strategies so simple surfaces stay cheap and textured or irregular surfaces fall back to atlas slices.
+PolyCSS renders in the DOM, so performance is mostly determined by how many polygons are mounted and how much texture atlas area they consume. The renderer uses several CSS strategies so simple surfaces stay cheap and textured or irregular surfaces fall back to atlas slices.
 
 - One visible polygon becomes one leaf DOM element.
 - Flat rectangles and stable quads use solid CSS leaves.
@@ -200,7 +200,7 @@ For diagnostics, all renderer packages export `collectPolyRenderStats(root)`, wh
 | `@layoutit/polycss-react` | React components, hooks, controls, and core re-exports. |
 | `@layoutit/polycss-vue` | Vue 3 components, composables, controls, and core re-exports. |
 
-## Made with polycss
+## Made with PolyCSS
 
 [Layoutit Voxels](https://voxels.layoutit.com)
 -> A CSS Voxel editor
diff --git a/packages/polycss/package.json b/packages/polycss/package.json
index 4f8f0c2d..0d1bf8c1 100644
--- a/packages/polycss/package.json
+++ b/packages/polycss/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@layoutit/polycss",
   "version": "0.2.0",
-  "description": "Polycss vanilla / custom-elements + imperative API. Renders OBJ / glTF / GLB mesh polygons as DOM via CSS matrix3d.",
+  "description": "PolyCSS vanilla / custom-elements + imperative API. Renders OBJ / glTF / GLB mesh polygons as DOM via CSS matrix3d.",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
diff --git a/packages/polycss/src/api/createPolyCamera.ts b/packages/polycss/src/api/createPolyCamera.ts
index 282704eb..c4b1c565 100644
--- a/packages/polycss/src/api/createPolyCamera.ts
+++ b/packages/polycss/src/api/createPolyCamera.ts
@@ -99,7 +99,7 @@ export function createPolyOrthographicCamera(
 
 /**
  * Ergonomic alias for `createPolyOrthographicCamera`. The default camera in
- * polycss is orthographic because the engine's structural advantages
+ * PolyCSS is orthographic because the engine's structural advantages
  * (integer-pixel atlas slicing, DOM-as-render-tree) are most visible in
  * iso/voxel/diagrammatic scenes. Use `createPolyPerspectiveCamera` explicitly
  * when depth foreshortening is needed.
diff --git a/packages/polycss/src/api/createPolyFirstPersonControls.ts b/packages/polycss/src/api/createPolyFirstPersonControls.ts
index c9d2f775..09ea958d 100644
--- a/packages/polycss/src/api/createPolyFirstPersonControls.ts
+++ b/packages/polycss/src/api/createPolyFirstPersonControls.ts
@@ -190,14 +190,14 @@ export function createPolyFirstPersonControls(
   // True first-person model (matches three.js PointerLockControls semantics):
   //   - `cameraOrigin` is the camera's WORLD position (the eye).
   //   - `target` is a DERIVED point ahead of the camera along its look
-  //     direction at offset `perspective / tile`, so polycss's perspective
+  //     direction at offset `perspective / tile`, so PolyCSS's perspective
   //     viewer (located at +CSS_Z from scene origin) mathematically coincides
   //     with `cameraOrigin` in world space.
   //   - Mouselook rotates `target` AROUND `cameraOrigin` (origin fixed) →
   //     in-place rotation, not orbit.
   //   - WASD moves `cameraOrigin` (target follows via the same offset).
   //
-  // Without this separation, polycss's rotation pivots around `target` itself,
+  // Without this separation, PolyCSS's rotation pivots around `target` itself,
   // which is camera position with distance=0 — that's orbit-style and reads
   // as "the camera circles a point in front of itself" when you mouselook.
   let cameraOrigin: [number, number, number] = [0, 0, opts.groundZ + opts.eyeHeight];
@@ -205,7 +205,7 @@ export function createPolyFirstPersonControls(
   function forwardDir(rotX: number, rotY: number): [number, number, number] {
     const rx = (rotX * Math.PI) / 180;
     const ry = (rotY * Math.PI) / 180;
-    // Derived from polycss's scene transform inverse: the world direction
+    // Derived from PolyCSS's scene transform inverse: the world direction
     // that maps to CSS -Z (into the screen) under `rotateX(rotX) rotate(rotY)`
     // + the axis swap (worldY→CSS X, worldX→CSS Y).
     return [
@@ -411,7 +411,7 @@ export function createPolyFirstPersonControls(
       }
 
       if (dirty) {
-        // Re-derive target from the new origin so polycss's perspective viewer
+        // Re-derive target from the new origin so PolyCSS's perspective viewer
         // tracks the camera. Without this, walking forward would move
         // `cameraOrigin` but target would stay put, and the visible center
         // would drift behind us.
diff --git a/packages/polycss/src/api/createPolyScene.ts b/packages/polycss/src/api/createPolyScene.ts
index 4deb79b1..7e7af732 100644
--- a/packages/polycss/src/api/createPolyScene.ts
+++ b/packages/polycss/src/api/createPolyScene.ts
@@ -1620,7 +1620,7 @@ export function createPolyScene(
       const w2 = worldCss(face.vertices[2]!, rpos);
       const e1: Vec3 = [w1[0] - O[0], w1[1] - O[1], w1[2] - O[2]];
       const e2: Vec3 = [w2[0] - O[0], w2[1] - O[1], w2[2] - O[2]];
-      // Normal = e2 × e1 (NOT e1 × e2). polycss uses an axis swap
+      // Normal = e2 × e1 (NOT e1 × e2). PolyCSS uses an axis swap
       // (world Y → CSS X) when emitting leaves, which flips
       // handedness. The atlas builder's outward face normal in CSS
       // coords is the LEFT-hand cross product (= -right-hand). For
@@ -2051,7 +2051,7 @@ export function createPolyScene(
 
   // Recomputes the shadow ground plane from the minimum world-Z across all
   // casting meshes. World Z stays as CSS Z under the world→CSS axis swap.
-  // In polycss's world convention Z is up — the red-green plane in the axes
+  // In PolyCSS's world convention Z is up — the red-green plane in the axes
   // helper is the floor. An optional `lift` (in world units) raises the
   // plane slightly above the bbox floor to prevent z-fighting with
   // receiver polygons.
diff --git a/packages/polycss/src/api/createSelect.ts b/packages/polycss/src/api/createSelect.ts
index 591d3a8b..dc3cbe85 100644
--- a/packages/polycss/src/api/createSelect.ts
+++ b/packages/polycss/src/api/createSelect.ts
@@ -1,5 +1,5 @@
 /**
- * createSelect — additive selection layer for vanilla polycss scenes.
+ * createSelect — additive selection layer for vanilla PolyCSS scenes.
  * Mirrors the React `<Select>` API: tracks one or more selected
  * meshes, fires `onChange` whenever the set changes, supports
  * single-click toggle (re-clicking the selected mesh deselects it),
diff --git a/packages/polycss/src/api/createTransformControls.ts b/packages/polycss/src/api/createTransformControls.ts
index ed5fc548..4176188c 100644
--- a/packages/polycss/src/api/createTransformControls.ts
+++ b/packages/polycss/src/api/createTransformControls.ts
@@ -62,7 +62,7 @@ const ALPHA_IDLE = 0.6;
 const ALPHA_HOVER = 0.8;
 const ALPHA_DRAGGING = 1.0;
 
-/** polycss world→CSS remap. Match TransformControls in @layoutit/polycss-react. */
+/** PolyCSS world→CSS remap. Match TransformControls in @layoutit/polycss-react. */
 const WORLD_AXIS_FOR_CSS: Record<0 | 1 | 2, 0 | 1 | 2> = { 0: 1, 1: 0, 2: 2 };
 
 /** Six arrow specs (translate mode). `cssAxis` is the visible direction
@@ -145,7 +145,7 @@ function snap(value: number, step: number | null | undefined): number {
 }
 
 /** Compute the bbox center of a mesh's polygons in scene-CSS pixels.
- *  polycss world→CSS axis remap: world-Y → CSS-x, world-X → CSS-y,
+ *  PolyCSS world→CSS axis remap: world-Y → CSS-x, world-X → CSS-y,
  *  world-Z → CSS-z. The result is the offset we add to the gizmo
  *  position so the gizmo overlays the visible center of the mesh. The
  *  mesh wrapper sets `transform-origin: var(--origin)` to the same bbox
diff --git a/packages/polycss/src/elements/PolyCameraElement.ts b/packages/polycss/src/elements/PolyCameraElement.ts
index cdd27c2d..11f03bfb 100644
--- a/packages/polycss/src/elements/PolyCameraElement.ts
+++ b/packages/polycss/src/elements/PolyCameraElement.ts
@@ -1,7 +1,7 @@
 /**
  * <poly-camera> — ergonomic alias for <poly-orthographic-camera>.
  *
- * The default camera in polycss is orthographic. `<poly-camera>` maps to
+ * The default camera in PolyCSS is orthographic. `<poly-camera>` maps to
  * `PolyOrthographicCameraElement` so the canonical tree shape works without
  * spelling out "orthographic" when it isn't relevant to the scene being built.
  *
diff --git a/packages/polycss/src/elements/index.ts b/packages/polycss/src/elements/index.ts
index e4989ba3..fd4a773b 100644
--- a/packages/polycss/src/elements/index.ts
+++ b/packages/polycss/src/elements/index.ts
@@ -1,5 +1,5 @@
 /**
- * @layoutit/polycss/elements — side-effect entry that registers the polycss custom
+ * @layoutit/polycss/elements — side-effect entry that registers the PolyCSS custom
  * elements with `customElements`.
  *
  * Importing this module has the effect of making the elements available
diff --git a/packages/polycss/src/elements/parseAttr.ts b/packages/polycss/src/elements/parseAttr.ts
index e19a5179..7ec2fc07 100644
--- a/packages/polycss/src/elements/parseAttr.ts
+++ b/packages/polycss/src/elements/parseAttr.ts
@@ -1,5 +1,5 @@
 /**
- * Shared attribute-parsing helpers for polycss custom elements.
+ * Shared attribute-parsing helpers for PolyCSS custom elements.
  * Used by PolyOrbitControlsElement, PolyMapControlsElement,
  * PolyPerspectiveCameraElement, and PolyOrthographicCameraElement.
  */
diff --git a/packages/polycss/src/index.ts b/packages/polycss/src/index.ts
index bd7195cf..d90e964f 100644
--- a/packages/polycss/src/index.ts
+++ b/packages/polycss/src/index.ts
@@ -1,5 +1,5 @@
 /**
- * polycss — vanilla / custom-elements / imperative entry point.
+ * PolyCSS — vanilla / custom-elements / imperative entry point.
  *
  * Public surface:
  *   - `createPolyScene(host, options)` — imperative scene API
diff --git a/packages/polycss/src/render/atlas/plan.ts b/packages/polycss/src/render/atlas/plan.ts
index 0074c698..8940b4ea 100644
--- a/packages/polycss/src/render/atlas/plan.ts
+++ b/packages/polycss/src/render/atlas/plan.ts
@@ -8,7 +8,7 @@ import {
 } from "@layoutit/polycss-core";
 
 /**
- * Polycss wrapper: extracts the `__polycssProjectiveQuadGuards` override bag
+ * PolyCSS wrapper: extracts the `__polycssProjectiveQuadGuards` override bag
  * from `doc.defaultView` and delegates to the pure-math core function.
  */
 export function resolveProjectiveQuadGuards(
diff --git a/packages/polycss/src/render/atlas/solidTrianglePlan.ts b/packages/polycss/src/render/atlas/solidTrianglePlan.ts
index 129ddcca..f10e61fa 100644
--- a/packages/polycss/src/render/atlas/solidTrianglePlan.ts
+++ b/packages/polycss/src/render/atlas/solidTrianglePlan.ts
@@ -11,7 +11,7 @@ import type { RenderTextureAtlasOptions } from "./types";
 import { resolveSolidTrianglePrimitive } from "./strategy";
 
 /**
- * Polycss wrapper for computeSolidTrianglePlan that pre-resolves the primitive
+ * PolyCSS wrapper for computeSolidTrianglePlan that pre-resolves the primitive
  * from options.doc before delegating to the pure core function.
  */
 export function computeSolidTrianglePlan(
@@ -33,7 +33,7 @@ export function computeSolidTrianglePlan(
 }
 
 /**
- * Polycss wrapper for computeSolidTrianglePlanFromCssPoints that pre-resolves
+ * PolyCSS wrapper for computeSolidTrianglePlanFromCssPoints that pre-resolves
  * the primitive from options.doc before delegating to the pure core function.
  */
 export function computeSolidTrianglePlanFromCssPoints(
diff --git a/packages/polycss/src/styles/styles.ts b/packages/polycss/src/styles/styles.ts
index 431e216f..ff38a4c5 100644
--- a/packages/polycss/src/styles/styles.ts
+++ b/packages/polycss/src/styles/styles.ts
@@ -268,7 +268,7 @@ const CORE_BASE_STYLES = `
 @property --clz { syntax: "<number>"; inherits: true; initial-value: 1; }
 
 /* Ground-plane position in CSS pixels along the CSS-Z axis (= world-Z, the
-   up axis in polycss's world convention). Stored as a <number> so it can be
+   up axis in PolyCSS's world convention). Stored as a <number> so it can be
    used directly inside matrix3d() calc() expressions (matrix3d requires
    dimensionless entries — no px units).
    Set by recomputeShadowGround() from the min world-Z of casting meshes. */
@@ -400,7 +400,7 @@ const CORE_BASE_STYLES = `
  * Shadow projection matrix. Projects any 3D point P onto the horizontal
  * ground plane (cssZ ≈ G) along the CSS-space light direction (--clx/y/z).
  *
- * In polycss's world convention world Z is up (red-green plane is the
+ * In PolyCSS's world convention world Z is up (red-green plane is the
  * floor in the axes helper). After the world→CSS swap (Y↔X), world Z stays
  * as CSS Z, so the ground plane normal in CSS space is +cssZ.
  *
diff --git a/packages/react/README.md b/packages/react/README.md
index dfee357d..5d571c90 100644
--- a/packages/react/README.md
+++ b/packages/react/README.md
@@ -1,14 +1,14 @@
 <p align="center">
-  <img src="https://polycss.com/voxisologo.png" alt="polycss" width="300" />
+  <img src="https://polycss.com/voxisologo.png" alt="PolyCSS" width="300" />
 </p>
 
-# polycss
+# PolyCSS
 
 A CSS polygon mesh engine. A 3D renderer for the DOM. Renders OBJ, glTF, GLB, MagicaVoxel `.vox`, and generated primitives as real HTML elements transformed with CSS `matrix3d(...)`. Supports colors, textures, lighting, shadows, controls, selection, animation, and per-polygon interaction. Works with React, Vue, custom elements, or plain JavaScript.
 
 Visit [polycss.com](https://polycss.com) for docs and model examples.
 
-<img width="1915" height="900" alt="polycss scene" src="https://polycss.com/voxcss-intro.png" />
+<img width="1915" height="900" alt="PolyCSS scene" src="https://polycss.com/voxcss-intro.png" />
 
 ## Installation
 
@@ -23,7 +23,7 @@ npm install @layoutit/polycss-vue
 npm install @layoutit/polycss
 ```
 
-You can also load polycss directly from a CDN. Here is a minimal custom-element scene:
+You can also load PolyCSS directly from a CDN. Here is a minimal custom-element scene:
 
 ```html
 <script type="module" src="https://esm.sh/@layoutit/polycss/elements"></script>
@@ -171,7 +171,7 @@ Supported formats:
 
 ## Performance
 
-polycss renders in the DOM, so performance is mostly determined by how many polygons are mounted and how much texture atlas area they consume. The renderer uses several CSS strategies so simple surfaces stay cheap and textured or irregular surfaces fall back to atlas slices.
+PolyCSS renders in the DOM, so performance is mostly determined by how many polygons are mounted and how much texture atlas area they consume. The renderer uses several CSS strategies so simple surfaces stay cheap and textured or irregular surfaces fall back to atlas slices.
 
 - One visible polygon becomes one leaf DOM element.
 - Flat rectangles and stable quads use solid CSS leaves.
@@ -200,7 +200,7 @@ For diagnostics, all renderer packages export `collectPolyRenderStats(root)`, wh
 | `@layoutit/polycss-react` | React components, hooks, controls, and core re-exports. |
 | `@layoutit/polycss-vue` | Vue 3 components, composables, controls, and core re-exports. |
 
-## Made with polycss
+## Made with PolyCSS
 
 [Layoutit Voxels](https://voxels.layoutit.com)
 -> A CSS Voxel editor
diff --git a/packages/react/src/camera/PolyCamera.tsx b/packages/react/src/camera/PolyCamera.tsx
index 7297c838..561dac42 100644
--- a/packages/react/src/camera/PolyCamera.tsx
+++ b/packages/react/src/camera/PolyCamera.tsx
@@ -1,7 +1,7 @@
 /**
  * PolyCamera — alias for PolyOrthographicCamera.
  *
- * The default camera in polycss is orthographic — the engine's structural
+ * The default camera in PolyCSS is orthographic — the engine's structural
  * advantages (integer-pixel atlas slicing, DOM-as-render-tree) are most
  * visible in iso/voxel/diagrammatic scenes. Use PolyPerspectiveCamera
  * explicitly when depth foreshortening is needed.
diff --git a/packages/react/src/controls/PolyFirstPersonControls.test.tsx b/packages/react/src/controls/PolyFirstPersonControls.test.tsx
index 95492076..22eb5e59 100644
--- a/packages/react/src/controls/PolyFirstPersonControls.test.tsx
+++ b/packages/react/src/controls/PolyFirstPersonControls.test.tsx
@@ -228,7 +228,7 @@ describe("PolyFirstPersonControls", () => {
   });
 
   // ── Origin/target identity ───────────────────────────────────────────────
-  // The cameraOrigin model exists so polycss's perspective viewer coincides
+  // The cameraOrigin model exists so PolyCSS's perspective viewer coincides
   // with `cameraOrigin` in world space. Invariant:
   //   target = origin + lookDir(rotX, rotY) * (perspective_css / BASE_TILE)
   // Mouselook must rotate target around the FIXED origin (in-place rotation,
diff --git a/packages/react/src/controls/TransformControls.tsx b/packages/react/src/controls/TransformControls.tsx
index de7ea71d..b1aa19e5 100644
--- a/packages/react/src/controls/TransformControls.tsx
+++ b/packages/react/src/controls/TransformControls.tsx
@@ -154,7 +154,7 @@ function gizmoLengthForMesh(polygons: Polygon[]): number {
 
 /**
  * Return the bbox center of `polygons` in scene-CSS pixels, mapped via the
- * standard polycss world→CSS axis remap (vertex[1]→CSS X, vertex[0]→CSS Y,
+ * standard PolyCSS world→CSS axis remap (vertex[1]→CSS X, vertex[0]→CSS Y,
  * vertex[2]→CSS Z).
  *
  * Used to offset the gizmo wrapper so it sits at the mesh's visual center
@@ -257,7 +257,7 @@ function snap(value: number, step: number | null | undefined): number {
  * user sees the arrow and the direction `<PolyMesh position>` deltas
  * apply along, since position is in scene-CSS pixels.
  *
- * polycss's world→CSS remap (core/src/scene/polygonGeometry.ts) sends
+ * PolyCSS's world→CSS remap (core/src/scene/polygonGeometry.ts) sends
  * world-Y → CSS-x and world-X → CSS-y, so to draw an arrow visually
  * along CSS-x we have to feed `arrowPolygons` axis=1 (world-Y), and
  * vice versa. `WORLD_AXIS_FOR_CSS` is that lookup — used only when
diff --git a/packages/react/src/scene/atlas/detection.test.ts b/packages/react/src/scene/atlas/detection.test.ts
index 8dd45a71..5647c1ba 100644
--- a/packages/react/src/scene/atlas/detection.test.ts
+++ b/packages/react/src/scene/atlas/detection.test.ts
@@ -5,7 +5,7 @@
  * borderShapeSupported / solidTriangleSupported / cornerShapeSupported helpers
  * that the wrappers delegate to.
  *
- * These match the semantics verified in polycss's strategySelection.test.ts
+ * These match the semantics verified in PolyCSS's strategySelection.test.ts
  * (detection sections). We import from the React-local copy so drift between
  * the three copies surfaces immediately.
  */
diff --git a/packages/react/src/scene/atlas/filterPlans.test.ts b/packages/react/src/scene/atlas/filterPlans.test.ts
index 991272df..4ba4d8cf 100644
--- a/packages/react/src/scene/atlas/filterPlans.test.ts
+++ b/packages/react/src/scene/atlas/filterPlans.test.ts
@@ -1,7 +1,7 @@
 /**
  * Feature tests: filterAtlasPlans wrapper (React atlasBrowser copy)
  *
- * Mirrors polycss's strategySelection.test.ts filter section.
+ * Mirrors PolyCSS's strategySelection.test.ts filter section.
  * Imports from the React-local copy so drift surfaces immediately.
  */
 import { describe, it, expect } from "vitest";
diff --git a/packages/react/src/scene/atlas/packing.test.ts b/packages/react/src/scene/atlas/packing.test.ts
index 134ce68c..3c7614c4 100644
--- a/packages/react/src/scene/atlas/packing.test.ts
+++ b/packages/react/src/scene/atlas/packing.test.ts
@@ -1,7 +1,7 @@
 /**
  * Feature tests: packTextureAtlasPlansWithScale wrapper (React atlasBrowser copy)
  *
- * Mirrors polycss's atlasPacking.test.ts.
+ * Mirrors PolyCSS's atlasPacking.test.ts.
  * Imports from the React-local copy so drift surfaces immediately.
  */
 import { describe, it, expect } from "vitest";
diff --git a/packages/react/src/scene/atlas/paintDefaults.test.ts b/packages/react/src/scene/atlas/paintDefaults.test.ts
index f0eef7e5..5d374583 100644
--- a/packages/react/src/scene/atlas/paintDefaults.test.ts
+++ b/packages/react/src/scene/atlas/paintDefaults.test.ts
@@ -1,7 +1,7 @@
 /**
  * Feature tests: getSolidPaintDefaultsFromPlans wrapper (React atlasBrowser copy)
  *
- * Mirrors polycss's solidPaintDefaults.test.ts.
+ * Mirrors PolyCSS's solidPaintDefaults.test.ts.
  * Imports from the React-local copy so drift surfaces immediately.
  */
 import { describe, it, expect } from "vitest";
diff --git a/packages/react/src/scene/events.ts b/packages/react/src/scene/events.ts
index ca65ab51..3e1f0553 100644
--- a/packages/react/src/scene/events.ts
+++ b/packages/react/src/scene/events.ts
@@ -1,7 +1,7 @@
 /**
  * Pointer event API for <PolyMesh>. Mirrors @react-three/fiber's mesh
  * event surface (handler names + payload shape) so devs migrating from
- * three.js use the same mental model. polycss is DOM-native so we get
+ * three.js use the same mental model. PolyCSS is DOM-native so we get
  * native pointer events for free — no raycaster, no canvas event
  * synthesis.
  *
diff --git a/packages/react/src/scene/useSceneContext.ts b/packages/react/src/scene/useSceneContext.ts
index af19aee8..d72a8ffb 100644
--- a/packages/react/src/scene/useSceneContext.ts
+++ b/packages/react/src/scene/useSceneContext.ts
@@ -16,7 +16,7 @@ export interface UseSceneContextResult {
 }
 
 /**
- * React hook that runs the polycss scene-context pipeline:
+ * React hook that runs the PolyCSS scene-context pipeline:
  *   normalizePolygons → mergePolygons by default → bbox compute.
  *
  * Returns the processed polygons + the scene-wide axis-aligned bbox. Memoized
diff --git a/packages/react/src/store/sceneStore.ts b/packages/react/src/store/sceneStore.ts
index 71a23048..9f5706b7 100644
--- a/packages/react/src/store/sceneStore.ts
+++ b/packages/react/src/store/sceneStore.ts
@@ -1,5 +1,5 @@
 /**
- * Lightweight reactive store for polycss scene state.
+ * Lightweight reactive store for PolyCSS scene state.
  * Uses useSyncExternalStore under the hood — zero dependencies.
  * Components subscribe to specific slices via selectors,
  * so only the components that care about a changed value re-render.
diff --git a/packages/react/src/styles/styles.ts b/packages/react/src/styles/styles.ts
index 479915c4..564fb441 100644
--- a/packages/react/src/styles/styles.ts
+++ b/packages/react/src/styles/styles.ts
@@ -242,7 +242,7 @@ const CORE_BASE_STYLES = `
 @property --clz { syntax: "<number>"; inherits: true; initial-value: 1; }
 
 /* Ground-plane position in CSS pixels along the CSS-Z axis (= world-Z, the
-   up axis in polycss's world convention). Stored as a <number> so it can be
+   up axis in PolyCSS's world convention). Stored as a <number> so it can be
    used directly inside matrix3d() calc() expressions (matrix3d requires
    dimensionless entries — no px units).
    Set by PolyScene from the min world-Z of casting meshes. */
@@ -360,7 +360,7 @@ const CORE_BASE_STYLES = `
  * Shadow projection matrix. Projects any 3D point P onto the horizontal
  * ground plane (cssZ ≈ G) along the CSS-space light direction (--clx/y/z).
  *
- * In polycss's world convention world Z is up (red-green plane is the
+ * In PolyCSS's world convention world Z is up (red-green plane is the
  * floor in the axes helper). After the world→CSS swap (Y↔X), world Z stays
  * as CSS Z, so the ground plane normal in CSS space is +cssZ.
  *
diff --git a/packages/vue/README.md b/packages/vue/README.md
index dfee357d..5d571c90 100644
--- a/packages/vue/README.md
+++ b/packages/vue/README.md
@@ -1,14 +1,14 @@
 <p align="center">
-  <img src="https://polycss.com/voxisologo.png" alt="polycss" width="300" />
+  <img src="https://polycss.com/voxisologo.png" alt="PolyCSS" width="300" />
 </p>
 
-# polycss
+# PolyCSS
 
 A CSS polygon mesh engine. A 3D renderer for the DOM. Renders OBJ, glTF, GLB, MagicaVoxel `.vox`, and generated primitives as real HTML elements transformed with CSS `matrix3d(...)`. Supports colors, textures, lighting, shadows, controls, selection, animation, and per-polygon interaction. Works with React, Vue, custom elements, or plain JavaScript.
 
 Visit [polycss.com](https://polycss.com) for docs and model examples.
 
-<img width="1915" height="900" alt="polycss scene" src="https://polycss.com/voxcss-intro.png" />
+<img width="1915" height="900" alt="PolyCSS scene" src="https://polycss.com/voxcss-intro.png" />
 
 ## Installation
 
@@ -23,7 +23,7 @@ npm install @layoutit/polycss-vue
 npm install @layoutit/polycss
 ```
 
-You can also load polycss directly from a CDN. Here is a minimal custom-element scene:
+You can also load PolyCSS directly from a CDN. Here is a minimal custom-element scene:
 
 ```html
 <script type="module" src="https://esm.sh/@layoutit/polycss/elements"></script>
@@ -171,7 +171,7 @@ Supported formats:
 
 ## Performance
 
-polycss renders in the DOM, so performance is mostly determined by how many polygons are mounted and how much texture atlas area they consume. The renderer uses several CSS strategies so simple surfaces stay cheap and textured or irregular surfaces fall back to atlas slices.
+PolyCSS renders in the DOM, so performance is mostly determined by how many polygons are mounted and how much texture atlas area they consume. The renderer uses several CSS strategies so simple surfaces stay cheap and textured or irregular surfaces fall back to atlas slices.
 
 - One visible polygon becomes one leaf DOM element.
 - Flat rectangles and stable quads use solid CSS leaves.
@@ -200,7 +200,7 @@ For diagnostics, all renderer packages export `collectPolyRenderStats(root)`, wh
 | `@layoutit/polycss-react` | React components, hooks, controls, and core re-exports. |
 | `@layoutit/polycss-vue` | Vue 3 components, composables, controls, and core re-exports. |
 
-## Made with polycss
+## Made with PolyCSS
 
 [Layoutit Voxels](https://voxels.layoutit.com)
 -> A CSS Voxel editor
diff --git a/packages/vue/src/camera/PolyCamera.ts b/packages/vue/src/camera/PolyCamera.ts
index 7297c838..561dac42 100644
--- a/packages/vue/src/camera/PolyCamera.ts
+++ b/packages/vue/src/camera/PolyCamera.ts
@@ -1,7 +1,7 @@
 /**
  * PolyCamera — alias for PolyOrthographicCamera.
  *
- * The default camera in polycss is orthographic — the engine's structural
+ * The default camera in PolyCSS is orthographic — the engine's structural
  * advantages (integer-pixel atlas slicing, DOM-as-render-tree) are most
  * visible in iso/voxel/diagrammatic scenes. Use PolyPerspectiveCamera
  * explicitly when depth foreshortening is needed.
diff --git a/packages/vue/src/controls/PolyFirstPersonControls.test.ts b/packages/vue/src/controls/PolyFirstPersonControls.test.ts
index f8dbb651..95429b76 100644
--- a/packages/vue/src/controls/PolyFirstPersonControls.test.ts
+++ b/packages/vue/src/controls/PolyFirstPersonControls.test.ts
@@ -379,7 +379,7 @@ describe("PolyFirstPersonControls (Vue)", () => {
   });
 
   // ── Origin/target identity ───────────────────────────────────────────────
-  // The cameraOrigin model exists so polycss's perspective viewer coincides
+  // The cameraOrigin model exists so PolyCSS's perspective viewer coincides
   // with `cameraOrigin` in world space. Invariant:
   //   target = origin + lookDir(rotX, rotY) * (perspective_css / BASE_TILE)
   // Mouselook must rotate target around the FIXED origin. These pin both
diff --git a/packages/vue/src/scene/events.ts b/packages/vue/src/scene/events.ts
index c85b0312..2bf6087a 100644
--- a/packages/vue/src/scene/events.ts
+++ b/packages/vue/src/scene/events.ts
@@ -1,7 +1,7 @@
 /**
  * Pointer event API for `<PolyMesh>` (Vue). Mirrors @react-three/fiber's
  * mesh event surface (handler names + payload shape) so devs migrating
- * from three.js use the same mental model. polycss is DOM-native so
+ * from three.js use the same mental model. PolyCSS is DOM-native so
  * we get native pointer events for free — no raycaster, no canvas
  * event synthesis.
  *
diff --git a/packages/vue/src/scene/useSceneContext.ts b/packages/vue/src/scene/useSceneContext.ts
index 30344434..f802b42a 100644
--- a/packages/vue/src/scene/useSceneContext.ts
+++ b/packages/vue/src/scene/useSceneContext.ts
@@ -13,7 +13,7 @@ export interface UseSceneContextResult {
 }
 
 /**
- * Vue 3 composable that runs the polycss scene-context pipeline:
+ * Vue 3 composable that runs the PolyCSS scene-context pipeline:
  *   normalizePolygons → mergePolygons by default → bbox compute.
  *
  * Returns a Ref to the processed polygons + the scene-wide axis-aligned bbox.
diff --git a/packages/vue/src/store/sceneStore.ts b/packages/vue/src/store/sceneStore.ts
index afceddb8..8a6256cd 100644
--- a/packages/vue/src/store/sceneStore.ts
+++ b/packages/vue/src/store/sceneStore.ts
@@ -1,5 +1,5 @@
 /**
- * Lightweight reactive store for polycss scene state.
+ * Lightweight reactive store for PolyCSS scene state.
  * Components subscribe to specific slices via selectors,
  * so only the components that care about a changed value re-render.
  */
diff --git a/packages/vue/src/styles/styles.ts b/packages/vue/src/styles/styles.ts
index 278adb84..3f87c2e5 100644
--- a/packages/vue/src/styles/styles.ts
+++ b/packages/vue/src/styles/styles.ts
@@ -193,7 +193,7 @@ const CORE_BASE_STYLES = `
 @property --clz { syntax: "<number>"; inherits: true; initial-value: 1; }
 
 /* Ground-plane position in CSS pixels along the CSS-Z axis (= world-Z, the
-   up axis in polycss's world convention). Stored as a <number> so it can be
+   up axis in PolyCSS's world convention). Stored as a <number> so it can be
    used directly inside matrix3d() calc() expressions (matrix3d requires
    dimensionless entries — no px units).
    Set from the min world-Z of casting meshes. */
diff --git a/website/astro.config.mjs b/website/astro.config.mjs
index 824bf417..ad2a46db 100644
--- a/website/astro.config.mjs
+++ b/website/astro.config.mjs
@@ -42,7 +42,7 @@ export default defineConfig({
     react(),
     sitemap(),
     starlight({
-      title: 'Polycss',
+      title: 'PolyCSS',
       description: 'A CSS polygon mesh engine. DOM-native 3D rendering.',
       disable404Route: true,
       components: {
diff --git a/website/package.json b/website/package.json
index 59cca315..9e71a48e 100644
--- a/website/package.json
+++ b/website/package.json
@@ -3,7 +3,7 @@
   "type": "module",
   "version": "0.2.0",
   "private": true,
-  "description": "Polycss documentation and landing page.",
+  "description": "PolyCSS documentation and landing page.",
   "license": "MIT",
   "scripts": {
     "dev": "astro dev",
diff --git a/website/scripts/generate-llms-txt.mjs b/website/scripts/generate-llms-txt.mjs
index 719fcf89..f7294317 100644
--- a/website/scripts/generate-llms-txt.mjs
+++ b/website/scripts/generate-llms-txt.mjs
@@ -56,7 +56,7 @@ for (const file of files) {
 }
 
 const indexLines = [
-  '# Polycss',
+  '# PolyCSS',
   '',
   '> A CSS polygon mesh engine. DOM-native 3D rendering. MIT licensed.',
   '',
@@ -79,7 +79,7 @@ indexLines.push('', '## Source', '', '- GitHub: https://github.com/LayoutitStudi
 writeFileSync(join(DIST_DIR, 'llms.txt'), indexLines.join('\n'));
 
 const fullLines = [
-  '# Polycss -- Full Documentation',
+  '# PolyCSS -- Full Documentation',
   '',
   '> A CSS polygon mesh engine. DOM-native 3D rendering.',
   '',
diff --git a/website/src/components/BuilderWorkbench/builder-workbench.css b/website/src/components/BuilderWorkbench/builder-workbench.css
index 646186c2..0315f668 100644
--- a/website/src/components/BuilderWorkbench/builder-workbench.css
+++ b/website/src/components/BuilderWorkbench/builder-workbench.css
@@ -479,7 +479,7 @@
   display: none !important;
 }
 
-/* Force both faces of every wireframe edge to render. polycss applies
+/* Force both faces of every wireframe edge to render. PolyCSS applies
    `backface-visibility: hidden` to polygon leaves via a rule
    `.polycss-scene b/i/s/u {...}` that gets injected at runtime AFTER
    this stylesheet loads, so equal-specificity overrides lose. The
diff --git a/website/src/components/BuilderWorkbench/geometry/ghost.ts b/website/src/components/BuilderWorkbench/geometry/ghost.ts
index 2cc10c87..02989058 100644
--- a/website/src/components/BuilderWorkbench/geometry/ghost.ts
+++ b/website/src/components/BuilderWorkbench/geometry/ghost.ts
@@ -11,7 +11,7 @@
  * Earlier attempts passed polygons in model-local coords and let
  * PolyMesh's `scale` + `position` transform place them. That kept
  * collapsing the box to the floor — most likely because the scale+
- * position-around-bbox-center wrapping interacts with polycss's
+ * position-around-bbox-center wrapping interacts with PolyCSS's
  * basis chooser in a way I can't easily debug. Direct world coords
  * sidestep all of that.
  */
@@ -65,7 +65,7 @@ export interface WireframeStyle {
 
 /** Build the 6 axis-aligned face quads of an arbitrary cuboid using
  *  axisBox's vertex labelling + CCW-from-outside winding. Each face's
- *  surface normal points OUTWARD so polycss's basis chooser keeps the
+ *  surface normal points OUTWARD so PolyCSS's basis chooser keeps the
  *  matrix3d determinant positive (negative determinants flatten). */
 function cuboidFaces(
   x0: number, x1: number,
@@ -259,7 +259,7 @@ export function rotatePolygonsAroundPivot(
  * mirrors `axisBox` in core/helpers/axesPolygons.ts — the same helper
  * `<PolyAxesHelper>` uses to render its thin cuboids in 3D. Each face's
  * winding is CCW from the OUTWARD-facing side so the surface normal
- * points outward and polycss's basis chooser keeps the matrix3d
+ * points outward and PolyCSS's basis chooser keeps the matrix3d
  * determinant positive (negative determinants get treated as
  * back-facing and silently flatten).
  *
diff --git a/website/src/components/BuilderWorkbench/geometry/screenToWorld.ts b/website/src/components/BuilderWorkbench/geometry/screenToWorld.ts
index 8ec5cc02..520dec80 100644
--- a/website/src/components/BuilderWorkbench/geometry/screenToWorld.ts
+++ b/website/src/components/BuilderWorkbench/geometry/screenToWorld.ts
@@ -27,7 +27,7 @@
  *      M^-1 = translate(+cssTarget) * rotate(-rotY) * rotateX(-rotX) * scale(1/zoom)
  *      Apply to eye and a far point (t=2) on the ray.
  *   4. In scene-local space, CSS-Z = planeWorldZ * BASE_TILE (because the
- *      polycss axis swap maps worldZ to cssZ). Parameterise the scene-local
+ *      PolyCSS axis swap maps worldZ to cssZ). Parameterise the scene-local
  *      ray and solve for the t that gives that cssZ.
  *   5. Read cssX, cssY at that t. Convert back:
  *        worldX = cssY / BASE_TILE
@@ -179,7 +179,7 @@ export function projectScreenToWorldGround({
   const hitCssX = rayOriginScene[0] + t * (rayFarScene[0] - rayOriginScene[0]);
   const hitCssY = rayOriginScene[1] + t * (rayFarScene[1] - rayOriginScene[1]);
 
-  // polycss axis swap: cssX = worldY * tile, cssY = worldX * tile.
+  // PolyCSS axis swap: cssX = worldY * tile, cssY = worldX * tile.
   const worldX = hitCssY / BASE_TILE;
   const worldY = hitCssX / BASE_TILE;
 
diff --git a/website/src/components/BuilderWorkbench/geometry/terrain.ts b/website/src/components/BuilderWorkbench/geometry/terrain.ts
index 4b2a60df..d13cf098 100644
--- a/website/src/components/BuilderWorkbench/geometry/terrain.ts
+++ b/website/src/components/BuilderWorkbench/geometry/terrain.ts
@@ -90,7 +90,7 @@ export function buildTerrainPolygons(opts: TerrainRenderOptions): Polygon[] {
     const p11: [number, number, number] = [x1, y1, z11];
     const p01: [number, number, number] = [x0, y1, z01];
     // Split each cell into 2 triangles along the (p00 → p11) diagonal.
-    // A non-planar quad would be auto-snapped by polycss (see CLAUDE.md
+    // A non-planar quad would be auto-snapped by PolyCSS (see AGENTS.md
     // "Coplanarity is a hard requirement at render time…") which opens
     // visible seams with neighbouring cells; triangles are inherently
     // planar so the warped surface stays gap-free. CCW from +Z on both
diff --git a/website/src/components/BuilderWorkbench/hooks/usePlacementMode.ts b/website/src/components/BuilderWorkbench/hooks/usePlacementMode.ts
index a3ede4ea..47c97b05 100644
--- a/website/src/components/BuilderWorkbench/hooks/usePlacementMode.ts
+++ b/website/src/components/BuilderWorkbench/hooks/usePlacementMode.ts
@@ -173,7 +173,7 @@ export function usePlacementMode({
   // We attach to `.dn-viewport` (the wrapper element around <PolyScene>) so
   // events outside the viewport (over the sidebar, dock, etc.) are not
   // captured — only pointer activity over the 3D area drives placement.
-  // A transparent PolyMesh catcher used to handle this, but polycss's color
+  // A transparent PolyMesh catcher used to handle this, but PolyCSS's color
   // pipeline doesn't render "transparent" colors as truly invisible (they
   // came out opaque white), so we now drive placement entirely from DOM
   // events without a catcher mesh.
diff --git a/website/src/components/DocsHeader.astro b/website/src/components/DocsHeader.astro
index dfb231a5..a2d067ac 100644
--- a/website/src/components/DocsHeader.astro
+++ b/website/src/components/DocsHeader.astro
@@ -62,7 +62,7 @@ const topLinks = [
       href="https://github.com/LayoutitStudio/polycss"
       target="_blank"
       rel="noopener noreferrer"
-      aria-label="View polycss on GitHub"
+      aria-label="View PolyCSS on GitHub"
     >
       <span class="github-social__main">
         <svg class="github-social__icon" viewBox="0 0 16 16" aria-hidden="true" focusable="false">
diff --git a/website/src/components/GalleryWorkbench/GalleryWorkbench.tsx b/website/src/components/GalleryWorkbench/GalleryWorkbench.tsx
index c870ccbf..da3ed187 100644
--- a/website/src/components/GalleryWorkbench/GalleryWorkbench.tsx
+++ b/website/src/components/GalleryWorkbench/GalleryWorkbench.tsx
@@ -573,7 +573,7 @@ export default function GalleryWorkbench() {
   // Hover state for the mesh — wired the r3f / three.js way via
   // onPointerOver / onPointerOut on <PolyMesh>. Demonstrates the
   // mesh-event API (events.ts → InteractionProps) — same shape as
-  // r3f, no raycasting needed because polycss uses DOM events.
+  // r3f, no raycasting needed because PolyCSS uses DOM events.
   const [hoveredMeshId, setHoveredMeshId] = useState<string | null>(null);
   // Mesh handle for the currently rendered model (vanilla path only). The
   // Inspector folder uses this to push color-group edits back into the
diff --git a/website/src/components/GalleryWorkbench/presets/attributions.ts b/website/src/components/GalleryWorkbench/presets/attributions.ts
index 312dc183..0a194521 100644
--- a/website/src/components/GalleryWorkbench/presets/attributions.ts
+++ b/website/src/components/GalleryWorkbench/presets/attributions.ts
@@ -107,11 +107,11 @@ export const POLY_PIZZA_SAXOPHONE_ATTRIBUTION: ModelAttribution = {
 };
 
 export const POLYCSS_GENERATED_PRIMITIVE_ATTRIBUTION: ModelAttribution = {
-  creator: "Generated by polycss",
+  creator: "Generated by PolyCSS",
 };
 
 export const POLYCSS_LOCAL_FIXTURE_ATTRIBUTION: ModelAttribution = {
-  creator: "Local polycss fixture",
+  creator: "Local PolyCSS fixture",
 };
 
 export const QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION: ModelAttribution = {
diff --git a/website/src/components/PolyDemo.astro b/website/src/components/PolyDemo.astro
index 811c50b9..2b249ea7 100644
--- a/website/src/components/PolyDemo.astro
+++ b/website/src/components/PolyDemo.astro
@@ -215,7 +215,7 @@ const { id, model, mtl, generator, generatorParams, controls, defaults, showStat
     // Fibonacci triple (s, a, b) ≈ φ ratios. Same vertex layout as
     // /debug/platonicShapes; emitted as 12 native pentagons (NOT
     // fan-triangulated) so each face is a single atlas-backed polygon. Shows off
-    // polycss's N-vertex polygon support — voxcss couldn't do this.
+    // PolyCSS's N-vertex polygon support — voxcss couldn't do this.
     const s = size;
     const a = Math.round(size * 8 / 13);
     const b = Math.round(size * 21 / 13);
diff --git a/website/src/components/VanillaScene/VanillaScene.tsx b/website/src/components/VanillaScene/VanillaScene.tsx
index a85776b3..3d6c02e2 100644
--- a/website/src/components/VanillaScene/VanillaScene.tsx
+++ b/website/src/components/VanillaScene/VanillaScene.tsx
@@ -862,7 +862,7 @@ export function VanillaScene({
   ]);
 
   // Effect 3.5 — ground receiver. A flat quad in the XY plane (Z is "up"
-  // in polycss's world convention — the red-green plane in the axes helper
+  // in PolyCSS's world convention — the red-green plane in the axes helper
   // is the floor) at the model's min-Z, sized to ~3× the model's horizontal
   // span. Gives shadows something to land on. excludeFromAutoCenter so
   // toggling it doesn't shift the camera pivot; castShadow:false because
diff --git a/website/src/content/docs/api/headless.mdx b/website/src/content/docs/api/headless.mdx
index 83ac14a9..71779d3e 100644
--- a/website/src/content/docs/api/headless.mdx
+++ b/website/src/content/docs/api/headless.mdx
@@ -3,7 +3,7 @@ title: Headless API
 description: Vanilla JavaScript API for loading meshes and rendering polygon scenes without a framework.
 ---
 
-The headless API (`@layoutit/polycss-core`) gives you direct access to polycss parsers and utilities without React, Vue, or any framework. All exports are also available from `@layoutit/polycss` (the vanilla package) so vanilla users install just one package.
+The headless API (`@layoutit/polycss-core`) gives you direct access to PolyCSS parsers and utilities without React, Vue, or any framework. All exports are also available from `@layoutit/polycss` (the vanilla package) so vanilla users install just one package.
 
 ## `parseObj(text, options?)`
 
@@ -304,7 +304,7 @@ transform.detach();
 
 ## `collectPolyRenderStats(root, options?)`
 
-Reads an already-rendered polycss DOM subtree and returns a one-shot diagnostic snapshot. It counts mounted polygon leaves, shadow leaves, surface leaf categories, and bucket wrappers; it does not observe changes or mutate the scene.
+Reads an already-rendered PolyCSS DOM subtree and returns a one-shot diagnostic snapshot. It counts mounted polygon leaves, shadow leaves, surface leaf categories, and bucket wrappers; it does not observe changes or mutate the scene.
 
 ```ts
 import { collectPolyRenderStats } from "@layoutit/polycss";
@@ -337,7 +337,7 @@ Register the custom elements by importing the side-effect entry point:
 </poly-camera>
 ```
 
-See the [polycss README](https://github.com/LayoutitStudio/polycss/tree/main/packages/polycss) for the full custom element attribute reference.
+See the [PolyCSS README](https://github.com/LayoutitStudio/polycss/tree/main/packages/polycss) for the full custom element attribute reference.
 
 Registered element families include:
 
@@ -356,5 +356,5 @@ Registered element families include:
 | `@layoutit/polycss-react` | React components, hooks, controls, selection, animation, core re-exports, render diagnostics |
 | `@layoutit/polycss-vue` | Vue components, composables, controls, selection, animation, core re-exports, render diagnostics |
 | `@layoutit/polycss` | Vanilla imperative API + custom element classes + controls + selection + render diagnostics |
-| `@layoutit/polycss/elements` | Side-effect: registers the polycss custom elements |
+| `@layoutit/polycss/elements` | Side-effect: registers the PolyCSS custom elements |
 | `@layoutit/polycss-core` | Pure parsers / math, zero DOM: `parseObj`, `parseGltf`, `parseVox`, `loadMesh`, types |
diff --git a/website/src/content/docs/api/types.mdx b/website/src/content/docs/api/types.mdx
index 1093927c..882fffee 100644
--- a/website/src/content/docs/api/types.mdx
+++ b/website/src/content/docs/api/types.mdx
@@ -123,7 +123,7 @@ interface PolyRenderStats {
   shadowLeafCount: number;
   /** Surface leaf categories used by the renderer. */
   surfaceLeafCounts: PolyRenderSurfaceLeafCounts;
-  /** Number of polycss bucket wrapper nodes under the measured scope. */
+  /** Number of PolyCSS bucket wrapper nodes under the measured scope. */
   bucketCount: number;
 }
 ```
diff --git a/website/src/content/docs/components/poly-camera.mdx b/website/src/content/docs/components/poly-camera.mdx
index 5d87de5c..248b827a 100644
--- a/website/src/content/docs/components/poly-camera.mdx
+++ b/website/src/content/docs/components/poly-camera.mdx
@@ -5,7 +5,7 @@ description: "Camera components for controlling the 3D viewport: perspective, or
 
 import { Tabs, TabItem } from '@astrojs/starlight/components';
 
-polycss provides two camera components: `<PolyCamera>` (alias `<PolyOrthographicCamera>`) for parallel projection, and `<PolyPerspectiveCamera>` for scenes with depth foreshortening. The camera element is always the **outer** node — `<poly-scene>` / `PolyScene` is nested inside it. This is required by the CSS rendering model: CSS `perspective` only applies to descendants, so the scene's `transform: matrix3d(...)` must be a child of the camera.
+PolyCSS provides two camera components: `<PolyCamera>` (alias `<PolyOrthographicCamera>`) for parallel projection, and `<PolyPerspectiveCamera>` for scenes with depth foreshortening. The camera element is always the **outer** node — `<poly-scene>` / `PolyScene` is nested inside it. This is required by the CSS rendering model: CSS `perspective` only applies to descendants, so the scene's `transform: matrix3d(...)` must be a child of the camera.
 
 `<PolyCamera>` is orthographic by default. Use `<PolyPerspectiveCamera>` when depth foreshortening is needed (e.g. first-person or game-like scenes).
 
@@ -18,7 +18,7 @@ For pointer drag, wheel zoom, and autorotate, drop a `<PolyOrbitControls>` child
 | Isometric / voxel / diagrammatic scenes | `<PolyCamera>` (alias `<PolyOrthographicCamera>`) — **default** |
 | 3D scenes with depth foreshortening | `<PolyPerspectiveCamera>` |
 
-polycss defaults to orthographic rather than perspective — polycss's strengths (integer-pixel atlas, no per-frame JS, DOM stacking) are most visible in ortho scenes. This deliberately diverges from three.js's default.
+PolyCSS defaults to orthographic rather than perspective — PolyCSS's strengths (integer-pixel atlas, no per-frame JS, DOM stacking) are most visible in ortho scenes. This deliberately diverges from three.js's default.
 
 ## `PolyCamera` / `PolyOrthographicCamera`
 
diff --git a/website/src/content/docs/components/poly-controls.mdx b/website/src/content/docs/components/poly-controls.mdx
index 9588ac4f..ea73d641 100644
--- a/website/src/content/docs/components/poly-controls.mdx
+++ b/website/src/content/docs/components/poly-controls.mdx
@@ -5,7 +5,7 @@ description: "Camera and object controls: orbit, map, first-person, and transfor
 
 import { Tabs, TabItem } from '@astrojs/starlight/components';
 
-polycss ships additive controls that follow the three.js split:
+PolyCSS ships additive controls that follow the three.js split:
 
 - **`PolyOrbitControls`**: orbit-style drag (pointer drag rotates around the scene center) + wheel zoom + autorotate. This is the default pick for most scenes.
 - **`PolyMapControls`**: map/pan-style drag (pointer drag pans the camera across the surface). Use for top-down or flat layouts.
@@ -276,7 +276,7 @@ Imperative handles expose `lock()`, `unlock()`, `isLocked()`, `getOrigin()`, `se
 
 ## Transform Controls
 
-`PolyTransformControls` attaches to a `PolyMeshHandle` and renders a polycss gizmo. Translate mode provides axis arrows and plane handles; rotate mode provides axis rings. Dragging updates the attached mesh directly and emits transform-change callbacks.
+`PolyTransformControls` attaches to a `PolyMeshHandle` and renders a PolyCSS gizmo. Translate mode provides axis arrows and plane handles; rotate mode provides axis rings. Dragging updates the attached mesh directly and emits transform-change callbacks.
 
 ```tsx
 import { useState } from "react";
diff --git a/website/src/content/docs/components/poly-scene.mdx b/website/src/content/docs/components/poly-scene.mdx
index bb16ec31..2998738d 100644
--- a/website/src/content/docs/components/poly-scene.mdx
+++ b/website/src/content/docs/components/poly-scene.mdx
@@ -5,7 +5,7 @@ description: Scene component that sets up the 3D viewport, camera, and lighting
 
 import { Tabs, TabItem } from '@astrojs/starlight/components';
 
-The scene is the root of every polycss render tree. It applies scene-level lighting and atlas options, then renders its children (typically meshes or individual polygons) in 3D space. `<poly-scene>` / `PolyScene` must always be nested inside a camera element (`<poly-camera>` / `PolyCamera` or the perspective variant): the camera owns the projection and orbital state.
+The scene is the root of every PolyCSS render tree. It applies scene-level lighting and atlas options, then renders its children (typically meshes or individual polygons) in 3D space. `<poly-scene>` / `PolyScene` must always be nested inside a camera element (`<poly-camera>` / `PolyCamera` or the perspective variant): the camera owns the projection and orbital state.
 
 It's available as a custom element (`<poly-scene>`), via the imperative `createPolyScene(host, opts)` API, and as React / Vue components (`<PolyScene>`).
 
diff --git a/website/src/content/docs/core-concepts.mdx b/website/src/content/docs/core-concepts.mdx
index e7be76b0..fdbad6e0 100644
--- a/website/src/content/docs/core-concepts.mdx
+++ b/website/src/content/docs/core-concepts.mdx
@@ -1,15 +1,15 @@
 ---
 title: Core Concepts
-description: "The mental model behind polycss: PolyScene, PolyCamera, PolyMesh, Poly, and the rendering pipeline."
+description: "The mental model behind PolyCSS: PolyScene, PolyCamera, PolyMesh, Poly, and the rendering pipeline."
 ---
 
 import PolyDemo from '../../components/PolyDemo.astro';
 
-This page covers the mental model behind polycss. Each section describes a building block and how it composes with the others.
+This page covers the mental model behind PolyCSS. Each section describes a building block and how it composes with the others.
 
 ## A single block
 
-Where voxcss used to render a single voxel cube, polycss renders any regular polyhedron the same way: each face becomes one DOM element. The dodecahedron below is 12 native pentagons (not 36 triangles): flip the shape selector to see how the same renderer handles every Platonic solid.
+Where voxcss used to render a single voxel cube, PolyCSS renders any regular polyhedron the same way: each face becomes one DOM element. The dodecahedron below is 12 native pentagons (not 36 triangles): flip the shape selector to see how the same renderer handles every Platonic solid.
 
 <PolyDemo
   id="block-demo"
@@ -21,11 +21,11 @@ Where voxcss used to render a single voxel cube, polycss renders any regular pol
 
 ## Three building blocks
 
-polycss exposes three composable concepts. Each one ships as a custom element (vanilla) and as a React / Vue component:
+PolyCSS exposes three composable concepts. Each one ships as a custom element (vanilla) and as a React / Vue component:
 
 - **Scene** (`<poly-scene>` / `PolyScene`): the render tree root. Always nested inside a camera element. Sets up lighting and fills its parent element.
 - **Mesh** (`<poly-mesh>` / `PolyMesh`): loads a mesh from a URL (OBJ / glTF / GLB / VOX). Internally expands to one polygon child per face. Convenience wrapper around the parser + renderer.
-- **Polygon** (`<poly-polygon>` / `Poly`): one polygon. The atomic primitive. Renders as one internal DOM leaf with `transform: matrix3d(...)`. Accepts standard DOM event handlers, classes, and styles: this is what makes polycss "DOM-native 3D" rather than "3D inside a black-box canvas".
+- **Polygon** (`<poly-polygon>` / `Poly`): one polygon. The atomic primitive. Renders as one internal DOM leaf with `transform: matrix3d(...)`. Accepts standard DOM event handlers, classes, and styles: this is what makes PolyCSS "DOM-native 3D" rather than "3D inside a black-box canvas".
 
 A mesh element is internally `polygons.map(p => <poly-polygon …>)`, so any rendered mesh can be inspected, styled, or handled per-polygon.
 
@@ -80,7 +80,7 @@ Because polygons are plain objects, you can generate them from loops, load them
 
 ### World coordinate convention
 
-Polycss world space: **+X right, +Y forward (into screen), +Z up**. The camera's default `rotX=65, rotY=45` gives a classic isometric angle. Parsers (`parseObj`, `parseGltf`) normalize imported coordinates to this convention.
+PolyCSS world space: **+X right, +Y forward (into screen), +Z up**. The camera's default `rotX=65, rotY=45` gives a classic isometric angle. Parsers (`parseObj`, `parseGltf`) normalize imported coordinates to this convention.
 
 ### `(0,0,0)` origin and `autoCenter`
 
@@ -98,11 +98,11 @@ Scene content renders relative to the (0,0,0) origin. Most mesh files are author
 
 ## Rendering Pipeline
 
-polycss is structured in three layers:
+PolyCSS is structured in three layers:
 
 1. **Core** (`@layoutit/polycss-core`): Pure math and parsing. Handles OBJ / glTF / GLB / VOX parsing, UV decoding, lighting math, and polygon normalization. No DOM dependency.
 2. **DOM renderer**: Takes parsed polygons and produces one leaf DOM element per visible polygon. The renderer prefers CSS primitives for solid quads, triangles, and clipped solids, then falls back to atlas slices for textures or unsupported shapes. Atlas canvas work is one-shot; camera, mesh, and dynamic-light updates use transforms and CSS custom properties.
-3. **Entry points**: The vanilla `polycss` package exposes custom elements (`<poly-camera>`, `<poly-scene>`, `<poly-mesh>`, `<poly-polygon>`, controls, helpers, shapes) plus imperative APIs such as `createPolyCamera`, `createPolyScene`, `createSelect`, and `createTransformControls`. React (`@layoutit/polycss-react`) and Vue (`@layoutit/polycss-vue`) bindings mirror that surface with framework-native reactivity, lifecycle, and prop updates.
+3. **Entry points**: The vanilla `@layoutit/polycss` package exposes custom elements (`<poly-camera>`, `<poly-scene>`, `<poly-mesh>`, `<poly-polygon>`, controls, helpers, shapes) plus imperative APIs such as `createPolyCamera`, `createPolyScene`, `createSelect`, and `createTransformControls`. React (`@layoutit/polycss-react`) and Vue (`@layoutit/polycss-vue`) bindings mirror that surface with framework-native reactivity, lifecycle, and prop updates.
 
 ## Render Strategies
 
@@ -120,7 +120,7 @@ You normally do not target these tags directly; use `Poly`, `PolyMesh`, classes,
 
 ## Automatic Polygon Merge
 
-Before rendering, polycss automatically optimizes loaded meshes. `meshResolution: "lossless"` keeps exact planar candidates only; the default `"lossy"` mode can merge near-coplanar candidates within a bounded displacement budget and then spend a small repair budget on high-risk seams. This keeps DOM element counts low for flat surfaces without changing the intended rendered shape.
+Before rendering, PolyCSS automatically optimizes loaded meshes. `meshResolution: "lossless"` keeps exact planar candidates only; the default `"lossy"` mode can merge near-coplanar candidates within a bounded displacement budget and then spend a small repair budget on high-risk seams. This keeps DOM element counts low for flat surfaces without changing the intended rendered shape.
 
 Per-polygon DOM identity is preserved for polygons that cannot merge; polygons inside a merged flat region become one rendered element.
 
diff --git a/website/src/content/docs/guides/animation.mdx b/website/src/content/docs/guides/animation.mdx
index d5c1ae31..95350f57 100644
--- a/website/src/content/docs/guides/animation.mdx
+++ b/website/src/content/docs/guides/animation.mdx
@@ -1,11 +1,11 @@
 ---
 title: Animation
-description: Playing glTF and GLB animation clips with polycss mesh handles.
+description: Playing glTF and GLB animation clips with PolyCSS mesh handles.
 ---
 
 import { Tabs, TabItem } from '@astrojs/starlight/components';
 
-polycss can sample usable glTF / GLB animation clips into fresh polygon frames. The parser exposes `ParseResult.animation`; the animation mixer drives a mesh handle by calling `setPolygons()` as clips play.
+PolyCSS can sample usable glTF / GLB animation clips into fresh polygon frames. The parser exposes `ParseResult.animation`; the animation mixer drives a mesh handle by calling `setPolygons()` as clips play.
 
 This is the main exception to the "no per-polygon JavaScript in the render loop" rule. Skinning changes polygon vertices independently, so animation samples in JavaScript while the renderer keeps the mounted DOM topology stable where possible.
 
diff --git a/website/src/content/docs/guides/performance.mdx b/website/src/content/docs/guides/performance.mdx
index 42a75d48..bca54bb1 100644
--- a/website/src/content/docs/guides/performance.mdx
+++ b/website/src/content/docs/guides/performance.mdx
@@ -1,11 +1,11 @@
 ---
 title: Performance
-description: Optimizing polycss scenes and understanding DOM-based rendering tradeoffs.
+description: Optimizing PolyCSS scenes and understanding DOM-based rendering tradeoffs.
 ---
 
 import PolyDemo from '../../../components/PolyDemo.astro';
 
-polycss renders meshes as real DOM elements: every visible polygon is an HTML leaf with a CSS transform. That gives you DevTools inspection, DOM events, and CSS styling on every polygon, but it means **performance scales with mounted element count and atlas area**. Understanding both is key to building smooth scenes.
+PolyCSS renders meshes as real DOM elements: every visible polygon is an HTML leaf with a CSS transform. That gives you DevTools inspection, DOM events, and CSS styling on every polygon, but it means **performance scales with mounted element count and atlas area**. Understanding both is key to building smooth scenes.
 
 ## Live demo: polygon count vs. performance
 
@@ -22,7 +22,7 @@ The sphere below starts at subdivision level 3 (320 triangles). Bump subdivision
 
 ## Polygon count matters
 
-The dominant cost in polycss is usually browser work over the DOM tree: style, layout, paint, and compositing over many transformed leaves. Camera and mesh motion are expressed as ancestor transforms where possible, so the hot path avoids per-polygon JavaScript, but the browser still has to process every mounted leaf.
+The dominant cost in PolyCSS is usually browser work over the DOM tree: style, layout, paint, and compositing over many transformed leaves. Camera and mesh motion are expressed as ancestor transforms where possible, so the hot path avoids per-polygon JavaScript, but the browser still has to process every mounted leaf.
 
 Confirmed during benchmarking on a 10k-triangle mesh with auto-rotate:
 - **Scripting**: ~579ms / 7s (mostly React re-renders)
@@ -30,7 +30,7 @@ Confirmed during benchmarking on a 10k-triangle mesh with auto-rotate:
 
 ## Automatic mesh optimization
 
-polycss automatically optimizes loaded meshes before rendering. The default `meshResolution: "lossy"` path merges compatible polygons, can use bounded geometric approximation, and may add a small repair split budget to reduce high-risk visible seams. `meshResolution: "lossless"` keeps exact planar candidates only.
+PolyCSS automatically optimizes loaded meshes before rendering. The default `meshResolution: "lossy"` path merges compatible polygons, can use bounded geometric approximation, and may add a small repair split budget to reduce high-risk visible seams. `meshResolution: "lossless"` keeps exact planar candidates only.
 
 This is most useful for architectural meshes with large flat surfaces: walls, floors, ceilings, voxel faces, and other areas where many same-material triangles can collapse without visual change.
 
diff --git a/website/src/content/docs/guides/projections.mdx b/website/src/content/docs/guides/projections.mdx
index e1c69e21..71c89e9c 100644
--- a/website/src/content/docs/guides/projections.mdx
+++ b/website/src/content/docs/guides/projections.mdx
@@ -6,7 +6,7 @@ description: Choosing perspective depth and camera angles for different visual s
 import { Tabs, TabItem } from '@astrojs/starlight/components';
 import PolyDemo from '../../../components/PolyDemo.astro';
 
-polycss uses CSS 3D perspective to project the scene. Camera attributes (`rot-x`, `rot-y`, `zoom`, `perspective`) live on the wrapping camera element — `<poly-camera>` for orthographic (default) or `<poly-perspective-camera>` for perspective — never on `<poly-scene>`. `PolyCamera` is orthographic by default; pick `PolyPerspectiveCamera` when depth foreshortening is needed.
+PolyCSS uses CSS 3D perspective to project the scene. Camera attributes (`rot-x`, `rot-y`, `zoom`, `perspective`) live on the wrapping camera element — `<poly-camera>` for orthographic (default) or `<poly-perspective-camera>` for perspective — never on `<poly-scene>`. `PolyCamera` is orthographic by default; pick `PolyPerspectiveCamera` when depth foreshortening is needed.
 
 ## Live demo: camera controls
 
diff --git a/website/src/content/docs/guides/shapes.mdx b/website/src/content/docs/guides/shapes.mdx
index e6afeea9..99f25346 100644
--- a/website/src/content/docs/guides/shapes.mdx
+++ b/website/src/content/docs/guides/shapes.mdx
@@ -6,7 +6,7 @@ description: Using the Poly component for per-polygon click handlers, hover stat
 import { Tabs, TabItem } from '@astrojs/starlight/components';
 import PolyDemo from '../../../components/PolyDemo.astro';
 
-Every polygon rendered by polycss is a real DOM element. You can attach standard event handlers, apply CSS classes, and inspect them in DevTools: that's true regardless of which entry point you use. The single-polygon primitive is `<poly-polygon>` (vanilla custom element) / `<Poly>` (React, Vue).
+Every polygon rendered by PolyCSS is a real DOM element. You can attach standard event handlers, apply CSS classes, and inspect them in DevTools: that's true regardless of which entry point you use. The single-polygon primitive is `<poly-polygon>` (vanilla custom element) / `<Poly>` (React, Vue).
 
 ## Live demo: interactive scene
 
diff --git a/website/src/content/docs/guides/textures.mdx b/website/src/content/docs/guides/textures.mdx
index 0dcd99a9..712360e2 100644
--- a/website/src/content/docs/guides/textures.mdx
+++ b/website/src/content/docs/guides/textures.mdx
@@ -1,12 +1,12 @@
 ---
 title: Loading Meshes
-description: Loading OBJ, glTF, GLB, and VOX meshes into polycss with UV textures and material colors.
+description: Loading OBJ, glTF, GLB, and VOX meshes into PolyCSS with UV textures and material colors.
 ---
 
 import { Tabs, TabItem } from '@astrojs/starlight/components';
 import PolyDemo from '../../../components/PolyDemo.astro';
 
-polycss loads 3D mesh files (OBJ, glTF, GLB, and MagicaVoxel VOX) and renders them as DOM elements. UV textures are extracted from OBJ/glTF/GLB files and packed into generated atlas pages; each atlas-backed polygon is an internal `<s>` leaf that uses CSS background positioning.
+PolyCSS loads 3D mesh files (OBJ, glTF, GLB, and MagicaVoxel VOX) and renders them as DOM elements. UV textures are extracted from OBJ/glTF/GLB files and packed into generated atlas pages; each atlas-backed polygon is an internal `<s>` leaf that uses CSS background positioning.
 
 ## Live demo: UV-textured GLB
 
@@ -87,7 +87,7 @@ import { PolyCamera, PolyScene, PolyMesh } from "@layoutit/polycss-vue";
 
 ## OBJ with MTL
 
-When your OBJ has a companion MTL file with textures, polycss reads `map_Kd` entries and applies them as UV-mapped textures. Pass the `mtl` attribute / prop:
+When your OBJ has a companion MTL file with textures, PolyCSS reads `map_Kd` entries and applies them as UV-mapped textures. Pass the `mtl` attribute / prop:
 
 ```html
 <!-- Vanilla -->
@@ -176,7 +176,7 @@ function Viewer() {
 
 ## Atlas pipeline
 
-For textured polygons, polycss runs a one-time atlas canvas pass at mount. Flat-color polygons can bypass the atlas when they can render as CSS solids or `border-shape` polygons.
+For textured polygons, PolyCSS runs a one-time atlas canvas pass at mount. Flat-color polygons can bypass the atlas when they can render as CSS solids or `border-shape` polygons.
 
 1. Extract the texture image from the file (or fetch it by URL) when the polygon has a texture.
 2. Solve a 6-DOF affine transform from the polygon's UV coordinates to its 2D screen footprint when UVs are available.
@@ -195,7 +195,7 @@ Generated atlas blob URLs are revoked on unmount (call `dispose()` or let `PolyM
 - **`textureQuality`**: leave at `"auto"` for workload-based bitmap caps and browser/device sprite sizing, or set a numeric raster scale for explicit quality. `0.5` uses about one quarter of the atlas bitmap memory of `1`.
 - Shared textured edges are repaired automatically during atlas generation. Geometry stays unchanged; only low-alpha atlas pixels at those shared edges are filled from nearby opaque texels.
 - **`baseUrl`**: for OBJ/glTF files with external texture paths, pass the file's URL so relative paths resolve correctly.
-- For large meshes: blob URLs for embedded textures and generated atlases are revoked when `dispose()` is called. Always let polycss manage this: don't hold references to blob URLs across remounts.
+- For large meshes: blob URLs for embedded textures and generated atlases are revoked when `dispose()` is called. Always let PolyCSS manage this: don't hold references to blob URLs across remounts.
 
 ## Related
 
diff --git a/website/src/content/docs/introduction.mdx b/website/src/content/docs/introduction.mdx
index bb7b64e8..a6ae3d28 100644
--- a/website/src/content/docs/introduction.mdx
+++ b/website/src/content/docs/introduction.mdx
@@ -1,17 +1,17 @@
 ---
 title: Introduction
-description: "polycss is a CSS polygon-mesh renderer: DOM-native 3D without WebGL."
+description: "PolyCSS is a CSS polygon-mesh renderer: DOM-native 3D without WebGL."
 ---
 
 import { Tabs, TabItem } from '@astrojs/starlight/components';
 
-**polycss** renders 3D meshes in the DOM. No WebGL, no canvas-as-scene: the rendered output is a tree of standard DOM elements positioned with `transform: matrix3d(...)`. Each visible polygon becomes one leaf DOM node you can inspect in DevTools, target with CSS, or attach events to.
+**PolyCSS** renders 3D meshes in the DOM. No WebGL, no canvas-as-scene: the rendered output is a tree of standard DOM elements positioned with `transform: matrix3d(...)`. Each visible polygon becomes one leaf DOM node you can inspect in DevTools, target with CSS, or attach events to.
 
 Internally, the renderer chooses the cheapest CSS strategy per polygon. Solid rectangles, stable quads, triangles, and clipped solids can render as CSS primitives; textured polygons and unsupported shapes fall back to generated atlas slices. Atlas rasterization happens once at mount, then camera, mesh, and light updates flow through CSS transforms and custom properties.
 
 ## Framework Support
 
-polycss is **vanilla-first**. The default entry point is custom elements (`<poly-camera>`, `<poly-scene>`, `<poly-mesh>`, `<poly-polygon>`, controls, helpers, and shapes) plus imperative APIs such as `createPolyCamera`, `createPolyScene`, and `createPolyOrbitControls`: no framework required. First-class bindings for **React** and **Vue** ship as separate packages on top of the same engine. Pick whatever fits your stack.
+PolyCSS is **vanilla-first**. The default entry point is custom elements (`<poly-camera>`, `<poly-scene>`, `<poly-mesh>`, `<poly-polygon>`, controls, helpers, and shapes) plus imperative APIs such as `createPolyCamera`, `createPolyScene`, and `createPolyOrbitControls`: no framework required. First-class bindings for **React** and **Vue** ship as separate packages on top of the same engine. Pick whatever fits your stack.
 
 ## Installation
 
@@ -35,7 +35,7 @@ npm install @layoutit/polycss-vue
 
 ### CDN (custom elements)
 
-You can also load polycss directly from a CDN with no build step:
+You can also load PolyCSS directly from a CDN with no build step:
 
 ```html
 <script type="module" src="https://esm.sh/@layoutit/polycss/elements"></script>
diff --git a/website/src/content/docs/quickstart.mdx b/website/src/content/docs/quickstart.mdx
index 894078ab..431e4249 100644
--- a/website/src/content/docs/quickstart.mdx
+++ b/website/src/content/docs/quickstart.mdx
@@ -1,6 +1,6 @@
 ---
 title: Quickstart
-description: Render your first polycss 3D mesh in under a minute.
+description: Render your first PolyCSS 3D mesh in under a minute.
 ---
 
 import { Tabs, TabItem } from '@astrojs/starlight/components';
diff --git a/website/src/pages/404.astro b/website/src/pages/404.astro
index 4ed1218a..d3c174e5 100644
--- a/website/src/pages/404.astro
+++ b/website/src/pages/404.astro
@@ -1,5 +1,5 @@
 ---
-const title = "Page not found | polycss";
+const title = "Page not found | PolyCSS";
 const description = "The requested page could not be found.";
 ---
 
diff --git a/website/src/pages/index.astro b/website/src/pages/index.astro
index 0eaf05d1..5c3f6a19 100644
--- a/website/src/pages/index.astro
+++ b/website/src/pages/index.astro
@@ -16,10 +16,10 @@ function highlight(code: string, lang: string): string {
   return hljs.highlight(code, { language: lang }).value;
 }
 
-const title = "polycss: CSS polygon-mesh renderer for the DOM";
+const title = "PolyCSS: CSS polygon-mesh renderer for the DOM";
 const description = "Render textured 3D meshes in the DOM. No WebGL: each polygon is a real DOM element you can style, click, and inspect in DevTools.";
 const siteUrl = "https://polycss.com";
-// Reusing the legacy voxcss social card until a polycss-specific image lands.
+// Reusing the legacy voxcss social card until a PolyCSS-specific image lands.
 const ogImage = `${siteUrl}/voxcss-intro.png`;
 
 const frameworkTabs = [
@@ -83,7 +83,7 @@ const installCmds = [
 const ldJson = {
   "@context": "https://schema.org",
   "@type": "SoftwareApplication",
-  name: "polycss",
+  name: "PolyCSS",
   applicationCategory: "DeveloperApplication",
   operatingSystem: "Web",
   description,
@@ -93,7 +93,7 @@ const ldJson = {
   sameAs: ["https://github.com/LayoutitStudio/polycss"],
   publisher: {
     "@type": "Organization",
-    name: "polycss",
+    name: "PolyCSS",
     url: siteUrl,
   },
 };
@@ -134,7 +134,7 @@ const ldJson = {
       <div class="home">
         <section class="hero" id="hero">
           <div class="hero-copy">
-            <h1><img width="300" height="72" style="width: 300px; height: auto" src="/voxisologo.png" alt="polycss" /></h1>
+            <h1><img width="300" height="72" style="width: 300px; height: auto" src="/voxisologo.png" alt="PolyCSS" /></h1>
             <p>
               Render textured 3D meshes in the DOM with CSS.
               No WebGL or &lt;canvas&gt; needed: each polygon is a real DOM element.
@@ -201,7 +201,7 @@ const ldJson = {
           <div class="stacking-copy">
             <h2>How It Works</h2>
             <p>
-              polycss loads OBJ, glTF, GLB, and VOX mesh files. Each polygon
+              PolyCSS loads OBJ, glTF, GLB, and VOX mesh files. Each polygon
               becomes a DOM element positioned with <code>transform: matrix3d(...)</code>.
               UV-textured triangles are packed into generated atlas sprites with
               CSS background positioning. The browser's compositor handles the
@@ -226,7 +226,7 @@ const ldJson = {
             </div>
           </header>
           <div class="getting-lede">
-            <p>polycss provides custom elements (<code>&lt;poly-camera&gt;</code>, <code>&lt;poly-scene&gt;</code>, <code>&lt;poly-mesh&gt;</code>), an imperative <code>createPolyCamera</code> / <code>createPolyScene</code> API, and optional React / Vue bindings. Each polygon in the mesh becomes a DOM element you can style and interact with: use whichever entry point fits your stack.</p>
+            <p>PolyCSS provides custom elements (<code>&lt;poly-camera&gt;</code>, <code>&lt;poly-scene&gt;</code>, <code>&lt;poly-mesh&gt;</code>), an imperative <code>createPolyCamera</code> / <code>createPolyScene</code> API, and optional React / Vue bindings. Each polygon in the mesh becomes a DOM element you can style and interact with: use whichever entry point fits your stack.</p>
           </div>
           <div class="getting-grid">
             <div class="getting-content">