@series-inc/rundot-3d-engine 0.6.9 → 0.6.11

package/SKILL.md

@@ -0,0 +1,366 @@
+# Rundot 3D Engine
+
+The Rundot 3D Engine (`@series-inc/rundot-3d-engine`) is a Three.js-based game engine with ECS architecture, Rapier physics, and StowKit asset integration.
+
+## Quick Start
+
+```typescript
+import { VenusGame, GameObject, Component } from "@series-inc/rundot-3d-engine"
+import { MeshRenderer, RigidBodyComponentThree, RigidBodyType, ColliderShape } from "@series-inc/rundot-3d-engine/systems"
+
+class MyGame extends VenusGame {
+    protected async onStart(): Promise<void> {
+        // Load assets
+        const stowkit = StowKitSystem.getInstance()
+        const buildJson = (await import("../prefabs/build.json")).default
+        await stowkit.loadFromBuildJson(buildJson, {
+            fetchBlob: (path) => fetch(path).then(r => r.blob()),
+        })
+
+        // Create a player
+        const player = new GameObject("Player")
+        player.position.set(0, 1, 0)
+
+        // Add mesh
+        const meshObj = new GameObject("PlayerMesh")
+        meshObj.addComponent(new MeshRenderer("player_mesh"))
+        player.add(meshObj)
+
+        // Add physics
+        player.addComponent(new RigidBodyComponentThree({
+            type: RigidBodyType.DYNAMIC,
+            shape: ColliderShape.CAPSULE,
+            radius: 0.5,
+            height: 2,
+            lockRotationX: true,
+            lockRotationY: true,
+            lockRotationZ: true,
+        }))
+
+        // Add lighting
+        const light = new THREE.DirectionalLight(0xffffff, 1)
+        light.position.set(5, 10, 5)
+        this.scene.add(light)
+    }
+
+    protected preRender(deltaTime: number): void {
+        // Per-frame logic
+    }
+
+    protected async onDispose(): Promise<void> {
+        // Cleanup
+    }
+}
+
+MyGame.create()
+```
+
+## Core Architecture
+
+### VenusGame — Game Base Class
+
+Manages renderer, scene, camera, and all engine systems.
+
+```typescript
+class MyGame extends VenusGame {
+    protected getConfig(): VenusGameConfig {
+        return {
+            backgroundColor: 0x87CEEB,
+            antialias: true,
+            shadowMapEnabled: true,
+            shadowMapType: "vsm",        // or "pcf_soft"
+            toneMapping: "aces",          // "aces" | "linear" | "none"
+            toneMappingExposure: 1.0,
+            audioEnabled: true,
+            cameraType: "perspective",    // or "orthographic"
+            orthoSize: 10,               // half-height for ortho camera
+        }
+    }
+
+    protected async onStart(): Promise<void> { /* init game */ }
+    protected preRender(deltaTime: number): void { /* per-frame logic */ }
+    protected async onDispose(): Promise<void> { /* cleanup */ }
+}
+```
+
+**Static access** (after initialization):
+- `VenusGame.scene` — Three.js scene
+- `VenusGame.camera` — active camera
+- `VenusGame.renderer` — WebGL renderer
+- `VenusGame.instance` — game instance
+
+**Lifecycle order:** Physics → Tweens → Components → `preRender()` → `render()`
+
+**IMPORTANT:** Use the `deltaTime` parameter in `preRender()`. Never call `this.clock.getDelta()`.
+
+### GameObject — Entity Class
+
+Extends `THREE.Object3D`. Auto-added to scene on creation.
+
+```typescript
+const obj = new GameObject("MyObject")
+obj.position.set(0, 1, 0)
+obj.addComponent(new MyComponent())
+
+// Hierarchy
+const child = new GameObject("Child")
+obj.add(child)
+
+// Component access
+const comp = obj.getComponent(MyComponent)
+obj.hasComponent(MyComponent)
+obj.removeComponent(MyComponent)
+
+// Enable/disable
+obj.setEnabled(false)  // triggers onDisabled() on all components
+obj.setEnabled(true)   // triggers onEnabled()
+
+// Cleanup
+obj.dispose()  // disposes all components and children
+```
+
+### Component — Behavior Base Class
+
+```typescript
+class MyComponent extends Component {
+    protected onCreate(): void {
+        // Called when added to GameObject — init here
+    }
+
+    public update(deltaTime: number): void {
+        // Called every frame
+        this.gameObject.position.x += deltaTime
+    }
+
+    public lateUpdate(deltaTime: number): void {
+        // Called after all update() calls — camera follow, UI updates
+    }
+
+    public onEnabled(): void { /* GameObject enabled */ }
+    public onDisabled(): void { /* GameObject disabled */ }
+
+    protected onCleanup(): void {
+        // Called on removal or dispose — cleanup listeners, resources
+    }
+}
+```
+
+**Access from Component:**
+- `this.gameObject` — the attached GameObject
+- `this.scene` — the Three.js scene
+- `this.getComponent(Type)` — get sibling component
+
+## Systems
+
+### MeshRenderer — Static Mesh Display
+
+```typescript
+import { MeshRenderer } from "@series-inc/rundot-3d-engine/systems"
+
+// ALWAYS use child GameObject pattern
+const renderer = new MeshRenderer("asset_name", castShadow?, receiveShadow?, isStatic?, materialOverride?)
+const meshObj = new GameObject("Mesh")
+meshObj.addComponent(renderer)
+parentGameObject.add(meshObj)
+
+// Check if loaded
+renderer.isLoaded()
+renderer.getBounds()
+renderer.setVisible(false)
+renderer.setMaterial(customMaterial)
+```
+
+**Static meshes** (`isStatic: true`) skip per-frame matrix updates — use for non-moving objects.
+
+### SkeletalRenderer — Animated Characters
+
+```typescript
+import { SkeletalRenderer } from "@series-inc/rundot-3d-engine/systems"
+
+const skelRenderer = new SkeletalRenderer("character_mesh")
+const meshObj = new GameObject("CharacterMesh")
+meshObj.addComponent(skelRenderer)
+character.add(meshObj)
+```
+
+### RigidBodyComponentThree — Physics
+
+```typescript
+import { RigidBodyComponentThree, RigidBodyType, ColliderShape } from "@series-inc/rundot-3d-engine/systems"
+
+// Dynamic (affected by physics)
+new RigidBodyComponentThree({
+    type: RigidBodyType.DYNAMIC,
+    shape: ColliderShape.BOX,         // BOX, SPHERE, CAPSULE
+    size: new THREE.Vector3(1, 1, 1), // box dimensions
+    radius: 0.5,                      // sphere/capsule radius
+    height: 2,                        // capsule height
+    mass: 1.0,
+    friction: 0.5,
+    restitution: 0.8,                 // bounciness
+    linearDamping: 0.5,
+    angularDamping: 0.5,
+    lockRotationX/Y/Z: true,          // lock rotation axes
+    fitToMesh: true,                  // auto-size from mesh bounds
+})
+
+// Static (immovable)
+new RigidBodyComponentThree({ type: RigidBodyType.STATIC, shape: ColliderShape.BOX, size: ... })
+
+// Kinematic (script-controlled)
+new RigidBodyComponentThree({ type: RigidBodyType.KINEMATIC, ... })
+
+// Trigger (sensor, no physics response)
+new RigidBodyComponentThree({ type: RigidBodyType.STATIC, shape: ColliderShape.BOX, isSensor: true })
+rb.registerOnTriggerEnter((other) => console.log("entered", other.name))
+rb.registerOnTriggerExit((other) => console.log("exited", other.name))
+
+// Velocity & forces (dynamic only)
+rb.setVelocity(new THREE.Vector3(0, 5, 0))
+rb.applyImpulse(new THREE.Vector3(10, 0, 0))
+rb.applyForce(new THREE.Vector3(0, -9.8, 0))
+```
+
+### AnimationGraphComponent — State Machine Animations
+
+```typescript
+import { AnimationGraphComponent } from "@series-inc/rundot-3d-engine/systems"
+
+const config = {
+    parameters: {
+        speed: { type: "float", default: 0 },
+        isGrounded: { type: "bool", default: true },
+    },
+    states: {
+        idle: { animation: "idle" },
+        walk: { animation: "walk" },
+        run: { animation: "run" },
+        locomotion: {
+            tree: {
+                parameter: "speed",
+                children: [
+                    { animation: "idle", threshold: 0 },
+                    { animation: "walk", threshold: 1 },
+                    { animation: "run", threshold: 2 },
+                ],
+            },
+        },
+    },
+    transitions: [
+        { from: "idle", to: "walk", when: { speed: 1 } },
+        { from: "walk", to: "run", when: { speed: 2 } },
+        { from: "attack", to: "idle", exitTime: 1.0 },  // after anim finishes
+    ],
+    initialState: "idle",
+}
+
+const animGraph = new AnimationGraphComponent(model, config)
+character.addComponent(animGraph)
+
+// Drive transitions via parameters
+animGraph.setParameter("speed", 2)
+animGraph.setState("attack")  // direct state change
+animGraph.getCurrentState()
+```
+
+### StowKitSystem — Asset Loading
+
+```typescript
+import { StowKitSystem } from "@series-inc/rundot-3d-engine/systems"
+
+const stowkit = StowKitSystem.getInstance()
+
+// Load from build.json
+await stowkit.loadFromBuildJson(buildJson, {
+    fetchBlob: (path) => fetch(path).then(r => r.blob()),
+})
+
+// Access assets
+const mesh = await stowkit.getMesh("name")       // async
+const mesh = stowkit.getMeshSync("name")          // sync (null if not loaded)
+const tex = await stowkit.getTexture("name")
+const clip = await stowkit.getAnimation("walk", "character_mesh")
+const audio = await stowkit.getAudio("sfx_click")
+const skinned = await stowkit.getSkinnedMesh("character", 1.0)
+
+// Clone with shadow settings
+const clone = await stowkit.cloneMesh("name", castShadow, receiveShadow)
+
+// GPU instancing
+await stowkit.registerMeshForInstancing("coin_batch", "coin_mesh", true, true, 500)
+```
+
+### Other Systems
+
+- **AudioSystem** — 2D/3D positional audio with AudioListener management
+- **InputManager** — keyboard, mouse, touch, and gamepad input
+- **LightingSystem** — directional, point, and spot lights with shadow management
+- **NavigationSystem** — A* pathfinding on navigation meshes
+- **ParticleSystem** — GPU particle effects
+- **TweenSystem** — property animation and easing
+- **UISystem** — HTML-based UI overlay system
+- **PrefabSystem** — load and instantiate prefab hierarchies from JSON
+- **SplineSystem** — Catmull-Rom spline paths for cameras, movement, etc.
+
+## Patterns
+
+### Separation of Concerns
+
+```typescript
+// Logic/physics on parent
+const character = new GameObject("Character")
+character.addComponent(new CharacterController())
+character.addComponent(new RigidBodyComponentThree({ type: RigidBodyType.DYNAMIC, shape: ColliderShape.CAPSULE }))
+
+// Visual as child (can offset independently)
+const visual = new GameObject("Visual")
+visual.addComponent(new SkeletalRenderer("character_mesh"))
+character.add(visual)
+visual.position.y = -1
+```
+
+### Cache Component References
+
+```typescript
+class MyComponent extends Component {
+    private meshRenderer?: MeshRenderer
+
+    protected onCreate(): void {
+        this.meshRenderer = this.getComponent(MeshRenderer) // cache in onCreate
+    }
+
+    public update(deltaTime: number): void {
+        // use cached ref — don't search every frame
+    }
+}
+```
+
+### Factory Pattern
+
+```typescript
+class EnemyFactory {
+    static create(type: string): GameObject {
+        const enemy = new GameObject(`Enemy_${type}`)
+        enemy.addComponent(new EnemyAI())
+        const meshObj = new GameObject("Mesh")
+        meshObj.addComponent(new MeshRenderer(`enemy_${type}`))
+        enemy.add(meshObj)
+        return enemy
+    }
+}
+```
+
+## Common Mistakes
+
+- **Don't create GameObjects in `update()`** — causes memory leaks. Create once, reuse or pool.
+- **Don't access `this.gameObject` in constructor** — use `onCreate()` instead.
+- **Don't forget `dispose()`** — always dispose GameObjects when done.
+- **Don't add multiple components of same type** to one GameObject — use child GameObjects.
+- **Don't call `this.clock.getDelta()`** — use the `deltaTime` parameter.
+- **Don't bypass MeshRenderer** by loading meshes directly from StowKitSystem — use the component pattern.
+
+## Dependencies
+
+- `three` (peer, >=0.180.0)
+- `@dimforge/rapier3d` — Rapier physics engine
+- `@series-inc/stowkit-reader` + `@series-inc/stowkit-three-loader` — asset loading

package/dist/{chunk-UDJVZHS6.js → chunk-WLXQBO3A.js}

@@ -1081,6 +1081,124 @@ import { Preferences } from "@capacitor/preferences";
 import { LocalNotifications } from "@capacitor/local-notifications";
 import { App } from "@capacitor/app";
 import { SplashScreen } from "@capacitor/splash-screen";
+
+// src/platform/datadog-analytics/index.ts
+var OTEL_ENDPOINT = "https://otel.run.game";
+var LOGS_PATH = "/v1/logs";
+function toOtlpValue(v) {
+  if (typeof v === "string") return { stringValue: v };
+  if (typeof v === "number") return Number.isInteger(v) ? { intValue: String(v) } : { doubleValue: v };
+  if (typeof v === "boolean") return { boolValue: v };
+  return { stringValue: String(v) };
+}
+function toOtlpAttributes(data) {
+  return Object.entries(data).map(([key, value]) => ({ key, value: toOtlpValue(value) }));
+}
+function generateSessionId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 11)}`;
+}
+var config = {
+  endpoint: OTEL_ENDPOINT.replace(/\/$/, ""),
+  serviceName: "unknown",
+  serviceVersion: "0.0.0",
+  platform: "web",
+  sessionId: ""
+};
+function init(options) {
+  config.sessionId = generateSessionId();
+  if (options) {
+    if (options.serviceName !== void 0) config.serviceName = options.serviceName;
+    if (options.serviceVersion !== void 0) config.serviceVersion = options.serviceVersion;
+    if (options.platform !== void 0) config.platform = options.platform;
+  }
+}
+function getEndpoint() {
+  if (config.platform === "android" || config.platform === "ios") {
+    return config.endpoint;
+  }
+  if (typeof window !== "undefined") {
+    const host = window.location?.hostname ?? "";
+    if (host === "localhost" || host === "127.0.0.1") {
+      return `${window.location.origin}/api/otel`;
+    }
+  }
+  return config.endpoint;
+}
+function send(attributes, body) {
+  const payload = {
+    resourceLogs: [
+      {
+        resource: {
+          attributes: [
+            { key: "service.name", value: { stringValue: config.serviceName } },
+            { key: "service.version", value: { stringValue: config.serviceVersion } },
+            { key: "log.type", value: { stringValue: "hermes" } }
+          ]
+        },
+        scopeLogs: [
+          {
+            scope: { name: "datadog-analytics", version: "1.0.0" },
+            logRecords: [
+              {
+                timeUnixNano: String(Date.now() * 1e6),
+                severityText: "INFO",
+                severityNumber: 9,
+                body: { stringValue: body },
+                attributes: toOtlpAttributes({
+                  timestamp: Date.now(),
+                  platform: config.platform,
+                  service_name: config.serviceName,
+                  session_id: config.sessionId,
+                  ...attributes
+                })
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  };
+  const url = `${getEndpoint()}${LOGS_PATH}`;
+  return fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload)
+  }).then((res) => {
+    if (!res.ok && typeof console !== "undefined" && console.warn) {
+      console.warn("[DatadogAnalytics] send failed:", res.status, url);
+    }
+    return res.ok;
+  }).catch((err) => {
+    if (typeof console !== "undefined" && console.warn) {
+      console.warn("[DatadogAnalytics] send error:", err);
+    }
+    return false;
+  });
+}
+function trackCustom(params) {
+  const { name, screen, desc, ...rest } = params;
+  return send(
+    { event_type: name, screen_name: screen ?? "", ...desc !== void 0 && { description: desc }, ...rest },
+    name
+  );
+}
+function trackFunnel(params) {
+  const { step, screenName, stepNumber = 0, funnelName = "studio_funnel", ...context } = params;
+  return send(
+    { event_type: "step_funnel", screen_name: screenName, funnel_name: funnelName, step_name: step, step_number: stepNumber, ...context },
+    `step_funnel:${step}`
+  );
+}
+var DatadogAnalytics = {
+  init,
+  trackCustom,
+  trackFunnel
+};
+
+// src/platform/CapacitorPlatform.ts
 var LOG_PREFIX = "[Capacitor]";
 function stringToNotificationId(str) {
   let hash = 0;
@@ -1140,14 +1258,16 @@ var CapacitorPlatform = class {
   };
   // AppsFlyer module (lazy-loaded, only on native)
   appsFlyerModule = null;
-  // Analytics implementation - AppsFlyer on native, console fallback otherwise
+  // Analytics implementation - AppsFlyer + Datadog on native (Capacitor builds), console fallback otherwise
   analytics = {
     trackFunnelStep: (step, name) => {
       console.log(`${LOG_PREFIX} analytics.trackFunnelStep(${step}, "${name}")`);
+      this.sendDatadogFunnel(step, name);
       this.sendAppsFlyerEvent(`funnel_step_${step}`, { af_content: name });
     },
     recordCustomEvent: (eventName, params) => {
       console.log(`${LOG_PREFIX} analytics.recordCustomEvent("${eventName}")`, params);
+      this.sendDatadogCustomEvent(eventName, params ?? {});
       this.sendAppsFlyerEvent(eventName, params ?? {});
     }
   };
@@ -1156,6 +1276,17 @@ var CapacitorPlatform = class {
     this.appsFlyerModule.AppsFlyer.logEvent({ eventName, eventValue }).catch(() => {
     });
   }
+  datadogInitialized = false;
+  sendDatadogFunnel(step, name) {
+    if (!this.datadogInitialized) return;
+    DatadogAnalytics.trackFunnel({ step: name, screenName: name, stepNumber: step }).catch(() => {
+    });
+  }
+  sendDatadogCustomEvent(eventName, params) {
+    if (!this.datadogInitialized) return;
+    DatadogAnalytics.trackCustom({ name: eventName, ...params }).catch(() => {
+    });
+  }
   // Ads implementation
   // TODO: Add @capacitor-community/admob when ready for monetization
   ads = {
@@ -1250,13 +1381,23 @@ var CapacitorPlatform = class {
   // Notifications implementation using @capacitor/local-notifications
   notifications = {
     scheduleAsync: async (title, body, delaySeconds, notificationId) => {
+      if (!Capacitor.isNativePlatform()) {
+        return;
+      }
       const id = notificationId ? stringToNotificationId(notificationId) : Date.now();
       console.log(`${LOG_PREFIX} notifications.scheduleAsync("${title}", "${body}", ${delaySeconds}s, id=${id})`);
       try {
-        const permission = await LocalNotifications.requestPermissions();
-        console.log(`${LOG_PREFIX} notifications: permission status =`, permission.display);
+        const existing = await LocalNotifications.checkPermissions();
+        let permission = existing;
+        if (existing.display !== "granted") {
+          if (existing.display === "denied") {
+            console.log(`${LOG_PREFIX} notifications: permission denied, skipping`);
+            return;
+          }
+          permission = await LocalNotifications.requestPermissions();
+        }
         if (permission.display !== "granted") {
-          console.warn(`${LOG_PREFIX} notifications: permission not granted (${permission.display})`);
+          console.log(`${LOG_PREFIX} notifications: permission not granted (${permission.display})`);
           return;
         }
         await this.ensureNotificationChannel();
@@ -1310,6 +1451,12 @@ var CapacitorPlatform = class {
       this.pauseCallbacks.push(callback);
     }
   };
+  initDatadogAsync() {
+    const platform = Capacitor.getPlatform();
+    DatadogAnalytics.init({ serviceName: "burgertime-capacitor", serviceVersion: "0.0.0", platform });
+    this.datadogInitialized = true;
+    console.log(`${LOG_PREFIX} Datadog analytics: initialized (${platform})`);
+  }
   async initAppsFlyerAsync() {
     console.log(`${LOG_PREFIX} AppsFlyer: initAppsFlyerAsync() called (native platform)`);
     const devKey = import.meta.env?.VITE_APPSFLYER_DEV_KEY;
@@ -1359,6 +1506,7 @@ var CapacitorPlatform = class {
   // Initialize
   async initializeAsync(options) {
     console.log(`${LOG_PREFIX} initializeAsync()`, options);
+    this.initDatadogAsync();
     if (Capacitor.isNativePlatform()) {
       await this.initAppsFlyerAsync();
     }
@@ -5533,6 +5681,8 @@ var StowKitSystem = class _StowKitSystem {
   materialConverter;
   decoderPaths = { ...DEFAULT_DECODER_PATHS };
   fetchBlob;
+  onTimingStart;
+  onTimingEnd;
   // Loaded packs by alias
   packs = /* @__PURE__ */ new Map();
   // Asset caches
@@ -5572,11 +5722,13 @@ var StowKitSystem = class _StowKitSystem {
    * @param config Configuration including material converter and CDN fetch function
    * @returns The loaded PrefabCollection
    */
-  async loadFromBuildJson(buildJson, config) {
-    this.materialConverter = config.materialConverter;
-    this.fetchBlob = config.fetchBlob;
-    if (config.decoderPaths) {
-      this.decoderPaths = { ...DEFAULT_DECODER_PATHS, ...config.decoderPaths };
+  async loadFromBuildJson(buildJson, config2) {
+    this.materialConverter = config2.materialConverter;
+    this.fetchBlob = config2.fetchBlob;
+    this.onTimingStart = config2.onTimingStart;
+    this.onTimingEnd = config2.onTimingEnd;
+    if (config2.decoderPaths) {
+      this.decoderPaths = { ...DEFAULT_DECODER_PATHS, ...config2.decoderPaths };
     }
     const prefabCollection = PrefabCollection.createFromJSON(
       buildJson
@@ -5589,13 +5741,22 @@ var StowKitSystem = class _StowKitSystem {
     await Promise.all(
       mounts.filter((mount) => !this.packs.has(mount.alias)).map(async (mount) => {
         console.log(`[StowKitSystem] Loading pack "${mount.alias}" from ${mount.path}`);
-        const blob = await config.fetchBlob(mount.path);
+        const fetchLabel = `StowKit: fetch - ${mount.alias}`;
+        this.onTimingStart?.(fetchLabel);
+        const blob = await config2.fetchBlob(mount.path);
+        this.onTimingEnd?.(fetchLabel);
+        const arrayBufferLabel = `StowKit: arrayBuffer - ${mount.alias}`;
+        this.onTimingStart?.(arrayBufferLabel);
         const arrayBuffer = await blob.arrayBuffer();
+        this.onTimingEnd?.(arrayBufferLabel);
+        const unpackLabel = `StowKit: unpack - ${mount.alias}`;
+        this.onTimingStart?.(unpackLabel);
         const pack = await StowKitLoader2.loadFromMemory(arrayBuffer, {
           basisPath: this.decoderPaths.basis,
           dracoPath: this.decoderPaths.draco,
           wasmPath: this.decoderPaths.wasm
         });
+        this.onTimingEnd?.(unpackLabel);
         this.packs.set(mount.alias, pack);
       })
     );
@@ -5620,13 +5781,22 @@ var StowKitSystem = class _StowKitSystem {
       throw new Error("StowKitSystem: fetchBlob not configured. Call loadFromBuildJson first.");
     }
     console.log(`[StowKitSystem] Loading pack "${alias}" from ${path}`);
+    const fetchLabel = `StowKit: fetch - ${alias}`;
+    this.onTimingStart?.(fetchLabel);
     const blob = await this.fetchBlob(path);
+    this.onTimingEnd?.(fetchLabel);
+    const arrayBufferLabel = `StowKit: arrayBuffer - ${alias}`;
+    this.onTimingStart?.(arrayBufferLabel);
     const arrayBuffer = await blob.arrayBuffer();
+    this.onTimingEnd?.(arrayBufferLabel);
+    const unpackLabel = `StowKit: unpack - ${alias}`;
+    this.onTimingStart?.(unpackLabel);
     const pack = await StowKitLoader2.loadFromMemory(arrayBuffer, {
       basisPath: this.decoderPaths.basis,
       dracoPath: this.decoderPaths.draco,
       wasmPath: this.decoderPaths.wasm
     });
+    this.onTimingEnd?.(unpackLabel);
     this.packs.set(alias, pack);
     console.log(`[StowKitSystem] Pack "${alias}" loaded`);
   }
@@ -6242,4 +6412,4 @@ export {
   PrefabLoader,
   StowKitSystem
 };
-//# sourceMappingURL=chunk-UDJVZHS6.js.map
+//# sourceMappingURL=chunk-WLXQBO3A.js.map