diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..00689f0
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,15 @@
+# Build the Vite app, then serve the static bundle with nginx.
+# HF Spaces docker SDK: the container must listen on app_port (8080);
+# nginx-unprivileged listens on 8080 by default and runs as non-root,
+# which is exactly what Spaces expects.
+
+FROM node:22-alpine AS build
+WORKDIR /build
+COPY app/package.json app/package-lock.json ./
+RUN npm ci
+COPY app/ ./
+RUN npm run build
+
+FROM nginxinc/nginx-unprivileged:alpine
+COPY --from=build /build/dist /usr/share/nginx/html
+EXPOSE 8080
diff --git a/app/.gitignore b/app/.gitignore
new file mode 100644
index 0000000..b947077
--- /dev/null
+++ b/app/.gitignore
@@ -0,0 +1,2 @@
+node_modules/
+dist/
diff --git a/app/index.html b/app/index.html
new file mode 100644
index 0000000..e56e23e
--- /dev/null
+++ b/app/index.html
@@ -0,0 +1,21 @@
+
+
+
+
+
+ Microduck
+
+
+
+
+
+
+
diff --git a/app/package-lock.json b/app/package-lock.json
new file mode 100644
index 0000000..f2b2929
--- /dev/null
+++ b/app/package-lock.json
@@ -0,0 +1,2052 @@
+{
+ "name": "app",
+ "version": "1.0.0",
+ "lockfileVersion": 3,
+ "requires": true,
+ "packages": {
+ "": {
+ "name": "app",
+ "version": "1.0.0",
+ "license": "ISC",
+ "dependencies": {
+ "@emotion/react": "^11.14.0",
+ "@emotion/styled": "^11.14.1",
+ "@mui/material": "^9.3.1",
+ "@react-three/fiber": "^9.7.0",
+ "react": "^19.2.8",
+ "react-dom": "^19.2.8",
+ "three": "^0.164.1",
+ "zustand": "^5.0.15"
+ },
+ "devDependencies": {
+ "@vitejs/plugin-react": "^6.1.0",
+ "vite": "^8.2.2"
+ }
+ },
+ "node_modules/@babel/code-frame": {
+ "version": "7.29.7",
+ "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz",
+ "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-validator-identifier": "^7.29.7",
+ "js-tokens": "^4.0.0",
+ "picocolors": "^1.1.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/generator": {
+ "version": "7.29.8",
+ "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.8.tgz",
+ "integrity": "sha512-gZbepsdh3WDtgZKWL+vTPh71LSBrm/Y4/QDZBVCcYfmeTEEuoOYwlSy+G1StfJg+/Zy550u/3TATbm7qDbbMtg==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/parser": "^7.29.8",
+ "@babel/types": "^7.29.8",
+ "@jridgewell/gen-mapping": "^0.3.12",
+ "@jridgewell/trace-mapping": "^0.3.28",
+ "jsesc": "^3.0.2"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-globals": {
+ "version": "7.29.7",
+ "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz",
+ "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-module-imports": {
+ "version": "7.29.7",
+ "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz",
+ "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/traverse": "^7.29.7",
+ "@babel/types": "^7.29.7"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-string-parser": {
+ "version": "7.29.7",
+ "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
+ "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-validator-identifier": {
+ "version": "7.29.7",
+ "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
+ "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/parser": {
+ "version": "7.29.8",
+ "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.8.tgz",
+ "integrity": "sha512-E8lTAYNB1KW+FH+VGJuZM1ioAx2E6oVlvQFRrf5P8ZZmsiJXYAD9vTFV7yyEURNzgh1dFqMZuO6tUwcARbqFCA==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/types": "^7.29.8"
+ },
+ "bin": {
+ "parser": "bin/babel-parser.js"
+ },
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
+ "node_modules/@babel/runtime": {
+ "version": "7.29.7",
+ "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz",
+ "integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/template": {
+ "version": "7.29.7",
+ "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz",
+ "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/code-frame": "^7.29.7",
+ "@babel/parser": "^7.29.7",
+ "@babel/types": "^7.29.7"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/traverse": {
+ "version": "7.29.8",
+ "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.8.tgz",
+ "integrity": "sha512-I5z7H3bf/41ktsNVLtpN0wAa336HkqIHQ5BuPLEhTkt1jVSyZpeNKIzTgEWmlxjdg81R0IgUCcaE+Ok3NvrfZg==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/code-frame": "^7.29.7",
+ "@babel/generator": "^7.29.8",
+ "@babel/helper-globals": "^7.29.7",
+ "@babel/parser": "^7.29.8",
+ "@babel/template": "^7.29.7",
+ "@babel/types": "^7.29.8",
+ "debug": "^4.3.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/types": {
+ "version": "7.29.8",
+ "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.8.tgz",
+ "integrity": "sha512-Vj1jF3cPfxg7OAfoI7QnVKLoILlm2JF9pnVHrX8qx7AHMiYWT+NDAA7jChlNgRS4WTLc/fD1lXLmPixluj+3Gg==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-string-parser": "^7.29.7",
+ "@babel/helper-validator-identifier": "^7.29.7"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@emotion/babel-plugin": {
+ "version": "11.13.5",
+ "resolved": "https://registry.npmjs.org/@emotion/babel-plugin/-/babel-plugin-11.13.5.tgz",
+ "integrity": "sha512-pxHCpT2ex+0q+HH91/zsdHkw/lXd468DIN2zvfvLtPKLLMo6gQj7oLObq8PhkrxOZb/gGCq03S3Z7PDhS8pduQ==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-module-imports": "^7.16.7",
+ "@babel/runtime": "^7.18.3",
+ "@emotion/hash": "^0.9.2",
+ "@emotion/memoize": "^0.9.0",
+ "@emotion/serialize": "^1.3.3",
+ "babel-plugin-macros": "^3.1.0",
+ "convert-source-map": "^1.5.0",
+ "escape-string-regexp": "^4.0.0",
+ "find-root": "^1.1.0",
+ "source-map": "^0.5.7",
+ "stylis": "4.2.0"
+ }
+ },
+ "node_modules/@emotion/cache": {
+ "version": "11.14.0",
+ "resolved": "https://registry.npmjs.org/@emotion/cache/-/cache-11.14.0.tgz",
+ "integrity": "sha512-L/B1lc/TViYk4DcpGxtAVbx0ZyiKM5ktoIyafGkH6zg/tj+mA+NE//aPYKG0k8kCHSHVJrpLpcAlOBEXQ3SavA==",
+ "license": "MIT",
+ "dependencies": {
+ "@emotion/memoize": "^0.9.0",
+ "@emotion/sheet": "^1.4.0",
+ "@emotion/utils": "^1.4.2",
+ "@emotion/weak-memoize": "^0.4.0",
+ "stylis": "4.2.0"
+ }
+ },
+ "node_modules/@emotion/hash": {
+ "version": "0.9.2",
+ "resolved": "https://registry.npmjs.org/@emotion/hash/-/hash-0.9.2.tgz",
+ "integrity": "sha512-MyqliTZGuOm3+5ZRSaaBGP3USLw6+EGykkwZns2EPC5g8jJ4z9OrdZY9apkl3+UP9+sdz76YYkwCKP5gh8iY3g==",
+ "license": "MIT"
+ },
+ "node_modules/@emotion/is-prop-valid": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/@emotion/is-prop-valid/-/is-prop-valid-1.4.0.tgz",
+ "integrity": "sha512-QgD4fyscGcbbKwJmqNvUMSE02OsHUa+lAWKdEUIJKgqe5IwRSKd7+KhibEWdaKwgjLj0DRSHA9biAIqGBk05lw==",
+ "license": "MIT",
+ "dependencies": {
+ "@emotion/memoize": "^0.9.0"
+ }
+ },
+ "node_modules/@emotion/memoize": {
+ "version": "0.9.0",
+ "resolved": "https://registry.npmjs.org/@emotion/memoize/-/memoize-0.9.0.tgz",
+ "integrity": "sha512-30FAj7/EoJ5mwVPOWhAyCX+FPfMDrVecJAM+Iw9NRoSl4BBAQeqj4cApHHUXOVvIPgLVDsCFoz/hGD+5QQD1GQ==",
+ "license": "MIT"
+ },
+ "node_modules/@emotion/react": {
+ "version": "11.14.0",
+ "resolved": "https://registry.npmjs.org/@emotion/react/-/react-11.14.0.tgz",
+ "integrity": "sha512-O000MLDBDdk/EohJPFUqvnp4qnHeYkVP5B0xEG0D/L7cOKP9kefu2DXn8dj74cQfsEzUqh+sr1RzFqiL1o+PpA==",
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "@babel/runtime": "^7.18.3",
+ "@emotion/babel-plugin": "^11.13.5",
+ "@emotion/cache": "^11.14.0",
+ "@emotion/serialize": "^1.3.3",
+ "@emotion/use-insertion-effect-with-fallbacks": "^1.2.0",
+ "@emotion/utils": "^1.4.2",
+ "@emotion/weak-memoize": "^0.4.0",
+ "hoist-non-react-statics": "^3.3.1"
+ },
+ "peerDependencies": {
+ "react": ">=16.8.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@emotion/serialize": {
+ "version": "1.3.3",
+ "resolved": "https://registry.npmjs.org/@emotion/serialize/-/serialize-1.3.3.tgz",
+ "integrity": "sha512-EISGqt7sSNWHGI76hC7x1CksiXPahbxEOrC5RjmFRJTqLyEK9/9hZvBbiYn70dw4wuwMKiEMCUlR6ZXTSWQqxA==",
+ "license": "MIT",
+ "dependencies": {
+ "@emotion/hash": "^0.9.2",
+ "@emotion/memoize": "^0.9.0",
+ "@emotion/unitless": "^0.10.0",
+ "@emotion/utils": "^1.4.2",
+ "csstype": "^3.0.2"
+ }
+ },
+ "node_modules/@emotion/sheet": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/@emotion/sheet/-/sheet-1.4.0.tgz",
+ "integrity": "sha512-fTBW9/8r2w3dXWYM4HCB1Rdp8NLibOw2+XELH5m5+AkWiL/KqYX6dc0kKYlaYyKjrQ6ds33MCdMPEwgs2z1rqg==",
+ "license": "MIT"
+ },
+ "node_modules/@emotion/styled": {
+ "version": "11.14.1",
+ "resolved": "https://registry.npmjs.org/@emotion/styled/-/styled-11.14.1.tgz",
+ "integrity": "sha512-qEEJt42DuToa3gurlH4Qqc1kVpNq8wO8cJtDzU46TjlzWjDlsVyevtYCRijVq3SrHsROS+gVQ8Fnea108GnKzw==",
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "@babel/runtime": "^7.18.3",
+ "@emotion/babel-plugin": "^11.13.5",
+ "@emotion/is-prop-valid": "^1.3.0",
+ "@emotion/serialize": "^1.3.3",
+ "@emotion/use-insertion-effect-with-fallbacks": "^1.2.0",
+ "@emotion/utils": "^1.4.2"
+ },
+ "peerDependencies": {
+ "@emotion/react": "^11.0.0-rc.0",
+ "react": ">=16.8.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@emotion/unitless": {
+ "version": "0.10.0",
+ "resolved": "https://registry.npmjs.org/@emotion/unitless/-/unitless-0.10.0.tgz",
+ "integrity": "sha512-dFoMUuQA20zvtVTuxZww6OHoJYgrzfKM1t52mVySDJnMSEa08ruEvdYQbhvyu6soU+NeLVd3yKfTfT0NeV6qGg==",
+ "license": "MIT"
+ },
+ "node_modules/@emotion/use-insertion-effect-with-fallbacks": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/@emotion/use-insertion-effect-with-fallbacks/-/use-insertion-effect-with-fallbacks-1.2.0.tgz",
+ "integrity": "sha512-yJMtVdH59sxi/aVJBpk9FQq+OR8ll5GT8oWd57UpeaKEVGab41JWaCFA7FRLoMLloOZF/c/wsPoe+bfGmRKgDg==",
+ "license": "MIT",
+ "peerDependencies": {
+ "react": ">=16.8.0"
+ }
+ },
+ "node_modules/@emotion/utils": {
+ "version": "1.4.2",
+ "resolved": "https://registry.npmjs.org/@emotion/utils/-/utils-1.4.2.tgz",
+ "integrity": "sha512-3vLclRofFziIa3J2wDh9jjbkUz9qk5Vi3IZ/FSTKViB0k+ef0fPV7dYrUIugbgupYDx7v9ud/SjrtEP8Y4xLoA==",
+ "license": "MIT"
+ },
+ "node_modules/@emotion/weak-memoize": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/@emotion/weak-memoize/-/weak-memoize-0.4.0.tgz",
+ "integrity": "sha512-snKqtPW01tN0ui7yu9rGv69aJXr/a/Ywvl11sUjNtEcRc+ng/mQriFL0wLXMef74iHa/EkftbDzU9F8iFbH+zg==",
+ "license": "MIT"
+ },
+ "node_modules/@jridgewell/gen-mapping": {
+ "version": "0.3.13",
+ "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+ "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/sourcemap-codec": "^1.5.0",
+ "@jridgewell/trace-mapping": "^0.3.24"
+ }
+ },
+ "node_modules/@jridgewell/resolve-uri": {
+ "version": "3.1.2",
+ "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+ "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
+ "node_modules/@jridgewell/sourcemap-codec": {
+ "version": "1.5.5",
+ "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+ "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+ "license": "MIT"
+ },
+ "node_modules/@jridgewell/trace-mapping": {
+ "version": "0.3.31",
+ "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+ "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/resolve-uri": "^3.1.0",
+ "@jridgewell/sourcemap-codec": "^1.4.14"
+ }
+ },
+ "node_modules/@mui/core-downloads-tracker": {
+ "version": "9.3.1",
+ "resolved": "https://registry.npmjs.org/@mui/core-downloads-tracker/-/core-downloads-tracker-9.3.1.tgz",
+ "integrity": "sha512-IAyAFNQbT7hysJ9HXphiOmWJF7G1OglzHanqCgvQgH9LA2ydxtmaTBDbcBqw6euZesyShiwvpvbnYO1GY1AyXQ==",
+ "license": "MIT",
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ }
+ },
+ "node_modules/@mui/material": {
+ "version": "9.3.1",
+ "resolved": "https://registry.npmjs.org/@mui/material/-/material-9.3.1.tgz",
+ "integrity": "sha512-NahAEGIXqS1K0bA4th1jeFxBguS59NOcLbMA0vU+fSaPWKjtwGBGGHeTwlc9PSmzMjOZKceeFWESB8fVHr31hA==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.29.7",
+ "@mui/core-downloads-tracker": "^9.3.1",
+ "@mui/system": "^9.3.0",
+ "@mui/types": "^9.3.0",
+ "@mui/utils": "^9.3.0",
+ "@popperjs/core": "^2.11.8",
+ "@types/react-transition-group": "^4.4.12",
+ "clsx": "^2.1.1",
+ "csstype": "^3.2.3",
+ "prop-types": "^15.8.1",
+ "react-is": "^19.2.8",
+ "react-transition-group": "^4.4.5"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@emotion/react": "^11.5.0",
+ "@emotion/styled": "^11.3.0",
+ "@mui/material-pigment-css": "^9.3.0",
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+ "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@emotion/react": {
+ "optional": true
+ },
+ "@emotion/styled": {
+ "optional": true
+ },
+ "@mui/material-pigment-css": {
+ "optional": true
+ },
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/private-theming": {
+ "version": "9.3.0",
+ "resolved": "https://registry.npmjs.org/@mui/private-theming/-/private-theming-9.3.0.tgz",
+ "integrity": "sha512-ERvqk5pejf9aRnQcDILSWGtFmsEMiVxlQ4+xsVCjsEvmK0fV9BiVP/cQwAF5dwyDFbve4lTrlcgeFEecVzTNiA==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.29.7",
+ "@mui/utils": "^9.3.0",
+ "prop-types": "^15.8.1"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/styled-engine": {
+ "version": "9.3.0",
+ "resolved": "https://registry.npmjs.org/@mui/styled-engine/-/styled-engine-9.3.0.tgz",
+ "integrity": "sha512-x9+KYxhjoHYZ4nioxdKnvQWdw0RScbhoZfQ4tv3Db742683U3wlYSp6zV6Us78dMFnKnyTrPTkQKyutp14gnKA==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.29.7",
+ "@emotion/cache": "^11.14.0",
+ "@emotion/serialize": "^1.3.3",
+ "@emotion/sheet": "^1.4.0",
+ "csstype": "^3.2.3",
+ "prop-types": "^15.8.1"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@emotion/react": "^11.4.1",
+ "@emotion/styled": "^11.3.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@emotion/react": {
+ "optional": true
+ },
+ "@emotion/styled": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/system": {
+ "version": "9.3.0",
+ "resolved": "https://registry.npmjs.org/@mui/system/-/system-9.3.0.tgz",
+ "integrity": "sha512-0l4LqHJxZj65xSrioniGsxm7VNoGXonPo203oZjhBUvIDPeBqRTb7Mqc45Qxs6sO6WGR7WE/9cJ6lb4lkvHkjg==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.29.7",
+ "@mui/private-theming": "^9.3.0",
+ "@mui/styled-engine": "^9.3.0",
+ "@mui/types": "^9.3.0",
+ "@mui/utils": "^9.3.0",
+ "clsx": "^2.1.1",
+ "csstype": "^3.2.3",
+ "prop-types": "^15.8.1"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@emotion/react": "^11.5.0",
+ "@emotion/styled": "^11.3.0",
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@emotion/react": {
+ "optional": true
+ },
+ "@emotion/styled": {
+ "optional": true
+ },
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/types": {
+ "version": "9.3.0",
+ "resolved": "https://registry.npmjs.org/@mui/types/-/types-9.3.0.tgz",
+ "integrity": "sha512-2JSxyfpEFWNUB2vKs/T1BvkfyNisMHWph8bLMj8T0uHwmLl/0qfAwQkfwMT6kxLXN9uIum9AEbECXU8er3amIg==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.29.7"
+ },
+ "peerDependencies": {
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/utils": {
+ "version": "9.3.0",
+ "resolved": "https://registry.npmjs.org/@mui/utils/-/utils-9.3.0.tgz",
+ "integrity": "sha512-2HZdHwWJ6eB+7lVGSOHsByGw8jeRulT4g0NZ608Wb8Q57DE2jbNqrWPFuJsvkQQiBiTmlpvQL3i+/62zsiPrkw==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.29.7",
+ "@mui/types": "^9.3.0",
+ "@types/prop-types": "^15.7.15",
+ "clsx": "^2.1.1",
+ "prop-types": "^15.8.1",
+ "react-is": "^19.2.8"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@oxc-project/types": {
+ "version": "0.146.0",
+ "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.146.0.tgz",
+ "integrity": "sha512-XC0QsnnhVe7sLIWmYmdPw7x5P0h4W8vUU3Nv1ySgWXtvCz8NizoAEpGXA0sOYoJQV2Rl13LgURAHQ5cI5ILCSA==",
+ "dev": true,
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/Boshen"
+ }
+ },
+ "node_modules/@popperjs/core": {
+ "version": "2.11.8",
+ "resolved": "https://registry.npmjs.org/@popperjs/core/-/core-2.11.8.tgz",
+ "integrity": "sha512-P1st0aksCrn9sGZhp8GMYwBnQsbvAWsZAX44oXNNvLHGqAOcoVxmjZiohstwQ7SqKnbR47akdNi+uleWD8+g6A==",
+ "license": "MIT",
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/popperjs"
+ }
+ },
+ "node_modules/@react-three/fiber": {
+ "version": "9.7.0",
+ "resolved": "https://registry.npmjs.org/@react-three/fiber/-/fiber-9.7.0.tgz",
+ "integrity": "sha512-EWm9FwcaOZQu/ExFW5rggoCMM1NJet5YbxVxKaOE+KSncrjU0Wx7017qSyGFvupviK89nMYGCWU3BIK4dI1clw==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.17.8",
+ "@types/webxr": "*",
+ "base64-js": "^1.5.1",
+ "buffer": "^6.0.3",
+ "its-fine": "^2.0.0",
+ "react-use-measure": "^2.1.7",
+ "scheduler": "^0.27.0",
+ "suspend-react": "^0.1.3",
+ "use-sync-external-store": "^1.4.0",
+ "zustand": "^5.0.3"
+ },
+ "peerDependencies": {
+ "expo": ">=43.0",
+ "expo-asset": ">=8.4",
+ "expo-file-system": ">=11.0",
+ "expo-gl": ">=11.0",
+ "react": ">=19 <19.3",
+ "react-dom": ">=19 <19.3",
+ "react-native": ">=0.78",
+ "three": ">=0.156"
+ },
+ "peerDependenciesMeta": {
+ "expo": {
+ "optional": true
+ },
+ "expo-asset": {
+ "optional": true
+ },
+ "expo-file-system": {
+ "optional": true
+ },
+ "expo-gl": {
+ "optional": true
+ },
+ "react-dom": {
+ "optional": true
+ },
+ "react-native": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@rolldown/binding-android-arm-eabi": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm-eabi/-/binding-android-arm-eabi-1.2.5.tgz",
+ "integrity": "sha512-DLe/i+l8ynIBY7XEQ191TeZvCoowIGa18R+dIV30GW7DiOtp74i/xX8hs8GUjW5ARV7VZuie3d6AumSmCwbeRA==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-android-arm64": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.2.5.tgz",
+ "integrity": "sha512-zXcwKlQApYAOELHd8PwKDFkagYF9Wy4e0RJ+0qnzl9Pjnpj75TEG8ufv40p2J7kCEfwZAsNiuzRIyNNMWT38ig==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-darwin-arm64": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.2.5.tgz",
+ "integrity": "sha512-dK4QakI42nzWgJT5sm4y4y/O//D4OxM75/cH28RLV+nzIN9AY+YsbuUVrUTjlLjXR6vpyxFbSsbmNuJ6BP9sww==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-darwin-x64": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.2.5.tgz",
+ "integrity": "sha512-fqSALaUu1Wjd1nK2uW2kJDWdLCc8lx1IcY+MTY26Aurfdx19anlzhqXOgCFbBFQnlFDTn4TC1/7Nz4Bl2mLP3A==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-freebsd-x64": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.2.5.tgz",
+ "integrity": "sha512-/vCnNxlkxs9tKxNDcyWUePpJ/PgTzxIaVhoM5SmG8UV+GR/IcPam4VYxi7GIMo7PSDuNqlJqvprqii9NqqVCMw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "freebsd"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.2.5.tgz",
+ "integrity": "sha512-abk0NLA519LxRCszmbE0jYKuQ9YPocOXTiOXOo6Yr+YAT95VH+PtqYAjOJvGKt3viEd/x4qzabAlwd5bHOOARg==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-arm64-gnu": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.2.5.tgz",
+ "integrity": "sha512-Y7eALiJ8lr0M2HH103Js+g7V34wf6snlpZLAsHI90uLhr3PVlNsbFVAXJC9d/V6BnPyKtpSwI+NcB/RLxsQxuA==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-arm64-musl": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.2.5.tgz",
+ "integrity": "sha512-xMvZgnbZg4YVnR/AX2b3oOPDTFYJvUVaJg5FedA/LuvexAtXibZQej4cnTkw3rjsJ/ggUROB64TdtETiim+FYA==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-ppc64-gnu": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.2.5.tgz",
+ "integrity": "sha512-GRjeqTUDHTo5GwntsLaAMcBahG3nlpjftXWZLN73HiYQlhwEowvarFgQnRnQZtIp4keXX7quXFbG38uPZBa2EA==",
+ "cpu": [
+ "ppc64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-s390x-gnu": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.2.5.tgz",
+ "integrity": "sha512-vLNTR45F2Uwc8AufkNXPmB4VliaXs+FvcheEogIzOXzO4l+LzieXF5A/TWxLy5HtqpsRCHUfd0lPVrrdgXdLHQ==",
+ "cpu": [
+ "s390x"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-x64-gnu": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.2.5.tgz",
+ "integrity": "sha512-Mgj59/HTuYeK9Gz2MA+mBWKnHsAgkBSec15ZMb1st3oIfFbX7gCjOae7GydHhzcyQi9Z/7M1QuN9bR3oFqF0jQ==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-x64-musl": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.2.5.tgz",
+ "integrity": "sha512-mY8AP0/ichsbhAxGnLa3d3+MwV0EfgrPND2bplI3Ym8T6R2pJ0N87bvrKVwNXmdy3jnr6eQBecdqx/HMknBmpA==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-openharmony-arm64": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.2.5.tgz",
+ "integrity": "sha512-8SLssA2oweAxyRgDp789ACfRb/3P+zNRJpzZxSizxF9m8NUDQ4+3xjo8ttjhVGGw6Qxb70oZiEtIjaKikCO7Yw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "openharmony"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-win32-arm64-msvc": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.2.5.tgz",
+ "integrity": "sha512-vGbruD5zquhoc8D9SViXgN2FBJtNdTyQ4DtG+SWiEGlJiAzoKcZ2xp+xuXCffhubVdt0NJlTZqkeRuERy7g8Cw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-win32-x64-msvc": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.2.5.tgz",
+ "integrity": "sha512-e/SXpgISz+IoqVcSSI0rx/d/he8zqLex+/rCWpnHpmVfmPIUjag9H6P7zotf0gJHwPUhQxZ/mF8tr6acebT9yw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/pluginutils": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz",
+ "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/parse-json": {
+ "version": "4.0.2",
+ "resolved": "https://registry.npmjs.org/@types/parse-json/-/parse-json-4.0.2.tgz",
+ "integrity": "sha512-dISoDXWWQwUquiKsyZ4Ng+HX2KsPL7LyHKHQwgGFEA3IaKac4Obd+h2a/a6waisAoepJlBcx9paWqjA8/HVjCw==",
+ "license": "MIT"
+ },
+ "node_modules/@types/prop-types": {
+ "version": "15.7.15",
+ "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz",
+ "integrity": "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==",
+ "license": "MIT"
+ },
+ "node_modules/@types/react": {
+ "version": "19.2.18",
+ "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.18.tgz",
+ "integrity": "sha512-AnzbBERsrLKtk2XSfTbYRLjQPdy116Sty4q+T+Bp3IC4l6jNBvreVPAHmpq9qhXQM7CXZPjLVmGMw9sy+hxQ3w==",
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "csstype": "^3.2.2"
+ }
+ },
+ "node_modules/@types/react-reconciler": {
+ "version": "0.28.9",
+ "resolved": "https://registry.npmjs.org/@types/react-reconciler/-/react-reconciler-0.28.9.tgz",
+ "integrity": "sha512-HHM3nxyUZ3zAylX8ZEyrDNd2XZOnQ0D5XfunJF5FLQnZbHHYq4UWvW1QfelQNXv1ICNkwYhfxjwfnqivYB6bFg==",
+ "license": "MIT",
+ "peerDependencies": {
+ "@types/react": "*"
+ }
+ },
+ "node_modules/@types/react-transition-group": {
+ "version": "4.4.12",
+ "resolved": "https://registry.npmjs.org/@types/react-transition-group/-/react-transition-group-4.4.12.tgz",
+ "integrity": "sha512-8TV6R3h2j7a91c+1DXdJi3Syo69zzIZbz7Lg5tORM5LEJG7X/E6a1V3drRyBRZq7/utz7A+c4OgYLiLcYGHG6w==",
+ "license": "MIT",
+ "peerDependencies": {
+ "@types/react": "*"
+ }
+ },
+ "node_modules/@types/webxr": {
+ "version": "0.5.24",
+ "resolved": "https://registry.npmjs.org/@types/webxr/-/webxr-0.5.24.tgz",
+ "integrity": "sha512-h8fgEd/DpoS9CBrjEQXR+dIDraopAEfu4wYVNY2tEPwk60stPWhvZMf4Foo5FakuQ7HFZoa8WceaWFervK2Ovg==",
+ "license": "MIT"
+ },
+ "node_modules/@vitejs/plugin-react": {
+ "version": "6.1.0",
+ "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-6.1.0.tgz",
+ "integrity": "sha512-qd2BzUBehkov86WFhg0JkEFEYyCLG9uPCe6qWTY/kRlss9OvJrOF2UbIWT7p+8IzZHkEu0DNGHc4HSv+JdDLsw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@rolldown/pluginutils": "^1.0.1"
+ },
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ },
+ "peerDependencies": {
+ "@rolldown/plugin-babel": "^0.1.7 || ^0.2.0",
+ "babel-plugin-react-compiler": "^1.0.0",
+ "oxc-transform-react": "^0.145.0",
+ "vite": "^8.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@rolldown/plugin-babel": {
+ "optional": true
+ },
+ "babel-plugin-react-compiler": {
+ "optional": true
+ },
+ "oxc-transform-react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/babel-plugin-macros": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/babel-plugin-macros/-/babel-plugin-macros-3.1.0.tgz",
+ "integrity": "sha512-Cg7TFGpIr01vOQNODXOOaGz2NpCU5gl8x1qJFbb6hbZxR7XrcE2vtbAsTAbJ7/xwJtUuJEw8K8Zr/AE0LHlesg==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.12.5",
+ "cosmiconfig": "^7.0.0",
+ "resolve": "^1.19.0"
+ },
+ "engines": {
+ "node": ">=10",
+ "npm": ">=6"
+ }
+ },
+ "node_modules/base64-js": {
+ "version": "1.5.1",
+ "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+ "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ],
+ "license": "MIT"
+ },
+ "node_modules/buffer": {
+ "version": "6.0.3",
+ "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz",
+ "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==",
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "base64-js": "^1.3.1",
+ "ieee754": "^1.2.1"
+ }
+ },
+ "node_modules/callsites": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+ "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/clsx": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
+ "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/convert-source-map": {
+ "version": "1.9.0",
+ "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz",
+ "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==",
+ "license": "MIT"
+ },
+ "node_modules/cosmiconfig": {
+ "version": "7.1.0",
+ "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-7.1.0.tgz",
+ "integrity": "sha512-AdmX6xUzdNASswsFtmwSt7Vj8po9IuqXm0UXz7QKPuEUmPB4XyjGfaAr2PSuELMwkRMVH1EpIkX5bTZGRB3eCA==",
+ "license": "MIT",
+ "dependencies": {
+ "@types/parse-json": "^4.0.0",
+ "import-fresh": "^3.2.1",
+ "parse-json": "^5.0.0",
+ "path-type": "^4.0.0",
+ "yaml": "^1.10.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/cosmiconfig/node_modules/yaml": {
+ "version": "1.10.3",
+ "resolved": "https://registry.npmjs.org/yaml/-/yaml-1.10.3.tgz",
+ "integrity": "sha512-vIYeF1u3CjlhAFekPPAk2h/Kv4T3mAkMox5OymRiJQB0spDP10LHvt+K7G9Ny6NuuMAb25/6n1qyUjAcGNf/AA==",
+ "license": "ISC",
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/csstype": {
+ "version": "3.2.3",
+ "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+ "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+ "license": "MIT"
+ },
+ "node_modules/debug": {
+ "version": "4.4.3",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+ "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+ "license": "MIT",
+ "dependencies": {
+ "ms": "^2.1.3"
+ },
+ "engines": {
+ "node": ">=6.0"
+ },
+ "peerDependenciesMeta": {
+ "supports-color": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/detect-libc": {
+ "version": "2.1.2",
+ "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+ "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/dom-helpers": {
+ "version": "5.2.1",
+ "resolved": "https://registry.npmjs.org/dom-helpers/-/dom-helpers-5.2.1.tgz",
+ "integrity": "sha512-nRCa7CK3VTrM2NmGkIy4cbK7IZlgBE/PYMn55rrXefr5xXDP0LdtfPnblFDoVdcAfslJ7or6iqAUnx0CCGIWQA==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.8.7",
+ "csstype": "^3.0.2"
+ }
+ },
+ "node_modules/error-ex": {
+ "version": "1.3.4",
+ "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.4.tgz",
+ "integrity": "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==",
+ "license": "MIT",
+ "dependencies": {
+ "is-arrayish": "^0.2.1"
+ }
+ },
+ "node_modules/es-errors": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+ "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/escape-string-regexp": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+ "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/fdir": {
+ "version": "6.5.0",
+ "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+ "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=12.0.0"
+ },
+ "peerDependencies": {
+ "picomatch": "^3 || ^4"
+ },
+ "peerDependenciesMeta": {
+ "picomatch": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/find-root": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/find-root/-/find-root-1.1.0.tgz",
+ "integrity": "sha512-NKfW6bec6GfKc0SGx1e07QZY9PE99u0Bft/0rzSD5k3sO/vwkVUpDUKVm5Gpp5Ue3YfShPFTX2070tDs5kB9Ng==",
+ "license": "MIT"
+ },
+ "node_modules/fsevents": {
+ "version": "2.3.3",
+ "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+ "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+ }
+ },
+ "node_modules/function-bind": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+ "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/hasown": {
+ "version": "2.0.4",
+ "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
+ "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
+ "license": "MIT",
+ "dependencies": {
+ "function-bind": "^1.1.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/hoist-non-react-statics": {
+ "version": "3.3.2",
+ "resolved": "https://registry.npmjs.org/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz",
+ "integrity": "sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==",
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "react-is": "^16.7.0"
+ }
+ },
+ "node_modules/hoist-non-react-statics/node_modules/react-is": {
+ "version": "16.13.1",
+ "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
+ "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
+ "license": "MIT"
+ },
+ "node_modules/ieee754": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+ "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ],
+ "license": "BSD-3-Clause"
+ },
+ "node_modules/import-fresh": {
+ "version": "3.3.1",
+ "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+ "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+ "license": "MIT",
+ "dependencies": {
+ "parent-module": "^1.0.0",
+ "resolve-from": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=6"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/is-arrayish": {
+ "version": "0.2.1",
+ "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
+ "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==",
+ "license": "MIT"
+ },
+ "node_modules/is-core-module": {
+ "version": "2.16.2",
+ "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.2.tgz",
+ "integrity": "sha512-evOr8xfXKxE6qSR0hSXL2r3sd7ALj8+7jQEUvPYcm5sgZFdJ+AYzT6yNmJenvIYQBgIGwfwz08sL8zoL7yq2BA==",
+ "license": "MIT",
+ "dependencies": {
+ "hasown": "^2.0.3"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/its-fine": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/its-fine/-/its-fine-2.0.0.tgz",
+ "integrity": "sha512-KLViCmWx94zOvpLwSlsx6yOCeMhZYaxrJV87Po5k/FoZzcPSahvK5qJ7fYhS61sZi5ikmh2S3Hz55A2l3U69ng==",
+ "license": "MIT",
+ "dependencies": {
+ "@types/react-reconciler": "^0.28.9"
+ },
+ "peerDependencies": {
+ "react": "^19.0.0"
+ }
+ },
+ "node_modules/js-tokens": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+ "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+ "license": "MIT"
+ },
+ "node_modules/jsesc": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+ "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+ "license": "MIT",
+ "bin": {
+ "jsesc": "bin/jsesc"
+ },
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/json-parse-even-better-errors": {
+ "version": "2.3.1",
+ "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
+ "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
+ "license": "MIT"
+ },
+ "node_modules/lightningcss": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.33.0.tgz",
+ "integrity": "sha512-WkUDrojuJs0xkgGf2udWxa3yGBRxPtxUkB79i6aCZLRgc7PM8fZe9TosfPDcvEpQZbuFASnHYmRLBLUbmLOIIA==",
+ "dev": true,
+ "license": "MPL-2.0",
+ "dependencies": {
+ "detect-libc": "^2.0.3"
+ },
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ },
+ "optionalDependencies": {
+ "lightningcss-android-arm64": "1.33.0",
+ "lightningcss-darwin-arm64": "1.33.0",
+ "lightningcss-darwin-x64": "1.33.0",
+ "lightningcss-freebsd-x64": "1.33.0",
+ "lightningcss-linux-arm-gnueabihf": "1.33.0",
+ "lightningcss-linux-arm64-gnu": "1.33.0",
+ "lightningcss-linux-arm64-musl": "1.33.0",
+ "lightningcss-linux-x64-gnu": "1.33.0",
+ "lightningcss-linux-x64-musl": "1.33.0",
+ "lightningcss-win32-arm64-msvc": "1.33.0",
+ "lightningcss-win32-x64-msvc": "1.33.0"
+ }
+ },
+ "node_modules/lightningcss-android-arm64": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.33.0.tgz",
+ "integrity": "sha512-gEpRTalKdosp4Bb8qWtc2iOgE5SeIHlpS1up9bFq2wAyYhl1UdTObYiHe98zEM9SQvSoqQZ1IQD0JNpg3Ml5pg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-darwin-arm64": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.33.0.tgz",
+ "integrity": "sha512-Sciaz8eenNTKn9b3t7+xr0ipTp9YxKQY4npwQ3mrRuL0BAVHBLyZxofhaKBAVtzmtRZ/zTyo0/to4B1uWG/Djg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-darwin-x64": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.33.0.tgz",
+ "integrity": "sha512-Z5UPAxzrjlWNNyGy6i65cJzzvgJ5D3T6wMvs+gWpY9d7qRhANrxqAp6LhxIgZhWEw18RfJTGcRxjuLIBr+m8XQ==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-freebsd-x64": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.33.0.tgz",
+ "integrity": "sha512-QQM/Ti/hQajJwCY+RiWuCZ9sdtI/XQk7nDK5vC8kkdwixezOlDgvDx7+RT+QjK6FcFT4MpsuoBnHIo/O3StRRg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "freebsd"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-linux-arm-gnueabihf": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.33.0.tgz",
+ "integrity": "sha512-N7FVBe6iS24MlM6R/4RBTxGhQheZGs7tiQ9U32UtF75NzP5Q7xWPRqLBCKxlRQRk3rY1jCIPLzx7WzOhuUIRLQ==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-linux-arm64-gnu": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.33.0.tgz",
+ "integrity": "sha512-j2v/itmy4HlNxlc6voKXYgBqNi0Ng2LShg4z7GufpEgs05P+2suBVyi9I6YHq5uoVFx9ETin3eCEhLVyXGQnKg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-linux-arm64-musl": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.33.0.tgz",
+ "integrity": "sha512-yiO5ROMuYQgXbC60yjZU5CYSFZGKXL0HFATXt9mHJn1+zW55oCtMI9NfcVhYLMFDL7gV7oBPon/EmMMGg2OvtQ==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-linux-x64-gnu": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.33.0.tgz",
+ "integrity": "sha512-ar+Ju7LmcN0Jo4FpL4hpFybwNG9/3A/Br5KW2n2jyODg3MEZXaDYADdemoNS+BDNfMgKvylJLj4S5tyRActuAg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-linux-x64-musl": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.33.0.tgz",
+ "integrity": "sha512-RYiYbkokw0trfKqqzfF55lginwEPrD3OJDfTuJzFs1MK6iFnDenaz1fqLLtX4ITG3OktJQXOeTaw1awrBAlZPw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-win32-arm64-msvc": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.33.0.tgz",
+ "integrity": "sha512-1K+MPfLSFVpphzpdbfkhlWk6wBrTObBzS2T6db10PNOZgR9GoVsAWzwNyuhUYYbTp23j+4RrncfujZ4uAzXvwA==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-win32-x64-msvc": {
+ "version": "1.33.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.33.0.tgz",
+ "integrity": "sha512-OlEICDx/Xl0FqSp4bry8zFnCvGpig3Gl4gCquvYwHuqJKEC1+n9NgDniFvqHGmMv1ZkqDJrDqKKSykTDX+ehuA==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lines-and-columns": {
+ "version": "1.2.4",
+ "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
+ "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
+ "license": "MIT"
+ },
+ "node_modules/loose-envify": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+ "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+ "license": "MIT",
+ "dependencies": {
+ "js-tokens": "^3.0.0 || ^4.0.0"
+ },
+ "bin": {
+ "loose-envify": "cli.js"
+ }
+ },
+ "node_modules/ms": {
+ "version": "2.1.3",
+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+ "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+ "license": "MIT"
+ },
+ "node_modules/nanoid": {
+ "version": "3.3.18",
+ "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.18.tgz",
+ "integrity": "sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "license": "MIT",
+ "bin": {
+ "nanoid": "bin/nanoid.cjs"
+ },
+ "engines": {
+ "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+ }
+ },
+ "node_modules/object-assign": {
+ "version": "4.1.1",
+ "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+ "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/parent-module": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+ "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+ "license": "MIT",
+ "dependencies": {
+ "callsites": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/parse-json": {
+ "version": "5.2.0",
+ "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
+ "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/code-frame": "^7.0.0",
+ "error-ex": "^1.3.1",
+ "json-parse-even-better-errors": "^2.3.0",
+ "lines-and-columns": "^1.1.6"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/path-parse": {
+ "version": "1.0.7",
+ "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+ "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+ "license": "MIT"
+ },
+ "node_modules/path-type": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
+ "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/picocolors": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+ "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+ "license": "ISC"
+ },
+ "node_modules/picomatch": {
+ "version": "4.0.5",
+ "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz",
+ "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true,
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/jonschlinkert"
+ }
+ },
+ "node_modules/postcss": {
+ "version": "8.5.26",
+ "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.26.tgz",
+ "integrity": "sha512-u82N74LFzG8ca+dD8puPnplTXoGH4fTPpVGuIbt36G3qvNlkvfD0lEAZSxaly3KX8TS/L1A1gsCEmvKmBcVbkQ==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/postcss/"
+ },
+ {
+ "type": "tidelift",
+ "url": "https://tidelift.com/funding/github/npm/postcss"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "nanoid": "^3.3.17",
+ "picocolors": "^1.1.1",
+ "source-map-js": "^1.2.1"
+ },
+ "engines": {
+ "node": "^10 || ^12 || >=14"
+ }
+ },
+ "node_modules/prop-types": {
+ "version": "15.8.1",
+ "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
+ "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==",
+ "license": "MIT",
+ "dependencies": {
+ "loose-envify": "^1.4.0",
+ "object-assign": "^4.1.1",
+ "react-is": "^16.13.1"
+ }
+ },
+ "node_modules/prop-types/node_modules/react-is": {
+ "version": "16.13.1",
+ "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
+ "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
+ "license": "MIT"
+ },
+ "node_modules/react": {
+ "version": "19.2.8",
+ "resolved": "https://registry.npmjs.org/react/-/react-19.2.8.tgz",
+ "integrity": "sha512-PWaYA1L/q9u2u7xYQi+Y3L3Yfnie7XyLeaJICV1MGD6LprsBxcAqGjYyr0eY3p+QdsA+x/Irkt4Qif8D63+Sbw==",
+ "license": "MIT",
+ "peer": true,
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/react-dom": {
+ "version": "19.2.8",
+ "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.8.tgz",
+ "integrity": "sha512-rVprimfGBG3DR+Tq0IQG2DT5PxKth1WIGDmj5yPmlzr4YBe7uyE+Du4oVqTDXZSHGGGXRtTJEGSSePyQCMBglQ==",
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "scheduler": "^0.27.0"
+ },
+ "peerDependencies": {
+ "react": "^19.2.8"
+ }
+ },
+ "node_modules/react-is": {
+ "version": "19.2.8",
+ "resolved": "https://registry.npmjs.org/react-is/-/react-is-19.2.8.tgz",
+ "integrity": "sha512-s5un28nYxKJw5gvUHyW5PCC28CvBqLu9r3cWgzHT4Vo/5fqqkFcdRYsGcKf50WMPpjjFZS5d76fn3YCo2njKwQ==",
+ "license": "MIT"
+ },
+ "node_modules/react-transition-group": {
+ "version": "4.4.5",
+ "resolved": "https://registry.npmjs.org/react-transition-group/-/react-transition-group-4.4.5.tgz",
+ "integrity": "sha512-pZcd1MCJoiKiBR2NRxeCRg13uCXbydPnmB4EOeRrY7480qNWO8IIgQG6zlDkm6uRMsURXPuKq0GWtiM59a5Q6g==",
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "@babel/runtime": "^7.5.5",
+ "dom-helpers": "^5.0.1",
+ "loose-envify": "^1.4.0",
+ "prop-types": "^15.6.2"
+ },
+ "peerDependencies": {
+ "react": ">=16.6.0",
+ "react-dom": ">=16.6.0"
+ }
+ },
+ "node_modules/react-use-measure": {
+ "version": "2.1.7",
+ "resolved": "https://registry.npmjs.org/react-use-measure/-/react-use-measure-2.1.7.tgz",
+ "integrity": "sha512-KrvcAo13I/60HpwGO5jpW7E9DfusKyLPLvuHlUyP5zqnmAPhNc6qTRjUQrdTADl0lpPpDVU2/Gg51UlOGHXbdg==",
+ "license": "MIT",
+ "peerDependencies": {
+ "react": ">=16.13",
+ "react-dom": ">=16.13"
+ },
+ "peerDependenciesMeta": {
+ "react-dom": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/resolve": {
+ "version": "1.22.12",
+ "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.12.tgz",
+ "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==",
+ "license": "MIT",
+ "dependencies": {
+ "es-errors": "^1.3.0",
+ "is-core-module": "^2.16.1",
+ "path-parse": "^1.0.7",
+ "supports-preserve-symlinks-flag": "^1.0.0"
+ },
+ "bin": {
+ "resolve": "bin/resolve"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/resolve-from": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+ "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=4"
+ }
+ },
+ "node_modules/rolldown": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.2.5.tgz",
+ "integrity": "sha512-VD2IE5PUG4Oj8zz2VGykiYd5wbnjdIiSsNQb8Qu5B+noEp+A78mu2iVvpp27g8es14Tk9rofNs5Tku9iQCS4fA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@oxc-project/types": "=0.146.0",
+ "@rolldown/pluginutils": "^1.0.0"
+ },
+ "bin": {
+ "rolldown": "bin/cli.mjs"
+ },
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ },
+ "optionalDependencies": {
+ "@rolldown/binding-android-arm-eabi": "1.2.5",
+ "@rolldown/binding-android-arm64": "1.2.5",
+ "@rolldown/binding-darwin-arm64": "1.2.5",
+ "@rolldown/binding-darwin-x64": "1.2.5",
+ "@rolldown/binding-freebsd-x64": "1.2.5",
+ "@rolldown/binding-linux-arm-gnueabihf": "1.2.5",
+ "@rolldown/binding-linux-arm64-gnu": "1.2.5",
+ "@rolldown/binding-linux-arm64-musl": "1.2.5",
+ "@rolldown/binding-linux-ppc64-gnu": "1.2.5",
+ "@rolldown/binding-linux-s390x-gnu": "1.2.5",
+ "@rolldown/binding-linux-x64-gnu": "1.2.5",
+ "@rolldown/binding-linux-x64-musl": "1.2.5",
+ "@rolldown/binding-openharmony-arm64": "1.2.5",
+ "@rolldown/binding-win32-arm64-msvc": "1.2.5",
+ "@rolldown/binding-win32-x64-msvc": "1.2.5"
+ }
+ },
+ "node_modules/scheduler": {
+ "version": "0.27.0",
+ "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
+ "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==",
+ "license": "MIT"
+ },
+ "node_modules/source-map": {
+ "version": "0.5.7",
+ "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
+ "integrity": "sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==",
+ "license": "BSD-3-Clause",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/source-map-js": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+ "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/stylis": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/stylis/-/stylis-4.2.0.tgz",
+ "integrity": "sha512-Orov6g6BB1sDfYgzWfTHDOxamtX1bE/zo104Dh9e6fqJ3PooipYyfJ0pUmrZO2wAvO8YbEyeFrkV91XTsGMSrw==",
+ "license": "MIT"
+ },
+ "node_modules/supports-preserve-symlinks-flag": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+ "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/suspend-react": {
+ "version": "0.1.3",
+ "resolved": "https://registry.npmjs.org/suspend-react/-/suspend-react-0.1.3.tgz",
+ "integrity": "sha512-aqldKgX9aZqpoDp3e8/BZ8Dm7x1pJl+qI3ZKxDN0i/IQTWUwBx/ManmlVJ3wowqbno6c2bmiIfs+Um6LbsjJyQ==",
+ "license": "MIT",
+ "peerDependencies": {
+ "react": ">=17.0"
+ }
+ },
+ "node_modules/three": {
+ "version": "0.164.1",
+ "resolved": "https://registry.npmjs.org/three/-/three-0.164.1.tgz",
+ "integrity": "sha512-iC/hUBbl1vzFny7f5GtqzVXYjMJKaTPxiCxXfrvVdBi1Sf+jhd1CAkitiFwC7mIBFCo3MrDLJG97yisoaWig0w==",
+ "license": "MIT",
+ "peer": true
+ },
+ "node_modules/tinyglobby": {
+ "version": "0.2.17",
+ "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
+ "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fdir": "^6.5.0",
+ "picomatch": "^4.0.4"
+ },
+ "engines": {
+ "node": ">=12.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/SuperchupuDev"
+ }
+ },
+ "node_modules/use-sync-external-store": {
+ "version": "1.6.0",
+ "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.6.0.tgz",
+ "integrity": "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==",
+ "license": "MIT",
+ "peerDependencies": {
+ "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+ }
+ },
+ "node_modules/vite": {
+ "version": "8.2.2",
+ "resolved": "https://registry.npmjs.org/vite/-/vite-8.2.2.tgz",
+ "integrity": "sha512-cFKLV/PRgAUlIRm5WjMjJ86jrftzpqcgH+Us+DS8mI3CDNiH30Whrz8uHL3+MOLPAgqbMBAqWdAHAphOAM+z/Q==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "lightningcss": "^1.33.0",
+ "picomatch": "^4.0.5",
+ "postcss": "^8.5.26",
+ "rolldown": "~1.2.4",
+ "tinyglobby": "^0.2.17"
+ },
+ "bin": {
+ "vite": "bin/vite.js"
+ },
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ },
+ "funding": {
+ "url": "https://github.com/vitejs/vite?sponsor=1"
+ },
+ "optionalDependencies": {
+ "fsevents": "~2.3.3"
+ },
+ "peerDependencies": {
+ "@types/node": "^20.19.0 || >=22.12.0",
+ "@vitejs/devtools": "^0.4.0 || ^0.5.0",
+ "esbuild": "^0.27.0 || ^0.28.0",
+ "jiti": ">=1.21.0",
+ "less": "^4.0.0",
+ "sass": "^1.70.0",
+ "sass-embedded": "^1.70.0",
+ "stylus": ">=0.54.8",
+ "sugarss": "^5.0.0",
+ "terser": "^5.16.0",
+ "tsx": "^4.8.1",
+ "yaml": "^2.4.2"
+ },
+ "peerDependenciesMeta": {
+ "@types/node": {
+ "optional": true
+ },
+ "@vitejs/devtools": {
+ "optional": true
+ },
+ "esbuild": {
+ "optional": true
+ },
+ "jiti": {
+ "optional": true
+ },
+ "less": {
+ "optional": true
+ },
+ "sass": {
+ "optional": true
+ },
+ "sass-embedded": {
+ "optional": true
+ },
+ "stylus": {
+ "optional": true
+ },
+ "sugarss": {
+ "optional": true
+ },
+ "terser": {
+ "optional": true
+ },
+ "tsx": {
+ "optional": true
+ },
+ "yaml": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/zustand": {
+ "version": "5.0.15",
+ "resolved": "https://registry.npmjs.org/zustand/-/zustand-5.0.15.tgz",
+ "integrity": "sha512-MpSEjRiBkA9crSYeOUH32rJC7SVqAbm0Fqcqge/bUi2PPoLcBWKOsG+C8mevmpr8TwXHBVkChbbJiyvkE+i/3A==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=12.20.0"
+ },
+ "peerDependencies": {
+ "@types/react": ">=18.0.0",
+ "immer": ">=9.0.6",
+ "react": ">=18.0.0",
+ "use-sync-external-store": ">=1.2.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "immer": {
+ "optional": true
+ },
+ "react": {
+ "optional": true
+ },
+ "use-sync-external-store": {
+ "optional": true
+ }
+ }
+ }
+ }
+}
diff --git a/app/package.json b/app/package.json
new file mode 100644
index 0000000..2eae818
--- /dev/null
+++ b/app/package.json
@@ -0,0 +1,25 @@
+{
+ "name": "microduck-sandbox",
+ "private": true,
+ "version": "1.0.0",
+ "type": "module",
+ "scripts": {
+ "dev": "vite",
+ "build": "vite build",
+ "preview": "vite preview"
+ },
+ "dependencies": {
+ "@emotion/react": "^11.14.0",
+ "@emotion/styled": "^11.14.1",
+ "@mui/material": "^9.3.1",
+ "@react-three/fiber": "^9.7.0",
+ "react": "^19.2.8",
+ "react-dom": "^19.2.8",
+ "three": "^0.164.1",
+ "zustand": "^5.0.15"
+ },
+ "devDependencies": {
+ "@vitejs/plugin-react": "^6.1.0",
+ "vite": "^8.2.2"
+ }
+}
diff --git a/app/public/assets b/app/public/assets
new file mode 120000
index 0000000..41aef43
--- /dev/null
+++ b/app/public/assets
@@ -0,0 +1 @@
+../../assets
\ No newline at end of file
diff --git a/app/public/policies b/app/public/policies
new file mode 120000
index 0000000..aae576c
--- /dev/null
+++ b/app/public/policies
@@ -0,0 +1 @@
+../../policies
\ No newline at end of file
diff --git a/app/public/robot b/app/public/robot
new file mode 120000
index 0000000..afbd639
--- /dev/null
+++ b/app/public/robot
@@ -0,0 +1 @@
+../../robot
\ No newline at end of file
diff --git a/app/src/App.jsx b/app/src/App.jsx
new file mode 100644
index 0000000..f1cc288
--- /dev/null
+++ b/app/src/App.jsx
@@ -0,0 +1,87 @@
+// App shell: layers in z order - scene canvas (1), halftone (2), CRT (5),
+// HUD + touch overlay (9-12), BIOS readout (20), title menu (30), preboot
+// veil (40). Also owns the pre-game device detection (gamepad, touch) and
+// the preboot -> title -> enter flow.
+import { useEffect } from "react";
+import GameCanvas from "./scene/GameCanvas.jsx";
+import { Halftone, CrtOverlay } from "./ui/Overlays.jsx";
+import Hud from "./ui/Hud.jsx";
+import TouchOverlay from "./ui/TouchOverlay.jsx";
+import BiosOverlay from "./ui/BiosOverlay.jsx";
+import TitleMenu from "./ui/TitleMenu.jsx";
+import Preboot from "./ui/Preboot.jsx";
+import { useGame } from "./store.js";
+import { signed } from "./game/signed.js";
+
+export default function App() {
+ useEffect(() => {
+ const params = new URLSearchParams(location.search);
+
+ // Gamepad presence for the tutorial variant, before the game controller
+ // takes over polling (the game loop keeps mirroring it afterwards).
+ const pollPad = () => {
+ const gp = [...(navigator.getGamepads?.() ?? [])].find((p) => p && p.connected);
+ useGame.setState({ padConnected: !!gp });
+ };
+ window.addEventListener("gamepadconnected", pollPad);
+ window.addEventListener("gamepaddisconnected", pollPad);
+ pollPad();
+
+ // Touch detection, latching: (pointer: coarse) OR any real touch proves
+ // the device (DevTools device modes and hybrid laptops often fail the
+ // media query). __microduckTouched hands the proof to controls/touch.js
+ // which boots later. ?touch=1 forces the thumbs on any device.
+ const coarse = matchMedia("(pointer: coarse)");
+ const armTouch = () => {
+ window.__microduckTouched = true;
+ useGame.setState({ touchMode: true });
+ };
+ const onCoarse = () => coarse.matches && armTouch();
+ if (coarse.matches) armTouch();
+ else coarse.addEventListener("change", onCoarse);
+ window.addEventListener("touchstart", armTouch, { once: true, passive: true });
+ if (params.get("touch") === "1") armTouch();
+
+ // Preboot veil: hold the title page until its logo and the fonts are
+ // in (grey spinner meanwhile), capped so a broken asset can never wall
+ // the menu off. ?boot=1 skips the title entirely - testing hook.
+ if (params.get("boot") === "1") {
+ useGame.setState({ prebootDone: true, entered: true, menuOpen: false });
+ } else {
+ const img = new Image();
+ img.src = signed("./assets/duck-head-mark.webp");
+ const imgReady = new Promise((res) => {
+ if (img.complete && img.naturalWidth) res();
+ else {
+ img.addEventListener("load", res, { once: true });
+ img.addEventListener("error", res, { once: true });
+ }
+ });
+ const fontsReady = document.fonts?.ready ?? Promise.resolve();
+ const cap = new Promise((res) => setTimeout(res, 2500));
+ Promise.race([Promise.all([imgReady, fontsReady]), cap]).then(() => {
+ useGame.setState({ prebootDone: true, menuOpen: true });
+ });
+ }
+
+ return () => {
+ window.removeEventListener("gamepadconnected", pollPad);
+ window.removeEventListener("gamepaddisconnected", pollPad);
+ coarse.removeEventListener("change", onCoarse);
+ window.removeEventListener("touchstart", armTouch);
+ };
+ }, []);
+
+ return (
+ <>
+
+
+
+
+
+
+
+
+ >
+ );
+}
diff --git a/app/src/game/arena.js b/app/src/game/arena.js
new file mode 100644
index 0000000..cb42210
--- /dev/null
+++ b/app/src/game/arena.js
@@ -0,0 +1,235 @@
+// Arena visuals: the infinite Tron grid floor and the four wall grid
+// planes, ported verbatim from the pre-React rl.js. Both carry a uReveal
+// uniform for the entrance draw-in (driven by ceremony.js).
+import * as THREE from "three";
+import { ARENA_HALF, ARENA_WALL_H, ARENA_WALL_T, GRID_SECTION } from "./constants.js";
+
+// Infinite shader grid, ported from drei's : anti-aliased world-space
+// lines at cell/section frequencies with a radial fade around the duck.
+// Lines derive from world coordinates, so re-centering the mesh under the
+// camera target every frame makes the grid effectively infinite without any
+// visible swimming.
+export function makeInfiniteGrid() {
+ const material = new THREE.ShaderMaterial({
+ transparent: true,
+ depthWrite: false,
+ uniforms: {
+ uCell: { value: 0.1 },
+ uSection: { value: GRID_SECTION },
+ uCellColor: { value: new THREE.Color(0x8e8371) },
+ uSectionColor: { value: new THREE.Color(0xffb366) },
+ uFadeDist: { value: 3.0 },
+ uFocus: { value: new THREE.Vector3() },
+ // Entrance draw-in progress; 1 = steady state (branch skipped).
+ // Starts at 0: the world stays hidden behind the welcome modal and
+ // the BIOS readout until playBios cues startEntrance.
+ uReveal: { value: 0.0 },
+ },
+ vertexShader: /* glsl */ `
+ varying vec3 vWorld;
+ void main() {
+ vec4 w = modelMatrix * vec4(position, 1.0);
+ vWorld = w.xyz;
+ gl_Position = projectionMatrix * viewMatrix * w;
+ }
+ `,
+ fragmentShader: /* glsl */ `
+ varying vec3 vWorld;
+ uniform float uCell, uSection, uFadeDist, uReveal;
+ uniform vec3 uCellColor, uSectionColor, uFocus;
+ // Tron-style line: a thicker antialiased core plus a faint, much
+ // wider halo added on top (squared falloff keeps it a whisper of a
+ // glow rather than a bloom wash).
+ float lineProf(float g) {
+ float core = 1.0 - smoothstep(0.0, 1.8, g);
+ float halo = 1.0 - smoothstep(0.0, 7.0, g);
+ return core + halo * halo * 0.22;
+ }
+ float gridLine(vec2 p, float size) {
+ vec2 r = p / size;
+ vec2 g = abs(fract(r - 0.5) - 0.5) / fwidth(r);
+ return lineProf(min(g.x, g.y));
+ }
+ // Entrance draw-in: one family of parallel lines, drawn line by line.
+ // id picks the line, "along" runs down its length. Each line waits
+ // out its own hashed delay, then extends from the origin outward with
+ // a hard front. Returns (mask, head): head marks the bright segment
+ // right behind the draw front while the line is still growing.
+ vec2 drawLine(float id, float along, float t0, float spread, float dur, float maxLen) {
+ float jit = fract(sin(id * 127.1) * 43758.5453);
+ float grow = clamp((uReveal - t0 - jit * spread) / dur, 0.0, 1.0);
+ float len = grow * maxLen;
+ float a = abs(along);
+ float mask = 1.0 - smoothstep(len - 0.05, len, a);
+ float head = (1.0 - smoothstep(0.0, 0.6, len - a)) * mask
+ * step(0.001, grow) * (1.0 - step(0.999, grow));
+ return vec2(mask, head);
+ }
+ void main() {
+ float cell = gridLine(vWorld.xz, uCell);
+ // Section lattice shifted half a cell: with 5 sections across the
+ // 3 m arena (odd count) this centers a CELL on the origin and puts
+ // section lines exactly on the walls at +-1.5.
+ vec2 pSec = vWorld.xz + 0.5 * uSection;
+ float section = gridLine(pSec, uSection);
+ float d = distance(vWorld.xz, uFocus.xz);
+ float fade = pow(clamp(1.0 - d / uFadeDist, 0.0, 1.0), 1.6);
+ vec3 col = mix(uCellColor, uSectionColor, clamp(section, 0.0, 1.0));
+ float alpha = min(max(section * 0.6, cell * 0.4) * fade, 1.0);
+ // Entrance: only the bright section lines get the line-by-line draw
+ // (staggered, with a hot draw head); the fine cells just fade in
+ // over the reveal's second half - drawing every small line reads as
+ // visual noise. lineProf(min(gx, gy)) == max of per-axis profiles
+ // (profile is monotonic) and the cell fade lands on exactly the
+ // steady-state cell term, so at uReveal 1 this branch equals the
+ // formula above exactly (and is skipped).
+ if (uReveal < 1.0) {
+ vec2 rs = pSec / uSection;
+ vec2 gs = abs(fract(rs - 0.5) - 0.5) / fwidth(rs);
+ // Const-x lines run along z and vice versa; the offset
+ // decorrelates the two families' hashed delays.
+ vec2 sx = drawLine(floor(rs.x + 0.5), vWorld.z, 0.00, 0.30, 0.35, 8.0);
+ vec2 sz = drawLine(floor(rs.y + 0.5) + 57.0, vWorld.x, 0.05, 0.30, 0.35, 8.0);
+ float secR = max(lineProf(gs.x) * sx.x, lineProf(gs.y) * sz.x);
+ float cellR = cell * smoothstep(0.5, 1.0, uReveal);
+ float headGlow = max(lineProf(gs.x) * sx.y, lineProf(gs.y) * sz.y);
+ col = mix(uCellColor, uSectionColor, clamp(secR, 0.0, 1.0));
+ alpha = min(max(secR * 0.6, cellR * 0.4) * fade, 1.0);
+ // Bright draw head: a short white-hot tip sells the "drawing" read.
+ headGlow = clamp(headGlow, 0.0, 1.0);
+ col = mix(col, vec3(1.0, 0.86, 0.55), headGlow * 0.8);
+ alpha = min(alpha + headGlow * fade * 0.5, 1.0);
+ }
+ if (alpha < 0.004) discard;
+ gl_FragColor = vec4(col, alpha);
+ }
+ `,
+ });
+ const mesh = new THREE.Mesh(new THREE.PlaneGeometry(30, 30), material);
+ mesh.rotation.x = -Math.PI / 2;
+ return mesh;
+}
+
+// Arena walls, drawn in the same grid language as the floor: identical
+// cell/section lines from world coordinates, same radial fade around the
+// duck, plus a vertical fade toward the top edge so the walls read as a
+// light enclosure instead of solid slabs.
+function makeWallGridMaterial(alongX) {
+ return new THREE.ShaderMaterial({
+ transparent: true,
+ depthWrite: false,
+ side: THREE.DoubleSide,
+ uniforms: {
+ uCell: { value: 0.1 },
+ uSection: { value: GRID_SECTION },
+ uCellColor: { value: new THREE.Color(0x8e8371) },
+ uSectionColor: { value: new THREE.Color(0xffb366) },
+ // Gentler radial fade than the floor: the walls sit 1.5+ m from the
+ // duck by construction and would vanish with the floor's 3 m fade.
+ uFadeDist: { value: 5.0 },
+ uFocus: { value: new THREE.Vector3() },
+ uWallH: { value: ARENA_WALL_H },
+ uAlongX: { value: alongX ? 1.0 : 0.0 },
+ // Entrance draw-in progress; 1 = steady state (branch skipped).
+ // Starts at 0, same as the floor grid: hidden until startEntrance.
+ uReveal: { value: 0.0 },
+ },
+ vertexShader: /* glsl */ `
+ varying vec3 vWorld;
+ void main() {
+ vec4 w = modelMatrix * vec4(position, 1.0);
+ vWorld = w.xyz;
+ gl_Position = projectionMatrix * viewMatrix * w;
+ }
+ `,
+ fragmentShader: /* glsl */ `
+ varying vec3 vWorld;
+ uniform float uCell, uSection, uFadeDist, uWallH, uAlongX, uReveal;
+ uniform vec3 uCellColor, uSectionColor, uFocus;
+ // Same Tron-style core + faint halo as the floor grid.
+ float lineProf(float g) {
+ float core = 1.0 - smoothstep(0.0, 1.8, g);
+ float halo = 1.0 - smoothstep(0.0, 7.0, g);
+ return core + halo * halo * 0.22;
+ }
+ float gridLine(vec2 p, float size) {
+ vec2 r = p / size;
+ vec2 g = abs(fract(r - 0.5) - 0.5) / fwidth(r);
+ return lineProf(min(g.x, g.y));
+ }
+ // Same line-by-line draw as the floor grid (see its comments).
+ vec2 drawLine(float id, float along, float t0, float spread, float dur, float maxLen) {
+ float jit = fract(sin(id * 127.1) * 43758.5453);
+ float grow = clamp((uReveal - t0 - jit * spread) / dur, 0.0, 1.0);
+ float len = grow * maxLen;
+ float a = abs(along);
+ float mask = 1.0 - smoothstep(len - 0.05, len, a);
+ float head = (1.0 - smoothstep(0.0, 0.35, len - a)) * mask
+ * step(0.001, grow) * (1.0 - step(0.999, grow));
+ return vec2(mask, head);
+ }
+ void main() {
+ // Wall surface coords: the in-plane horizontal world axis + height.
+ float h = mix(vWorld.z, vWorld.x, uAlongX);
+ vec2 p = vec2(h, vWorld.y);
+ float cell = gridLine(p, uCell);
+ // Horizontal axis shifted half a section to match the floor's odd
+ // lattice (vertical section lines meet the floor's at the base);
+ // the height axis keeps its base line at y = 0.
+ vec2 pSec = vec2(p.x + 0.5 * uSection, p.y);
+ float section = gridLine(pSec, uSection);
+ float d = distance(vWorld.xz, uFocus.xz);
+ float fade = pow(clamp(1.0 - d / uFadeDist, 0.0, 1.0), 1.6);
+ float vert = 1.0 - clamp(vWorld.y / uWallH, 0.0, 1.0);
+ vec3 col = mix(uCellColor, uSectionColor, clamp(section, 0.0, 1.0));
+ float alpha = min(max(section * 0.9, cell * 0.6) * fade * (0.3 + 0.7 * vert), 1.0);
+ // Entrance: section lines only - horizontals zip out from the
+ // wall's center, verticals rise from the ground, each with a
+ // hashed delay; the fine cells fade in over the reveal's second
+ // half. Same steady-state equivalence argument as the floor grid.
+ if (uReveal < 1.0) {
+ vec2 rs = pSec / uSection;
+ vec2 gs = abs(fract(rs - 0.5) - 0.5) / fwidth(rs);
+ // Const-height lines run along h (grow from center outward);
+ // const-h lines run along y (grow up from the ground).
+ vec2 sh = drawLine(floor(rs.y + 0.5), p.x, 0.00, 0.30, 0.40, 2.0);
+ vec2 sv = drawLine(floor(rs.x + 0.5) + 31.0, p.y, 0.30, 0.30, 0.30, uWallH);
+ float secR = max(lineProf(gs.y) * sh.x, lineProf(gs.x) * sv.x);
+ float cellR = cell * smoothstep(0.5, 1.0, uReveal);
+ float headGlow = max(lineProf(gs.y) * sh.y, lineProf(gs.x) * sv.y);
+ col = mix(uCellColor, uSectionColor, clamp(secR, 0.0, 1.0));
+ alpha = min(max(secR * 0.9, cellR * 0.6) * fade * (0.3 + 0.7 * vert), 1.0);
+ headGlow = clamp(headGlow, 0.0, 1.0);
+ col = mix(col, vec3(1.0, 0.86, 0.55), headGlow * 0.8);
+ alpha = min(alpha + headGlow * fade * 0.5, 1.0);
+ }
+ if (alpha < 0.004) discard;
+ gl_FragColor = vec4(col, alpha);
+ }
+ `,
+ });
+}
+
+// The four wall planes at their inner faces (three coords: MJCF x -> x,
+// MJCF y -> -z). Returns the meshes plus their materials (the ceremony and
+// the per-frame focus update both need the material list).
+export function makeArenaWalls() {
+ const wallMats = [];
+ const wallMeshes = [];
+ const wallLen = 2 * (ARENA_HALF + ARENA_WALL_T);
+ const wallDefs = [
+ { x: ARENA_HALF, z: 0, rotY: -Math.PI / 2, alongX: false },
+ { x: -ARENA_HALF, z: 0, rotY: Math.PI / 2, alongX: false },
+ { x: 0, z: ARENA_HALF, rotY: Math.PI, alongX: true },
+ { x: 0, z: -ARENA_HALF, rotY: 0, alongX: true },
+ ];
+ for (const w of wallDefs) {
+ const mat = makeWallGridMaterial(w.alongX);
+ wallMats.push(mat);
+ const mesh = new THREE.Mesh(new THREE.PlaneGeometry(wallLen, ARENA_WALL_H), mat);
+ mesh.position.set(w.x, ARENA_WALL_H / 2, w.z);
+ mesh.rotation.y = w.rotY;
+ wallMeshes.push(mesh);
+ }
+ return { wallMats, wallMeshes };
+}
diff --git a/app/src/game/ball-actor.js b/app/src/game/ball-actor.js
new file mode 100644
index 0000000..62b1739
--- /dev/null
+++ b/app/src/game/ball-actor.js
@@ -0,0 +1,102 @@
+// Ball actor: physics stays in rl.js, this owns the mesh + wireframe FX.
+//
+// visual:
+// hidden parked, mesh off
+// live following qpos, optional appear scan playing
+// ghost physics already parked; mesh frozen at last pose while the
+// reverse scan peels it away
+//
+// spawn while live/ghost queues a pop: despawn finishes, then the caller
+// places physics and appear()s.
+
+// Appear/disappear speed. The shared wireframe FX timeline lasts
+// fx.TOTAL_S (0.9 s, tuned for the duck's ceremony); the ball plays the
+// same timeline time-scaled to these snappier durations.
+const BALL_APPEAR_S = 0.35; // spawn pop-in (scan up)
+const BALL_DISAPPEAR_S = 0.25; // despawn/park peel-away (reverse scan)
+
+export function createBallActor({ THREE, scene, camera, renderer, fxModule, mesh, group }) {
+ const fx = fxModule.createWireframeFx();
+ fx.init({ THREE, scene, root: group, camera, renderer, hidden: false });
+
+ let visual = "hidden"; // hidden | live | ghost
+ let ghost = null;
+ let pendingSpawn = false;
+ let fxPrev = null;
+
+ function appear() {
+ visual = "live";
+ ghost = null;
+ mesh.visible = true;
+ fx.start();
+ fxPrev = performance.now();
+ }
+
+ function despawn({ cancelQueued = false, parkPhysics }) {
+ if (cancelQueued) pendingSpawn = false;
+ if (visual === "hidden") return;
+ if (visual === "live") {
+ ghost = {
+ pos: mesh.position.clone(),
+ quat: mesh.quaternion.clone(),
+ };
+ visual = "ghost";
+ }
+ parkPhysics();
+ fx.startReverse();
+ fxPrev = performance.now();
+ }
+
+ function queueRespawn() {
+ pendingSpawn = true;
+ }
+
+ function poseFromQpos(qpos, adr) {
+ mesh.position.set(qpos[adr], qpos[adr + 1], qpos[adr + 2]);
+ mesh.quaternion.set(qpos[adr + 4], qpos[adr + 5], qpos[adr + 6], qpos[adr + 3]);
+ }
+
+ function sync(qpos, adr, physicsLive) {
+ if (visual === "ghost" && ghost) {
+ mesh.visible = true;
+ mesh.position.copy(ghost.pos);
+ mesh.quaternion.copy(ghost.quat);
+ } else if (physicsLive) {
+ mesh.visible = true;
+ poseFromQpos(qpos, adr);
+ } else {
+ mesh.visible = false;
+ }
+ }
+
+ function drive(onQueuedSpawn) {
+ if (fx.playing) {
+ const now = performance.now();
+ if (fxPrev === null) fxPrev = now;
+ const dt = Math.min((now - fxPrev) / 1000, 0.25);
+ fxPrev = now;
+ // Time-scale the FX so the ball pops in/out at its own speed.
+ const speed = fx.TOTAL_S / (fx.reversing ? BALL_DISAPPEAR_S : BALL_APPEAR_S);
+ fx.update(dt * speed);
+ }
+ if (visual === "ghost" && fx.isDone()) {
+ mesh.visible = false;
+ visual = "hidden";
+ ghost = null;
+ fx.restore();
+ const queued = pendingSpawn;
+ pendingSpawn = false;
+ if (queued) onQueuedSpawn();
+ }
+ }
+
+ return {
+ appear,
+ despawn,
+ queueRespawn,
+ poseFromQpos,
+ sync,
+ drive,
+ get visual() { return visual; },
+ };
+}
diff --git a/app/src/game/ball-visual.js b/app/src/game/ball-visual.js
new file mode 100644
index 0000000..0ecdea9
--- /dev/null
+++ b/app/src/game/ball-visual.js
@@ -0,0 +1,149 @@
+// Ball visuals: procedural soccer-ball texture + the render mesh, ported
+// verbatim from the pre-React rl.js.
+import * as THREE from "three";
+import { BALL_RADIUS } from "./constants.js";
+
+// Soccer-ball look computed per pixel on the sphere itself, so there is
+// no pole or seam special case by design. The truncated icosahedron is
+// reconstructed as a spherical Voronoi diagram over 32 sites: the 12
+// icosahedron vertices (black pentagon centers, one sitting at each
+// pole) and its 20 face centers (white hexagon centers). A pixel is
+// black when its nearest site is a pentagon center and it sits clear of
+// the cell boundary by a seam margin - which yields big flat-edged black
+// pentagons separated from the white hexagons by thin seams, corners
+// almost touching, exactly like the real panel layout.
+function makeSoccerBallTexture(renderer) {
+ const W = 1024, H = 512;
+ const c = document.createElement("canvas");
+ c.width = W;
+ c.height = H;
+ const ctx = c.getContext("2d");
+ // 12 icosahedron vertices: 2 poles + two staggered rings of 5 at
+ // latitude +-atan(1/2) (~26.57 deg) - the pentagon centers.
+ const sites = [];
+ const addSite = (v, isPent) => {
+ const n = Math.hypot(v[0], v[1], v[2]);
+ sites.push({ x: v[0] / n, y: v[1] / n, z: v[2] / n, pent: isPent });
+ };
+ const verts = [[0, 0, 1], [0, 0, -1]];
+ const latR = Math.atan(0.5), cr = Math.cos(latR), sr = Math.sin(latR);
+ for (let i = 0; i < 5; i++) {
+ const a = (i * 72 * Math.PI) / 180;
+ const b = ((i * 72 + 36) * Math.PI) / 180;
+ verts.push([cr * Math.cos(a), cr * Math.sin(a), sr]);
+ verts.push([cr * Math.cos(b), cr * Math.sin(b), -sr]);
+ }
+ for (const v of verts) addSite(v, true);
+ // 20 face centers (hexagon centers): normalized centroids of every
+ // mutually-adjacent vertex triple (adjacent pairs have dot = 1/sqrt(5)).
+ const adj = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2] > 0.3;
+ for (let i = 0; i < 12; i++) {
+ for (let j = i + 1; j < 12; j++) {
+ if (!adj(verts[i], verts[j])) continue;
+ for (let k = j + 1; k < 12; k++) {
+ if (adj(verts[i], verts[k]) && adj(verts[j], verts[k])) {
+ addSite([
+ verts[i][0] + verts[j][0] + verts[k][0],
+ verts[i][1] + verts[j][1] + verts[k][1],
+ verts[i][2] + verts[j][2] + verts[k][2],
+ ], false);
+ }
+ }
+ }
+ }
+ // Seam half-width and anti-alias band, in radians of arc.
+ const SEAM = (1.6 * Math.PI) / 180;
+ const AA = (0.35 * Math.PI) / 180;
+ // Groove reach for the bump map: a touch wider than the painted seam so
+ // the recess shoulders catch light on both sides of the line.
+ const GROOVE = SEAM * 1.5;
+ const BG = [233, 231, 224], INK = [23, 23, 29], STITCH = [200, 197, 188];
+ const img = ctx.createImageData(W, H);
+ const px = img.data;
+ // Height map sharing the same panel construction: seams become recessed
+ // grooves, plus a very fine leather/PVC grain over the whole surface.
+ const bc = document.createElement("canvas");
+ bc.width = W;
+ bc.height = H;
+ const bctx = bc.getContext("2d");
+ const bimg = bctx.createImageData(W, H);
+ const bpx = bimg.data;
+ for (let row = 0; row < H; row++) {
+ const lat = Math.PI / 2 - ((row + 0.5) / H) * Math.PI;
+ const cl = Math.cos(lat), sl = Math.sin(lat);
+ for (let col = 0; col < W; col++) {
+ const lon = ((col + 0.5) / W) * 2 * Math.PI - Math.PI;
+ const dx = cl * Math.cos(lon), dy = cl * Math.sin(lon), dz = sl;
+ let best = -2, second = -2, bestPent = false;
+ for (const s of sites) {
+ const d = dx * s.x + dy * s.y + dz * s.z;
+ if (d > best) { second = best; best = d; bestPent = s.pent; }
+ else if (d > second) second = d;
+ }
+ // Signed distance to the Voronoi cell boundary along the geodesic.
+ const halfGap = (Math.acos(Math.min(1, second)) - Math.acos(Math.min(1, best))) / 2;
+ // Black panel: inside a pentagon cell, clear of the seam margin.
+ const black = bestPent ? Math.min(1, Math.max(0, (halfGap - SEAM) / AA)) : 0;
+ // Subtle stitch line on every remaining cell boundary so the white
+ // hexagons read as panels too.
+ const stitch = Math.min(1, Math.max(0, 1 - halfGap / (SEAM * 0.6))) * (1 - black);
+ const o = (row * W + col) * 4;
+ for (let ch = 0; ch < 3; ch++) {
+ const base = BG[ch] + (STITCH[ch] - BG[ch]) * stitch;
+ px[o + ch] = base + (INK[ch] - base) * black;
+ }
+ px[o + 3] = 255;
+ // Bump: quadratic groove profile (soft shoulders, no golf-ball
+ // embossing) + grain noise.
+ const groove = Math.max(0, 1 - halfGap / GROOVE) ** 2;
+ const hgt = 205 - groove * 115 + (Math.random() - 0.5) * 14;
+ const h8 = Math.max(0, Math.min(255, hgt));
+ bpx[o] = h8; bpx[o + 1] = h8; bpx[o + 2] = h8;
+ bpx[o + 3] = 255;
+ }
+ }
+ ctx.putImageData(img, 0, 0);
+ bctx.putImageData(bimg, 0, 0);
+ const finish = (canvas, srgb) => {
+ const tex = new THREE.CanvasTexture(canvas);
+ // The bump map stays linear; only the color map is sRGB.
+ if (srgb) tex.colorSpace = THREE.SRGBColorSpace;
+ // Texel footprints get extremely anamorphic near the UV poles; without
+ // anisotropy the cap edge visibly scallops at close range.
+ tex.anisotropy = renderer.capabilities.getMaxAnisotropy();
+ return tex;
+ };
+ return { map: finish(c, true), bumpMap: finish(bc, false) };
+}
+
+// Same Z-up -> Y-up trick as the duck rig: the group takes the axis fix,
+// the mesh inside takes the raw MJCF free-joint pose.
+export function createBallVisual(renderer) {
+ const group = new THREE.Group();
+ group.rotation.x = -Math.PI / 2;
+ const tex = makeSoccerBallTexture(renderer);
+ const mesh = new THREE.Mesh(
+ // 48x32 segments: the coarser default makes the UV interpolation near
+ // the poles visibly scallop the round cap edge of the texture.
+ new THREE.SphereGeometry(BALL_RADIUS, 48, 32),
+ // Physical material for the waxed vintage-leather look: matte-ish base
+ // with a whisper of clearcoat so highlights ride the seam grooves.
+ new THREE.MeshPhysicalMaterial({
+ map: tex.map,
+ bumpMap: tex.bumpMap,
+ bumpScale: 0.0012,
+ metalness: 0,
+ roughness: 0.55,
+ clearcoat: 0.2,
+ clearcoatRoughness: 0.35,
+ }),
+ );
+ mesh.userData.meshName = "ball";
+ // The 48x32 render sphere is far too dense for the wireframe scan (it
+ // reads as a solid glowing blob); the FX overlay uses this geodesic
+ // stand-in instead - 80 triangles, clean hologram lines.
+ mesh.userData.fxWireGeometry = new THREE.IcosahedronGeometry(BALL_RADIUS, 1);
+ mesh.visible = false;
+ group.add(mesh);
+ return { group, mesh };
+}
diff --git a/app/src/game/ceremony.js b/app/src/game/ceremony.js
new file mode 100644
index 0000000..1e6e4c2
--- /dev/null
+++ b/app/src/game/ceremony.js
@@ -0,0 +1,236 @@
+// Cutscene layer: page-load entrance and every later respawn.
+//
+// Physics (resetSim) snaps the duck to the stand keyframe; this module
+// owns what the player sees around that snap. Two mutually exclusive
+// timelines share the duck's wireframe FX:
+//
+// entrance (once) grid + walls draw in, then the duck scans up
+// respawn (every kill / Space / loco switch)
+// 0.00 duck clipped away, camera glides home from the kill view
+// 0.80 camera almost settled -> duck scan-up cues
+// 0.90 camera lands
+// 1.70 scan done, inputs unlock
+//
+// rl.js injects the world (rig, grid, camera reset) and the lock/flash
+// callbacks; this file never touches MuJoCo.
+
+export const CAM_RESET_S = 0.9;
+export const RESPAWN_SCAN_AT = 0.8; // cue scan-up at 80% of the camera glide
+
+const ENTRANCE_GRID_S = 1.1;
+const ENTRANCE_WALL_DELAY_S = 0.35;
+const ENTRANCE_WALL_S = 0.9;
+const ENTRANCE_FX_START_S = 0.6;
+
+const clamp01 = (x) => Math.min(Math.max(x, 0), 1);
+
+export function createCeremony({
+ THREE, scene, camera, renderer, fx,
+ getRig, grid, wallMats,
+ syncRig, startCameraReset,
+ setLocked, flashReset,
+}) {
+ const ENTRANCE_TOTAL_S = Math.max(
+ ENTRANCE_GRID_S,
+ ENTRANCE_WALL_DELAY_S + ENTRANCE_WALL_S,
+ ENTRANCE_FX_START_S + fx.TOTAL_S,
+ );
+
+ let fxRig = null;
+ let fxPrev = null;
+ // Decorative props (addPropFx): each owns a wireframe FX bound to its
+ // own root. They cue whenever the duck's scan cues (entrance and every
+ // respawn), offset by their stagger, and drive on their OWN clock so a
+ // late-finishing prop never extends the input lock or the ceremony's
+ // completion checks.
+ const props = []; // { fx, delayS, at, started, prev }
+ let entranceT0 = null;
+ let entranceFxCued = false;
+ let entranceDone = false;
+ let respawn = null; // { t0, scanCued } | null
+ let entranceFinishedResolve;
+ const entranceFinished = new Promise((r) => { entranceFinishedResolve = r; });
+
+ function bind() {
+ const rig = getRig();
+ if (fxRig === rig) return;
+ fx.dispose();
+ fx.init({ THREE, scene, rig, camera, renderer });
+ rig.placer.traverse((o) => {
+ if (o.isMesh && !o.userData.meshName) o.userData.fxOverlay = true;
+ });
+ fxRig = rig;
+ }
+
+ function fxStart() {
+ bind();
+ fx.start();
+ fxPrev = performance.now();
+ propsCue();
+ }
+ function propsCue() {
+ const now = performance.now();
+ for (const p of props) {
+ p.at = now + p.delayS * 1000;
+ p.started = false;
+ p.prev = null;
+ }
+ }
+ function propsHide() {
+ for (const p of props) {
+ p.fx.setProgress(0);
+ p.at = null;
+ p.started = false;
+ }
+ }
+ function propsFinish() {
+ for (const p of props) {
+ if (!p.started) p.fx.start();
+ p.fx.update(1e3);
+ p.at = null;
+ }
+ }
+ // Deterministic screenshot/test hook (setFx): park every prop at the
+ // same scan progress as the duck, detached from the timed driver.
+ function propsSetProgress(v) {
+ for (const p of props) {
+ p.fx.setProgress(v);
+ p.at = null;
+ p.started = false;
+ }
+ }
+ function driveProps() {
+ const now = performance.now();
+ for (const p of props) {
+ if (p.at === null || now < p.at) continue;
+ if (!p.started) {
+ p.fx.start();
+ p.started = true;
+ p.prev = now;
+ continue;
+ }
+ if (p.fx.isDone()) continue;
+ const dt = Math.min((now - p.prev) / 1000, 0.25);
+ p.prev = now;
+ p.fx.update(dt);
+ }
+ }
+ function fxDrive() {
+ if (fxPrev === null || fx.isDone()) return;
+ const now = performance.now();
+ const dt = Math.min((now - fxPrev) / 1000, 0.25);
+ fxPrev = now;
+ fx.update(dt);
+ }
+ function fxForceFinish() {
+ if (!fx.isDone()) fx.update(1e3);
+ }
+
+ function startEntrance() {
+ if (entranceT0 !== null || entranceDone) return;
+ entranceT0 = performance.now();
+ entranceFxCued = false;
+ grid.material.uniforms.uReveal.value = 0;
+ for (const m of wallMats) m.uniforms.uReveal.value = 0;
+ }
+
+ function driveEntrance() {
+ if (entranceT0 === null) return;
+ const t = (performance.now() - entranceT0) / 1000;
+ grid.material.uniforms.uReveal.value = clamp01(t / ENTRANCE_GRID_S);
+ const wallR = clamp01((t - ENTRANCE_WALL_DELAY_S) / ENTRANCE_WALL_S);
+ for (const m of wallMats) m.uniforms.uReveal.value = wallR;
+ if (t >= ENTRANCE_FX_START_S && !entranceFxCued) {
+ entranceFxCued = true;
+ fxStart();
+ }
+ fxDrive();
+ if (t >= ENTRANCE_TOTAL_S) {
+ if (!fx.isDone() && t < ENTRANCE_TOTAL_S + 0.5) return;
+ fxForceFinish();
+ entranceT0 = null;
+ entranceDone = true;
+ grid.material.uniforms.uReveal.value = 1;
+ for (const m of wallMats) m.uniforms.uReveal.value = 1;
+ setLocked(false);
+ entranceFinishedResolve();
+ }
+ }
+
+ function playRespawn() {
+ if (!entranceDone) return;
+ setLocked(true);
+ flashReset();
+ bind();
+ startCameraReset();
+ syncRig();
+ fx.setProgress(0);
+ propsHide();
+ respawn = { t0: performance.now(), scanCued: false };
+ }
+
+ function driveRespawn() {
+ if (!respawn) return;
+ const u = (performance.now() - respawn.t0) / 1000 / CAM_RESET_S;
+ if (!respawn.scanCued && u >= RESPAWN_SCAN_AT) {
+ respawn.scanCued = true;
+ fxStart();
+ }
+ if (respawn.scanCued) fxDrive();
+ if (respawn.scanCued && fx.isDone()) {
+ respawn = null;
+ setLocked(false);
+ }
+ }
+
+ function drive() {
+ driveEntrance();
+ driveRespawn();
+ driveProps();
+ }
+
+ function setReveal(floor, wall = floor) {
+ entranceT0 = null;
+ grid.material.uniforms.uReveal.value = floor;
+ for (const m of wallMats) m.uniforms.uReveal.value = wall;
+ }
+
+ function setFx(p) {
+ entranceT0 = null;
+ respawn = null;
+ bind();
+ if (p >= 1) {
+ fx.start();
+ fxForceFinish();
+ propsFinish();
+ setLocked(false);
+ entranceFinishedResolve();
+ } else {
+ fx.setProgress(p);
+ propsSetProgress(p);
+ }
+ }
+
+ // Register a decorative prop's wireframe FX (already init'd on its own
+ // root, hidden). It materializes delayS after each duck scan cue.
+ function addPropFx(propFx, delayS = 0) {
+ props.push({ fx: propFx, delayS, at: null, started: false, prev: null });
+ }
+
+ // Boot hidden: clip parked below the feet from the first frame.
+ bind();
+
+ return {
+ CAM_RESET_S,
+ startEntrance,
+ playRespawn,
+ drive,
+ bind,
+ setReveal,
+ setFx,
+ addPropFx,
+ entranceFinished,
+ get entranceDone() { return entranceDone; },
+ get respawnActive() { return respawn !== null; },
+ };
+}
diff --git a/app/src/game/constants.js b/app/src/game/constants.js
new file mode 100644
index 0000000..1259f64
--- /dev/null
+++ b/app/src/game/constants.js
@@ -0,0 +1,74 @@
+// Shared sim constants, lifted verbatim from the pre-React rl.js.
+
+export const POLICY_DIR = "./policies";
+export const POLICIES = {
+ walk: `${POLICY_DIR}/BEST_alpha_walking.onnx`,
+ sitstand: `${POLICY_DIR}/BEST_alpha_sitstand.onnx`,
+ roll: `${POLICY_DIR}/roulade.onnx`,
+ // Blind one-shot kicks (the operator aims the robot, no ball in obs):
+ // the runtime swaps these in for a 0.5 s window, commands zeroed.
+ kickL: `${POLICY_DIR}/ball_kick_left.onnx`,
+ kickR: `${POLICY_DIR}/ball_kick_right.onnx`,
+ // Roller variant (lazy-loaded on first switch, never at boot):
+ // drive = velocity-tracking skating, crouch = one-shot crouch-glide
+ // driven by a phase encoding in the command slots (ground-pick style).
+ drive: `${POLICY_DIR}/BEST_roller.onnx`,
+ crouch: `${POLICY_DIR}/BEST_roller_crouch.onnx`,
+};
+
+// From the ONNX metadata (identical for all alpha policies) and the STAND
+// keyframe in mjlab's scene_walk.xml. Order matches the actuators in
+// the MJCF.
+export const JOINT_NAMES = [
+ "left_hip_yaw", "left_hip_roll", "left_hip_pitch", "left_knee", "left_ankle",
+ "neck_pitch", "head_pitch", "head_yaw", "head_roll",
+ "right_hip_yaw", "right_hip_roll", "right_hip_pitch", "right_knee", "right_ankle",
+];
+export const DEFAULT_POSE = new Float32Array([
+ 0, -0.08726646259971647, -0.457924, -0.004940, 0.452984,
+ 0.3490658503988659, 0.3490658503988659, 0, 0,
+ 0, 0.08726646259971647, 0.457924, 0.004940, -0.452984,
+]);
+export const NUM_JOINTS = 14;
+export const OBS_SIZE = 61;
+export const CMD_SIZE = 13;
+export const ACTION_SCALE = 1.0;
+export const TIMESTEP = 0.005;
+export const DECIMATION = 4;
+export const CTRL_DT = TIMESTEP * DECIMATION; // 50 Hz
+
+// Velocity command limits, same as infer_policy.py's keyboard mapping.
+// No strafe input anymore: the lateral cmd slot stays zeroed for the obs.
+export const VEL_FWD = 0.25, VEL_BACK = -0.2, VEL_ANG = 1.0;
+// Roller mode limits, from the runtime's roller branch: asymmetric vx
+// (0.6 push / 0.5 brake), no lateral. The real runtime launches rollers
+// with --max-angular-vel 0.3: faster commanded turns tip the robot over,
+// so the playground clamps wz the same way.
+export const RVEL_FWD = 0.6, RVEL_BACK = -0.5, RVEL_ANG = 0.3;
+// Crouch-glide one-shot: command = [cos(2pi*phase), sin(2pi*phase), 0],
+// phase advancing at 1/CROUCH_PERIOD_S per second and the cycle exiting
+// at 0.7 - exactly the runtime's ground-pick slot the policy was trained
+// against (mjlab CROUCH_PERIOD = 5.0, cycle end 0.7 => 3.5 s gesture).
+export const CROUCH_PERIOD_S = 5.0;
+export const CROUCH_END_PHASE = 0.7;
+
+// Kickable ball: radius and parking spot (far away = hidden by default).
+export const BALL_RADIUS = 0.05;
+export const BALL_PARK_POS = "50 0 0.05";
+
+// Square arena boxing the play area: static walls at +-ARENA_HALF keep
+// the ball (and the duck) inside. Tall enough that neither steps over.
+export const ARENA_HALF = 1.5; // inner half-size, m
+export const ARENA_WALL_H = 0.25;
+export const ARENA_WALL_T = 0.05;
+// Section grid: 5 cells across the 3 m arena (ODD, so a true middle
+// column/row of cells exists; the lattice is shifted half a cell in the
+// shaders so the walls land exactly on section lines).
+export const GRID_SECTION = (2 * ARENA_HALF) / 5; // 0.6 m
+// Spawn: center of the middle section cell in the SECOND ROW FROM THE
+// BACK wall. The duck faces +X (identity freejoint quat, walks toward
+// local +X), so "back" is the -X wall: row centers sit at x = -1.2,
+// -0.6, 0, 0.6, 1.2 -> second row is -0.6; middle column is y = 0.
+// MJCF coordinates (three.js: x -> x, y -> -z).
+export const SPAWN_X = -ARENA_HALF + 1.5 * GRID_SECTION; // -0.6
+export const SPAWN_Y = 0;
diff --git a/app/src/game/controls/controller.js b/app/src/game/controls/controller.js
new file mode 100644
index 0000000..23d80ea
--- /dev/null
+++ b/app/src/game/controls/controller.js
@@ -0,0 +1,188 @@
+// Controller: the video-game-style input core. Aggregates pluggable input
+// SOURCES (keyboard, gamepad, later touch) into one game-facing surface:
+//
+// - a continuous COMMAND: the [vx, vy, wz] twist the policy tracks, plus
+// auxiliary analog AXES (jaw 0..1, camera-orbit rates -1..1);
+// - discrete ACTIONS: edge-triggered events (roll, kicks, ball spawn...)
+// dispatched to subscribers the moment a source fires them;
+// - HUD support: per-source pressed-state snapshots and activity info so
+// the hint keycaps can light up per physical control and per device.
+//
+// The game code (rl.js) instantiates the sources, registers them here,
+// calls update(dt) once per render frame, reads getCommand()/getAxes()
+// where it builds the policy observation, and subscribes its trigger
+// functions with on(action, cb).
+//
+// ── Source interface contract ────────────────────────────────────────────
+// Every input source module (keyboard.js, gamepad.js, a future touch.js
+// with a virtual joystick + buttons) implements:
+//
+// id Unique string ("keyboard", "gamepad", "touch"...). Action
+// subscribers receive it as meta.source, so game code can
+// attribute HUD flashes / keycap lighting to the right device.
+// connected Boolean hardware presence. Keyboard: always true. Gamepad:
+// a pad is currently reported by navigator.getGamepads().
+// command Float32Array(3) [vx, vy, wz], ALREADY scaled to the game's
+// velocity limits (sources take a getVelocityLimits() callback
+// returning [fwd, back, ang], so limits can change at runtime,
+// e.g. the legs <-> rollers switch). Must be a stable array
+// reference updated in place: getCommand() hands it out
+// without copying, and the control loop reads it between
+// render frames.
+// axes { jaw, orbitX, orbitY } - auxiliary continuous channels.
+// jaw in [0, 1] (mouth opening), orbit axes in [-1, 1]
+// (camera orbit rate; the inertia/smoothing lives downstream
+// in the camera code, sources report raw deflection). Stable
+// object reference, updated in place. Channels a source does
+// not drive stay 0.
+// pressed Plain object of booleans (stable reference) mirroring which
+// physical controls are currently down. HUD highlighting
+// only - never game logic.
+// isActive() Whether the source currently claims authority over the
+// continuous command. Keyboard: any move key held. Gamepad:
+// stick deflected, and it keeps the claim until its smoothed
+// command settles back to ~zero.
+// init() Attach event listeners / hardware hooks. Called by
+// Controller.init(), NOT at construction (rl.js constructs
+// the sources early but arms the listeners at the same point
+// in the boot where they historically went live).
+// dispose() Detach everything init() attached.
+// poll(dt) Per-frame tick (dt in seconds, clamped by the caller).
+// Read the hardware, update command/axes/pressed in place,
+// and fire edge-triggered actions via this.onAction(name).
+// onAction (name, meta?) => void, assigned by the Controller at
+// registration. Sources may call it from poll() (gamepad
+// button edges) or straight from event handlers (keyboard:
+// keeps the historical press-to-effect latency).
+//
+// ── Arbitration ──────────────────────────────────────────────────────────
+// Continuous command: sources are registered in PRIORITY order (first =
+// highest). Each frame the first source reporting isActive() owns the
+// twist; when none is active the LAST registered source's command is used
+// as the fallback (it reads zero when idle). With [gamepad, keyboard] this
+// reproduces the historical `padActive ? padCmd : velCmd` exactly: live
+// sticks win over held keys, and the keyboard takes back over once the
+// pad's smoothed command has settled.
+// Aux axes are merged across ALL sources regardless of who owns the twist
+// (the pad triggers drive the jaw even while walking on the keyboard):
+// jaw = max over sources, orbit = largest-magnitude value per axis.
+//
+// ── Actions ──────────────────────────────────────────────────────────────
+// roll one-shot roll (crouch-glide in roller mode; game decides)
+// kickL, kickR one-shot kicks, explicit foot
+// alternateKick one-shot kick, feet alternated by the game
+// spawnBall pop / respawn the kickable ball
+// sitToggle sit <-> stand (game gates it to legs mode)
+// locoToggle legs <-> rollers switch
+// chaseToggle chase camera on/off
+// reset full sim reset (Space)
+// walk back to the walk/run mode (pad DpadUp short press)
+// quack chirp + jaw flap (pad RT edge, Schmitt-triggered)
+//
+// ── Input lock ───────────────────────────────────────────────────────────
+// setLocked(true) zeroes getCommand() - the twist gate used while the
+// entrance/respawn ceremony plays. Discrete actions still dispatch: each
+// game trigger applies its own lock policy (e.g. Space-reset and the
+// chase-cam toggle historically work while locked, kicks don't).
+
+const ZERO_CMD = new Float32Array(3);
+
+export class Controller {
+ #sources = [];
+ #listeners = new Map(); // action -> Set(cb)
+ #locked = false;
+ #axes = { jaw: 0, orbitX: 0, orbitY: 0 };
+
+ constructor({ sources = [] } = {}) {
+ for (const s of sources) this.addSource(s);
+ }
+
+ // Register in priority order (first registered wins arbitration ties).
+ addSource(source) {
+ source.onAction = (action, meta) =>
+ this.#dispatch(action, { source: source.id, ...meta });
+ this.#sources.push(source);
+ }
+
+ // Read-only source list, for advanced per-source queries the merged view
+ // can't answer (e.g. "is ANY source commanding a turn right now?").
+ get sources() {
+ return this.#sources;
+ }
+
+ // Arm every source's listeners/hardware hooks.
+ init() {
+ for (const s of this.#sources) s.init?.();
+ }
+
+ dispose() {
+ for (const s of this.#sources) s.dispose?.();
+ }
+
+ // Per-frame tick: poll every source (they fire their edge actions from
+ // inside poll), then merge the aux axes.
+ update(dt) {
+ for (const s of this.#sources) s.poll?.(dt);
+ let jaw = 0, ox = 0, oy = 0;
+ for (const s of this.#sources) {
+ const a = s.axes;
+ if (!a) continue;
+ jaw = Math.max(jaw, a.jaw ?? 0);
+ if (Math.abs(a.orbitX ?? 0) > Math.abs(ox)) ox = a.orbitX;
+ if (Math.abs(a.orbitY ?? 0) > Math.abs(oy)) oy = a.orbitY;
+ }
+ this.#axes.jaw = jaw;
+ this.#axes.orbitX = ox;
+ this.#axes.orbitY = oy;
+ }
+
+ setLocked(v) {
+ this.#locked = !!v;
+ }
+
+ get locked() {
+ return this.#locked;
+ }
+
+ // Merged continuous twist [vx, vy, wz] (see the arbitration notes above).
+ // Returns live source arrays without copying - treat as read-only.
+ getCommand() {
+ if (this.#locked) return ZERO_CMD;
+ for (const s of this.#sources) if (s.isActive()) return s.command;
+ const fallback = this.#sources[this.#sources.length - 1];
+ return fallback ? fallback.command : ZERO_CMD;
+ }
+
+ // Merged aux axes { jaw, orbitX, orbitY }, refreshed by update().
+ getAxes() {
+ return this.#axes;
+ }
+
+ // Any source claiming twist authority (HUD "user is driving" signal).
+ anyActive() {
+ return this.#sources.some((s) => s.isActive());
+ }
+
+ // Per-source pressed snapshots for HUD keycap highlighting:
+ // { keyboard: {...}, gamepad: {...} }.
+ getPressed() {
+ const out = {};
+ for (const s of this.#sources) out[s.id] = s.pressed ?? {};
+ return out;
+ }
+
+ // Subscribe to a discrete action; cb(meta) with meta.source = source id.
+ // Returns an unsubscribe function.
+ on(action, cb) {
+ let set = this.#listeners.get(action);
+ if (!set) this.#listeners.set(action, (set = new Set()));
+ set.add(cb);
+ return () => set.delete(cb);
+ }
+
+ #dispatch(action, meta) {
+ const set = this.#listeners.get(action);
+ if (!set) return;
+ for (const cb of set) cb(meta);
+ }
+}
diff --git a/app/src/game/controls/gamepad.js b/app/src/game/controls/gamepad.js
new file mode 100644
index 0000000..fdec581
--- /dev/null
+++ b/app/src/game/controls/gamepad.js
@@ -0,0 +1,153 @@
+// Gamepad input source (see controller.js for the source interface
+// contract). Same mapping as the robot runtime (microduck_runtime):
+//
+// Left stick vertical = vx (asymmetric fwd/back), horizontal = turn,
+// EMA-smoothed like the runtime's cmd_alpha.
+// Right stick camera orbit rate (reported raw in axes.orbitX/Y; the
+// velocity smoothing / coasting lives downstream in the
+// camera code). R3 toggles the chase cam.
+// X roll (crouch-glide in roller mode - game decides)
+// Y ball spawn/respawn
+// RB / LB right / left kick
+// DpadDown sit <-> stand
+// DpadUp short press = back to run; HOLD ~1 s = legs <-> rollers
+// (like the robot's 3 s hold, shortened for the web)
+// RT / LT analog jaw (max of both); RT edge quacks through a
+// Schmitt trigger (fire at >= 0.35, re-arm below 0.2 - a
+// single threshold re-fires on jitter, which is how one
+// squeeze used to quack several times).
+
+const PAD_DEADZONE = 0.15;
+const PAD_ALPHA = 0.12; // EMA smoothing toward the stick target
+const dz = (v) => (Math.abs(v) < PAD_DEADZONE ? 0 : v);
+
+// Standard-mapping button indices.
+const BTN_X = 2, BTN_Y = 3, BTN_LB = 4, BTN_RB = 5, BTN_LT = 6, BTN_RT = 7;
+const BTN_R3 = 11, BTN_DPAD_UP = 12, BTN_DPAD_DOWN = 13;
+
+const DPAD_UP_HOLD_MS = 1000; // hold-to-switch-loco duration
+
+export class GamepadSource {
+ id = "gamepad";
+ connected = false;
+ command = new Float32Array(3); // [vx, 0, wz], EMA-smoothed
+ axes = { jaw: 0, orbitX: 0, orbitY: 0 };
+ pressed = {
+ x: false, y: false, rb: false, lb: false, r3: false,
+ dpadDown: false, dpadUp: false,
+ };
+ onAction = () => {}; // assigned by the Controller at registration
+
+ #getVelocityLimits;
+ #active = false; // owns twist authority (stick input, until EMA settles)
+ #dpadUpAt = 0; // wall-clock of the current DpadUp press
+ #dpadUpFired = false; // latch: one loco switch per hold
+ #rtArmed = true; // Schmitt trigger state for the RT quack
+
+ constructor({ getVelocityLimits }) {
+ this.#getVelocityLimits = getVelocityLimits;
+ }
+
+ init() {} // poll-based: nothing to attach
+ dispose() {}
+
+ isActive() {
+ return this.#active;
+ }
+
+ poll() {
+ const prev = this.pressed;
+ const gp = [...(navigator.getGamepads?.() ?? [])].find((p) => p && p.connected);
+ this.connected = !!gp;
+ if (!gp) {
+ if (this.#active) {
+ this.#active = false;
+ this.command.fill(0);
+ this.axes.jaw = 0;
+ }
+ this.axes.orbitX = 0;
+ this.axes.orbitY = 0;
+ return;
+ }
+ const now = performance.now();
+
+ // Left stick only: vertical = forward/back, horizontal = turn.
+ // (No strafe; the right stick doesn't drive movement.)
+ const lx = dz(gp.axes[0] ?? 0), ly = dz(gp.axes[1] ?? 0);
+ const up = -ly; // browser sticks report up as -1
+ const [limF, limB, limA] = this.#getVelocityLimits();
+ const target = [
+ up >= 0 ? up * limF : up * -limB,
+ 0,
+ -lx * limA,
+ ];
+ for (let i = 0; i < 3; i++) this.command[i] += PAD_ALPHA * (target[i] - this.command[i]);
+ // Sticks grab command authority on first input, release when back at
+ // rest (then the keyboard takes over again through the Controller's
+ // arbitration).
+ const stickInput = lx !== 0 || ly !== 0;
+ if (stickInput) this.#active = true;
+ else if (
+ this.#active &&
+ Math.abs(this.command[0]) + Math.abs(this.command[1]) + Math.abs(this.command[2]) < 0.01
+ ) {
+ this.#active = false;
+ this.command.fill(0);
+ }
+
+ // Right stick: raw (deadzoned) orbit rate. Reported every frame - the
+ // downstream camera step needs the zeros too so a released stick
+ // coasts to a stop.
+ this.axes.orbitX = dz(gp.axes[2] ?? 0);
+ this.axes.orbitY = dz(gp.axes[3] ?? 0);
+
+ // R3 (right stick click): chase-cam toggle, gamepad twin of KeyC.
+ const r3 = !!gp.buttons[BTN_R3]?.pressed;
+ if (r3 && !prev.r3) this.onAction("chaseToggle");
+ prev.r3 = r3;
+
+ const x = !!gp.buttons[BTN_X]?.pressed;
+ if (x && !prev.x) this.onAction("roll");
+ prev.x = x;
+
+ const y = !!gp.buttons[BTN_Y]?.pressed;
+ if (y && !prev.y) this.onAction("spawnBall");
+ prev.y = y;
+
+ const rb = !!gp.buttons[BTN_RB]?.pressed;
+ if (rb && !prev.rb) this.onAction("kickR");
+ prev.rb = rb;
+ const lb = !!gp.buttons[BTN_LB]?.pressed;
+ if (lb && !prev.lb) this.onAction("kickL");
+ prev.lb = lb;
+
+ const dpadDown = !!gp.buttons[BTN_DPAD_DOWN]?.pressed;
+ if (dpadDown && !prev.dpadDown) this.onAction("sitToggle");
+ prev.dpadDown = dpadDown;
+
+ // DpadUp: short press = back to run; hold fires ONE loco switch.
+ const dpadUp = !!gp.buttons[BTN_DPAD_UP]?.pressed;
+ if (dpadUp && !prev.dpadUp) {
+ this.#dpadUpAt = now;
+ this.#dpadUpFired = false;
+ this.onAction("walk");
+ }
+ if (dpadUp && !this.#dpadUpFired && now - this.#dpadUpAt >= DPAD_UP_HOLD_MS) {
+ this.#dpadUpFired = true; // latch: one switch per hold
+ this.onAction("locoToggle");
+ }
+ prev.dpadUp = dpadUp;
+
+ // Triggers drive the mouth (max of both); RT quacks on its
+ // Schmitt-triggered rising edge.
+ const rt = gp.buttons[BTN_RT]?.value ?? 0;
+ const lt = gp.buttons[BTN_LT]?.value ?? 0;
+ this.axes.jaw = Math.max(rt, lt);
+ if (this.#rtArmed && rt >= 0.35) {
+ this.onAction("quack");
+ this.#rtArmed = false;
+ } else if (!this.#rtArmed && rt < 0.2) {
+ this.#rtArmed = true;
+ }
+ }
+}
diff --git a/app/src/game/controls/keyboard.js b/app/src/game/controls/keyboard.js
new file mode 100644
index 0000000..510877e
--- /dev/null
+++ b/app/src/game/controls/keyboard.js
@@ -0,0 +1,116 @@
+// Keyboard input source (see controller.js for the source interface
+// contract). Hold-to-command movement keys plus one-shot action keys.
+//
+// e.code is the PHYSICAL key position, so one map covers QWERTY and AZERTY:
+// arrows / WASD (ZQSD) run + turn. No strafe - vy stays 0.
+
+const KEYMAP = {
+ ArrowUp: "fwd", KeyW: "fwd",
+ ArrowDown: "back", KeyS: "back",
+ ArrowLeft: "turnl", KeyA: "turnl",
+ ArrowRight: "turnr", KeyD: "turnr",
+};
+
+// One-shot keys -> controller actions. Physical Q/E (A/E on AZERTY) are the
+// explicit left / right kicks, mirroring the pad's LB / RB; F alternates.
+const ACTION_KEYS = {
+ KeyB: "spawnBall",
+ KeyC: "chaseToggle",
+ KeyM: "locoToggle",
+ KeyR: "roll",
+ KeyQ: "kickL",
+ KeyE: "kickR",
+ KeyF: "alternateKick",
+};
+
+export class KeyboardSource {
+ id = "keyboard";
+ connected = true; // a keyboard is always assumed present
+ command = new Float32Array(3); // [vx, 0, wz], scaled to velocity limits
+ axes = { jaw: 0, orbitX: 0, orbitY: 0 }; // keyboard drives none of these
+ pressed = { fwd: false, back: false, turnl: false, turnr: false };
+ onAction = () => {}; // assigned by the Controller at registration
+
+ #held = new Set();
+ #getVelocityLimits;
+ // Limits snapshot so poll() only re-maps held keys when they actually
+ // change (the legs <-> rollers switch); event handlers do the live work.
+ #lims = [NaN, NaN, NaN];
+ #onKeyDown = null;
+ #onKeyUp = null;
+ #onBlur = null;
+
+ constructor({ getVelocityLimits }) {
+ this.#getVelocityLimits = getVelocityLimits;
+ }
+
+ init() {
+ this.#onKeyDown = (e) => {
+ if (e.repeat) return;
+ // Space always resets, and must not scroll the page.
+ if (e.code === "Space") {
+ e.preventDefault();
+ this.onAction("reset");
+ return;
+ }
+ const action = ACTION_KEYS[e.code];
+ if (action) {
+ this.onAction(action);
+ return;
+ }
+ const move = KEYMAP[e.code];
+ if (!move) return;
+ e.preventDefault();
+ this.#held.add(move);
+ this.#refresh();
+ };
+ this.#onKeyUp = (e) => {
+ const move = KEYMAP[e.code];
+ if (!move) return;
+ this.#held.delete(move);
+ this.#refresh();
+ };
+ // Losing window focus drops every held key (keyup events are missed).
+ this.#onBlur = () => {
+ this.#held.clear();
+ this.#refresh();
+ };
+ window.addEventListener("keydown", this.#onKeyDown);
+ window.addEventListener("keyup", this.#onKeyUp);
+ window.addEventListener("blur", this.#onBlur);
+ }
+
+ dispose() {
+ window.removeEventListener("keydown", this.#onKeyDown);
+ window.removeEventListener("keyup", this.#onKeyUp);
+ window.removeEventListener("blur", this.#onBlur);
+ }
+
+ // Claims twist authority while any movement key is held.
+ isActive() {
+ return this.#held.size > 0;
+ }
+
+ // The command is event-driven (recomputed on keydown/keyup/blur, so a
+ // press lands the same tick, not on the next frame); poll only re-maps
+ // held keys onto fresh velocity limits after a locomotion switch.
+ poll() {
+ const [limF, limB, limA] = this.#getVelocityLimits();
+ if (limF !== this.#lims[0] || limB !== this.#lims[1] || limA !== this.#lims[2]) {
+ this.#refresh();
+ }
+ }
+
+ #refresh() {
+ const lims = this.#getVelocityLimits();
+ const [limF, limB, limA] = lims;
+ this.#lims = lims;
+ const held = this.#held;
+ this.command[0] = held.has("fwd") ? limF : held.has("back") ? limB : 0;
+ this.command[2] = held.has("turnl") ? limA : held.has("turnr") ? -limA : 0;
+ this.pressed.fwd = held.has("fwd");
+ this.pressed.back = held.has("back");
+ this.pressed.turnl = held.has("turnl");
+ this.pressed.turnr = held.has("turnr");
+ }
+}
diff --git a/app/src/game/controls/touch.js b/app/src/game/controls/touch.js
new file mode 100644
index 0000000..906b696
--- /dev/null
+++ b/app/src/game/controls/touch.js
@@ -0,0 +1,180 @@
+// Touch input source (see controller.js for the source interface
+// contract). Game Boy layout, two thumbs:
+//
+// Left thumb FLOATING analog stick: the lower-left quadrant of the
+// screen (#touch-zone) is the grab area, and the stick base
+// (#touch-stick) re-anchors under the finger wherever it
+// lands - so the thumb never has to find a fixed circle -
+// then snaps back to its resting spot on release. Vertical
+// = vx (asymmetric fwd/back limits), horizontal = turn. The
+// nub tracks the finger clamped to the base circle; the
+// command is EMA-smoothed like the gamepad's so releases
+// don't snap.
+// Right thumb two round caps: A (#touch-a) fires alternateKick - the
+// game alternates feet; B (#touch-b) quacks on press and
+// holds the beak open (axes.jaw = 1) while held.
+//
+// The overlay DOM lives in index.html (#touch-ui); this module only wires
+// pointer events to it. `connected` (mirrored onto body.touch-mode by
+// rl.js, which is what actually shows the overlay) arms two ways:
+// - (pointer: coarse) matches: phones/tablets, before any touch;
+// - OR the first real touch anywhere: catches DevTools device modes and
+// hybrid laptops the media query misses. Latching, like a gamepad.
+
+const TOUCH_ALPHA = 0.18; // EMA smoothing toward the stick target
+const TOUCH_DEADZONE = 0.12; // normalized deflection ignored around center
+
+export class TouchSource {
+ id = "touch";
+ connected = false;
+ command = new Float32Array(3); // [vx, 0, wz], EMA-smoothed
+ axes = { jaw: 0, orbitX: 0, orbitY: 0 };
+ pressed = { stick: false, a: false, b: false };
+ onAction = () => {}; // assigned by the Controller at registration
+
+ #getVelocityLimits;
+ #active = false; // owns twist authority (stick engaged, until EMA settles)
+ #target = [0, 0]; // normalized deflection [x, right+] [y, up+]
+ #mq = null;
+ #onMq = null;
+ #disposers = [];
+
+ constructor({ getVelocityLimits }) {
+ this.#getVelocityLimits = getVelocityLimits;
+ }
+
+ init() {
+ this.#mq = window.matchMedia("(pointer: coarse)");
+ // Latching: once a device has proven it can touch, keep the thumbs.
+ // __microduckTouched carries a touch seen by the title page before
+ // this module booted.
+ if (window.__microduckTouched) this.connected = true;
+ this.#onMq = () => { this.connected = this.connected || this.#mq.matches; };
+ this.#mq.addEventListener("change", this.#onMq);
+ this.#onMq();
+ const armTouch = () => { this.connected = true; };
+ window.addEventListener("touchstart", armTouch, { once: true, passive: true });
+ this.#disposers.push(() => window.removeEventListener("touchstart", armTouch));
+
+ const zone = document.getElementById("touch-zone");
+ const stick = document.getElementById("touch-stick");
+ const nub = stick?.querySelector(".nub");
+ if (zone && stick && nub) this.#bindStick(zone, stick, nub);
+
+ this.#bindButton("touch-a", "a", () => this.onAction("alternateKick"));
+ this.#bindButton("touch-b", "b", () => this.onAction("quack"));
+ }
+
+ dispose() {
+ this.#mq?.removeEventListener("change", this.#onMq);
+ for (const off of this.#disposers) off();
+ this.#disposers = [];
+ }
+
+ isActive() {
+ return this.#active;
+ }
+
+ poll() {
+ const [x, y] = this.#target;
+ const [limF, limB, limA] = this.#getVelocityLimits();
+ const tvx = y >= 0 ? y * limF : y * -limB;
+ const twz = -x * limA;
+ this.command[0] += TOUCH_ALPHA * (tvx - this.command[0]);
+ this.command[2] += TOUCH_ALPHA * (twz - this.command[2]);
+ // Same authority rule as the gamepad sticks: grab on input, release
+ // once the smoothed command has settled back to ~zero.
+ if (this.pressed.stick) this.#active = true;
+ else if (this.#active && Math.abs(this.command[0]) + Math.abs(this.command[2]) < 0.01) {
+ this.#active = false;
+ this.command.fill(0);
+ }
+ // B holds the beak open; quack itself fired on the press edge.
+ this.axes.jaw = this.pressed.b ? 1 : 0;
+ }
+
+ #on(el, type, fn) {
+ el.addEventListener(type, fn);
+ this.#disposers.push(() => el.removeEventListener(type, fn));
+ }
+
+ #bindStick(zone, stick, nub) {
+ let pointerId = null;
+ let center = null; // stick center while grabbed, zone-local px
+ const setFrom = (e) => {
+ const zr = zone.getBoundingClientRect();
+ const R = stick.offsetWidth / 2;
+ const travel = R * 0.62; // max nub travel inside the base circle
+ let dx = e.clientX - zr.left - center.x;
+ let dy = e.clientY - zr.top - center.y;
+ const d = Math.hypot(dx, dy);
+ if (d > travel) { dx *= travel / d; dy *= travel / d; }
+ nub.style.transform = `translate(${dx}px, ${dy}px)`;
+ const nx = dx / travel, ny = -dy / travel; // up is +y
+ const mag = Math.hypot(nx, ny);
+ const live = mag >= TOUCH_DEADZONE;
+ this.#target[0] = live ? nx : 0;
+ this.#target[1] = live ? ny : 0;
+ };
+ const release = () => {
+ pointerId = null;
+ center = null;
+ this.pressed.stick = false;
+ stick.classList.remove("live");
+ nub.style.transform = "";
+ // Back to the CSS resting spot until the next grab.
+ stick.style.left = "";
+ stick.style.top = "";
+ stick.style.bottom = "";
+ this.#target[0] = 0;
+ this.#target[1] = 0;
+ };
+ this.#on(zone, "pointerdown", (e) => {
+ e.preventDefault();
+ pointerId = e.pointerId;
+ // Anchor the base exactly under the finger - a clamped anchor would
+ // start the stick with a phantom deflection near the zone edges. The
+ // circle clipping off-screen there is the standard floating-stick
+ // look, and it takes no pointer events anyway.
+ const zr = zone.getBoundingClientRect();
+ const R = stick.offsetWidth / 2;
+ center = { x: e.clientX - zr.left, y: e.clientY - zr.top };
+ stick.style.left = `${center.x - R}px`;
+ stick.style.top = `${center.y - R}px`;
+ stick.style.bottom = "auto";
+ this.pressed.stick = true;
+ stick.classList.add("live");
+ setFrom(e); // zero deflection at grab
+ // Last: capture can throw on exotic pointers and must not eat the
+ // press state above.
+ try { zone.setPointerCapture(e.pointerId); } catch {}
+ });
+ this.#on(zone, "pointermove", (e) => {
+ if (e.pointerId === pointerId) setFrom(e);
+ });
+ this.#on(zone, "pointerup", (e) => {
+ if (e.pointerId === pointerId) release();
+ });
+ this.#on(zone, "pointercancel", (e) => {
+ if (e.pointerId === pointerId) release();
+ });
+ }
+
+ #bindButton(elId, key, fire) {
+ const el = document.getElementById(elId);
+ if (!el) return;
+ this.#on(el, "pointerdown", (e) => {
+ e.preventDefault();
+ this.pressed[key] = true;
+ el.classList.add("down");
+ fire(); // on the press edge, not the release: arcade latency
+ try { el.setPointerCapture(e.pointerId); } catch {}
+ });
+ const release = () => {
+ this.pressed[key] = false;
+ el.classList.remove("down");
+ };
+ this.#on(el, "pointerup", release);
+ this.#on(el, "pointercancel", release);
+ }
+}
diff --git a/app/src/game/duck.js b/app/src/game/duck.js
new file mode 100644
index 0000000..691af84
--- /dev/null
+++ b/app/src/game/duck.js
@@ -0,0 +1,339 @@
+// Standalone JS port of microduck_app's src/duck/kinematics.ts.
+// Loads kinematics.json (built from the MJCF by build_kinematics.py) and
+// builds an Object3D tree with one Group per body. Joints become per-body
+// local rotations driven by setJointAngles / setJoint.
+
+import * as THREE from "three";
+import { STLLoader } from "three/addons/loaders/STLLoader.js";
+import { mergeVertices, toCreasedNormals } from "three/addons/utils/BufferGeometryUtils.js";
+
+// Cache-busting version appended to every STL request. python http.server
+// sends no Cache-Control, so browsers apply heuristic caching keyed on
+// Last-Modified and can keep serving stale mesh bytes even after the files
+// change on disk. Bump this whenever the mesh files are regenerated.
+export const MESH_VERSION = "8";
+
+// Default model directory: the complete mjlab export (converted from
+// robot_walk.xml by tools/mjcf_to_kinematics.py). robot/v1.5/ and
+// robot/alpha/ stay on disk for reference but the code no longer
+// targets them.
+export const MODEL_DIR = "./robot/mjlab";
+
+// On a private HF Space, asset requests carry the ?__sign JWT (auth
+// cookies may be blocked in the hub iframe). Identity everywhere else.
+import { signed } from "./signed.js";
+
+// Meshes fully occluded inside the shells at every demo camera angle,
+// verified empirically by per-mesh pixel-diff (front 3/4, back, low
+// front close-up): hiding each changes exactly 0 pixels. Skipped at
+// load time so their bytes are never fetched. Load everything with
+// `?all=1` for debugging.
+const HIDDEN_MESHES = new Set([]);
+
+export async function loadKinematics(url) {
+ // Same cache-buster as the STLs: force-cache would otherwise keep
+ // serving a stale kinematics.json after the mesh list changes.
+ const r = await fetch(signed(`${url}?v=${MESH_VERSION}`), { cache: "force-cache" });
+ if (!r.ok) throw new Error(`kinematics fetch ${r.status}`);
+ const k = await r.json();
+ // Full-resolution meshes by default (the reduction will be redone
+ // interactively in Blender later). `?lite=1` opts into a decimated
+ // meshes-lite/ sibling if present.
+ if (new URLSearchParams(location.search).get("lite") === "1") {
+ k.mesh_dir = k.mesh_dir.replace(/\/meshes$/, "/meshes-lite");
+ }
+ return k;
+}
+
+// Materials are PBR (MeshStandardMaterial), same family as the Reachy
+// mobile app's glb viewer. Optional silhouette outlines via three's
+// OutlineEffect - see main.js.
+
+export async function buildRig(k, opts = {}) {
+ // placer holds world-space position + yaw (no axis-conversion).
+ const placer = new THREE.Group();
+ placer.name = "duck_placer";
+ // root applies the MJCF +Z up -> three.js +Y up convention fix.
+ const root = new THREE.Group();
+ root.name = "duck_root";
+ root.rotation.x = -Math.PI / 2;
+ placer.add(root);
+
+ const bodies = new Map();
+ const joints = new Map();
+ const loader = new STLLoader();
+
+ // STL files carry per-facet normals, which shade as a faceted mess.
+ // Weld vertices, then rebuild normals with a crease angle: curved
+ // surfaces smooth out, machined edges stay hard - the cel look needs
+ // both. Two scale/attribute pitfalls here:
+ // - mergeVertices hashes ALL attributes, so the per-facet STL normals
+ // must be dropped first or coincident vertices never merge.
+ // - toCreasedNormals groups vertices on a fixed 0.01-unit hash grid.
+ // Our meshes are in meters, so that grid is 1 cm: normals of vertices
+ // up to a centimeter apart get averaged together, which shades like a
+ // heavily decimated mesh. Scaling to mm makes the grid 10 um.
+ const CREASE = Math.PI / 5; // 36 deg
+ const meshCache = new Map();
+ const loadMesh = (name) => {
+ if (!meshCache.has(name)) {
+ meshCache.set(
+ name,
+ loader.loadAsync(signed(`${k.mesh_dir}/${name}?v=${MESH_VERSION}`)).then((raw) => {
+ raw.deleteAttribute("normal");
+ const welded = mergeVertices(raw, 1e-4);
+ welded.scale(1000, 1000, 1000);
+ const display = toCreasedNormals(welded, CREASE);
+ display.scale(1e-3, 1e-3, 1e-3);
+ welded.scale(1e-3, 1e-3, 1e-3);
+ return { display, welded };
+ }),
+ );
+ }
+ return meshCache.get(name);
+ };
+
+ for (const b of k.bodies) {
+ const g = new THREE.Group();
+ g.name = b.name;
+ g.position.set(b.pos[0], b.pos[1], b.pos[2]);
+ g.quaternion.set(b.quat[1], b.quat[2], b.quat[3], b.quat[0]);
+ bodies.set(b.name, g);
+ }
+ for (const b of k.bodies) {
+ const g = bodies.get(b.name);
+ if (b.parent && bodies.has(b.parent)) bodies.get(b.parent).add(g);
+ else root.add(g);
+ }
+ for (const b of k.bodies) {
+ if (!b.joint || (b.joint.type && b.joint.type !== "hinge")) continue;
+ const g = bodies.get(b.name);
+ joints.set(b.joint.name, {
+ body: g,
+ axis: new THREE.Vector3(...b.joint.axis).normalize(),
+ baseQuat: g.quaternion.clone(),
+ range: b.joint.range ?? null,
+ });
+ }
+
+ // Cache materials by their resolved PBR props so identical parts share
+ // one GPU material instance.
+ const matCache = new Map();
+ // Optional (meshName, bodyName, rgba) -> material spec hook. A spec is
+ // { color: [r,g,b], roughness, metalness, opacity? }; plain rgba arrays
+ // are also accepted for backwards compat.
+ const materialForMesh = opts.materialForMesh ?? null;
+ const matFor = (spec) => {
+ const color = spec.color;
+ const roughness = spec.roughness ?? 0.5;
+ const metalness = spec.metalness ?? 0.0;
+ const opacity = spec.opacity ?? 1;
+ const key = `${color.join(",")}|${roughness}|${metalness}|${opacity}`;
+ const cached = matCache.get(key);
+ if (cached) return cached;
+ const m = new THREE.MeshStandardMaterial({
+ color: new THREE.Color(...color),
+ roughness,
+ metalness,
+ transparent: opacity < 1,
+ opacity,
+ });
+ matCache.set(key, m);
+ return m;
+ };
+ const toSpec = (v, fallbackRgba) => {
+ if (!v) return { color: fallbackRgba.slice(0, 3), opacity: fallbackRgba[3] ?? 1 };
+ if (Array.isArray(v)) return { color: v.slice(0, 3), opacity: v[3] ?? 1 };
+ return v;
+ };
+
+ // Optional interior ink lines: hard edges above the threshold angle
+ // drawn as line segments, comic style. Cached per mesh file.
+ const inkOpts = opts.inkEdges ?? null;
+ const inkMat = inkOpts
+ ? new THREE.LineBasicMaterial({
+ color: inkOpts.color ?? 0x0a0a0e,
+ transparent: true,
+ opacity: inkOpts.opacity ?? 0.55,
+ })
+ : null;
+ const edgeCache = new Map();
+ const edgesFor = (name, welded) => {
+ if (!edgeCache.has(name)) {
+ edgeCache.set(name, new THREE.EdgesGeometry(welded, inkOpts.threshold ?? 40));
+ }
+ return edgeCache.get(name);
+ };
+
+ const pending = [];
+ const loadAll = new URLSearchParams(location.search).get("all") === "1";
+ // The MJCF lists a few geoms twice with identical transforms (visual +
+ // collision copies of power_support, soles, legs); drawing both would
+ // only z-fight, so exact duplicates are skipped.
+ const seenGeoms = new Set();
+ for (const b of k.bodies) {
+ const g = bodies.get(b.name);
+ if (!g) continue;
+ for (const geom of b.geoms) {
+ if (geom.type && geom.type !== "mesh") continue;
+ if (!geom.mesh) continue;
+ if (!loadAll && HIDDEN_MESHES.has(geom.mesh)) continue;
+ const dupKey = `${b.name}|${geom.mesh}|${geom.pos}|${geom.quat}`;
+ if (seenGeoms.has(dupKey)) continue;
+ seenGeoms.add(dupKey);
+ pending.push(
+ loadMesh(geom.mesh).then(({ display, welded }) => {
+ const rgba = geom.color
+ ? [geom.color[0], geom.color[1], geom.color[2], geom.color[3] ?? 1]
+ : [0.85, 0.85, 0.85, 1];
+ const spec = toSpec(materialForMesh?.(geom.mesh, b.name, rgba), rgba);
+ const m = new THREE.Mesh(display, matFor(spec));
+ // Mesh filename tag so callers can re-skin materials in place
+ // (survives cloneRig: Object3D.copy deep-copies userData).
+ m.userData.meshName = geom.mesh;
+ if (geom.pos) m.position.set(...geom.pos);
+ if (geom.quat) m.quaternion.set(geom.quat[1], geom.quat[2], geom.quat[3], geom.quat[0]);
+ g.add(m);
+ if (inkMat) {
+ const lines = new THREE.LineSegments(edgesFor(geom.mesh, welded), inkMat);
+ lines.position.copy(m.position);
+ lines.quaternion.copy(m.quaternion);
+ g.add(lines);
+ }
+ }),
+ );
+ }
+ }
+ await Promise.all(pending);
+
+ const rig = { placer, root, bodies, joints };
+ setupJawPivot(rig);
+ return rig;
+}
+
+// ── Jaw hinge ───────────────────────────────────────────────────────────
+// The mjlab model has no passive jaw joints: jaw.stl / jaw_soft.stl are
+// rigid geoms of the head body (named "jaw_soft" in the MJCF, it carries
+// the head_roll joint). The quack re-creates the hinge in JS: both jaw
+// meshes are reparented into a "jaw_pivot" group
+// whose origin sits on the rear top edge of their combined bounding box
+// (the physical hinge line), and setJawOpen rotates that pivot about the
+// robot's left-right axis so the beak tip swings down.
+const JAW_MESH_NAMES = new Set(["jaw.stl", "jaw_soft.stl"]);
+export const JAW_MAX_OPEN = 0.32; // rad at openness 1
+
+function setupJawPivot(rig) {
+ const meshes = [];
+ rig.root.traverse((o) => {
+ if (o.isMesh && JAW_MESH_NAMES.has(o.userData.meshName)) meshes.push(o);
+ });
+ if (!meshes.length) return;
+ const body = meshes[0].parent;
+ // The placer is still untransformed right after buildRig, so world
+ // coords == placer coords here: robot forward is +X, up is +Y.
+ rig.placer.updateWorldMatrix(true, true);
+ const box = new THREE.Box3();
+ for (const m of meshes) box.expandByObject(m);
+ const hingeW = new THREE.Vector3(box.min.x, box.max.y, (box.min.z + box.max.z) / 2);
+ // +angle about -Z rotates the +X beak tip toward -Y (down).
+ const axisW = new THREE.Vector3(0, 0, -1);
+ const bodyQuatInv = body.getWorldQuaternion(new THREE.Quaternion()).invert();
+ const hingeL = body.worldToLocal(hingeW.clone());
+ const axisL = axisW.applyQuaternion(bodyQuatInv).normalize();
+ const pivot = new THREE.Group();
+ pivot.name = "jaw_pivot";
+ pivot.position.copy(hingeL);
+ // Plain array so Object3D.copy's JSON userData clone preserves it.
+ pivot.userData.jawAxis = axisL.toArray();
+ body.add(pivot);
+ for (const m of meshes) {
+ m.position.sub(hingeL);
+ pivot.add(m);
+ }
+}
+
+// Open the beak: 0 = closed, 1 = fully open (JAW_MAX_OPEN rad). The pivot
+// is resolved lazily by name so clones from cloneRig work transparently.
+const _jawAxis = new THREE.Vector3();
+export function setJawOpen(rig, open) {
+ if (rig._jawPivot === undefined) {
+ rig._jawPivot = rig.placer.getObjectByName("jaw_pivot") ?? null;
+ }
+ const pivot = rig._jawPivot;
+ if (!pivot) return;
+ _jawAxis.fromArray(pivot.userData.jawAxis);
+ pivot.quaternion.setFromAxisAngle(_jawAxis, JAW_MAX_OPEN * open);
+}
+
+// Set one named joint, clamped to its MJCF range when known.
+export function setJoint(rig, name, angle) {
+ const j = rig.joints.get(name);
+ if (!j) return;
+ let a = angle;
+ if (j.range) a = Math.min(j.range[1], Math.max(j.range[0], a));
+ const rot = _q.setFromAxisAngle(j.axis, a);
+ j.body.quaternion.copy(j.baseQuat).multiply(rot);
+}
+const _q = new THREE.Quaternion();
+
+export function applyPose(rig, pose) {
+ for (const [name, ang] of Object.entries(pose)) setJoint(rig, name, ang);
+}
+
+// Deep-clone a built rig without re-parsing the STL files: Object3D.clone
+// shares geometry and materials, so N clones cost almost nothing on top of
+// the first buildRig. The bodies/joints maps are rebuilt by looking up the
+// cloned nodes by name (body names are unique in the MJCF).
+export function cloneRig(rig) {
+ const placer = rig.placer.clone(true);
+ const root = placer.getObjectByName("duck_root");
+ const bodies = new Map();
+ for (const name of rig.bodies.keys()) {
+ bodies.set(name, placer.getObjectByName(name));
+ }
+ const joints = new Map();
+ for (const [name, j] of rig.joints) {
+ joints.set(name, {
+ body: placer.getObjectByName(j.body.name),
+ axis: j.axis, // read-only, safe to share
+ baseQuat: j.baseQuat.clone(),
+ range: j.range,
+ });
+ }
+ return { placer, root, bodies, joints };
+}
+
+// Ground using the whole rig's bounding box (sitting pose folds the legs
+// under the trunk, so the feet are not the lowest point).
+const _box = new THREE.Box3();
+export function groundFullBody(rig, floorY = 0) {
+ rig.placer.updateWorldMatrix(true, true);
+ _box.setFromObject(rig.placer);
+ if (!Number.isFinite(_box.min.y)) return 0;
+ rig.placer.position.y += floorY - _box.min.y;
+ return floorY - _box.min.y;
+}
+
+// "SIT" keyframe. The mjlab model shares alpha's conventions (same
+// onshape-to-robot pipeline): neck_pitch range max is 1.0472, so
+// neck_pitch sits just under it (headroom for the breathing oscillation,
+// +-0.025) and head_pitch compensates to keep the head level-ish with a
+// slight upward tilt toward the camera. NOTE: head_pitch sign is
+// inverted vs v1.5 (positive = head down), so the compensation is
+// positive here (verified visually).
+export const SITTING_POSE = {
+ left_hip_yaw: 0.0,
+ left_hip_roll: 0.0,
+ left_hip_pitch: -0.5236,
+ left_knee: 1.0472,
+ left_ankle: 0.0,
+ neck_pitch: 1.02,
+ head_pitch: 0.9,
+ head_yaw: 0.0,
+ head_roll: 0.0,
+ right_hip_yaw: 0.0,
+ right_hip_roll: 0.0,
+ right_hip_pitch: 0.5236,
+ right_knee: -1.0472,
+ right_ankle: 0.0,
+};
diff --git a/app/src/game/fx/demo-glitch.html b/app/src/game/fx/demo-glitch.html
new file mode 100644
index 0000000..91b790d
--- /dev/null
+++ b/app/src/game/fx/demo-glitch.html
@@ -0,0 +1,140 @@
+
+
+
+
+
+ fx demo - glitch materialization
+
+
+
+
+
+
+ loading rig...
+
+
+
diff --git a/app/src/game/fx/demo-wireframe.html b/app/src/game/fx/demo-wireframe.html
new file mode 100644
index 0000000..24d7dbb
--- /dev/null
+++ b/app/src/game/fx/demo-wireframe.html
@@ -0,0 +1,113 @@
+
+
+
+
+
+ FX demo - holographic wireframe scan-up
+
+
+
+
+
+
+ FX: HOLOGRAPHIC WIREFRAME SCAN-UP
+
+
+
+
+
diff --git a/app/src/game/fx/fx-glitch.js b/app/src/game/fx/fx-glitch.js
new file mode 100644
index 0000000..085e500
--- /dev/null
+++ b/app/src/game/fx/fx-glitch.js
@@ -0,0 +1,311 @@
+// Cyberpunk 2077-style glitch materialization for the Microduck rig.
+//
+// The duck appears as stacked horizontal slices that flicker in and out
+// with random screen-space horizontal offsets, converging to their true
+// position. Chromatic aberration is faked with two additive silhouette
+// ghosts (cyan / orange) offset left-right, digital noise blocks flash
+// emissive or invert the surface colour, and a final warm flash "snaps"
+// everything crisp.
+//
+// Implementation: onBeforeCompile injections on CACHED clones of the rig
+// materials (same pattern and same program-cache trap as the entrance
+// dissolve in rl.js: clones are cached per original material and reused
+// on every replay, each with a unique customProgramCacheKey, otherwise
+// three.js would reuse a compiled program without re-binding uniforms).
+// All uniforms are shared singleton objects so one JS write per frame
+// drives every material.
+
+export const name = "glitch";
+
+const DURATION = 1.15; // seconds
+const TICK_HZ = 30; // discrete glitch update rate (digital feel)
+const SLICES = 24;
+
+// ── Shared uniforms (one instance drives all cloned materials) ──────────
+const uP = { value: 0 }; // progress 0..1 (0 = invisible)
+const uSeed = { value: 0 }; // discrete tick, drives all hashes
+const uAmp = { value: 0 }; // slice offset amplitude (view-space meters)
+const uFlash = { value: 0 }; // final snap flash intensity
+const uGhostOff = { value: 0 }; // RGB-split ghost separation (meters)
+const uB = { value: null }; // vec4(minY, height, sliceH, 0) world bounds
+
+let T = null; // injected THREE namespace
+let rigRef = null;
+let playing = false;
+let scrubbed = false;
+let done = true;
+let elapsed = 0;
+
+// Deterministic JS-side hash, mirrors the GLSL one.
+const jhash = (n) => {
+ const s = Math.sin(n * 127.1 + 311.7) * 43758.5453;
+ return s - Math.floor(s);
+};
+
+// ── GLSL injection ──────────────────────────────────────────────────────
+const GLSL_HELPERS = /* glsl */ `
+varying vec3 vGlW;
+uniform float uGlP, uGlSeed;
+uniform vec4 uGlB;
+float glHash2(vec2 q) { return fract(sin(dot(q, vec2(127.1, 311.7))) * 43758.5453); }
+vec3 glHash3(vec2 q) { return vec3(glHash2(q), glHash2(q + 17.17), glHash2(q + 31.3)); }
+`;
+
+function injectGlitch(shader, { signU = null, ghost = false } = {}) {
+ shader.uniforms.uGlP = uP;
+ shader.uniforms.uGlSeed = uSeed;
+ shader.uniforms.uGlAmp = uAmp;
+ shader.uniforms.uGlFlash = uFlash;
+ shader.uniforms.uGlGhostOff = uGhostOff;
+ shader.uniforms.uGlSign = signU ?? { value: 0 };
+ shader.uniforms.uGlB = uB;
+
+ shader.vertexShader = shader.vertexShader
+ .replace(
+ "#include ",
+ "#include \n" + GLSL_HELPERS + "uniform float uGlAmp, uGlSign, uGlGhostOff;\n",
+ )
+ .replace(
+ "#include ",
+ /* glsl */ `#include
+vec4 glWp = modelMatrix * vec4(transformed, 1.0);
+vGlW = glWp.xyz;
+if (uGlP < 1.0) {
+ float glSid = floor((glWp.y - uGlB.x) / uGlB.z);
+ // Fraction of moving slices shrinks as p rises: convergence.
+ float glMove = step(0.25 + 0.62 * uGlP, glHash2(vec2(glSid * 1.71 + 4.2, uGlSeed + 13.0)));
+ float glOff = (glHash2(vec2(glSid, uGlSeed)) - 0.5) * 2.0 * uGlAmp * glMove;
+ // Occasional whole-body frame jump for one tick.
+ if (glHash2(vec2(uGlSeed, 3.17)) > 0.86) {
+ glOff += (glHash2(vec2(uGlSeed, 9.91)) - 0.5) * 3.0 * uGlAmp;
+ }
+ glOff += uGlSign * uGlGhostOff;
+ // View-space X = screen-horizontal, the classic spawn-glitch axis.
+ mvPosition.x += glOff;
+ gl_Position = projectionMatrix * mvPosition;
+}`,
+ );
+
+ const sliceDiscard = /* glsl */ `
+float glEdge = 0.0, glInvAmt = 0.0;
+vec3 glAddC = vec3(0.0);
+if (uGlP < 1.0) {
+ float glSid = floor((vGlW.y - uGlB.x) / uGlB.z);
+ float glH = glHash2(vec2(glSid, uGlSeed + 0.7));
+ float glVis = smoothstep(0.02, 0.82, uGlP) * 1.35;
+ // Two-three full-silhouette pre-flashes right at the start.
+ float glPre = (uGlP > 0.015 && uGlP < 0.14 && glHash2(vec2(uGlSeed, 7.7)) > 0.72) ? 1.0 : 0.0;
+ glVis = max(glVis, glPre);
+ if (glH > glVis) discard;
+ glEdge = max(glPre * 0.7, (1.0 - smoothstep(0.0, 0.3, glVis - glH)) * (1.0 - uGlP));
+${ghost ? "" : /* glsl */ `
+ // Digital noise blocks: world-space rectangular patches, re-seeded per
+ // tick. Some invert the surface colour, most flash emissive.
+ vec2 glBq = floor((vGlW.xy + vec2(vGlW.z * 0.7, vGlW.z * 0.3)) * 52.0
+ + vec2(uGlSeed * 0.373, uGlSeed * 0.719));
+ vec3 glBh = glHash3(glBq + uGlSeed);
+ float glBGate = (1.0 - uGlP) * 0.16;
+ if (glBh.x > 1.0 - glBGate) {
+ if (glBh.y < 0.3) glInvAmt = 1.0;
+ else glAddC += (glBh.z < 0.6 ? vec3(0.15, 1.3, 1.5)
+ : (glBh.z < 0.85 ? vec3(1.4) : vec3(1.6, 0.5, 0.06))) * (0.7 + glBh.y);
+ }
+ // Faint rolling scanline shimmer.
+ glAddC += vec3(0.05, 0.3, 0.35) * (1.0 - uGlP) * 0.18
+ * step(0.6, fract(vGlW.y * 150.0 - uGlSeed * 0.21));
+`}
+}`;
+
+ const emissiveOut = ghost
+ ? "" // ghosts are pre-tinted additive silhouettes, no extra emissive
+ : /* glsl */ `
+gl_FragColor.rgb = mix(gl_FragColor.rgb, vec3(1.1) - gl_FragColor.rgb, glInvAmt);
+gl_FragColor.rgb += glAddC;
+gl_FragColor.rgb += glEdge * vec3(0.25, 1.15, 1.35);
+gl_FragColor.rgb += uGlFlash * vec3(1.25, 0.7, 0.35);`;
+
+ shader.fragmentShader = shader.fragmentShader
+ .replace(
+ "#include ",
+ "#include \n" + GLSL_HELPERS + "uniform float uGlFlash;\n",
+ )
+ .replace("#include ", "#include " + sliceDiscard)
+ .replace("#include ", "#include " + emissiveOut);
+}
+
+// ── Material clones (cached, never disposed between replays) ────────────
+const clones = new Map(); // original material uuid -> glitch clone
+let cloneNonce = 0;
+let saved = null; // Array<[mesh, originalMat, cloneMat]> while active
+
+function cloneFor(orig) {
+ let m = clones.get(orig.uuid);
+ if (m) return m;
+ m = orig.clone();
+ m.onBeforeCompile = (shader) => injectGlitch(shader);
+ const key = `microduck-glitch-${cloneNonce++}`;
+ m.customProgramCacheKey = () => key;
+ m.needsUpdate = true;
+ clones.set(orig.uuid, m);
+ return m;
+}
+
+function applyGlitchMats() {
+ if (saved) return;
+ saved = [];
+ rigRef.placer.traverse((o) => {
+ if (!o.isMesh || o.userData.glGhost) return;
+ const orig = o.material;
+ const m = cloneFor(orig);
+ saved.push([o, orig, m]);
+ o.material = m;
+ });
+}
+
+function restoreMats() {
+ if (!saved) return;
+ for (const [mesh, orig, clone] of saved) {
+ if (mesh.material === clone) mesh.material = orig;
+ }
+ saved = null;
+}
+
+// ── RGB-split ghosts ────────────────────────────────────────────────────
+// Two additive unlit silhouette copies of every rig mesh (cyan right,
+// orange left), sharing the slice-discard shader so their outline always
+// matches the sliced duck. Added as children of each mesh: they inherit
+// the full kinematic transform for free.
+let ghostMats = [];
+let ghostMeshes = [];
+
+function makeGhostMat(r, g, b, sign) {
+ const m = new T.MeshBasicMaterial({
+ transparent: true,
+ opacity: 0,
+ depthWrite: false,
+ blending: T.AdditiveBlending,
+ });
+ m.color.setRGB(r, g, b);
+ const signU = { value: sign };
+ m.onBeforeCompile = (shader) => injectGlitch(shader, { signU, ghost: true });
+ m.customProgramCacheKey = () => `microduck-glitch-ghost-${sign > 0 ? "r" : "l"}`;
+ return m;
+}
+
+function buildGhosts() {
+ ghostMats = [makeGhostMat(0.0, 1.1, 1.3, +1), makeGhostMat(1.3, 0.35, 0.02, -1)];
+ const hosts = [];
+ rigRef.placer.traverse((o) => {
+ if (o.isMesh && !o.userData.glGhost) hosts.push(o);
+ });
+ for (const mesh of hosts) {
+ for (const mat of ghostMats) {
+ const gm = new T.Mesh(mesh.geometry, mat);
+ gm.userData.glGhost = true;
+ gm.renderOrder = 2;
+ gm.frustumCulled = false;
+ gm.visible = false;
+ mesh.add(gm);
+ ghostMeshes.push(gm);
+ }
+ }
+}
+
+function setGhostsVisible(v) {
+ for (const gm of ghostMeshes) gm.visible = v;
+}
+
+// ── Deterministic per-progress uniform state ────────────────────────────
+// Everything derives from p alone (tick included), so setProgress(p) gives
+// reproducible frames for debugging/screenshots.
+function setUniformsFor(p) {
+ uP.value = p;
+ const tick = Math.floor(p * DURATION * TICK_HZ);
+ uSeed.value = tick;
+ const h = uB.value.y; // duck height
+ const gate = 0.35 + 0.65 * jhash(tick + 3.7);
+ uAmp.value = p < 0.92 ? h * 0.3 * Math.pow(1 - p, 1.3) * gate : 0;
+ uGhostOff.value =
+ p > 0.04 && p < 0.9 ? (0.06 + 0.3 * jhash(tick + 11.1)) * (1 - p) * h : 0;
+ uFlash.value = p > 0.86 ? 1.5 * Math.exp(-16 * (p - 0.86) * DURATION) : 0;
+ const ghostOp =
+ p > 0.04 && p < 0.9 ? (0.05 + 0.32 * (1 - p)) * (0.4 + 0.6 * jhash(tick + 5.5)) : 0;
+ for (const m of ghostMats) m.opacity = ghostOp;
+}
+
+function finish() {
+ uP.value = 1;
+ uFlash.value = 0;
+ setGhostsVisible(false);
+ restoreMats();
+ playing = false;
+ done = true;
+}
+
+// ── Public interface ────────────────────────────────────────────────────
+export function init({ THREE, scene, rig, camera, renderer }) {
+ T = THREE;
+ rigRef = rig;
+ rig.placer.updateWorldMatrix(true, true);
+ const box = new T.Box3().setFromObject(rig.placer);
+ const minY = box.min.y;
+ const height = Math.max(1e-3, box.max.y - minY);
+ uB.value = new T.Vector4(minY, height, height / SLICES, 0);
+ buildGhosts();
+ // Duck starts invisible: p=0 discards every fragment.
+ uP.value = 0;
+ applyGlitchMats();
+ done = true;
+ playing = false;
+}
+
+export function start() {
+ applyGlitchMats();
+ setGhostsVisible(true);
+ elapsed = 0;
+ playing = true;
+ scrubbed = false;
+ done = false;
+ setUniformsFor(0);
+}
+
+export function update(dt, t) {
+ if (!playing || scrubbed) return;
+ elapsed += dt;
+ const p = Math.min(1, elapsed / DURATION);
+ setUniformsFor(p);
+ if (p >= 1) finish();
+}
+
+export function isDone() {
+ return done;
+}
+
+export function dispose() {
+ restoreMats();
+ for (const gm of ghostMeshes) gm.parent?.remove(gm);
+ ghostMeshes = [];
+ for (const m of ghostMats) m.dispose();
+ ghostMats = [];
+ for (const m of clones.values()) m.dispose();
+ clones.clear();
+ playing = false;
+ done = true;
+ rigRef = null;
+}
+
+// Debug hook: freeze the effect at an exact progress value (deterministic,
+// used by the demo page for mid-effect screenshots). start() resumes
+// normal playback.
+export function setProgress(p) {
+ scrubbed = true;
+ if (p >= 1) {
+ finish();
+ return;
+ }
+ playing = true;
+ done = false;
+ applyGlitchMats();
+ setGhostsVisible(true);
+ setUniformsFor(Math.max(0, p));
+}
diff --git a/app/src/game/fx/fx-wireframe.js b/app/src/game/fx/fx-wireframe.js
new file mode 100644
index 0000000..064307b
--- /dev/null
+++ b/app/src/game/fx/fx-wireframe.js
@@ -0,0 +1,323 @@
+// Holographic wireframe scan-up materialization effect.
+//
+// Sequence (~0.9 s, reversible):
+// 1. An invisible scan height rises from the floor through the target;
+// the boundary reads on the surface itself (bright wireframe band
+// right under the scan height - no standalone disc geometry).
+// 2. Below the scan line the target shows as a flickering additive
+// wireframe hologram (scanline stripes, brightness boost near the
+// scan line).
+// 3. A second, fainter "solidify" line trails behind: fragments below
+// it render the real PBR materials (world-Y clip injected via
+// onBeforeCompile), with a hot edge right at the line. Once it
+// clears the top the original materials are restored directly.
+//
+// Played backwards, the same timeline de-materializes (solid peel ->
+// hologram -> gone). Used for the ball despawn; the duck only ever
+// materializes.
+//
+// createWireframeFx() returns an independent instance (duck and ball
+// scan at the same time without sharing uniforms). The module-level
+// named exports wrap a singleton so demo-wireframe.html is unchanged.
+//
+// Instance interface:
+// init({ THREE, scene, rig | root, camera, renderer, hidden? })
+// start() / startReverse() / update(dt) / isDone() / restore() / dispose()
+// Extra: setProgress(p), playing, reversing, TOTAL_S.
+
+export const name = "wireframe";
+
+// ── Timeline (seconds) ──────────────────────────────────────────────────
+const SCAN_S = 0.6; // wireframe scan line: floor -> top
+const SOLID_DELAY_S = 0.3; // solidify line starts this long after the scan
+const SOLID_S = 0.6; // solidify line: floor -> top
+export const TOTAL_S = SOLID_DELAY_S + SOLID_S; // 0.9
+
+const clamp01 = (x) => Math.min(Math.max(x, 0), 1);
+// Ease-out only: the rise starts at full speed the instant the scan cues
+// (a smoothstep ease-in reads as a stall near the feet) and lands softly.
+const ease = (x) => 1 - (1 - x) * (1 - x);
+
+// Deterministic pseudo-random flicker so setProgress(p) captures are
+// reproducible (no Math.random).
+const hash = (x) => {
+ const s = Math.sin(x * 127.1) * 43758.5453;
+ return s - Math.floor(s);
+};
+const flickerAt = (time) => {
+ let f = 0.82 + 0.18 * hash(Math.floor(time * 60) + 0.5);
+ if (hash(Math.floor(time * 24) + 7.7) < 0.12) f *= 0.5; // dropouts
+ return f;
+};
+
+// Unique customProgramCacheKey values across every instance: a fresh
+// clone of the same source material would otherwise reuse the compiled
+// program without re-running onBeforeCompile, leaving clip uniforms
+// unbound (see the dissolve comment in rl.js).
+let clipNonce = 0;
+
+const BOTTOM_PAD = 0.025;
+
+export function createWireframeFx() {
+ // Per-instance uniforms: duck and ball must not share a scan height.
+ const uScanY = { value: -1e3 };
+ const uSolidY = { value: -1e3 };
+ const uFlicker = { value: 1 };
+ const uTime = { value: 0 };
+
+ let ctx = null; // { THREE, scene, root, camera, renderer }
+ let t = 0;
+ let dir = 1; // +1 materialize, -1 dematerialize
+ let playing = false;
+ let finished = false;
+
+ let minY = 0;
+ let spanY = 0.3;
+
+ const clipClones = new Map();
+ let clipSaved = null; // Array<[mesh, originalMat, cloneMat]> while active
+
+ let wireMat = null;
+ let wireMeshes = [];
+
+ const isTargetMesh = (o) => o.isMesh && !o.userData.fxOverlay;
+
+ function clipCloneFor(orig) {
+ let m = clipClones.get(orig.uuid);
+ if (m) return m;
+ m = orig.clone();
+ m.onBeforeCompile = (shader) => {
+ shader.uniforms.uFxSolidY = uSolidY;
+ shader.vertexShader = shader.vertexShader
+ .replace("#include ", "#include \nvarying vec3 vFxW;")
+ .replace(
+ "#include ",
+ "#include \nvFxW = (modelMatrix * vec4(transformed, 1.0)).xyz;",
+ );
+ shader.fragmentShader = shader.fragmentShader
+ .replace(
+ "#include ",
+ "#include \nvarying vec3 vFxW;\nuniform float uFxSolidY;",
+ )
+ .replace(
+ "#include ",
+ /* glsl */ `#include
+float fxEdge = 0.0;
+if (vFxW.y > uFxSolidY) discard;
+fxEdge = 1.0 - smoothstep(0.002, 0.018, uFxSolidY - vFxW.y);`,
+ )
+ .replace(
+ "#include ",
+ /* glsl */ `#include
+gl_FragColor.rgb += fxEdge * vec3(0.95, 0.32, 0.05);`,
+ );
+ };
+ const key = `microduck-fx-wireframe-${clipNonce++}`;
+ m.customProgramCacheKey = () => key;
+ m.needsUpdate = true;
+ clipClones.set(orig.uuid, m);
+ return m;
+ }
+
+ function applyClipMaterials() {
+ if (clipSaved) return;
+ clipSaved = [];
+ ctx.root.traverse((o) => {
+ if (!isTargetMesh(o)) return;
+ const orig = o.material;
+ const clone = clipCloneFor(orig);
+ clipSaved.push([o, orig, clone]);
+ o.material = clone;
+ });
+ }
+
+ function restoreClipMaterials() {
+ if (!clipSaved) return;
+ for (const [mesh, orig, clone] of clipSaved) {
+ if (mesh.material === clone) mesh.material = orig;
+ }
+ clipSaved = null;
+ }
+
+ function makeWireMaterial(THREE) {
+ return new THREE.ShaderMaterial({
+ uniforms: { uScanY, uSolidY, uFlicker, uTime },
+ vertexShader: /* glsl */ `
+ varying vec3 vW;
+ void main() {
+ vec4 wp = modelMatrix * vec4(position, 1.0);
+ vW = wp.xyz;
+ gl_Position = projectionMatrix * viewMatrix * wp;
+ }`,
+ fragmentShader: /* glsl */ `
+ uniform float uScanY, uSolidY, uFlicker, uTime;
+ varying vec3 vW;
+ void main() {
+ if (vW.y > uScanY || vW.y < uSolidY) discard;
+ float lead = 1.0 - smoothstep(0.0, 0.06, uScanY - vW.y);
+ float tail = smoothstep(0.0, 0.018, vW.y - uSolidY);
+ float stripes = 0.7 + 0.3 * sin(vW.y * 900.0 - uTime * 45.0);
+ vec3 c = vec3(1.0, 0.34, 0.06) * (0.55 + 1.6 * lead);
+ float a = (0.10 + 0.40 * lead) * stripes * tail * uFlicker;
+ gl_FragColor = vec4(c, a);
+ }`,
+ wireframe: true,
+ transparent: true,
+ blending: THREE.AdditiveBlending,
+ depthWrite: false,
+ depthTest: true,
+ });
+ }
+
+ function buildWireOverlays(THREE, root) {
+ wireMat = makeWireMaterial(THREE);
+ root.traverse((o) => {
+ if (!isTargetMesh(o)) return;
+ // Child of the source mesh with identity transform so the overlay
+ // follows whatever pose the caller writes (duck joints or ball qpos).
+ // userData.fxWireGeometry substitutes a coarser geometry for the
+ // wireframe pass only (the ball's render sphere is too dense to read
+ // as a hologram); the solidify clip still runs on the real mesh.
+ const w = new THREE.Mesh(o.userData.fxWireGeometry ?? o.geometry, wireMat);
+ w.userData.fxOverlay = true;
+ w.renderOrder = 5;
+ w.visible = false;
+ o.add(w);
+ wireMeshes.push(w);
+ });
+ }
+
+ function applyAt(time) {
+ const scanP = ease(clamp01(time / SCAN_S));
+ const solidP = ease(clamp01((time - SOLID_DELAY_S) / SOLID_S));
+ uFlicker.value = flickerAt(time);
+ uTime.value = time;
+
+ const jitter = scanP > 0 && scanP < 1 ? (hash(time * 41.3) - 0.5) * 0.02 * spanY : 0;
+ uScanY.value = minY + spanY * scanP + jitter;
+ uSolidY.value = minY + spanY * solidP;
+
+ const wiresOn = time > 0 && solidP < 1;
+ for (const w of wireMeshes) w.visible = wiresOn;
+ }
+
+ function finish() {
+ // Forward: restore the real materials (fully solid). Reverse: leave
+ // the clip parked at t=0 (fully hidden) so restoring wouldn't flash
+ // the solid mesh for a frame; the caller hides the object then
+ // restore()s.
+ if (dir > 0) restoreClipMaterials();
+ else applyAt(0);
+ for (const w of wireMeshes) w.visible = false;
+ finished = true;
+ playing = false;
+ }
+
+ function computeRange() {
+ const { THREE, root } = ctx;
+ root.updateWorldMatrix(true, true);
+ const box = new THREE.Box3().setFromObject(root);
+ minY = Math.min(box.min.y, 0) - BOTTOM_PAD;
+ spanY = Math.max(box.max.y - minY, 0.04) * 1.06;
+ }
+
+ function arm(nextDir, resetT) {
+ dir = nextDir;
+ if (resetT) t = nextDir > 0 ? 0 : TOTAL_S;
+ finished = false;
+ computeRange();
+ applyClipMaterials();
+ applyAt(t);
+ playing = true;
+ }
+
+ function init({ THREE, scene, rig, root, camera, renderer, hidden = true }) {
+ const target = root ?? rig.placer;
+ ctx = { THREE, scene, root: target, camera, renderer };
+ computeRange();
+ buildWireOverlays(THREE, target);
+ t = 0;
+ dir = 1;
+ finished = false;
+ playing = false;
+ if (hidden) {
+ applyClipMaterials();
+ applyAt(0);
+ }
+ }
+
+ function start() {
+ // Mid-reverse: keep the current t and turn around. Fresh play: from 0.
+ arm(1, !playing);
+ }
+
+ function startReverse() {
+ arm(-1, !playing);
+ }
+
+ function update(dt) {
+ if (!playing || finished) return;
+ t += dir * dt;
+ if (dir > 0 && t >= TOTAL_S) {
+ t = TOTAL_S;
+ applyAt(t);
+ finish();
+ return;
+ }
+ if (dir < 0 && t <= 0) {
+ t = 0;
+ applyAt(t);
+ finish();
+ return;
+ }
+ applyAt(t);
+ }
+
+ function isDone() {
+ return finished;
+ }
+
+ function setProgress(p) {
+ playing = false;
+ finished = false;
+ dir = 1;
+ computeRange();
+ applyClipMaterials();
+ t = clamp01(p) * TOTAL_S;
+ applyAt(t);
+ }
+
+ function restore() {
+ restoreClipMaterials();
+ }
+
+ function dispose() {
+ restoreClipMaterials();
+ for (const w of wireMeshes) w.parent?.remove(w);
+ wireMeshes = [];
+ wireMat?.dispose();
+ wireMat = null;
+ ctx = null;
+ playing = false;
+ finished = false;
+ }
+
+ return {
+ init, start, startReverse, update, isDone, setProgress, restore, dispose,
+ get playing() { return playing; },
+ get reversing() { return playing && dir < 0; },
+ TOTAL_S,
+ };
+}
+
+// Singleton for the duck (and the isolated demo page). New callers that
+// need a second scan (the ball) go through createWireframeFx().
+const singleton = createWireframeFx();
+export const init = (...a) => singleton.init(...a);
+export const start = (...a) => singleton.start(...a);
+export const startReverse = (...a) => singleton.startReverse(...a);
+export const update = (...a) => singleton.update(...a);
+export const isDone = (...a) => singleton.isDone(...a);
+export const setProgress = (...a) => singleton.setProgress(...a);
+export const restore = (...a) => singleton.restore(...a);
+export const dispose = (...a) => singleton.dispose(...a);
diff --git a/app/src/game/game.js b/app/src/game/game.js
new file mode 100644
index 0000000..ad0cc8f
--- /dev/null
+++ b/app/src/game/game.js
@@ -0,0 +1,1305 @@
+// Microduck RL playground core: the REAL trained policies, not a procedural
+// waddle. Framework-agnostic port of the pre-React rl.js.
+//
+// Physics runs in MuJoCo compiled to WebAssembly (the official
+// @mujoco/mujoco bindings), stepping the same MJCF the policies were
+// trained on (apirrone/mjlab_microduck). The controller is one of the
+// exported ONNX checkpoints from apirrone/microduck_runtime, executed with
+// onnxruntime-web at 50 Hz (timestep 0.005 s, decimation 4) - exactly the
+// loop from mjlab_microduck/scripts/infer_policy.py.
+//
+// Obs layout (61D, "new-cmd-obs" flavor, from the ONNX metadata):
+// [base_ang_vel(3), projected_gravity(3), joint_pos(14), joint_vel(14),
+// last_action(14), command(13)]
+//
+// Integration contract with the React shell:
+// - bootGame({ scene, camera, renderer }) is called once from inside the
+// R3F canvas; it loads everything, wires inputs and starts the 50 Hz
+// control loop.
+// - frame(dt) is called by R3F's useFrame every animation frame; it does
+// everything the old rAF loop did EXCEPT renderer.render (R3F renders).
+// - UI state flows out through the zustand store (throttled), UI intents
+// flow back in through gameApi.
+
+import * as THREE from "three";
+import { OrbitControls } from "three/addons/controls/OrbitControls.js";
+import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
+import { signed } from "./signed.js";
+import {
+ POLICIES, JOINT_NAMES, DEFAULT_POSE, NUM_JOINTS, OBS_SIZE, CMD_SIZE,
+ ACTION_SCALE, TIMESTEP, DECIMATION, CTRL_DT,
+ VEL_FWD, VEL_BACK, VEL_ANG, RVEL_FWD, RVEL_BACK, RVEL_ANG,
+ CROUCH_PERIOD_S, CROUCH_END_PHASE,
+ BALL_RADIUS, BALL_PARK_POS, ARENA_HALF, SPAWN_X, SPAWN_Y,
+} from "./constants.js";
+import {
+ buildRig, cloneRig, loadKinematics, setJoint, setJawOpen, MODEL_DIR, MESH_VERSION,
+} from "./duck.js";
+import {
+ VARIANTS, VARIANT_NAMES, materialHookFor, DEFAULT_VARIANT, applyVariant, specToHex,
+} from "./variants.js";
+import { Controller } from "./controls/controller.js";
+import { KeyboardSource } from "./controls/keyboard.js";
+import { GamepadSource } from "./controls/gamepad.js";
+import { TouchSource } from "./controls/touch.js";
+import * as fx from "./fx/fx-wireframe.js";
+import { createCeremony, CAM_RESET_S } from "./ceremony.js";
+import { createBallActor } from "./ball-actor.js";
+import { initGhosts } from "./ghosts.js";
+import { makeInfiniteGrid, makeArenaWalls } from "./arena.js";
+import { createBallVisual } from "./ball-visual.js";
+import { useGame, gameApi, bootLine, bootNote, bootHalt } from "../store.js";
+
+// Physics + inference runtimes stay on the CDN, exactly like the pre-Vite
+// app: mujoco.js resolves its .wasm sidecar relative to its own URL, and
+// onnxruntime fetches its wasm from wasmPaths - neither ever touches the
+// bundle. @vite-ignore keeps Rollup's static analysis out of it.
+const MUJOCO_URL = "https://cdn.jsdelivr.net/npm/@mujoco/mujoco@3.11.0/mujoco.js";
+const ORT_URL = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.27.0/dist/ort.min.mjs";
+
+// Colour dot shown per variant in the quickbar. Variants can force theirs
+// with a `swatch` spec (purple does: its head is warm gray but its
+// identity is the purple accents).
+const SWATCH_SLOT = { classic: "feet", charcoal: "headDome", purple: "feet", blue: "facePlate" };
+export const VARIANT_SWATCHES = Object.fromEntries(
+ VARIANT_NAMES.map((name) => {
+ const v = VARIANTS[name];
+ return [name, specToHex(v.swatch ?? v[SWATCH_SLOT[name] ?? "bodyShell"])];
+ }),
+);
+
+let bootStarted = false;
+
+export async function bootGame({ scene, camera, renderer }) {
+ if (bootStarted) return;
+ bootStarted = true;
+ try {
+ await boot({ scene, camera, renderer });
+ } catch (err) {
+ console.error("[game] boot failed", err);
+ bootHalt(err?.message || String(err));
+ }
+}
+
+async function boot({ scene, camera, renderer }) {
+ const setStore = useGame.setState;
+ const store = useGame.getState;
+
+ bootNote("Microduck BIOS v1.0");
+ bootLine("MEMORY CHECK")("640K OK");
+ bootLine("DUCK FIRMWARE")("PRESENT");
+
+ // Surface async boot failures in the BIOS halt screen. Gated on the boot
+ // still being in flight: post-boot async noise (ghost relay hiccups,
+ // audio autoplay rejections...) must NOT cue the halt screen.
+ const bootGuard = (e, msg) => {
+ if (!store().bootDone && !store().bootFailed) bootHalt(msg);
+ };
+ window.addEventListener("unhandledrejection", (e) => {
+ console.error("[game] unhandled rejection", e.reason);
+ bootGuard(e, e.reason?.message || String(e.reason));
+ });
+ window.addEventListener("error", (e) => {
+ console.error("[game] window error", e.message);
+ bootGuard(e, e.message);
+ });
+
+ // Halting at the failure site: a rejected await inside this async boot
+ // would otherwise only surface through the caller's catch.
+ const traced = (label, p) => {
+ const done = bootLine(label);
+ return p.then(
+ (v) => { done("OK"); return v; },
+ (err) => {
+ done("FAILED");
+ console.error(`[game] ${label} FAILED`, err);
+ bootHalt(err?.message || String(err));
+ throw err;
+ },
+ );
+ };
+
+ // ── Runtimes (CDN) ──────────────────────────────────────────────────
+ const [{ default: loadMujocoFactory }, ort] = await traced(
+ "RUNTIME MODULES",
+ Promise.all([
+ import(/* @vite-ignore */ MUJOCO_URL),
+ import(/* @vite-ignore */ ORT_URL),
+ ]),
+ );
+ ort.env.wasm.wasmPaths = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.27.0/dist/";
+ ort.env.wasm.numThreads = 1; // static hosting sends no COOP/COEP headers
+
+ // ── MJCF preparation ────────────────────────────────────────────────
+ // robot_allcollisions.xml is what infer_policy.py's scene.xml includes:
+ // it carries body/shell collision geoms that robot_walk.xml lacks, which
+ // the sitstand policy needs (a sit rests the trunk on the ground).
+ // Visual meshes are irrelevant to the dynamics: every body carries an
+ // explicit , and visual geoms have contype=0 conaffinity=0.
+ // Stripping them means the MuJoCo VFS only needs the ~10 meshes
+ // referenced by collision geoms. Works for both variants.
+ async function buildPhysicsXml(xmlFile) {
+ const src = await (await fetch(signed(`${MODEL_DIR}/${xmlFile}`))).text();
+ const doc = new DOMParser().parseFromString(src, "text/xml");
+ for (const g of [...doc.querySelectorAll('geom[class="visual"]')]) g.remove();
+ const usedMeshes = new Set(
+ [...doc.querySelectorAll("geom[mesh]")].map((g) => g.getAttribute("mesh")),
+ );
+ for (const m of [...doc.querySelectorAll("asset > mesh")]) {
+ const name = m.getAttribute("name") ?? m.getAttribute("file").replace(/\.stl$/i, "");
+ if (!usedMeshes.has(name)) m.remove();
+ }
+ const root = doc.documentElement;
+ const el = (tag, attrs) => {
+ const e = doc.createElement(tag);
+ for (const [k, v] of Object.entries(attrs)) e.setAttribute(k, v);
+ return e;
+ };
+ root.appendChild(el("option", { timestep: String(TIMESTEP) }));
+ doc.querySelector("worldbody").appendChild(
+ el("geom", { name: "floor", type: "plane", size: "0 0 0.05", pos: "0 0 0" }),
+ );
+ // Arena walls: four static boxes (no joints, so no qpos/keyframe
+ // impact); default contype/conaffinity collides with ball and duck.
+ const ht = 0.05 / 2, hh = 0.25 / 2;
+ const off = ARENA_HALF + ht, span = ARENA_HALF + 0.05;
+ const walls = [
+ { name: "wall_px", pos: `${off} 0 ${hh}`, size: `${ht} ${span} ${hh}` },
+ { name: "wall_nx", pos: `${-off} 0 ${hh}`, size: `${ht} ${span} ${hh}` },
+ { name: "wall_py", pos: `0 ${off} ${hh}`, size: `${span} ${ht} ${hh}` },
+ { name: "wall_ny", pos: `0 ${-off} ${hh}`, size: `${span} ${ht} ${hh}` },
+ ];
+ for (const w of walls) {
+ doc.querySelector("worldbody").appendChild(
+ el("geom", { name: w.name, type: "box", pos: w.pos, size: w.size }),
+ );
+ }
+ // Kickable ball: a light free sphere (beach-ball feel). MuJoCo has no
+ // restitution parameter - the bounce comes from solref damping < 1, and
+ // the rolling-friction term makes it come to rest. Appended AFTER the
+ // robot body so the trunk freejoint stays first in qpos.
+ const ballBody = el("body", { name: "ball", pos: BALL_PARK_POS });
+ ballBody.appendChild(el("freejoint", { name: "ball_freejoint" }));
+ // condim 6 enables the torsional + rolling friction components; with
+ // the default condim 3 a rolling ball never decelerates.
+ ballBody.appendChild(el("geom", {
+ name: "ball_geom", type: "sphere", size: String(BALL_RADIUS),
+ mass: "0.03", friction: "0.4 0.01 0.003", solref: "0.03 0.4", condim: "6",
+ }));
+ doc.querySelector("worldbody").appendChild(ballBody);
+ // STAND keyframe from mjlab's scene_walk.xml. qpos must cover every
+ // joint in document order: the 14 actuated hinges take DEFAULT_POSE by
+ // name, anything else (the roller variant's passive wheels) starts at
+ // zero. The ball's 7 free-joint values MUST be appended or nq won't
+ // match; parked 50 m away = effectively absent.
+ const qposFree = `${SPAWN_X} ${SPAWN_Y} 0.12 1 0 0 0`;
+ const poseByName = new Map(JOINT_NAMES.map((n, i) => [n, DEFAULT_POSE[i]]));
+ const qposJoints = [...doc.querySelectorAll("body > joint")]
+ .map((j) => poseByName.get(j.getAttribute("name")) ?? 0)
+ .join(" ");
+ const pose14 = Array.from(DEFAULT_POSE).join(" ");
+ const kf = doc.createElement("keyframe");
+ kf.appendChild(el("key", {
+ name: "STAND",
+ qpos: `${qposFree} ${qposJoints} ${BALL_PARK_POS} 1 0 0 0`,
+ ctrl: pose14,
+ }));
+ root.appendChild(kf);
+ const meshFiles = [...doc.querySelectorAll("asset > mesh")].map((m) => m.getAttribute("file"));
+ return { xml: new XMLSerializer().serializeToString(doc), meshFiles };
+ }
+
+ // ── Boot physics + policy in parallel with the render rig ────────────
+ const [mujoco, { xml, meshFiles }, k] = await Promise.all([
+ traced("MUJOCO WASM", loadMujocoFactory()),
+ traced("PHYSICS MJCF", buildPhysicsXml("robot_allcollisions.xml")),
+ traced("KINEMATICS", loadKinematics(`${MODEL_DIR}/kinematics.json`)),
+ ]);
+
+ const doneMeshes = bootLine("MESH ASSETS");
+ const vfs = new mujoco.MjVFS();
+ // One shared VFS for both variants; already-loaded files are skipped so
+ // the roller lazy-load only fetches its 5 new meshes.
+ const vfsFiles = new Set();
+ async function addMeshesToVfs(files) {
+ await Promise.all(
+ files.map(async (f) => {
+ if (vfsFiles.has(f)) return;
+ vfsFiles.add(f);
+ // Same cache-busted URL as duck.js so the browser reuses the render
+ // meshes instead of downloading the collision subset a second time.
+ const buf = await (await fetch(signed(`${MODEL_DIR}/meshes/${f}?v=${MESH_VERSION}`), { cache: "force-cache" })).arrayBuffer();
+ // meshdir="assets" in the MJCF, so the compiler looks up "assets/".
+ vfs.addBuffer(`assets/${f}`, new Uint8Array(buf));
+ }),
+ );
+ }
+ try {
+ await addMeshesToVfs(meshFiles);
+ } catch (err) {
+ doneMeshes("FAILED");
+ bootHalt(err?.message || String(err));
+ throw err;
+ }
+ doneMeshes(`${meshFiles.length} FILES`);
+
+ const sessions = {};
+ // Always boot on the classic (orange) colourway; the quickbar re-skins live.
+ let currentVariant = DEFAULT_VARIANT;
+ const rigPromise = (async () => {
+ const doneRig = bootLine("RENDER RIG");
+ try {
+ const builtRig = await buildRig(k, { materialForMesh: materialHookFor(VARIANTS[currentVariant]) });
+ doneRig("OK");
+ return builtRig;
+ } catch (err) {
+ doneRig("FAILED");
+ bootHalt(err?.message || String(err));
+ throw err;
+ }
+ })();
+ // Boot policies with a live [n/5] counter on the BIOS line.
+ const donePolicies = bootLine("LOADING POLICIES");
+ const sessionOpts = { executionProviders: ["wasm"] };
+ let policiesLoaded = 0;
+ const bootPolicy = (url) =>
+ ort.InferenceSession.create(signed(url), sessionOpts).then((s) => {
+ donePolicies.progress(`${++policiesLoaded}/5`);
+ return s;
+ });
+ try {
+ [sessions.walk, sessions.sitstand, sessions.roll, sessions.kickL, sessions.kickR] =
+ await Promise.all([
+ bootPolicy(POLICIES.walk),
+ bootPolicy(POLICIES.sitstand),
+ bootPolicy(POLICIES.roll),
+ bootPolicy(POLICIES.kickL),
+ bootPolicy(POLICIES.kickR),
+ ]);
+ } catch (err) {
+ donePolicies("FAILED");
+ bootHalt(err?.message || String(err));
+ throw err;
+ }
+ donePolicies("5/5");
+
+ const doneCompile = bootLine("COMPILING PHYSICS");
+ let model, data;
+ try {
+ model = mujoco.MjModel.from_xml_string(xml, vfs);
+ data = new mujoco.MjData(model);
+ } catch (err) {
+ doneCompile("FAILED");
+ bootHalt(err?.message || String(err));
+ throw err;
+ }
+ doneCompile("COMPILED");
+
+ // Addresses resolved once per compiled variant. qpos/qvel/sensordata
+ // views are re-read at each use: the WASM heap can grow and detach
+ // earlier TypedArray views.
+ const JOINT_SET = new Set(JOINT_NAMES);
+ function resolveAddrs(model, kin) {
+ return {
+ qposAdr: JOINT_NAMES.map((n) => model.jnt(n).qposadr),
+ dofAdr: JOINT_NAMES.map((n) => model.jnt(n).dofadr),
+ gyroAdr: model.sensor("imu_ang_vel").adr,
+ trunkId: mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_BODY.value, "trunk_base"),
+ standKeyId: mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_KEY.value, "STAND"),
+ ballQposAdr: model.jnt("ball_freejoint").qposadr,
+ ballDofAdr: model.jnt("ball_freejoint").dofadr,
+ // Unactuated hinges (the roller variant's 4 passive wheels): not in
+ // the obs or ctrl, but synced to the render rig so the wheels spin.
+ extraJoints: kin.bodies
+ .filter((b) => b.joint && b.joint.type === "hinge" && !JOINT_SET.has(b.joint.name))
+ .map((b) => ({ name: b.joint.name, adr: model.jnt(b.joint.name).qposadr })),
+ };
+ }
+ // Active-variant address block, swapped wholesale by activateLoco.
+ let { qposAdr, dofAdr, gyroAdr, trunkId, standKeyId, ballQposAdr, ballDofAdr, extraJoints } =
+ resolveAddrs(model, k);
+
+ // Locomotion variants stay resident once built (model + data + rig +
+ // addresses); legs is registered when its render rig resolves below.
+ const locos = {};
+ let loco = "legs"; // "legs" | "rollers"
+ const velLims = () => (loco === "rollers"
+ ? [RVEL_FWD, RVEL_BACK, RVEL_ANG]
+ : [VEL_FWD, VEL_BACK, VEL_ANG]);
+
+ const lastAction = new Float32Array(NUM_JOINTS);
+ const obs = new Float32Array(OBS_SIZE);
+ const cmd = new Float32Array(CMD_SIZE); // [vx, vy, wz, head(4), body(6)]
+ // Input controller: keyboard + gamepad + touch sources merged into one
+ // continuous command + discrete action surface, in priority order.
+ const kbSource = new KeyboardSource({ getVelocityLimits: () => velLims() });
+ const padSource = new GamepadSource({ getVelocityLimits: () => velLims() });
+ const touchSource = new TouchSource({ getVelocityLimits: () => velLims() });
+ // Keyboard last: it reads zero when idle, so it doubles as the fallback.
+ const controller = new Controller({ sources: [padSource, touchSource, kbSource] });
+ // Right-stick camera state, read by the telemetry before the camera-orbit
+ // section below has evaluated.
+ let padOrbitLive = false;
+ // Robot input gate: twist commands, mode changes, rolls, kicks and ball
+ // spawns all stay inert until the entrance sequence has fully played out.
+ let inputLocked = true;
+ let ceremony = null;
+ let ball = null;
+ let stickers = null; // comic popups, currently disabled
+
+ let mode = "walk"; // "walk" | "sitstand" | "roll" | "kickL" | "kickR" | "crouch"
+ let sitFlag = 0;
+ const isKick = () => mode === "kickL" || mode === "kickR";
+ // Local-only kickable ball: false while parked at the keyframe spot
+ // (mesh hidden), true once popped in front of the duck.
+ let ballActive = false;
+
+ // The twist the policy actually receives. Mid-roll every movement input
+ // is ignored (zero twist) until the roll hands back to walk on its own.
+ const ZERO_CMD = new Float32Array(3);
+ function effectiveCmd() {
+ if (inputLocked || mode === "roll" || mode === "crouch" || isKick() || postKickLock > 0)
+ return ZERO_CMD;
+ return controller.getCommand();
+ }
+ let rollRun = null;
+ let crouchRun = null;
+ let kickRun = null;
+ let KICK_STEPS = 25;
+ // Post-kick grace: keep commands zeroed for a beat after the kick window
+ // hands back to walk. Step-counted like everything else.
+ const POST_KICK_LOCK_STEPS = 20; // 0.4 s at 50 Hz
+ let postKickLock = 0;
+
+ // Pending mode-transition timers (sit hand-over, stand-up hand-back).
+ let sitTimer = null;
+ let standTimer = null;
+ let fallenSince = null;
+ function clearModeTimers() {
+ clearTimeout(sitTimer); sitTimer = null;
+ clearTimeout(standTimer); standTimer = null;
+ }
+
+ function resetSim() {
+ // Single reset path: Space, fall-kill, failed roll, loco switch.
+ clearModeTimers();
+ rollRun = null;
+ kickRun = null;
+ crouchRun = null;
+ postKickLock = 0;
+ fallenSince = null;
+ mode = "walk";
+ mujoco.mj_resetDataKeyframe(model, data, standKeyId);
+ mujoco.mj_forward(model, data);
+ lastAction.fill(0);
+ sitFlag = 0;
+ // Park the ball in physics immediately; if it was on screen, the
+ // reverse scan peels it away at its last pose. A queued B-respawn is
+ // cancelled: a reset means no ball.
+ ball?.despawn({ cancelQueued: true, parkPhysics: parkBallPhysics });
+ ballActive = false;
+ syncButtons();
+ ceremony?.playRespawn();
+ }
+ resetSim();
+
+ function parkBallPhysics() {
+ const qpos = data.qpos, qvel = data.qvel;
+ qpos[ballQposAdr] = 50;
+ qpos[ballQposAdr + 1] = 0;
+ qpos[ballQposAdr + 2] = BALL_RADIUS;
+ qpos[ballQposAdr + 3] = 1;
+ qpos[ballQposAdr + 4] = 0;
+ qpos[ballQposAdr + 5] = 0;
+ qpos[ballQposAdr + 6] = 0;
+ for (let i = 0; i < 6; i++) qvel[ballDofAdr + i] = 0;
+ mujoco.mj_forward(model, data);
+ ballActive = false;
+ }
+
+ // Pop / respawn the ball ~0.35 m in front of the duck, with a small
+ // random heading + distance jitter. If the ball is already on screen,
+ // peel it away first (reverse scan) and pop the new one when that
+ // finishes - same appear/disappear pair as the duck's wireframe ceremony.
+ function spawnBall(opts = {}) {
+ if (inputLocked && !opts.fromQueue) return;
+ if (!ball) return;
+ if (ball.visual !== "hidden") {
+ ball.queueRespawn();
+ ball.despawn({ parkPhysics: parkBallPhysics });
+ return;
+ }
+ const qpos = data.qpos, qvel = data.qvel;
+ const yaw = Math.atan2(
+ 2 * (qpos[3] * qpos[6] + qpos[4] * qpos[5]),
+ 1 - 2 * (qpos[5] * qpos[5] + qpos[6] * qpos[6]),
+ );
+ const heading = yaw + (Math.random() - 0.5) * 0.7;
+ const dist = 0.35 + (Math.random() - 0.5) * 0.1;
+ const lim = ARENA_HALF - BALL_RADIUS - 0.05;
+ const clamp = (v) => Math.min(lim, Math.max(-lim, v));
+ qpos[ballQposAdr] = clamp(qpos[0] + Math.cos(heading) * dist);
+ qpos[ballQposAdr + 1] = clamp(qpos[1] + Math.sin(heading) * dist);
+ qpos[ballQposAdr + 2] = BALL_RADIUS + 0.02;
+ qpos[ballQposAdr + 3] = 1;
+ qpos[ballQposAdr + 4] = 0;
+ qpos[ballQposAdr + 5] = 0;
+ qpos[ballQposAdr + 6] = 0;
+ for (let i = 0; i < 6; i++) qvel[ballDofAdr + i] = 0;
+ mujoco.mj_forward(model, data);
+ ballActive = true;
+ // Snap the mesh to the new pose BEFORE the scan starts: the FX
+ // recomputes its bbox from the live mesh.
+ ball.poseFromQpos(qpos, ballQposAdr);
+ ball.appear();
+ stickers?.pop("spawn");
+ }
+
+ // ── Observation ─────────────────────────────────────────────────────
+ const _q = new THREE.Quaternion();
+ const _g = new THREE.Vector3();
+
+ function buildObs() {
+ const qpos = data.qpos, qvel = data.qvel, sens = data.sensordata;
+ let i = 0;
+ for (let a = 0; a < 3; a++) obs[i++] = sens[gyroAdr + a];
+ // projected gravity: world -z rotated into the trunk frame
+ const xq = data.body(trunkId).xquat; // [w, x, y, z]
+ _q.set(xq[1], xq[2], xq[3], xq[0]).conjugate();
+ _g.set(0, 0, -1).applyQuaternion(_q);
+ obs[i++] = _g.x; obs[i++] = _g.y; obs[i++] = _g.z;
+ for (let j = 0; j < NUM_JOINTS; j++) obs[i++] = qpos[qposAdr[j]] - DEFAULT_POSE[j];
+ for (let j = 0; j < NUM_JOINTS; j++) obs[i++] = qvel[dofAdr[j]];
+ for (let j = 0; j < NUM_JOINTS; j++) obs[i++] = lastAction[j];
+ // command: walking/drive use the twist; sitstand uses cmd[0] as the
+ // posture flag; the crouch-glide one-shot carries its phase encoding in
+ // the vel slots (ground-pick convention: [cos, sin, 0]).
+ cmd.fill(0, 0, 3);
+ if (mode === "sitstand") {
+ cmd[0] = sitFlag;
+ } else if (mode === "crouch" && crouchRun) {
+ const a = 2 * Math.PI * crouchRun.phase;
+ cmd[0] = Math.cos(a);
+ cmd[1] = Math.sin(a);
+ } else {
+ const c = effectiveCmd();
+ cmd[0] = c[0]; cmd[1] = c[1]; cmd[2] = c[2];
+ }
+ for (let c = 0; c < CMD_SIZE; c++) obs[i++] = cmd[c];
+ return obs;
+ }
+
+ // The ONNX session for the current mode: in the roller variant the main
+ // velocity mode runs the drive (skating) policy instead of the walker.
+ const activeSession = () =>
+ sessions[loco === "rollers" && mode === "walk" ? "drive" : mode];
+
+ // ── Control loop (50 Hz, async because ONNX inference is async) ──────
+ let ctrlHz = 0;
+
+ // Dead pose: walk/sitstand have no get-up skill, so a kill here is just
+ // a resetSim. "fallen" = trunk tilted past ~60 deg or sunk below the
+ // floor. NaN/Inf is a solver explosion: no grace, reset on the spot.
+ function poseIsDead() {
+ const z = data.qpos[2];
+ const gz = obs[5]; // projected gravity z, from the last obs
+ if (!Number.isFinite(z) || !Number.isFinite(gz)) return "exploded";
+ if (gz > -0.5 || z < 0.02) return "fallen";
+ return null;
+ }
+
+ async function controlStep() {
+ const feeds = { obs: new ort.Tensor("float32", buildObs(), [1, OBS_SIZE]) };
+ const out = await activeSession().run(feeds);
+ const act = out.actions.data;
+ lastAction.set(act);
+ const ctrl = data.ctrl;
+ for (let j = 0; j < NUM_JOINTS; j++) ctrl[j] = DEFAULT_POSE[j] + act[j] * ACTION_SCALE;
+ for (let s = 0; s < DECIMATION; s++) mujoco.mj_step(model, data);
+
+ const death = poseIsDead();
+ if (death === "exploded") {
+ resetSim();
+ } else if (death === "fallen") {
+ const now = performance.now();
+ const graceMs = mode === "roll" ? 5000 : 1000;
+ fallenSince ??= now;
+ if (now - fallenSince > graceMs) resetSim();
+ } else {
+ fallenSince = null;
+ }
+
+ // Ball respawn watchdog: outside the arena bounds means "escaped
+ // through a solver glitch", bring it back near the duck.
+ if (ballActive) {
+ const q = data.qpos;
+ const escaped =
+ Math.abs(q[ballQposAdr]) > ARENA_HALF + 0.1 ||
+ Math.abs(q[ballQposAdr + 1]) > ARENA_HALF + 0.1;
+ if (escaped) spawnBall();
+ }
+
+ if (postKickLock > 0 && mode === "walk") postKickLock--;
+
+ // One-shot kick: fixed 0.5 s window like the robot runtime, then
+ // straight back to walking. lastAction is NOT zeroed on either swap.
+ if (isKick() && kickRun) {
+ kickRun.steps++;
+ if (kickRun.steps >= KICK_STEPS) {
+ kickRun = null;
+ mode = "walk";
+ postKickLock = POST_KICK_LOCK_STEPS;
+ syncButtons();
+ }
+ }
+
+ // Crouch-glide one-shot: advance the trained phase clock and hand back
+ // to the drive policy at the runtime's cycle end.
+ if (mode === "crouch" && crouchRun) {
+ crouchRun.phase += CTRL_DT / CROUCH_PERIOD_S;
+ if (crouchRun.phase >= CROUCH_END_PHASE) {
+ crouchRun = null;
+ mode = "walk";
+ syncButtons();
+ }
+ }
+
+ // One-shot roll, step-counted like the robot runtime: hand back to
+ // walking once the trunk has tipped over and is upright again, or
+ // after a hard window if the roll never initiated.
+ if (mode === "roll" && rollRun) {
+ rollRun.steps++;
+ if (obs[5] > -0.3) rollRun.tipped = true;
+ const upright = obs[5] < -0.85;
+ const done = rollRun.tipped && upright && rollRun.steps >= 40;
+ const expired = rollRun.steps >= 150; // 3 s, roll should long be over
+ if (done || expired) {
+ rollRun = null;
+ mode = "walk";
+ lastAction.fill(0);
+ // Timed out mid-roll: don't hand a tipped duck to the walking
+ // policy (it has no get-up skill).
+ if (!upright) resetSim();
+ syncButtons();
+ }
+ }
+ }
+
+ let running = true;
+ (async function controlLoop() {
+ let next = performance.now();
+ let count = 0, hzT0 = next;
+ while (running) {
+ await controlStep();
+ count++;
+ const now = performance.now();
+ if (now - hzT0 > 500) {
+ ctrlHz = (count * 1000) / (now - hzT0);
+ count = 0; hzT0 = now;
+ }
+ next += CTRL_DT * 1000;
+ const wait = next - performance.now();
+ if (wait > 0) await new Promise((r) => setTimeout(r, wait));
+ else next = performance.now(); // fell behind: don't spiral
+ }
+ })();
+
+ // ── Scene wiring (grid, walls, rig, ball, jukebox) ───────────────────
+ // The grid/walls carry ceremony-driven uReveal uniforms and per-frame
+ // focus updates, so the game owns them; lights and environment live in
+ // the R3F layer.
+ const grid = makeInfiniteGrid();
+ scene.add(grid);
+ const { wallMats, wallMeshes } = makeArenaWalls();
+ for (const m of wallMeshes) scene.add(m);
+
+ let rig = await rigPromise;
+ scene.add(rig.placer);
+ let trunkGroup = rig.bodies.get("trunk_base");
+ locos.legs = {
+ model, data, rig, trunkGroup,
+ qposAdr, dofAdr, gyroAdr, trunkId, standKeyId, ballQposAdr, ballDofAdr, extraJoints,
+ };
+
+ // ── Locomotion variant switching (legs <-> rollers) ──────────────────
+ // The roller stack (XML + 5 extra meshes + kinematics + 2 ONNX policies)
+ // is lazy-loaded on the first switch, then kept resident.
+ let rollersLoading = null;
+ function ensureRollers() {
+ rollersLoading ??= (async () => {
+ const [{ xml: rXml, meshFiles: rMeshFiles }, rk] = await Promise.all([
+ buildPhysicsXml("robot_allcollisions_rollers.xml"),
+ loadKinematics(`${MODEL_DIR}/kinematics_rollers.json`),
+ ]);
+ const [rRig, sDrive, sCrouch] = await Promise.all([
+ buildRig(rk, { materialForMesh: materialHookFor(VARIANTS[currentVariant]) }),
+ ort.InferenceSession.create(signed(POLICIES.drive), sessionOpts),
+ ort.InferenceSession.create(signed(POLICIES.crouch), sessionOpts),
+ addMeshesToVfs(rMeshFiles),
+ ]);
+ sessions.drive = sDrive;
+ sessions.crouch = sCrouch;
+ const rModel = mujoco.MjModel.from_xml_string(rXml, vfs);
+ const rData = new mujoco.MjData(rModel);
+ locos.rollers = {
+ model: rModel, data: rData, rig: rRig, trunkGroup: rRig.bodies.get("trunk_base"),
+ ...resolveAddrs(rModel, rk),
+ };
+ })();
+ return rollersLoading;
+ }
+
+ function activateLoco(name) {
+ const L = locos[name];
+ loco = name;
+ scene.remove(rig.placer);
+ ({ model, data, rig, trunkGroup, qposAdr, dofAdr, gyroAdr, trunkId,
+ standKeyId, ballQposAdr, ballDofAdr, extraJoints } = L);
+ // The rig may have been built (or last shown) under another colourway.
+ applyVariant(rig, currentVariant);
+ scene.add(rig.placer);
+ setStore({ loco: name });
+ resetSim();
+ }
+
+ let locoSwitching = false;
+ async function setLoco(name, { force = false } = {}) {
+ if (name !== "legs" && name !== "rollers") return;
+ if (loco === name || locoSwitching) return;
+ if (!force && (inputLocked || rollRun || kickRun || crouchRun || standTimer)) return;
+ locoSwitching = true;
+ setStore({ locoSwitching: true });
+ try {
+ if (name === "rollers" && !locos.rollers) {
+ setStore({ rollersLoading: true });
+ await ensureRollers();
+ }
+ activateLoco(name);
+ } catch (e) {
+ rollersLoading = null;
+ console.error("[game] roller switch failed", e);
+ } finally {
+ setStore({ rollersLoading: false, locoSwitching: false });
+ locoSwitching = false;
+ }
+ }
+
+ async function toggleLoco() {
+ const next = loco === "legs" ? "rollers" : "legs";
+ setStore({ locoWant: next });
+ await setLoco(next);
+ }
+
+ // Quickbar loco intent: reconcile locoWant -> actual, retrying until the
+ // game allows the switch (mid-roll, respawn ceremony, ...). Replaces the
+ // old index.html reconciler that polled window.rl.
+ let locoReconciler = null;
+ function reconcileLoco() {
+ const want = store().locoWant;
+ if (want === loco) {
+ if (locoReconciler) { clearInterval(locoReconciler); locoReconciler = null; }
+ return;
+ }
+ if (want === "rollers") ensureRollers().catch(() => {});
+ if (!locoSwitching) setLoco(want);
+ locoReconciler ??= setInterval(reconcileLoco, 250);
+ }
+ useGame.subscribe((s) => s.locoWant, reconcileLoco);
+
+ // ── Cutscenes (entrance + respawn) ──────────────────────────────────
+ ceremony = createCeremony({
+ THREE, scene, camera, renderer, fx,
+ getRig: () => rig,
+ grid, wallMats,
+ syncRig, startCameraReset,
+ setLocked: (v) => {
+ inputLocked = v;
+ controller.setLocked(v);
+ // A ball is always in play: pop one the moment the entrance or a
+ // respawn ceremony hands control back.
+ if (!v && ball && !ballActive) spawnBall({ fromQueue: true });
+ },
+ flashReset: () => {},
+ });
+
+ const { group: ballGroup, mesh: ballMesh } = createBallVisual(renderer);
+ scene.add(ballGroup);
+ ball = createBallActor({
+ THREE, scene, camera, renderer, fxModule: fx, mesh: ballMesh, group: ballGroup,
+ });
+
+ // ── Jukebox prop (decorative corner dressing, no physics) ────────────
+ // assets/props/jukebox.glb carries two meshes exported from Blender: the
+ // ~39k-tri render mesh and a 500-tri "jukebox_wire" stand-in used only by
+ // the hologram pass (same fxWireGeometry escape hatch as the ball). It
+ // materializes with the duck's ceremony, staggered a beat behind, and
+ // replays on every respawn.
+ const JUKEBOX_H = 0.42; // target height, m
+ const JUKEBOX_MARGIN = 0.24; // center distance from each wall inner face
+ let jukeboxGroup = null;
+ try {
+ const gltf = await new GLTFLoader().loadAsync(
+ signed(`./assets/props/jukebox.glb?v=1`),
+ );
+ const jukebox = gltf.scene;
+ const jukeWire = jukebox.getObjectByName("jukebox_wire");
+ jukeWire.removeFromParent();
+ const jukeBox3 = new THREE.Box3().setFromObject(jukebox);
+ const jukeScale = JUKEBOX_H / (jukeBox3.max.y - jukeBox3.min.y);
+ jukebox.scale.setScalar(jukeScale);
+ jukebox.position.y = -jukeBox3.min.y * jukeScale;
+ jukebox.traverse((o) => {
+ if (o.isMesh) o.userData.fxWireGeometry = jukeWire.geometry;
+ });
+ const jukeGroup = new THREE.Group();
+ jukeGroup.add(jukebox);
+ // Back corner, behind the spawn (the duck faces +X), angled toward the
+ // center of the arena so the front panel reads from the play area.
+ jukeGroup.position.set(
+ -(ARENA_HALF - JUKEBOX_MARGIN), 0, -(ARENA_HALF - JUKEBOX_MARGIN),
+ );
+ jukeGroup.rotation.y = Math.PI / 4;
+ scene.add(jukeGroup);
+ jukeboxGroup = jukeGroup;
+ const jukeFx = fx.createWireframeFx();
+ jukeFx.init({ THREE, scene, root: jukeGroup, camera, renderer, hidden: true });
+ ceremony.addPropFx(jukeFx, 0.25);
+ } catch (err) {
+ // Decorative only: a missing/broken GLB must never halt the boot.
+ console.warn("[game] jukebox prop disabled:", err);
+ }
+
+ // ── Camera: orbit controls + chase cam + reset glide ─────────────────
+ const controls = new OrbitControls(camera, renderer.domElement);
+ controls.target.set(SPAWN_X, 0, -SPAWN_Y); // orbit around the spawn cell
+ controls.enableDamping = true;
+ controls.dampingFactor = 0.08;
+ controls.minDistance = 0.25;
+ controls.maxDistance = 3;
+ controls.maxPolarAngle = Math.PI / 2 - 0.03;
+
+ // Chase cam (default ON): each frame the camera eases toward a point
+ // behind the duck's heading at the current orbit distance, while the
+ // orbit target keeps easing to the trunk in syncRig. Implemented by
+ // overwriting camera.position AFTER controls.update() so we never fight
+ // OrbitControls' own spherical bookkeeping.
+ let chaseCam = true;
+ const CHASE_PITCH = 0.42; // rad above horizontal, keeps the floor in view
+ const CHASE_EASE = 0.05;
+ const _chasePos = new THREE.Vector3();
+ const _chaseDir = new THREE.Vector3();
+ // During one-shot rolls and kicks the trunk tumbles: hold the last
+ // healthy yaw for the whole one-shot.
+ let chaseHeldYaw = 0;
+ // Heading hysteresis (Schmitt trigger): the walking gait wiggles the
+ // trunk yaw ~±14 deg per step; two-layer EMA + engage/release thresholds
+ // keep the camera steady while walking straight but responsive on turns.
+ let chaseYawSmooth = 0;
+ let chaseYawFollow = 0;
+ let chaseYawTracking = false;
+ const CHASE_YAW_SMOOTH_EASE = 0.04;
+ const CHASE_YAW_ENGAGE = 0.17;
+ const CHASE_YAW_RELEASE = 0.03;
+ const CHASE_YAW_EASE = 0.10;
+ const CHASE_YAW_EASE_TURN = 0.5;
+ const wrapPi = (a) => Math.atan2(Math.sin(a), Math.cos(a));
+ function updateChaseCam() {
+ // Reset glide: one clean tween from wherever the camera is back to the
+ // home framing. Runs instead of the chase logic and hands control back
+ // to it on landing.
+ if (camResetT0 !== null) {
+ if (!chaseCam) { camResetT0 = null; return; }
+ const t = (performance.now() - camResetT0) / 1000 / CAM_RESET_S;
+ const e = t >= 1 ? 1 : t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+ camera.position.lerpVectors(_camFrom, _camTo, e);
+ controls.target.lerpVectors(_tgtFrom, _tgtTo, e);
+ camera.lookAt(controls.target);
+ if (t >= 1) camResetT0 = null;
+ return;
+ }
+ if (!chaseCam) return;
+ const qpos = data.qpos;
+ let rawYaw;
+ if (mode === "roll" || isKick()) {
+ rawYaw = chaseHeldYaw;
+ } else {
+ rawYaw = Math.atan2(
+ 2 * (qpos[3] * qpos[6] + qpos[4] * qpos[5]),
+ 1 - 2 * (qpos[5] * qpos[5] + qpos[6] * qpos[6]),
+ );
+ chaseHeldYaw = rawYaw;
+ }
+ // "turning" reads the raw per-source wz commands (not the locked/merged
+ // view) so an intentional turn engages on the first frame.
+ const turning = controller.sources.some((s) => Math.abs(s.command[2]) > 0.05);
+ chaseYawSmooth = wrapPi(
+ chaseYawSmooth +
+ wrapPi(rawYaw - chaseYawSmooth) * (turning ? CHASE_YAW_EASE_TURN : CHASE_YAW_SMOOTH_EASE),
+ );
+ const yawErr = wrapPi(chaseYawSmooth - chaseYawFollow);
+ if (turning || Math.abs(yawErr) > CHASE_YAW_ENGAGE) chaseYawTracking = true;
+ if (chaseYawTracking) {
+ chaseYawFollow = wrapPi(
+ chaseYawFollow + yawErr * (turning ? CHASE_YAW_EASE_TURN : CHASE_YAW_EASE),
+ );
+ if (!turning && Math.abs(yawErr) < CHASE_YAW_RELEASE) chaseYawTracking = false;
+ }
+ const yaw = chaseYawFollow;
+ const dist = camera.position.distanceTo(controls.target);
+ const horiz = dist * Math.cos(CHASE_PITCH);
+ const vert = dist * Math.sin(CHASE_PITCH);
+ // Duck forward in MJCF is (cos yaw, sin yaw, 0); Z-up -> Y-up maps it
+ // to three-space (cos yaw, 0, -sin yaw). Behind = minus that.
+ _chasePos.set(
+ controls.target.x - Math.cos(yaw) * horiz,
+ controls.target.y + vert,
+ controls.target.z + Math.sin(yaw) * horiz,
+ );
+ camera.position.lerp(_chasePos, CHASE_EASE);
+ // Re-project onto the orbit sphere: lerping between two points at the
+ // same radius cuts the chord, which would slowly zoom the camera in
+ // during large swings.
+ _chaseDir.copy(camera.position).sub(controls.target);
+ const len = _chaseDir.length();
+ if (len > 1e-6) camera.position.copy(controls.target).addScaledVector(_chaseDir, dist / len);
+ camera.lookAt(controls.target);
+ }
+ renderer.domElement.addEventListener("pointerdown", () => { chaseCam = false; });
+
+ // Camera reset glide (owned by the respawn ceremony): back to the
+ // page-load framing - the chase cam's ideal point behind the duck's
+ // spawn heading, at the boot orbit distance.
+ const CAM_HOME_DIST = camera.position.distanceTo(controls.target);
+ let camResetT0 = null;
+ const _camFrom = new THREE.Vector3(), _camTo = new THREE.Vector3();
+ const _tgtFrom = new THREE.Vector3(), _tgtTo = new THREE.Vector3();
+ function startCameraReset() {
+ const qpos = data.qpos;
+ const yaw = Math.atan2(
+ 2 * (qpos[3] * qpos[6] + qpos[4] * qpos[5]),
+ 1 - 2 * (qpos[5] * qpos[5] + qpos[6] * qpos[6]),
+ );
+ chaseHeldYaw = yaw;
+ chaseYawSmooth = yaw;
+ chaseYawFollow = yaw;
+ chaseYawTracking = false;
+ _tgtTo.set(qpos[0], qpos[2], -qpos[1]); // trunk at spawn, MJCF -> three
+ const horiz = CAM_HOME_DIST * Math.cos(CHASE_PITCH);
+ const vert = CAM_HOME_DIST * Math.sin(CHASE_PITCH);
+ _camTo.set(
+ _tgtTo.x - Math.cos(yaw) * horiz,
+ _tgtTo.y + vert,
+ _tgtTo.z + Math.sin(yaw) * horiz,
+ );
+ _camFrom.copy(camera.position);
+ _tgtFrom.copy(controls.target);
+ camResetT0 = performance.now();
+ chaseCam = true; // reset always re-attaches the chase cam
+ }
+
+ // Pause: while the menu is up over a live game, keys belong to the menu.
+ const setInputLock = (v) => { inputLocked = v; controller.setLocked(v); };
+ useGame.subscribe(
+ (s) => s.menuOpen,
+ (open) => {
+ if (!ceremony.entranceDone) return;
+ if (open) setInputLock(true);
+ else if (!ceremony.respawnActive) setInputLock(false);
+ },
+ );
+
+ // The rig's root already applies the MJCF Z-up -> three Y-up fix, so the
+ // trunk group can take the freejoint pose in raw MJCF coordinates.
+ const _target = new THREE.Vector3();
+ const _follow = new THREE.Vector3();
+ function syncRig() {
+ const qpos = data.qpos;
+ trunkGroup.position.set(qpos[0], qpos[1], qpos[2]);
+ trunkGroup.quaternion.set(qpos[4], qpos[5], qpos[6], qpos[3]);
+ for (let j = 0; j < NUM_JOINTS; j++) setJoint(rig, JOINT_NAMES[j], qpos[qposAdr[j]]);
+ // Passive hinges (roller wheels): purely visual, driven straight from qpos.
+ for (const ej of extraJoints) setJoint(rig, ej.name, qpos[ej.adr]);
+ // Ball: live follows qpos; ghost freeze is owned by the ball actor.
+ if (ball) ball.sync(qpos, ballQposAdr, ballActive);
+ // Follow cam: ease the orbit target toward the trunk and translate the
+ // camera by the same delta, so the camera-to-duck distance and viewing
+ // angle stay constant while the duck walks. Paused while the reset
+ // glide owns the camera.
+ if (camResetT0 === null) {
+ _target.set(qpos[0], qpos[2], -qpos[1]);
+ _follow.copy(_target).sub(controls.target);
+ // Horizontal follow at the usual rate; vertical much slower so the
+ // per-step gait bob doesn't nod the frame.
+ _follow.x *= 0.06;
+ _follow.z *= 0.06;
+ _follow.y *= 0.015;
+ controls.target.add(_follow);
+ camera.position.add(_follow);
+ }
+ // Keep the grid plane (and its fade center) under the action; the wall
+ // grids share the same radial fade focus.
+ grid.position.set(controls.target.x, 0, controls.target.z);
+ grid.material.uniforms.uFocus.value.copy(controls.target);
+ for (const m of wallMats) m.uniforms.uFocus.value.copy(controls.target);
+ }
+
+ // ── Quack: jaw + chirp ────────────────────────────────────────────────
+ // The jaw isn't a MuJoCo joint (duck.js re-creates the hinge in JS), so
+ // this is purely cosmetic and can't upset the policy. Voice banks from
+ // the robot runtime: each colourway gets its own bank and every quack
+ // draws a random chirp take from it.
+ const QUACK_MS = 480;
+ let quackAt = -Infinity;
+ let padJaw = 0;
+ const CHIRP_TAKES = "abcdefghijkl";
+ const VOICE_BANK = { classic: "duck1", charcoal: "duck2", purple: "duck3", blue: "duck4" };
+ const chirpCache = new Map();
+ function playChirp() {
+ const bank = VOICE_BANK[currentVariant] ?? "duck1";
+ const take = CHIRP_TAKES[(Math.random() * CHIRP_TAKES.length) | 0];
+ const url = signed(`./assets/voices/${bank}/chirp_${take}.wav`);
+ let a = chirpCache.get(url);
+ if (!a) {
+ a = new Audio(url);
+ a.volume = 0.7;
+ chirpCache.set(url, a);
+ }
+ a.currentTime = 0;
+ a.play().catch(() => {});
+ }
+ const quackLoud = () => {
+ quackAt = performance.now();
+ playChirp();
+ stickers?.pop("quack");
+ };
+ function jawOpenNow() {
+ const t = (performance.now() - quackAt) / QUACK_MS;
+ const flap = t >= 0 && t < 1 ? Math.sin(Math.PI * t) : 0;
+ return Math.max(flap, padJaw);
+ }
+ function syncJaw() {
+ setJawOpen(rig, jawOpenNow());
+ }
+
+ // ── Telemetry (throttled into the store) ─────────────────────────────
+ // FPS EMA is per-frame; the store write is 4 Hz so React re-renders
+ // stay far away from frame rate. Odometer integrates horizontal trunk
+ // travel; teleport-sized jumps (resets, loco swaps) don't count.
+ let fpsEma = 60;
+ let fpsLastT = performance.now();
+ let odoM = 0;
+ let odoX = null, odoY = null;
+ let telemetryLastPush = 0;
+ function renderTelemetry() {
+ const now = performance.now();
+ const dtF = (now - fpsLastT) / 1000;
+ fpsLastT = now;
+ if (dtF > 0 && dtF < 0.5) fpsEma += (1 / dtF - fpsEma) * 0.05;
+ const stepD = (odoX === null) ? 0 : Math.hypot(data.qpos[0] - odoX, data.qpos[1] - odoY);
+ if (stepD < 0.05) odoM += stepD; // plausible per-frame travel only
+ odoX = data.qpos[0];
+ odoY = data.qpos[1];
+ if (now - telemetryLastPush < 250) return;
+ telemetryLastPush = now;
+ setStore({
+ telemetry: {
+ fps: Math.round(fpsEma),
+ ctrlHz: Math.round(ctrlHz),
+ speed: Math.hypot(data.qvel[0], data.qvel[1]),
+ odo: odoM,
+ peers: ghosts?.peerCount() ?? 0,
+ },
+ });
+ }
+
+ // ── Right-stick camera orbit (inertia downstream of the controller) ──
+ // The stick steers an angular VELOCITY that eases toward the stick's
+ // target rate, so pushing ramps up gently and releasing coasts to a stop
+ // over ~0.3 s. Vertical is flight-style inverted.
+ const PAD_ORBIT_SPEED = 2.4; // rad/s at full deflection
+ const PAD_ORBIT_SMOOTH = 8; // 1/s response rate (~95% in 0.37 s)
+ const padOrbitVel = { az: 0, el: 0 };
+ const _padSph = new THREE.Spherical();
+ const _padOff = new THREE.Vector3();
+ function padOrbitStep(rx, ry, dt) {
+ padOrbitLive = rx !== 0 || ry !== 0;
+ if (padOrbitLive) chaseCam = false; // detach, same as a mouse grab
+ const k = 1 - Math.exp(-PAD_ORBIT_SMOOTH * dt);
+ padOrbitVel.az += (rx * PAD_ORBIT_SPEED - padOrbitVel.az) * k;
+ padOrbitVel.el += (-ry * PAD_ORBIT_SPEED * 0.75 - padOrbitVel.el) * k;
+ if (chaseCam) { padOrbitVel.az = 0; padOrbitVel.el = 0; return; }
+ if (Math.abs(padOrbitVel.az) < 1e-3 && Math.abs(padOrbitVel.el) < 1e-3) return;
+ _padOff.copy(camera.position).sub(controls.target);
+ _padSph.setFromVector3(_padOff);
+ _padSph.theta -= padOrbitVel.az * dt;
+ _padSph.phi += padOrbitVel.el * dt;
+ _padSph.phi = Math.min(controls.maxPolarAngle, Math.max(0.08, _padSph.phi));
+ _padSph.makeSafe();
+ camera.position.setFromSpherical(_padSph).add(controls.target);
+ camera.lookAt(controls.target);
+ }
+
+ // Multiplayer ghosts, initialised asynchronously at the end of the boot.
+ let ghosts = null;
+
+ // ── Per-frame drive, called by R3F's useFrame ────────────────────────
+ let padWasConnected = null;
+ let touchWasConnected = null;
+ function frame(dt) {
+ controller.update(dt);
+ padJaw = controller.getAxes().jaw;
+ if (padSource.connected !== padWasConnected) {
+ padWasConnected = padSource.connected;
+ setStore({ padConnected: padSource.connected });
+ }
+ if (touchSource.connected !== touchWasConnected) {
+ touchWasConnected = touchSource.connected;
+ setStore({ touchMode: touchSource.connected });
+ }
+ // Camera orbit runs every frame while a pad is present (the coasting
+ // needs the zero-deflection frames too); without a pad, park the state.
+ if (padSource.connected) {
+ padOrbitStep(controller.getAxes().orbitX, controller.getAxes().orbitY, dt);
+ } else {
+ padOrbitLive = false;
+ padOrbitVel.az = 0;
+ padOrbitVel.el = 0;
+ }
+ syncRig();
+ syncJaw();
+ ghosts?.update();
+ controls.update();
+ updateChaseCam();
+ ceremony.drive();
+ ball.drive(() => spawnBall({ fromQueue: true }));
+ renderTelemetry();
+ }
+
+ // ── Input wiring: arm the controller sources, bind actions ───────────
+ controller.init();
+
+ // Keyboard F alternates kicking feet; only advance the alternation on
+ // kicks that actually launched (triggerKick reports that).
+ let kbKickFoot = "left";
+ const srcTag = (source) => (source === "gamepad" ? "pad" : "kb");
+
+ controller.on("reset", () => resetSim());
+ controller.on("spawnBall", () => spawnBall());
+ controller.on("chaseToggle", () => { chaseCam = !chaseCam; });
+ controller.on("locoToggle", () => toggleLoco());
+ controller.on("roll", ({ source }) => triggerRoll(srcTag(source)));
+ controller.on("kickL", ({ source }) => triggerKick("left", srcTag(source)));
+ controller.on("kickR", ({ source }) => triggerKick("right", srcTag(source)));
+ controller.on("alternateKick", ({ source }) => {
+ if (triggerKick(kbKickFoot, srcTag(source))) {
+ kbKickFoot = kbKickFoot === "left" ? "right" : "left";
+ }
+ });
+ controller.on("sitToggle", () => {
+ if (loco !== "legs") return; // sitting is a legs-only skill
+ const sitting = mode === "sitstand" && sitFlag === 1;
+ setMode(sitting ? "walk" : "sit");
+ });
+ // Pad DpadUp short press: straight back to running (ignored mid-roll /
+ // mid-crouch: those hand back to walk on their own).
+ controller.on("walk", () => {
+ if (mode !== "walk" && mode !== "roll" && mode !== "crouch") setMode("walk");
+ });
+ controller.on("quack", () => quackLoud());
+
+ function setMode(next, { force = false } = {}) {
+ if (!force && inputLocked) return;
+ // No policy switching mid-roll or mid-kick: both end on their own and
+ // return to walk - switching now would floor the duck.
+ if ((mode === "roll" && rollRun) || (isKick() && kickRun) || (mode === "crouch" && crouchRun)) return;
+ if (next === "sit" && loco === "rollers") return;
+ clearModeTimers();
+ rollRun = null;
+ crouchRun = null;
+ if (next !== "sit") {
+ // Leaving a sit: let the sitstand policy stand the duck back up first.
+ if (mode === "sitstand" && sitFlag === 1) {
+ sitFlag = 0;
+ standTimer = setTimeout(() => {
+ standTimer = null;
+ mode = next;
+ lastAction.fill(0);
+ syncButtons();
+ }, 2000);
+ syncButtons();
+ return;
+ }
+ mode = next;
+ lastAction.fill(0);
+ } else {
+ // Hand over gently: hold the stand under the sitstand policy for a
+ // moment before commanding the sit, or the abrupt session switch
+ // knocks the duck over.
+ mode = "sitstand";
+ sitFlag = 0;
+ lastAction.fill(0);
+ sitTimer = setTimeout(() => {
+ sitTimer = null;
+ if (mode === "sitstand") { sitFlag = 1; syncButtons(); }
+ }, 800);
+ }
+ syncButtons();
+ }
+
+ // One roll, then straight back to running. lastAction is deliberately
+ // NOT zeroed: the runtime keeps one continuous action history across
+ // policy switches, and the roll initiates more reliably mid-gait.
+ function triggerRoll(source = "kb") {
+ if (loco === "rollers") return triggerCrouch(source);
+ if (inputLocked || mode !== "walk" || standTimer) return;
+ clearModeTimers();
+ mode = "roll";
+ sitFlag = 0;
+ rollRun = { steps: 0, tipped: false };
+ syncButtons();
+ stickers?.pop("roll");
+ }
+
+ // Roller-only one-shot: crouch, glide low, stand back up (phase-driven).
+ function triggerCrouch(source = "kb") {
+ if (inputLocked || mode !== "walk" || locoSwitching) return;
+ clearModeTimers();
+ mode = "crouch";
+ crouchRun = { phase: 0 };
+ syncButtons();
+ stickers?.pop("roll");
+ }
+
+ // One blind kick (the duck can't see any ball - it's a scripted boot).
+ // Returns whether the kick actually launched so the keyboard's foot
+ // alternation only advances on real kicks.
+ function triggerKick(foot, source = "kb") {
+ if (loco === "rollers") return false;
+ if (inputLocked || mode !== "walk" || standTimer) return false;
+ clearModeTimers();
+ mode = foot === "left" ? "kickL" : "kickR";
+ sitFlag = 0;
+ kickRun = { steps: 0 };
+ syncButtons();
+ stickers?.pop("kick");
+ return true;
+ }
+
+ function syncButtons() {
+ const sitting = mode === "sitstand" && sitFlag === 1;
+ const label =
+ mode === "roll" ? "Roll"
+ : mode === "crouch" ? "Crouch"
+ : isKick() ? "Kick"
+ : sitting ? "Sit"
+ : loco === "rollers" ? "Drive"
+ : "Run";
+ if (store().modeLabel !== label) setStore({ modeLabel: label });
+ if (store().ballActive !== ballActive) setStore({ ballActive });
+ }
+
+ // ── Public surface for the React UI ──────────────────────────────────
+ Object.assign(gameApi, {
+ frame,
+ setVariant: (name) => {
+ if (!VARIANTS[name] || name === currentVariant) return;
+ currentVariant = name;
+ applyVariant(rig, name);
+ setStore({ variant: name });
+ },
+ requestLoco: (name) => {
+ if (name !== "legs" && name !== "rollers") return;
+ setStore({ locoWant: name });
+ reconcileLoco();
+ },
+ resetSim,
+ spawnBall: () => spawnBall(),
+ startEntrance: () => ceremony.startEntrance(),
+ });
+
+ // Deterministic hooks for automated verification (rAF pauses in
+ // background tabs, and the control loop is async).
+ window.rl = {
+ get model() { return model; },
+ get data() { return data; },
+ mujoco, camera, controls,
+ get mode() { return mode; },
+ get sitFlag() { return sitFlag; },
+ buildObs, cmd,
+ velCmd: kbSource.command, lastAction, resetSim,
+ controller, kbSource, padSource,
+ spawnBall, triggerKick, triggerRoll, sessions, ort,
+ get loco() { return loco; },
+ get locoSwitching() { return locoSwitching; },
+ toggleLoco, setLoco, ensureRollers,
+ triggerCrouch,
+ get crouchPhase() { return crouchRun?.phase ?? null; },
+ get kickSteps() { return KICK_STEPS; },
+ set kickSteps(v) { KICK_STEPS = v; },
+ get ballActive() { return ballActive; },
+ get ballQposAdr() { return ballQposAdr; },
+ get chaseCam() { return chaseCam; },
+ set chaseCam(v) { chaseCam = !!v; },
+ get jukebox() { return jukeboxGroup; },
+ get camResetActive() { return camResetT0 !== null; },
+ get respawnActive() { return ceremony?.respawnActive ?? false; },
+ get camPose() {
+ return {
+ pos: camera.position.toArray(),
+ target: controls.target.toArray(),
+ };
+ },
+ get chaseYaw() { return { follow: chaseYawFollow, smooth: chaseYawSmooth, held: chaseHeldYaw, tracking: chaseYawTracking }; },
+ padOrbitStep,
+ jawOpenNow,
+ step: async (n = 1) => { for (let i = 0; i < n; i++) await controlStep(); },
+ render: () => { syncRig(); renderer.render(scene, camera); },
+ frame: (dt = 1 / 60) => frame(dt),
+ get ghosts() { return ghosts; },
+ get inputLocked() { return inputLocked; },
+ entrance: {
+ start: () => ceremony.startEntrance(),
+ setReveal: (floor, wall) => ceremony.setReveal(floor, wall),
+ setFx: (p) => ceremony.setFx(p),
+ },
+ };
+
+ // Boot complete: the sim/HUD go live immediately. The BIOS readout (if
+ // the user already waddled in, or when they do) sees bootDone and closes
+ // with READY. + fade on its own.
+ setStore({ bootDone: true });
+
+ // ── Multiplayer ghosts (WebRTC, serverless signaling) ────────────────
+ // Broadcast this duck's pose and render up to 3 other visitors live as
+ // translucent ducks. Fire-and-forget: any failure just means no ghosts.
+ const r3 = (x) => Math.round(x * 1000) / 1000;
+ try {
+ // Ghosts only join once the entrance has fully played: the world (and
+ // this duck) must stay hidden until then, translucent peers included.
+ await ceremony.entranceFinished;
+ ghosts = await initGhosts({
+ scene, rig, cloneRig, setJoint, setJawOpen, applyVariant,
+ jointNames: JOINT_NAMES,
+ // Ghost rig per locomotion flag: peers in roller mode clone the
+ // roller rig once this tab has built it, and fall back to the leg
+ // rig until then. Known v1 limitation, documented in the README.
+ getRigFor: (l) => (l && locos.rollers ? locos.rollers.rig : locos.legs.rig),
+ getLocalState: () => {
+ const qpos = data.qpos;
+ const j = new Array(NUM_JOINTS);
+ for (let i = 0; i < NUM_JOINTS; i++) j[i] = r3(qpos[qposAdr[i]]);
+ return {
+ p: [r3(qpos[0]), r3(qpos[1]), r3(qpos[2]), r3(qpos[3]), r3(qpos[4]), r3(qpos[5]), r3(qpos[6])],
+ j,
+ w: r3(jawOpenNow()),
+ v: currentVariant,
+ l: loco === "rollers" ? 1 : 0,
+ };
+ },
+ });
+ if (ghosts.room) ghosts.room.onPeerJoin = () => stickers?.pop("hi");
+ } catch (e) {
+ window.__ghostErr = String((e && e.stack) || e);
+ console.warn("ghosts disabled:", e);
+ }
+}
diff --git a/app/src/game/ghosts.js b/app/src/game/ghosts.js
new file mode 100644
index 0000000..36bf7cf
--- /dev/null
+++ b/app/src/game/ghosts.js
@@ -0,0 +1,288 @@
+// Live multiplayer ghosts: every open tab of the sandbox broadcasts its
+// duck state over WebRTC and renders the other visitors as translucent
+// ducks. There is no backend - this is a static Space - so peer discovery
+// uses Trystero's serverless signaling over public Nostr relays. Payloads
+// are tiny (22 floats + a variant name at SEND_HZ), and at most MAX_GHOSTS
+// ghosts are instantiated regardless of how many peers are in the room.
+//
+// This module deliberately imports nothing from duck.js / variants.js:
+// on the private Space those need the ?__sign JWT that only rl.js knows
+// how to append, so all rig helpers arrive through init parameters.
+
+const TRYSTERO_URL = "https://esm.run/trystero@0.25.3/nostr";
+const APP_ID = "microduck-sandbox";
+const ROOM = "lobby";
+const MAX_GHOSTS = 3;
+const SEND_HZ = 15;
+const GHOST_OPACITY = 0.35;
+// Snapshot interpolation: each ghost renders INTERP_DELAY_MS in the past,
+// lerping between the two buffered snapshots that bracket the render time
+// (timed by local ARRIVAL, so no clock sync and no payload change - old
+// clients interoperate). This replaces the old exponential chase toward
+// the latest packet, whose move-then-stall rhythm read as micro-stutter.
+// The delay absorbs network jitter; past the newest snapshot the ghost
+// holds pose, so a background-throttled 1 Hz sender degrades into slow
+// discrete steps instead of teleports. Nobody synchronizes on ghosts, so
+// the added latency is invisible.
+const INTERP_DELAY_MS = 150;
+const BUF_MAX = 40; // snapshots kept per ghost (~2.5 s at 15 Hz)
+// Idle visitors stay invisible: a ghost is only shown once its peer has
+// strayed from the pose of its first state message (everyone spawns at
+// the arena center). Once revealed it stays visible for the whole peer
+// session, so a reset teleporting the duck back to center doesn't blink
+// the ghost out.
+const REVEAL_DIST = 0.2; // m, horizontal distance from spawn
+const REVEAL_YAW = 0.4; // rad (~23deg), turning in place also reveals
+
+// state.p is raw MuJoCo qpos[0..6]: [x, y, z, qw, qx, qy, qz], Z-up.
+const yawOf = (p) =>
+ Math.atan2(2 * (p[3] * p[6] + p[4] * p[5]), 1 - 2 * (p[5] * p[5] + p[6] * p[6]));
+const hasMoved = (spawn, p) => {
+ const dx = p[0] - spawn.x, dy = p[1] - spawn.y;
+ if (dx * dx + dy * dy > REVEAL_DIST * REVEAL_DIST) return true;
+ const dyaw = yawOf(p) - spawn.yaw;
+ return Math.abs(Math.atan2(Math.sin(dyaw), Math.cos(dyaw))) > REVEAL_YAW;
+};
+
+export async function initGhosts(env) {
+ const noop = { update() {}, peerCount: () => 0, ghostCount: () => 0, debug: () => [], mapDots: () => [] };
+ let room;
+ try {
+ const { joinRoom } = await import(/* @vite-ignore */ TRYSTERO_URL);
+ room = joinRoom({ appId: APP_ID }, ROOM);
+ } catch (e) {
+ console.warn("ghosts disabled (signaling unavailable):", e);
+ return noop;
+ }
+
+ const { scene, cloneRig, setJoint, setJawOpen, applyVariant, jointNames, getLocalState } = env;
+ // Locomotion-variant rig source: state.l 1 = rollers, 0/absent = legs
+ // (old clients never send it). Falls back to the leg rig when the local
+ // tab hasn't built the roller rig yet - known v1 limitation.
+ const rigFor = (l) => (env.getRigFor ? env.getRigFor(l ?? 0) : env.rig);
+ // trystero 0.25 (backed by @trystero-p2p): makeAction returns
+ // { send, onMessage, onReceiveProgress } where onMessage is a SETTER -
+ // the receive handler is registered by assignment, not by calling it.
+ const act = room.makeAction("s");
+ // send() rejects when a peer's channel drops mid-transfer; that peer will
+ // be swept anyway, so failures are non-events.
+ const sendState = (data) => act.send(data).catch(() => {});
+
+ // Ghosts share geometry with the local rig (cloneRig), but get their own
+ // transparent material clones so repainting them never touches the
+ // visitor's own duck (variants.js caches materials globally).
+ //
+ // Rendering: a ghost reads as ONE translucent shell, not ~70 individually
+ // transparent meshes (through which every internal motor/PCB used to show).
+ // Classic depth-prepass silhouette, kept inside the transparent pass so the
+ // grid floor/walls (transparent ShaderMaterials at renderOrder 0) still
+ // draw behind ghosts instead of being depth-rejected:
+ // PREPASS (renderOrder 1): every ghost mesh duplicated as a color-less
+ // twin (colorWrite off, depthWrite on) -> the depth buffer ends up
+ // holding the nearest ghost surface per pixel.
+ // BEAUTY (renderOrder 2): the real meshes, transparent + depthWrite off;
+ // the default LessEqual depth test then rejects everything except the
+ // fragment matching the prepass depth, so internals and back shell
+ // layers are skipped and each pixel is shaded exactly once.
+ // Orders are shared by all ghosts (not per-ghost pairs): every beauty pass
+ // tests against every ghost's prepass depth, so overlapping ghosts occlude
+ // each other like solids instead of double-blending.
+ const PREPASS_ORDER = 1;
+ const BEAUTY_ORDER = 2;
+ const ghostify = (rig) => {
+ // Collect first: twins are added below and must not be re-traversed.
+ const meshes = [];
+ rig.root.traverse((o) => { if (o.isMesh) meshes.push(o); });
+ const cache = new Map();
+ let depthMat = null;
+ for (const o of meshes) {
+ // Materialization-FX wire overlays cloned along with the local rig:
+ // drop them, they share the LIVE scan shader material and would
+ // flash on this ghost every time the local duck re-materializes.
+ if (o.userData.fxOverlay) { o.parent?.remove(o); continue; }
+ if (o.userData.ghostPrepass) continue; // twin from a previous ghostify
+ let m = cache.get(o.material.uuid);
+ if (!m) {
+ m = o.material.clone();
+ m.transparent = true;
+ m.opacity = GHOST_OPACITY;
+ m.depthWrite = false;
+ cache.set(o.material.uuid, m);
+ }
+ o.material = m;
+ o.renderOrder = BEAUTY_ORDER;
+ if (!o.userData.hasGhostTwin) {
+ if (!depthMat) {
+ // Depth-only material: cloned (no THREE import here) and muted.
+ // transparent stays true so the twin sorts into the transparent
+ // pass, after the grid but before the beauty meshes.
+ depthMat = m.clone();
+ depthMat.colorWrite = false;
+ depthMat.depthWrite = true;
+ }
+ // Twin as an identity-transform child: follows joints for free. No
+ // userData.meshName, so applyVariant never repaints it.
+ const twin = new o.constructor(o.geometry, depthMat);
+ twin.renderOrder = PREPASS_ORDER;
+ twin.userData.ghostPrepass = true;
+ o.userData.hasGhostTwin = true;
+ o.add(twin);
+ }
+ }
+ };
+
+ const ghosts = new Map(); // peerId -> ghost
+ // Interpolation snapshot: the pose parts of a state message, stamped
+ // with the local arrival time.
+ const snapOf = (state) => ({ p: state.p, j: state.j, w: state.w ?? 0, at: performance.now() });
+ const makeGhost = (state) => {
+ const rig = cloneRig(rigFor(state.l));
+ applyVariant(rig, state.v);
+ ghostify(rig);
+ scene.add(rig.placer);
+ const trunk = rig.bodies.get("trunk_base");
+ // Snap straight to the first received pose: no fly-in from the origin.
+ trunk.position.set(state.p[0], state.p[1], state.p[2]);
+ trunk.quaternion.set(state.p[4], state.p[5], state.p[6], state.p[3]);
+ return {
+ rig, trunk, buf: [snapOf(state)],
+ variant: state.v, loco: state.l ?? 0,
+ };
+ };
+
+ const removeGhost = (peerId) => {
+ const g = ghosts.get(peerId);
+ if (!g) return;
+ scene.remove(g.rig.placer);
+ const seen = new Set();
+ g.rig.root.traverse((o) => {
+ if (o.isMesh && !seen.has(o.material.uuid)) {
+ seen.add(o.material.uuid);
+ o.material.dispose();
+ }
+ });
+ ghosts.delete(peerId);
+ };
+
+ // Handler signature in this build: (payload, context) where context is
+ // { peerId } - NOT the bare peerId string of classic trystero.
+ act.onMessage = (state, { peerId }) => {
+ let g = ghosts.get(peerId);
+ if (!g) {
+ if (ghosts.size >= MAX_GHOSTS) return; // room stays open, rendering capped
+ // Nostr relays replay recent events, so states from already-dead
+ // sessions can arrive right after joining: only ghost live peers.
+ if (!(peerId in room.getPeers())) return;
+ g = makeGhost(state);
+ // Idle-visitor gate: remember where this peer first appeared and keep
+ // its rig invisible until it strays from there (see hasMoved above).
+ g.spawn = { x: state.p[0], y: state.p[1], yaw: yawOf(state.p) };
+ g.revealed = false;
+ g.rig.placer.visible = false;
+ ghosts.set(peerId, g);
+ g.lastSeen = performance.now();
+ return;
+ }
+ g.lastSeen = performance.now();
+ g.buf.push(snapOf(state));
+ if (g.buf.length > BUF_MAX) g.buf.shift();
+ if (!g.revealed && hasMoved(g.spawn, state.p)) {
+ g.revealed = true; // latched for the rest of this peer session
+ g.rig.placer.visible = true;
+ }
+ // Peer switched legs <-> rollers: rebuild its ghost on the other rig
+ // (cheap - cloneRig shares geometry). The snapshot buffer carries over
+ // so the interpolated motion stays continuous across the swap.
+ if ((state.l ?? 0) !== g.loco) {
+ const { lastSeen, spawn, revealed, buf } = g;
+ removeGhost(peerId);
+ g = makeGhost(state);
+ Object.assign(g, { lastSeen, spawn, revealed, buf });
+ g.rig.placer.visible = revealed;
+ ghosts.set(peerId, g);
+ return;
+ }
+ if (state.v !== g.variant) {
+ g.variant = state.v;
+ applyVariant(g.rig, state.v);
+ ghostify(g.rig);
+ }
+ };
+
+ // Same setter-style registration as onMessage.
+ room.onPeerLeave = (peerId) => removeGhost(peerId);
+
+ // Graceful exit so other tabs drop this ghost immediately...
+ window.addEventListener("pagehide", () => {
+ try { room.leave(); } catch {}
+ });
+ // ...and a staleness sweep for peers that vanished without leaving
+ // (crashed tab, dropped connection): 5 s without a state packet means
+ // the peer is gone, not just lagging (even background-throttled tabs
+ // still send at ~1 Hz).
+ const STALE_MS = 5000;
+
+ // Broadcast + stale sweep on setInterval (not rAF) so both keep running
+ // in occluded tabs.
+ setInterval(() => {
+ const s = getLocalState();
+ if (s) sendState(s);
+ const now = performance.now();
+ for (const [peerId, g] of [...ghosts]) {
+ if (now - g.lastSeen > STALE_MS) removeGhost(peerId);
+ }
+ }, 1000 / SEND_HZ);
+
+ // Scratch THREE.Quaternions without importing three: slerp needs real
+ // instances, cloned here from any node of the already-built local rig.
+ const _qa = env.rig.placer.quaternion.clone();
+ const _qb = env.rig.placer.quaternion.clone();
+ return {
+ room,
+ peerCount: () => Object.keys(room.getPeers()).length,
+ ghostCount: () => ghosts.size,
+ // Minimap feed: revealed ghosts' arena positions in raw MJCF coords
+ // (trunk.position is set from qpos before the root's Z-up fix).
+ mapDots: () =>
+ [...ghosts.values()]
+ .filter((g) => g.revealed)
+ .map((g) => ({ x: g.trunk.position.x, y: g.trunk.position.y })),
+ debug: () => [...ghosts.values()].map((g) => {
+ let meshes = 0, visible = 0, op = null, twins = 0;
+ g.rig.root.traverse((o) => {
+ if (!o.isMesh) return;
+ if (o.userData.ghostPrepass) { twins++; return; }
+ meshes++; if (o.visible) visible++; op ??= o.material.opacity;
+ });
+ const w = g.trunk.getWorldPosition(g.trunk.position.clone());
+ return { p: g.trunk.position.toArray(), world: w.toArray(), inScene: !!g.rig.placer.parent, revealed: g.revealed, meshes, visible, twins, op, v: g.variant };
+ }),
+ update() {
+ const renderT = performance.now() - INTERP_DELAY_MS;
+ for (const g of ghosts.values()) {
+ const buf = g.buf;
+ // Drop snapshots fully in the past; keep [0] and [1] bracketing
+ // renderT (or the two newest, if renderT has caught up).
+ while (buf.length > 2 && buf[1].at <= renderT) buf.shift();
+ const a = buf[0];
+ const b = buf.length > 1 ? buf[1] : a;
+ // Clamped: before the segment -> a, past the newest -> hold b.
+ const span = b.at - a.at;
+ const u = span > 0 ? Math.min(1, Math.max(0, (renderT - a.at) / span)) : 1;
+ // Trunk pose in raw MJCF coords: the cloned root applies Z-up -> Y-up.
+ g.trunk.position.set(
+ a.p[0] + (b.p[0] - a.p[0]) * u,
+ a.p[1] + (b.p[1] - a.p[1]) * u,
+ a.p[2] + (b.p[2] - a.p[2]) * u,
+ );
+ _qa.set(a.p[4], a.p[5], a.p[6], a.p[3]); // THREE order x,y,z,w
+ _qb.set(b.p[4], b.p[5], b.p[6], b.p[3]);
+ g.trunk.quaternion.copy(_qa.slerp(_qb, u));
+ for (let i = 0; i < jointNames.length; i++) {
+ setJoint(g.rig, jointNames[i], a.j[i] + (b.j[i] - a.j[i]) * u);
+ }
+ setJawOpen(g.rig, a.w + (b.w - a.w) * u);
+ }
+ },
+ };
+}
diff --git a/app/src/game/signed.js b/app/src/game/signed.js
new file mode 100644
index 0000000..7c59a06
--- /dev/null
+++ b/app/src/game/signed.js
@@ -0,0 +1,13 @@
+// Private HF Space auth: the hub iframe URL carries a ?__sign JWT, but
+// subresource requests normally rely on a *.static.hf.space cookie that
+// browsers often block inside the iframe (third-party cookie blocking),
+// which 401s every same-origin fetch. Appending the JWT to each request
+// authenticates them regardless of cookie policy. No-op locally.
+//
+// Only ASSET requests (meshes, policies, XML, audio, images) go through
+// this now: application code ships in the Vite bundle, which the page load
+// itself already authenticated.
+const HF_SIGN = new URLSearchParams(location.search).get("__sign");
+
+export const signed = (url) =>
+ HF_SIGN ? `${url}${url.includes("?") ? "&" : "?"}__sign=${encodeURIComponent(HF_SIGN)}` : url;
diff --git a/app/src/game/stickers.js b/app/src/game/stickers.js
new file mode 100644
index 0000000..79ad61d
--- /dev/null
+++ b/app/src/game/stickers.js
@@ -0,0 +1,222 @@
+// Comic sticker popups: on notable game events (kick, quack, roll, ball
+// spawn, ghost peer joining) a die-cut sticker or a comic onomatopoeia pops
+// at a semi-random spot on screen, overshoots in, then fades out. Pure
+// CSS animations, no dependencies.
+//
+// Fully self-contained and OPTIONAL: this module owns its DOM layer and its
+//