@ringozz/godot 4.7.1-10 → 4.7.1-12

package/README.md

@@ -74,7 +74,7 @@ const tex   = await loadResourceAsync('res://textures/icon.jpg', Texture2D); //
 - `loadResourceAsync(path, cls, files?)` — generic over the Godot class: `cls.name` is the `ResourceLoader` type hint, and the return type is `InstanceType<typeof cls>`. Loads in the background (`loadThreadedRequest` + status polling). Godot default arguments apply: the napi dispatch truncates trailing `undefined` args, so `loadThreadedRequest` uses its default `CACHE_MODE_REUSE` and the resource stays cached in the engine (scene re-references don't re-read the file). On web it only works for paths already staged into MEMFS (generated asset modules handle this). When the asset's `files` map is passed, the staged product files (`.ctex`/`.scn`/native sources) are deleted from MEMFS after the resource loads — only the `.import` sidecars are kept, since they route imported source paths to their products. The decoded texture bytes don't linger in the JS heap.
 - `loadAsset(path, cls, files, deps, data)` — the generated asset modules' entry point (also usable directly): returns `{ materialize, load }`. It checks the engine's `ResourceCache` first (when the asset is already loaded, `load` resolves to the cached instance and staging is skipped), stages the bundled files via Godot's `copyToFS` (zero-copy handover of the fetched bytes; a no-op on desktop where the files already exist), loads via `loadResourceAsync`, and memoizes `load` on `data` (pass `import.meta.hot.data`) so HMR re-evaluations reuse the same fulfilled promise.
 
-Asset imports are resolved by `@ringozz/godot/preload` (a Bun plugin, registered via `bunfig.toml` preload for `bun run`/`bun test` and via `[serve.static] plugins` for `Bun.serve`'s fullstack HTML routes; the module's default export is the single plugin object) into a module per asset:
+Asset imports are resolved by `@ringozz/godot/preload` (a Bun plugin, registered via `bunfig.toml` preload for `bun run`/`bun test` and via `[serve.static] plugins` for `Bun.serve`'s fullstack HTML routes; the module's default export is the single plugin object) into a module per asset. Only **JS imports** are virtualized — HTML asset references (`<link rel="icon">`, `<img src>`) and CSS `url()` refs fall through to Bun's normal (content-hashed) asset handling, so favicons and other web assets co-exist with Godot imports:
 
 ```ts
 import foo from './models/foo.gltf';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ringozz/godot",
   "author": "Vladimir Davidovich",
-  "version": "4.7.1-10",
+  "version": "4.7.1-12",
   "description": "Node-API bindings for Godot Engine — call Godot classes from JavaScript",
   "keywords": [
     "godot"
@@ -38,7 +38,7 @@
   "optionalDependencies": {
     "@ringozz/godot-macos-arm64": "^4.7.1-3",
     "@ringozz/godot-windows-x86_64": "^4.7.1-3",
-    "@ringozz/godot-web-wasm32": "^4.7.1-10"
+    "@ringozz/godot-web-wasm32": "^4.7.1-11"
   },
   "peerDependencies": {
     "@types/bun": "*"

package/src/preload.ts

@@ -175,6 +175,22 @@ const assetPlugin: BunPlugin = {
 	name: 'godot-assets',
 	setup(build) {
 		build.onResolve({ filter: ASSET_RE }, (args) => {
+			// Only JS module imports of Godot source assets become `godot`
+			// modules. `Bun.build` reports JS imports as `import-statement`
+			// (and `dynamic-import`/`require-*`) but HTML asset references
+			// (<link>/<img>) and CSS url() refs as `internal`/`url-token` —
+			// those fall through so Bun copies/hashes the file normally. The
+			// runtime preload (bun run / bun test) reports JS imports with no
+			// kind (`undefined`), so treat that as a JS import too.
+			if (
+				args.kind !== undefined &&
+				args.kind !== 'import-statement' &&
+				args.kind !== 'dynamic-import' &&
+				args.kind !== 'require-call' &&
+				args.kind !== 'require-resolve'
+			) {
+				return;
+			}
 			const importerAbs = args.importer?.startsWith(`${NS}:`)
 				? args.importer.slice(NS.length + 1)
 				: args.importer;