threejs-awesome-graphics-agent-skills 0.1.0

package/.codex-plugin/plugin.json

@@ -0,0 +1,34 @@
+{
+  "name": "threejs-awesome-graphics-agent-skills",
+  "version": "0.1.0",
+  "description": "Expert agent skills for creating exceptional Three.js graphics.",
+  "author": {
+    "name": "Scott"
+  },
+  "license": "MIT",
+  "keywords": [
+    "threejs",
+    "webgl",
+    "webgpu",
+    "procedural-graphics",
+    "shaders",
+    "volumetrics"
+  ],
+  "skills": "./skills/",
+  "interface": {
+    "displayName": "Three.js Awesome Graphics Agent Skills",
+    "shortDescription": "Expert procedural Three.js graphics systems",
+    "longDescription": "Atomic expertise for procedural geometry, coherent materials, advanced shaders, atmosphere, volumetrics, shadows, temporal effects, and deliberate final-image pipelines in Three.js.",
+    "developerName": "Scott",
+    "category": "Developer Tools",
+    "capabilities": [
+      "Interactive",
+      "Write"
+    ],
+    "defaultPrompt": [
+      "Decompose an ambitious Three.js visual into expert systems.",
+      "Build a coherent procedural material and geometry pipeline.",
+      "Audit this scene's graphics mechanisms and visual evidence."
+    ]
+  }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Scott Sun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,177 @@
+# Three.js Awesome Graphics Agent Skills
+
+This is a Three.js agent skill pack for producing awesome graphics.
+
+It includes mesh design, lighting, PBR materials, textures, shaders, TSL/WebGPU, GLSL, post-processing, realism, stylization, particles, procedural visuals, color management, tone mapping, etc. Graphics excellence is the **main focus** of this skill pack, with sophisticated design aesthetics, philosophy, ergonomics, sensibility, taste
+
+This is NOT a three.js API cheat sheet, it skips basic 3D production fundamentals (any decent LLM already has that internal knowledge), it also skips three.js API technicalities (just look up docs or use existing API oriented agent skills). This skill pack is meant for agent to produce stunning 3D scenes and graphics that transcend simple demos. It brings the sophistication of good graphics and eliminates cheap effort.
+
+I aim to continuously update this skill pack as more three.js projects with awesome graphics emerge. I hope this skill pack can help anyone build awesome scenes and games with out of the box sophisticated graphics.
+
+## Operating model
+
+Load `$threejs-skill-router` for a broad visual task, then load only the atomic systems the work actually needs.
+
+Every graphics system is expected to expose:
+
+- deterministic or reproducible inputs;
+- named controlling fields and perceptual parameters;
+- diagnostic outputs;
+- scale, distance, and temporal stability rules;
+- an intentional mechanism-backed quality or resolution tier when the system defines one;
+- a no-post baseline that still reads.
+
+## Skills
+
+| Skill | Expertise |
+| --- | --- |
+| `threejs-skill-router` | Decompose a visual target into the smallest relevant expert systems. |
+| `threejs-camera-direction` | Authored lenses and shots, chase/side/orbit rigs, body-relative frames, handoffs, pointer look, floating origins. |
+| `threejs-procedural-animation` | Analytic timelines, gravity turns, staging, rotating-frame docking, springs, quaternion alignment, debris motion. |
+| `threejs-procedural-fields` | Shared scalar/vector fields, frequency bands, domain warping, causal masks, procedural normals. |
+| `threejs-procedural-materials` | Atlas filtering, specular AA, planetary materials, terrain wetness, frame PBR, per-instance dissolve. |
+| `threejs-procedural-geometry` | Sculpted frame rails, branch rings, semantic mesh writers, UV density, material groups. |
+| `threejs-procedural-vegetation` | Growth hierarchies, branch-ring geometry, stratified children, foliage normals, wind. |
+| `threejs-procedural-architecture` | Massing and façade grammars, exposed-edge analysis, modules, material-slot compilation. |
+| `threejs-procedural-planets` | Spherical terrain, ridges, craters, biomes, procedural normals, altitude filtering. |
+| `threejs-spectral-ocean` | Validated FFT synthesis, spectral cascades, choppy derivatives, Jacobian foam, ocean shading. |
+| `threejs-water-optics` | Shared analytic waves/normals, heuristic refraction, fallback absorption, reflection, crest foam. |
+| `threejs-atmosphere-aerial-perspective` | Shared Rayleigh/Mie atmosphere, sky, shell/post handoff, depth-based scattering. |
+| `threejs-volumetric-clouds` | Weather-shaped density, bounded raymarching, cloud lighting, history, cloud shadows. |
+| `threejs-raymarched-space-effects` | Curved-ray integration, black holes, accretion disks, wormholes, bounded quality. |
+| `threejs-procedural-vfx` | Reentry shells/wakes, instanced sparks, dissolving debris, dense pools, HDR hierarchy. |
+| `threejs-temporal-surfaces` | Persistent touch history, reduced blur, frost composite, and normal refraction. |
+| `threejs-shadow-systems` | Stable cascades and cached clipmap shadows with update budgets and invalidation. |
+| `threejs-screen-space-ambient-occlusion` | GTAO-style horizon sampling, bent normals, bilateral and temporal reconstruction. |
+| `threejs-bloom` | HDR extraction, multi-scale filtering, selective contribution, exposure coupling. |
+| `threejs-exposure-color-grading` | Encoded luminance metering, asymmetric adaptation, tone mapping, generated 3D LUT. |
+| `threejs-image-pipeline` | Shared render-signal ownership and ordering across multiple image-space systems. |
+| `threejs-visual-validation` | Fixed-view captures, diagnostic mosaics, seed/scale sweeps, temporal and GPU evidence. |
+
+## Examples of use
+
+```text
+Use $threejs-skill-router to decompose and build a procedural ocean planet
+with a ground-to-orbit camera.
+```
+
+```text
+Use $threejs-procedural-vegetation to build a deterministic tree species
+with coherent branching, bark scale, foliage normals, and hierarchical wind.
+```
+
+```text
+Use $threejs-camera-direction and $threejs-procedural-animation to stage a
+planet-relative ship approach with an authored side-camera handoff and docking.
+```
+
+```text
+Use $threejs-bloom to diagnose the HDR signal and tune bloom without making
+the glow carry the underlying form.
+```
+
+```text
+Use $threejs-visual-validation to produce a deterministic evidence set for
+this procedural material across camera distance, seeds, motion, and quality tiers.
+```
+
+## Install
+
+The published package and installer command are `threejs-awesome-graphics-agent-skills`.
+
+```sh
+# User-wide installation
+npx threejs-awesome-graphics-agent-skills install --agent codex
+npx threejs-awesome-graphics-agent-skills install --agent claude-code
+npx threejs-awesome-graphics-agent-skills install --agent cursor
+
+# Project installation
+npx threejs-awesome-graphics-agent-skills install --agent github-copilot --scope project
+
+# Any custom-built agent
+npx threejs-awesome-graphics-agent-skills install --agent custom --path ~/.my-agent/skills
+```
+
+Supported targets:
+
+| Target | User scope | Project scope |
+| --- | --- | --- |
+| `universal` | `~/.agents/skills` | `.agents/skills` |
+| `codex` | `~/.agents/skills` | `.agents/skills` |
+| `claude-code` | `~/.claude/skills` | `.claude/skills` |
+| `cursor` | `~/.cursor/skills` | `.cursor/skills` |
+| `github-copilot` | `~/.copilot/skills` | `.github/skills` |
+| `gemini-cli` | `~/.gemini/skills` | `.gemini/skills` |
+| `windsurf` | `~/.codeium/windsurf/skills` | `.windsurf/skills` |
+| `custom` | exact `--path` | exact `--path` |
+
+Each installation contains the complete pack so its router can reference every atomic skill. Use `--force` to replace an existing installation and `--dry-run` to inspect changes.
+
+```sh
+npx threejs-awesome-graphics-agent-skills uninstall --agent cursor
+```
+
+## Development
+
+```sh
+npm run validate
+npm test
+npm run check:freshness
+npm pack --dry-run
+```
+
+Inspect every included graphics example from one development surface:
+
+```sh
+npm run dev:examples
+```
+
+The gallery discovers development adapters corresponding to skill examples
+automatically and provides single-example and live-overview modes, viewport/DPR
+controls, pause/time controls, debug-mode routing, standalone launch, runtime
+metrics, and canvas capture. It is repository tooling and is not installed as
+an agent skill.
+
+Current accepted inspection surfaces:
+
+- [Atmosphere and aerial perspective](http://127.0.0.1:4173/?example=threejs-atmosphere-aerial-perspective%2Flut-aerial-perspective)
+  — precomputed sky radiance, sun transmittance, and depth-aware segment
+  scattering;
+- [Sculpted gallery frame](http://127.0.0.1:4173/?example=threejs-procedural-geometry%2Fsculpted-gallery-frame)
+  — profile-swept mesh, authored frame PBR, grazing lights, shadows, and
+  selective bloom;
+- [Ash growth system](http://127.0.0.1:4173/?example=threejs-procedural-vegetation%2Fstructured-ash-growth)
+  — species-specific hierarchy, branch geometry, foliage, wind, and meadow;
+- [Curved-ray accretion volume](http://127.0.0.1:4173/?example=threejs-raymarched-space-effects%2Fcurved-ray-accretion-volume)
+  — bounded ray steering, accretion density, transmittance, and bent
+  environment lookup;
+- [Spectral cascade ocean](http://127.0.0.1:4173/?example=threejs-spectral-ocean%2Fspectral-cascade-ocean)
+  — directional spectra, staged inverse FFT, choppy displacement, and
+  persistent Jacobian foam;
+- [Procedural planet surface](http://127.0.0.1:4173/?example=threejs-procedural-planets%2Fprocedural-planet-surface)
+  — coupled displacement, geological fields, biome masks, water, and
+  altitude-filtered material detail;
+- [Authored financial tower](http://127.0.0.1:4173/?example=threejs-procedural-architecture%2Fauthored-financial-tower)
+  — semantic massing, façade grammar, grouped mesh emission, and cached
+  clipmap shadows;
+- [Analytic wave optics](http://127.0.0.1:4173/?example=threejs-water-optics%2Fanalytic-wave-optics)
+  — shared displaced waves and normals, filtered microstructure, Fresnel,
+  refraction, absorption, and crest response;
+- [Weather volume clouds](http://127.0.0.1:4173/?example=threejs-volumetric-clouds%2Fweather-volume-clouds)
+  — packed weather channels, profile-shaped density, bounded integration,
+  directional lighting, and temporal reconstruction;
+- [Reentry plasma](http://127.0.0.1:4173/?example=threejs-procedural-vfx%2Freentry-plasma)
+  — closed layered wake shells, flow deformation, advected filaments, and
+  additive thermal emission;
+- [Touch-history frost](http://127.0.0.1:4173/?example=threejs-temporal-surfaces%2Ftouch-history-frost)
+  — persistent interaction history, static crystalline fields, reduced blur,
+  and two-scale refraction.
+
+Generate deterministic captures and a contact sheet:
+
+```sh
+npm run capture:examples
+```
+
+The gallery contract is documented in
+[`dev/example-gallery/README.md`](dev/example-gallery/README.md).

package/bin/threejs-awesome-graphics-agent-skills.mjs

@@ -0,0 +1,357 @@
+#!/usr/bin/env node
+
+import {
+  cp,
+  mkdir,
+  readFile,
+  readdir,
+  rename,
+  rm,
+  stat,
+  writeFile,
+} from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const skillsSource = path.join(packageRoot, "skills");
+const packageJson = JSON.parse(
+  await readFile(path.join(packageRoot, "package.json"), "utf8"),
+);
+const manifestName = ".threejs-awesome-graphics-agent-skills.json";
+
+const targets = {
+  universal: {
+    label: "Open Agent Skills",
+    project: [".agents", "skills"],
+    user: [".agents", "skills"],
+  },
+  codex: {
+    label: "OpenAI Codex",
+    project: [".agents", "skills"],
+    user: [".agents", "skills"],
+  },
+  "claude-code": {
+    label: "Claude Code",
+    project: [".claude", "skills"],
+    user: [".claude", "skills"],
+  },
+  cursor: {
+    label: "Cursor",
+    project: [".cursor", "skills"],
+    user: [".cursor", "skills"],
+  },
+  "github-copilot": {
+    label: "GitHub Copilot",
+    project: [".github", "skills"],
+    user: [".copilot", "skills"],
+  },
+  "gemini-cli": {
+    label: "Gemini CLI",
+    project: [".gemini", "skills"],
+    user: [".gemini", "skills"],
+  },
+  windsurf: {
+    label: "Windsurf / Devin Desktop",
+    project: [".windsurf", "skills"],
+    user: [".codeium", "windsurf", "skills"],
+  },
+};
+
+const aliases = {
+  agents: "universal",
+  claude: "claude-code",
+  copilot: "github-copilot",
+  gemini: "gemini-cli",
+  devin: "windsurf",
+};
+
+function printHelp() {
+  console.log(`Three.js Awesome Graphics Agent Skills ${packageJson.version}
+
+Usage:
+  threejs-awesome-graphics-agent-skills list
+  threejs-awesome-graphics-agent-skills install --agent <target> [options]
+  threejs-awesome-graphics-agent-skills uninstall --agent <target> [options]
+
+Targets:
+  universal, codex, claude-code, cursor, github-copilot, gemini-cli, windsurf
+  custom (requires --path)
+
+Options:
+  --scope <user|project>   Installation scope (default: user)
+  --path <directory>       Exact skills root; required for custom agents
+  --project-dir <path>     Project root for project-scoped installs
+  --force                  Replace existing installed skill directories
+  --dry-run                Print actions without writing
+  --version                Print package version
+  --help                   Show this help
+
+Examples:
+  npx threejs-awesome-graphics-agent-skills install --agent codex
+  npx threejs-awesome-graphics-agent-skills install --agent claude-code --scope project
+  npx threejs-awesome-graphics-agent-skills install --agent cursor,copilot --force
+  npx threejs-awesome-graphics-agent-skills install --agent custom --path ~/.my-agent/skills
+`);
+}
+
+function parseArgs(argv) {
+  const [rawCommand = "help", ...rest] = argv;
+  const command = rawCommand === "--help" || rawCommand === "-h"
+    ? "help"
+    : rawCommand === "--version" || rawCommand === "-v"
+      ? "version"
+      : rawCommand;
+  const options = {
+    command,
+    scope: "user",
+    agents: [],
+    force: false,
+    dryRun: false,
+    projectDir: process.cwd(),
+    customPath: null,
+  };
+
+  for (let index = 0; index < rest.length; index += 1) {
+    const argument = rest[index];
+    const value = rest[index + 1];
+    if (argument === "--agent" && value) {
+      options.agents.push(...value.split(",").filter(Boolean));
+      index += 1;
+    } else if (argument === "--scope" && value) {
+      options.scope = value;
+      index += 1;
+    } else if (argument === "--path" && value) {
+      options.customPath = value;
+      index += 1;
+    } else if (argument === "--project-dir" && value) {
+      options.projectDir = value;
+      index += 1;
+    } else if (argument === "--force") {
+      options.force = true;
+    } else if (argument === "--dry-run") {
+      options.dryRun = true;
+    } else if (argument === "--help" || argument === "-h") {
+      options.command = "help";
+    } else {
+      throw new Error(`Unknown or incomplete option: ${argument}`);
+    }
+  }
+
+  return options;
+}
+
+async function pathExists(targetPath) {
+  try {
+    await stat(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function availableSkills() {
+  const entries = await readdir(skillsSource, { withFileTypes: true });
+  return entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort();
+}
+
+function normalizeAgent(agent) {
+  const normalized = aliases[agent] ?? agent;
+  if (normalized !== "custom" && !targets[normalized]) {
+    throw new Error(`Unsupported agent target: ${agent}`);
+  }
+  return normalized;
+}
+
+function resolveDestination(agent, options) {
+  if (agent === "custom") {
+    if (!options.customPath) {
+      throw new Error("The custom target requires --path <skills-directory>.");
+    }
+    return path.resolve(options.customPath.replace(/^~(?=$|\/|\\)/, os.homedir()));
+  }
+
+  if (!["user", "project"].includes(options.scope)) {
+    throw new Error("--scope must be user or project.");
+  }
+
+  const base = options.scope === "user"
+    ? os.homedir()
+    : path.resolve(options.projectDir);
+  return path.join(base, ...targets[agent][options.scope]);
+}
+
+async function readInstallManifest(destination) {
+  try {
+    const manifest = JSON.parse(
+      await readFile(path.join(destination, manifestName), "utf8"),
+    );
+    if (
+      manifest.package !== packageJson.name ||
+      !Array.isArray(manifest.skills) ||
+      manifest.skills.some(
+        (skillName) =>
+          typeof skillName !== "string" ||
+          !/^[a-z0-9-]{1,63}$/.test(skillName),
+      )
+    ) {
+      throw new Error("invalid ownership manifest");
+    }
+    return manifest;
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw new Error(
+        `Unable to read ${path.join(destination, manifestName)}: ${error.message}`,
+      );
+    }
+    return {
+      package: packageJson.name,
+      version: packageJson.version,
+      skills: [],
+    };
+  }
+}
+
+async function writeInstallManifest(destination, manifest, dryRun) {
+  if (dryRun) return;
+  await writeFile(
+    path.join(destination, manifestName),
+    `${JSON.stringify(manifest, null, 2)}\n`,
+  );
+}
+
+async function installInto(destination, skillNames, options, agent) {
+  const previous = await readInstallManifest(destination);
+  const existing = [];
+  for (const skillName of skillNames) {
+    if (await pathExists(path.join(destination, skillName))) existing.push(skillName);
+  }
+
+  if (existing.length > 0 && !options.force) {
+    throw new Error(
+      `Existing skills at ${destination}: ${existing.join(", ")}. Re-run with --force to replace them.`,
+    );
+  }
+
+  console.log(`${options.dryRun ? "Would install" : "Installing"} ${skillNames.length} skills to ${destination}`);
+  if (!options.dryRun) await mkdir(destination, { recursive: true });
+
+  for (const skillName of skillNames) {
+    const source = path.join(skillsSource, skillName);
+    const target = path.join(destination, skillName);
+    const staging = path.join(destination, `.${skillName}.tmp-${process.pid}`);
+    const backup = path.join(destination, `.${skillName}.bak-${process.pid}`);
+    console.log(`- ${skillName}`);
+    if (options.dryRun) continue;
+
+    await rm(staging, { recursive: true, force: true });
+    await cp(source, staging, { recursive: true });
+    if (await pathExists(target)) {
+      await rename(target, backup);
+      try {
+        await rename(staging, target);
+        await rm(backup, { recursive: true, force: true });
+      } catch (error) {
+        await rename(backup, target);
+        throw error;
+      }
+    } else {
+      await rename(staging, target);
+    }
+  }
+
+  const currentSkills = new Set(skillNames);
+  for (const previousSkill of previous.skills ?? []) {
+    if (!currentSkills.has(previousSkill) && !options.dryRun) {
+      await rm(path.join(destination, previousSkill), { recursive: true, force: true });
+    }
+  }
+
+  await writeInstallManifest(destination, {
+    package: packageJson.name,
+    version: packageJson.version,
+    agent,
+    installedAt: new Date().toISOString(),
+    completePack: true,
+    skills: [...currentSkills].sort(),
+  }, options.dryRun);
+}
+
+async function uninstallFrom(destination, options) {
+  const manifest = await readInstallManifest(destination);
+  const tracked = new Set(manifest.skills ?? []);
+  if (tracked.size === 0) {
+    throw new Error(`No ${packageJson.name} installation manifest found at ${destination}.`);
+  }
+
+  const skillNames = [...tracked];
+
+  console.log(`${options.dryRun ? "Would remove" : "Removing"} ${skillNames.length} skills from ${destination}`);
+  for (const skillName of skillNames) {
+    console.log(`- ${skillName}`);
+    if (!options.dryRun) {
+      await rm(path.join(destination, skillName), { recursive: true, force: true });
+      tracked.delete(skillName);
+    }
+  }
+
+  if (!options.dryRun) {
+    await rm(path.join(destination, manifestName), { force: true });
+  }
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.command === "help") {
+    printHelp();
+    return;
+  }
+  if (options.command === "version") {
+    console.log(packageJson.version);
+    return;
+  }
+
+  const allSkills = await availableSkills();
+  if (options.command === "list") {
+    console.log("Agent targets:");
+    for (const [name, target] of Object.entries(targets)) {
+      console.log(`- ${name}: ${target.label}`);
+    }
+    console.log("- custom: any skills directory supplied with --path");
+    console.log("\nPack skills:");
+    for (const skillName of allSkills) console.log(`- ${skillName}`);
+    return;
+  }
+
+  if (!["install", "uninstall"].includes(options.command)) {
+    throw new Error(`Unknown command: ${options.command}`);
+  }
+  if (options.agents.length === 0) {
+    throw new Error("Specify at least one --agent target.");
+  }
+
+  const destinations = new Map();
+  for (const requestedAgent of options.agents) {
+    const agent = normalizeAgent(requestedAgent);
+    const destination = resolveDestination(agent, options);
+    if (!destinations.has(destination)) destinations.set(destination, agent);
+  }
+
+  for (const [destination, agent] of destinations) {
+    if (options.command === "install") {
+      await installInto(destination, allSkills, options, agent);
+    } else {
+      await uninstallFrom(destination, options);
+    }
+  }
+}
+
+main().catch((error) => {
+  console.error(`Error: ${error.message}`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "threejs-awesome-graphics-agent-skills",
+  "version": "0.1.0",
+  "description": "Expert agent skills for creating exceptional Three.js graphics.",
+  "license": "MIT",
+  "author": "Scott",
+  "keywords": [
+    "agent-skills",
+    "threejs",
+    "three.js",
+    "codex",
+    "claude-code",
+    "cursor",
+    "copilot",
+    "gemini-cli",
+    "windsurf",
+    "procedural-graphics",
+    "webgpu",
+    "tsl",
+    "glsl",
+    "shaders",
+    "volumetric-rendering",
+    "post-processing"
+  ],
+  "type": "module",
+  "bin": {
+    "threejs-awesome-graphics-agent-skills": "bin/threejs-awesome-graphics-agent-skills.mjs"
+  },
+  "files": [
+    ".codex-plugin/",
+    "bin/",
+    "skills/",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "validate": "node scripts/validate-pack.mjs",
+    "test": "npm run validate && npm run test:routing && npm run test:references && npm run test:installer && npm run test:gallery",
+    "dev:examples": "node dev/example-gallery/server.mjs --open",
+    "dev:examples:no-open": "node dev/example-gallery/server.mjs",
+    "dev:examples:fixture": "node dev/example-gallery/server.mjs --open --include-fixtures",
+    "capture:examples": "node scripts/capture-examples.mjs",
+    "test:references": "node scripts/test-reference-examples.mjs",
+    "test:routing": "node scripts/test-agent-routing.mjs",
+    "test:installer": "node scripts/test-installer.mjs",
+    "test:gallery": "node scripts/test-example-gallery.mjs",
+    "check:freshness": "node scripts/check-three-freshness.mjs",
+    "test:all": "npm test && npm run check:freshness",
+    "prepack": "npm run test:all",
+    "prepublishOnly": "npm run check:freshness"
+  },
+  "devDependencies": {
+    "playwright": "^1.60.0",
+    "three": "^0.184.0",
+    "yaml": "^2.9.0"
+  }
+}