@directivegames/genesys.js 3.1.24

package/dist/src/runtime/Utils.js

@@ -0,0 +1,113 @@
+import path from 'path';
+import { BUILT_PROJECT_FOLDER, DEFAULT_EDITOR_SCENE_KEY, DEFAULT_SCENE_KEY, DEFAULT_SCENE_NAME, ENGINE_VERSION_KEY, GAME_PROJECT_FILE_EXT, PROJECT_PATH_PREFIX, SCENE_NAME_EXT } from '../const.js';
+import { AssetPath } from '../storage/storageProvider.js';
+const getSceneFiles = async (storageProvider, forEditor) => {
+    const root = PROJECT_PATH_PREFIX;
+    const result = await storageProvider.listFiles(AssetPath.fromString(root), true);
+    const sceneFiles = result.files.filter(file => {
+        if (forEditor && file.path.includes(BUILT_PROJECT_FOLDER)) {
+            return false; // Skip files in the built project folder for editor
+        }
+        return file.path.endsWith(SCENE_NAME_EXT);
+    });
+    return sceneFiles;
+};
+export const findProjectFileForGame = async (storageProvider) => {
+    const root = PROJECT_PATH_PREFIX;
+    let result;
+    try {
+        // in non-editor environment, we need to include hidden files since they're in .dist
+        result = await storageProvider.listFiles(AssetPath.fromString(root), true /*recursive*/, true /*includeHiddenFiles*/);
+    }
+    catch (error) {
+        console.error('Failed to list files in project root:', root, error);
+        return null;
+    }
+    // Find any .genesys-project file
+    const projectFile = result.files.find(file => file.name.endsWith(GAME_PROJECT_FILE_EXT));
+    return projectFile ? projectFile.path : null;
+};
+/**
+ *
+ * @param storageProvider the storage provider to use
+ * @param forEditor if this is for the editor or the built project
+ * @returns a tuple of the project file path and its content as JSON
+ */
+export const loadProjectSettings = async (storageProvider, projectFilePath) => {
+    const projectFile = projectFilePath;
+    if (!projectFile) {
+        console.log('loadProjectSettings is not provided a project file');
+        return [null, {}];
+    }
+    let projectSettings = {};
+    if (projectFile) {
+        console.log('loadProjectSettings found projectFile:', projectFile);
+        try {
+            // Load the project file as JSON
+            const data = await storageProvider.downloadFileAsJson(AssetPath.fromString(projectFile));
+            projectSettings = data;
+        }
+        catch (error) {
+            console.warn('Failed to load project file:', projectFile, error);
+        }
+    }
+    return [projectFile, projectSettings];
+};
+export async function getProjectEngineVersion(storageProvider, projectFilePath) {
+    const [_, projectSettings] = await loadProjectSettings(storageProvider, projectFilePath);
+    return projectSettings[ENGINE_VERSION_KEY] ?? null;
+}
+export const getStartupScene = async (storageProvider, options) => {
+    try {
+        const forEditor = options.forEditor;
+        // Step 1: Look for .genesys-project file in the project root
+        const [projectFile, projectSettings] = await loadProjectSettings(storageProvider, options.projectFilePath);
+        if (projectFile) {
+            console.log('getStartupScene found project file:', projectFile, 'with settings:', projectSettings);
+            // Check if it has a defaultScene field
+            const configKey = forEditor ? DEFAULT_EDITOR_SCENE_KEY : DEFAULT_SCENE_KEY;
+            if (projectSettings && typeof projectSettings === 'object' && configKey in projectSettings) {
+                const defaultScenePath = path.join(path.dirname(projectFile), projectSettings[configKey]);
+                // Verify that the scene file actually exists
+                if (await storageProvider.exists(AssetPath.fromString(defaultScenePath))) {
+                    console.log('getStartupScene found startup scene from project file:', defaultScenePath);
+                    return defaultScenePath;
+                }
+            }
+        }
+        else {
+            console.log('getStartupScene found no project file');
+        }
+        // Step 2: Fallback to default scene file
+        const root = PROJECT_PATH_PREFIX;
+        const defaultScenePath = path.join(root, DEFAULT_SCENE_NAME);
+        console.log('getStartupScene checking default scene path:', defaultScenePath);
+        if (await storageProvider.exists(AssetPath.fromString(defaultScenePath))) {
+            return defaultScenePath;
+        }
+        const legacyDefaultScenePath = path.join(root, 'default.scene.json');
+        console.log('getStartupScene checking legacy default scene path:', legacyDefaultScenePath);
+        if (await storageProvider.exists(AssetPath.fromString(legacyDefaultScenePath))) {
+            return legacyDefaultScenePath;
+        }
+        console.log(`getStartupScene default scene not found: ${defaultScenePath} or ${legacyDefaultScenePath}. opening the latest scene file`);
+        // Step 3: Fallback to the latest scene file
+        const sceneFiles = await getSceneFiles(storageProvider, forEditor);
+        if (sceneFiles.length === 0) {
+            return null; // No scene files found
+        }
+        // Sort by modification time to get the latest one
+        // Note: FileItem has modifiedTime property
+        const sortedSceneFiles = sceneFiles.sort((a, b) => {
+            const aTime = a.modifiedTime ? new Date(a.modifiedTime).getTime() : 0;
+            const bTime = b.modifiedTime ? new Date(b.modifiedTime).getTime() : 0;
+            return bTime - aTime; // Sort in descending order (latest first)
+        });
+        return sortedSceneFiles[0].path;
+    }
+    catch (error) {
+        console.error('Failed to determine startup scene:', error);
+        return null;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/runtime/index.d.ts

@@ -0,0 +1,4 @@
+export * from './materials/index.js';
+export * from './GameRuntime.js';
+export * from './InjectedDependencies.js';
+export * from './Utils.js';

package/dist/src/runtime/index.js

@@ -0,0 +1,5 @@
+export * from './materials/index.js';
+export * from './GameRuntime.js';
+export * from './InjectedDependencies.js';
+export * from './Utils.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcnVudGltZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLFlBQVksQ0FBQyJ9

package/dist/src/runtime/materials/MatcapShaderMaterial.d.ts

@@ -0,0 +1,23 @@
+import * as THREE from 'three';
+import { ISerializableObjectTag } from '../../utils/serialization/serializable.js';
+import type { WorldSerializationContext } from '../../systems/WorldSerialization.js';
+import type { Dumper, Loader } from '../../utils/serialization/serializer.js';
+export interface MatcapParams {
+    matcap: THREE.Texture;
+    uRevealProgress?: number;
+    uIndirectDistanceAmplitude?: number;
+    uIndirectDistanceStrength?: number;
+    uIndirectDistancePower?: number;
+    uIndirectAngleStrength?: number;
+    uIndirectAngleOffset?: number;
+    uIndirectAnglePower?: number;
+    uIndirectColor?: THREE.Color | string | number;
+    name?: string;
+}
+export declare class MatcapShaderMaterial extends THREE.ShaderMaterial {
+    readonly [ISerializableObjectTag] = true;
+    constructor(params: MatcapParams);
+    export(context: WorldSerializationContext, includeDefaults: boolean): any;
+    serialize(dumper: Dumper): void;
+    deserialize(loader: Loader): void;
+}

package/dist/src/runtime/materials/MatcapShaderMaterial.js

@@ -0,0 +1,235 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var _a;
+import * as THREE from 'three';
+import { ClassRegistry, EngineClass } from '../../systems/ClassRegistry.js';
+import { ISerializableObjectTag } from '../../utils/serialization/serializable.js';
+const vertexShader = `
+#define MATCAP
+varying vec3 vViewPosition;
+#ifndef FLAT_SHADED
+  varying vec3 vNormal;
+#endif
+#include <common>
+#include <uv_pars_vertex>
+#include <displacementmap_pars_vertex>
+#include <fog_pars_vertex>
+#include <morphtarget_pars_vertex>
+#include <skinning_pars_vertex>
+#include <logdepthbuf_pars_vertex>
+#include <clipping_planes_pars_vertex>
+
+uniform float uRevealProgress;
+uniform float uEnableReveal;
+varying vec3 vWorldPosition;
+
+void main() {
+  #include <uv_vertex>
+  #include <beginnormal_vertex>
+  #include <morphnormal_vertex>
+  #include <skinbase_vertex>
+  #include <skinnormal_vertex>
+  #include <defaultnormal_vertex>
+  #ifndef FLAT_SHADED
+    vNormal = normalize( transformedNormal );
+  #endif
+  #include <begin_vertex>
+  #include <morphtarget_vertex>
+  #include <skinning_vertex>
+  #include <displacementmap_vertex>
+
+  vec4 worldPosition = modelMatrix * vec4(transformed, 1.0);
+
+  // Reveal (Y-up)
+  if(uEnableReveal > 0.5) {
+    float distanceToCenter = length(worldPosition.xyz);
+    float yAmplitude = 3.2;
+    float revealProgress = (uRevealProgress - distanceToCenter / 30.0) * 5.0;
+    revealProgress = 1.0 - clamp(revealProgress, -0.1, 1.0);
+    revealProgress = pow(revealProgress, 2.0);
+    if(uRevealProgress > 0.99) { revealProgress = 0.0; }
+    worldPosition.y -= revealProgress * yAmplitude;
+  }
+
+  vWorldPosition = worldPosition.xyz;
+  vec4 mvPosition = viewMatrix * worldPosition;
+  gl_Position = projectionMatrix * mvPosition;
+
+  #include <logdepthbuf_vertex>
+  #include <clipping_planes_vertex>
+  #include <fog_vertex>
+
+  vViewPosition = - mvPosition.xyz;
+}
+`;
+const fragmentShader = `
+#define MATCAP
+uniform vec3 diffuse;
+uniform float opacity;
+uniform sampler2D matcap;
+varying vec3 vViewPosition;
+#ifndef FLAT_SHADED
+  varying vec3 vNormal;
+#endif
+#include <common>
+#include <uv_pars_fragment>
+#include <map_pars_fragment>
+#include <alphamap_pars_fragment>
+#include <fog_pars_fragment>
+#include <bumpmap_pars_fragment>
+#include <normalmap_pars_fragment>
+#include <logdepthbuf_pars_fragment>
+#include <clipping_planes_pars_fragment>
+
+uniform float uIndirectDistanceAmplitude;
+uniform float uIndirectDistanceStrength;
+uniform float uIndirectDistancePower;
+uniform float uIndirectAngleStrength;
+uniform float uIndirectAngleOffset;
+uniform float uIndirectAnglePower;
+uniform vec3 uIndirectColor;
+uniform float uClipBelowGround;
+uniform float uGroundY;
+varying vec3 vWorldPosition;
+
+void main() {
+  // Optional discard below ground (Y-up)
+  if(uClipBelowGround > 0.5 && vWorldPosition.y < uGroundY) { discard; }
+  #include <clipping_planes_fragment>
+
+  vec4 diffuseColor = vec4(diffuse, opacity);
+  #include <logdepthbuf_fragment>
+  #include <map_fragment>
+  #include <alphamap_fragment>
+  #include <alphatest_fragment>
+  #include <normal_fragment_begin>
+  #include <normal_fragment_maps>
+
+  vec3 viewDir = normalize( vViewPosition );
+  vec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );
+  vec3 y = cross( viewDir, x );
+  vec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;
+
+  vec4 matcapColor = texture2D( matcap, uv );
+  vec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;
+
+  // Indirect/bounce light: distance above ground (uGroundY) and angle toward -Y
+  float distAboveGround = vWorldPosition.y - uGroundY;
+  float indirectDistanceStrength = clamp(1.0 - distAboveGround / uIndirectDistanceAmplitude, 0.0, 1.0) * uIndirectDistanceStrength;
+  indirectDistanceStrength = pow(indirectDistanceStrength, uIndirectDistancePower);
+  indirectDistanceStrength = clamp(indirectDistanceStrength, 0.0, 1.0);
+
+  vec3 worldNormal = inverseTransformDirection(vNormal, viewMatrix);
+  float indirectAngleStrength = dot(normalize(worldNormal), vec3(0.0, -1.0, 0.0)) + uIndirectAngleOffset;
+  indirectAngleStrength = clamp(indirectAngleStrength * uIndirectAngleStrength, 0.0, 1.0);
+  indirectAngleStrength = pow(indirectAngleStrength, uIndirectAnglePower);
+
+  float indirectStrength = indirectDistanceStrength * indirectAngleStrength;
+
+  gl_FragColor = vec4(mix(outgoingLight, uIndirectColor, indirectStrength), diffuseColor.a);
+  #include <opaque_fragment>
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+  #include <fog_fragment>
+  #include <premultiplied_alpha_fragment>
+  #include <dithering_fragment>
+}
+`;
+let MatcapShaderMaterial = class MatcapShaderMaterial extends THREE.ShaderMaterial {
+    constructor(params) {
+        const uniforms = {
+            ...THREE.UniformsLib.common,
+            ...THREE.UniformsLib.bumpmap,
+            ...THREE.UniformsLib.normalmap,
+            ...THREE.UniformsLib.displacementmap,
+            ...THREE.UniformsLib.fog,
+            matcap: { value: params.matcap },
+            uRevealProgress: { value: params.uRevealProgress ?? 1.0 },
+            uEnableReveal: { value: 0.0 },
+            uIndirectDistanceAmplitude: { value: params.uIndirectDistanceAmplitude ?? 1.75 },
+            uIndirectDistanceStrength: { value: params.uIndirectDistanceStrength ?? 0.5 },
+            uIndirectDistancePower: { value: params.uIndirectDistancePower ?? 2.0 },
+            uIndirectAngleStrength: { value: params.uIndirectAngleStrength ?? 1.5 },
+            uIndirectAngleOffset: { value: params.uIndirectAngleOffset ?? 0.6 },
+            uIndirectAnglePower: { value: params.uIndirectAnglePower ?? 1.0 },
+            uIndirectColor: { value: new THREE.Color(params.uIndirectColor ?? '#d04500') },
+            uClipBelowGround: { value: 0.0 },
+            uGroundY: { value: 0.0 }
+        };
+        super({
+            name: params.name ?? 'MatcapShaderMaterial',
+            uniforms,
+            defines: { MATCAP: '' },
+            lights: false,
+            transparent: false,
+            vertexShader,
+            fragmentShader,
+        });
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        // Matcap textures are usually authored in sRGB and not flipped
+        if (params.matcap) {
+            params.matcap.colorSpace = THREE.SRGBColorSpace;
+            params.matcap.flipY = false;
+        }
+    }
+    export(context, includeDefaults) {
+        // Emit a compact ctor suitable for .material.json
+        return {
+            class: ClassRegistry.getClassNameChecked(this),
+            uuid: this.uuid,
+            ctor: {
+                name: this.name,
+                matcap: this.uniforms.matcap?.value?.export ? this.uniforms.matcap.value : undefined,
+                uRevealProgress: this.uniforms.uRevealProgress?.value,
+                uIndirectDistanceAmplitude: this.uniforms.uIndirectDistanceAmplitude?.value,
+                uIndirectDistanceStrength: this.uniforms.uIndirectDistanceStrength?.value,
+                uIndirectDistancePower: this.uniforms.uIndirectDistancePower?.value,
+                uIndirectAngleStrength: this.uniforms.uIndirectAngleStrength?.value,
+                uIndirectAngleOffset: this.uniforms.uIndirectAngleOffset?.value,
+                uIndirectAnglePower: this.uniforms.uIndirectAnglePower?.value,
+                uIndirectColor: this.uniforms.uIndirectColor?.value?.getHexString ? `#${this.uniforms.uIndirectColor.value.getHexString()}` : this.uniforms.uIndirectColor?.value,
+            }
+        };
+    }
+    serialize(dumper) {
+        dumper.dumpValue('$uuid', this.uuid);
+        dumper.dumpCtorArgs([{
+                value: {
+                    uname: this.name,
+                    matcap: this.uniforms.matcap?.value,
+                    uRevealProgress: this.uniforms.uRevealProgress?.value,
+                    uIndirectDistanceAmplitude: this.uniforms.uIndirectDistanceAmplitude?.value,
+                    uIndirectDistanceStrength: this.uniforms.uIndirectDistanceStrength?.value,
+                    uIndirectDistancePower: this.uniforms.uIndirectDistancePower?.value,
+                    uIndirectAngleStrength: this.uniforms.uIndirectAngleStrength?.value,
+                    uIndirectAngleOffset: this.uniforms.uIndirectAngleOffset?.value,
+                    uIndirectAnglePower: this.uniforms.uIndirectAnglePower?.value,
+                    uIndirectColor: this.uniforms.uIndirectColor?.value?.getHexString ? `#${this.uniforms.uIndirectColor.value.getHexString()}` : this.uniforms.uIndirectColor?.value,
+                }
+            }]);
+        dumper.dumpProperties(this);
+    }
+    deserialize(loader) {
+        this.uuid = loader.loadValue('$uuid') ?? this.uuid;
+        loader.loadProperties(this);
+    }
+};
+_a = ISerializableObjectTag;
+MatcapShaderMaterial = __decorate([
+    EngineClass('MatcapShaderMaterial'),
+    __metadata("design:paramtypes", [Object])
+], MatcapShaderMaterial);
+export { MatcapShaderMaterial };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/runtime/materials/index.d.ts

@@ -0,0 +1 @@
+export * from './MatcapShaderMaterial.js';

package/dist/src/runtime/materials/index.js

@@ -0,0 +1,2 @@
+export * from './MatcapShaderMaterial.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcnVudGltZS9tYXRlcmlhbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQyJ9

package/dist/src/scripting/Plugin.d.ts

@@ -0,0 +1,64 @@
+import type { World } from '../game/World.js';
+/**
+ * Interface for Genesys plugins that extend the engine's functionality.
+ *
+ * Plugins are dynamically loaded TypeScript/JavaScript modules that can:
+ * - Add custom game logic and behaviors
+ * - Extend existing systems
+ * - Manage their own state and lifecycle
+ * - Integrate with the engine's world and component system
+ *
+ * @example
+ * ```typescript
+ * // Minimal plugin example
+ * import * as ENGINE from '@directivegames/genesys.js';
+ *
+ * export default class MyPlugin implements ENGINE.IPlugin {
+ *   private world: World;
+ *   private gameData = { score: 0 };
+ *
+ *   async init(world: World, previousState?: any): Promise<boolean> {
+ *     this.world = world;
+ *
+ *     // Restore previous state if available
+ *     if (previousState) {
+ *       this.gameData = previousState;
+ *     }
+ *
+ *     console.log('MyPlugin initialized with score:', this.gameData.score);
+ *     return true; // Success
+ *   }
+ *
+ *   async dispose(): Promise<void> {
+ *     console.log('MyPlugin disposed');
+ *     // Clean up resources, remove event listeners, etc.
+ *   }
+ *
+ *   saveState(): any {
+ *     // Return serializable state to persist between plugin reloads
+ *     return this.gameData;
+ *   }
+ * }
+ * ```
+ */
+export interface IPlugin {
+    /**
+     * Initialize the plugin with access to the game world.
+     *
+     * @param world - The main game world instance
+     * @param previousState - Optional state from a previous plugin instance
+     * @returns Promise<boolean> - true if initialization succeeded, false otherwise
+     */
+    init(world: World, previousState?: any): Promise<boolean>;
+    /**
+     * Clean up plugin resources when unloading.
+     * Called automatically when the plugin is unloaded or replaced.
+     */
+    dispose(): Promise<void>;
+    /**
+     * Save plugin state for persistence across reloads.
+     *
+     * @returns Serializable state object that will be passed to init() on reload
+     */
+    saveState(): any;
+}

package/dist/src/scripting/Plugin.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NjcmlwdGluZy9QbHVnaW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/src/scripting/PluginManager.d.ts

@@ -0,0 +1,40 @@
+import type { IPlugin } from './Plugin.js';
+import type { World } from '../game/World.js';
+/**
+ * Manages the loading, unloading, and lifecycle of plugins in the Genesys engine.
+ *
+ * The PluginManager provides dynamic code execution capabilities, allowing plugins
+ * to be loaded from TypeScript/JavaScript source code at runtime. It handles:
+ * - Compilation of plugin source code
+ * - Plugin instantiation and initialization
+ * - State persistence across plugin reloads
+ * - Safe disposal of plugin resources
+ */
+export declare class PluginManager {
+    private userCodeEngine;
+    private world;
+    private plugins;
+    private pluginStates;
+    /**
+     * Create a new PluginManager instance.
+     *
+     * @param world - WeakRef to the game world to prevent circular references
+     */
+    constructor(world: WeakRef<World>);
+    /**
+     * Load and initialize a plugin from TypeScript/JavaScript source code.
+     *
+     * @param name - Unique identifier for the plugin
+     * @param code - TypeScript/JavaScript source code implementing IPlugin interface
+     * @param loadPreviousState - Whether to restore the plugin's previous state
+     * @returns The loaded plugin instance, or null if loading failed
+     */
+    loadPlugin(name: string, code: string, loadPreviousState: boolean): Promise<IPlugin | null>;
+    /**
+     * Unload a plugin, saving its state and cleaning up resources.
+     *
+     * @param name - Name of the plugin to unload
+     */
+    unloadPlugin(name: string): Promise<void>;
+    private wrapInSandbox;
+}

package/dist/src/scripting/PluginManager.js

@@ -0,0 +1,111 @@
+import { UserCodeEngine } from '../utils/UserCodeEngine.js';
+/**
+ * Manages the loading, unloading, and lifecycle of plugins in the Genesys engine.
+ *
+ * The PluginManager provides dynamic code execution capabilities, allowing plugins
+ * to be loaded from TypeScript/JavaScript source code at runtime. It handles:
+ * - Compilation of plugin source code
+ * - Plugin instantiation and initialization
+ * - State persistence across plugin reloads
+ * - Safe disposal of plugin resources
+ */
+export class PluginManager {
+    /**
+     * Create a new PluginManager instance.
+     *
+     * @param world - WeakRef to the game world to prevent circular references
+     */
+    constructor(world) {
+        Object.defineProperty(this, "userCodeEngine", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new UserCodeEngine()
+        });
+        Object.defineProperty(this, "world", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "plugins", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "pluginStates", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        this.world = world;
+        this.userCodeEngine.initialize();
+    }
+    /**
+     * Load and initialize a plugin from TypeScript/JavaScript source code.
+     *
+     * @param name - Unique identifier for the plugin
+     * @param code - TypeScript/JavaScript source code implementing IPlugin interface
+     * @param loadPreviousState - Whether to restore the plugin's previous state
+     * @returns The loaded plugin instance, or null if loading failed
+     */
+    async loadPlugin(name, code, loadPreviousState) {
+        this.unloadPlugin(name);
+        const result = await this.userCodeEngine.compile(this.wrapInSandbox(code));
+        if (result.errors.length > 0) {
+            console.error('Compilation errors:', result.errors);
+            return null;
+        }
+        const module = await this.userCodeEngine.import(result);
+        const pluginClass = module.default;
+        if (!pluginClass) {
+            console.error('Plugin class not found');
+            return null;
+        }
+        try {
+            const plugin = new pluginClass();
+            if (await plugin.init(this.world.deref(), loadPreviousState ? this.pluginStates[name] : undefined)) {
+                this.plugins[name] = plugin;
+                return plugin;
+            }
+            else {
+                console.error(`Failed to initialize ${name} plugin.`);
+                return null;
+            }
+        }
+        catch (error) {
+            console.error('Error initializing plugin:', error);
+            return null;
+        }
+    }
+    /**
+     * Unload a plugin, saving its state and cleaning up resources.
+     *
+     * @param name - Name of the plugin to unload
+     */
+    async unloadPlugin(name) {
+        this.pluginStates[name] = this.plugins[name]?.saveState();
+        this.plugins[name]?.dispose();
+        delete this.plugins[name];
+    }
+    wrapInSandbox(code) {
+        return `
+            "use strict";
+
+            // Disable dangerous globals
+            const window = undefined;
+            const document = undefined;
+            // const eval = undefined;
+            const Function = undefined;
+            const require = undefined;
+            const process = undefined;
+            const global = undefined;
+            const globalThis = undefined;
+
+            ${code}
+        `;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/scripting/index.d.ts

@@ -0,0 +1 @@
+export * from './Plugin.js';

package/dist/src/scripting/index.js

@@ -0,0 +1,2 @@
+export * from './Plugin.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2NyaXB0aW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsYUFBYSxDQUFDIn0=

package/dist/src/storage/defaultStorageProvider.d.ts

@@ -0,0 +1,15 @@
+import type { AssetPath, FileListResult, FileUploadOptions, IStorageProvider } from './storageProvider.js';
+export declare class DefaultStorageProvider implements IStorageProvider {
+    resolvePath(path: AssetPath, expiry?: number): Promise<AssetPath>;
+    downloadFileAsBuffer(path: AssetPath): Promise<ArrayBuffer>;
+    downloadFileAsJson<T>(path: AssetPath): Promise<T>;
+    downloadFileAsText(path: AssetPath): Promise<string>;
+    uploadFile(path: AssetPath, content: Blob | File | string | ArrayBuffer, options?: FileUploadOptions): Promise<{
+        path: string;
+        name: string;
+    }>;
+    listFiles(path: AssetPath, recursive?: boolean, includeHiddenFiles?: boolean): Promise<FileListResult>;
+    exists(path: AssetPath): Promise<boolean>;
+    buildCurrentProject(runTsc: boolean): Promise<boolean>;
+    protected checkResponse(path: AssetPath, response: Response): void;
+}