@needle-tools/engine 5.1.0-canary.db0c38f → 5.1.0-canary.e9062c0

package/plugins/vite/dependency-watcher.d.ts

@@ -1,10 +1,10 @@
 /**
- * @param {"build" | "serve"} command
+ * @param {"build" | "serve" | undefined} _command
  * @param {unknown} _config
  * @param {import('../types').userSettings} userSettings
  * @returns {import('vite').Plugin | null}
  */
-export function needleDependencyWatcher(command: "build" | "serve", _config: unknown, userSettings: import("../types").userSettings): import("vite").Plugin | null;
+export function needleDependencyWatcher(_command: "build" | "serve" | undefined, _config: unknown, userSettings: import("../types").userSettings): import("vite").Plugin | null;
 export type PackageJson = {
     dependencies?: Record<string, string>;
     devDependencies?: Record<string, string>;

package/plugins/vite/dependency-watcher.js

@@ -12,14 +12,12 @@ function log(...msg) {
 }
 
 /**
- * @param {"build" | "serve"} command
+ * @param {"build" | "serve" | undefined} _command
  * @param {unknown} _config
  * @param {import('../types').userSettings} userSettings
  * @returns {import('vite').Plugin | null}
  */
-export function needleDependencyWatcher(command, _config, userSettings) {
-    if (command === "build") return null;
-
+export function needleDependencyWatcher(_command, _config, userSettings) {
     if (userSettings?.noDependencyWatcher === true) return null;
 
     const dir = process.cwd();
@@ -28,6 +26,7 @@ export function needleDependencyWatcher(command, _config, userSettings) {
 
     return /** @type {import('vite').Plugin} */ ({
         name: 'needle-dependency-watcher',
+        apply: 'serve',
         /** @param {import('vite').ViteDevServer} server */
         configureServer(server) {
             manageClients(server);

package/plugins/vite/drop.d.ts

@@ -1,7 +1,7 @@
 /** Experimental, allow dropping files from Unity into the running scene.
- * @param {"build" | "serve"} command
+ * @param {"build" | "serve" | undefined} _command
  * @param {import('../types/needleConfig').needleMeta | null | undefined} config
  * @param {import('../types/userconfig.js').userSettings} userSettings
  * @returns {import('vite').Plugin | null | undefined}
  */
-export function needleDrop(command: "build" | "serve", config: import("../types/needleConfig").needleMeta | null | undefined, userSettings: import("../types/userconfig.js").userSettings): import("vite").Plugin | null | undefined;
+export function needleDrop(_command: "build" | "serve" | undefined, config: import("../types/needleConfig").needleMeta | null | undefined, userSettings: import("../types/userconfig.js").userSettings): import("vite").Plugin | null | undefined;

package/plugins/vite/drop.js

@@ -7,18 +7,17 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 /** Experimental, allow dropping files from Unity into the running scene.
- * @param {"build" | "serve"} command
+ * @param {"build" | "serve" | undefined} _command
  * @param {import('../types/needleConfig').needleMeta | null | undefined} config
  * @param {import('../types/userconfig.js').userSettings} userSettings
  * @returns {import('vite').Plugin | null | undefined}
  */
-export function needleDrop(command, config, userSettings) {
-    if (command === "build") return;
-    
+export function needleDrop(_command, config, userSettings) {
     if(userSettings.useDrop !== true) return null;
 
     return {
         name: "needle:drop",
+        apply: 'serve',
         config(/** @type {{ server?: { hmr?: { port?: number } } }} */ viteConfig) {
             if(userSettings)
             if (!viteConfig.server) viteConfig.server = {};

package/plugins/vite/dts-generator.d.ts

@@ -2,6 +2,6 @@
  * @param {"build" | "serve"} _command  Vite command (unused — runs in both modes)
  * @param {import('../types/needleConfig').needleMeta | null | undefined} _config
  * @param {import('../types').userSettings} [_userSettings]
- * @returns {import('vite').Plugin}
+ * @returns {import('vite').Plugin | null}
  */
-export function needleDtsGenerator(_command: "build" | "serve", _config: import("../types/needleConfig").needleMeta | null | undefined, _userSettings?: import("../types").userSettings): import("vite").Plugin;
+export function needleDtsGenerator(_command: "build" | "serve", _config: import("../types/needleConfig").needleMeta | null | undefined, _userSettings?: import("../types").userSettings): import("vite").Plugin | null;

package/plugins/vite/dts-generator.js

@@ -16,12 +16,24 @@
  *   needleDtsGenerator(command, needleConfig, userSettings)
  */
 
-import { join, resolve } from 'path';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, realpathSync } from 'fs';
 import { tryLoadProjectConfig } from './config.js';
 import { generateBindingsDts } from '../dts-generator/index.js';
 import { needleLog } from './logging.js';
 
+// Two dirs up from plugins/vite/ → package root.
+// Use fileURLToPath so %7E and other URL-encoded characters in the path are decoded correctly.
+// realpathSync follows symlinks so the path is stable even in npm link / monorepo setups.
+import { fileURLToPath } from 'url';
+let _packageRoot = /** @type {string | null} */ (null);
+try {
+    _packageRoot = realpathSync(join(dirname(fileURLToPath(import.meta.url)), '..', '..'));
+} catch (_e) {
+    // If we can't resolve the package root (e.g. unusual install layout), the plugin
+    // will silently skip generation rather than crashing the dev server.
+}
+
 /**
  * Ensure `.vscode/settings.json` references the generated `needle-html-data.json`
  * so VS Code provides `data-bind-needle` completions in HTML files automatically.
@@ -60,9 +72,14 @@ function ensureVscodeHtmlCustomData(projectRoot, htmlDataPath) {
  * @param {"build" | "serve"} _command  Vite command (unused — runs in both modes)
  * @param {import('../types/needleConfig').needleMeta | null | undefined} _config
  * @param {import('../types').userSettings} [_userSettings]
- * @returns {import('vite').Plugin}
+ * @returns {import('vite').Plugin | null}
  */
 export function needleDtsGenerator(_command, _config, _userSettings) {
+
+    if(_userSettings?.dts?.enabled === false) {
+        return null;
+    }
+
     let projectRoot = process.cwd();
 
     function resolveCodegenDir() {
@@ -73,7 +90,11 @@ export function needleDtsGenerator(_command, _config, _userSettings) {
     }
 
     function resolveOutputPath() {
-        return join(resolveCodegenDir(), "needle-bindings.d.ts");
+        // Write to a .needle dotfolder at the package root.
+        // Not in the `files` allowlist → never npm-published.
+        // ../../.needle/ from plugins/types/ resolves correctly for both
+        // symlinked (js/package~/) and published (node_modules/@needle-tools/engine/) layouts.
+        return join(/** @type {string} */ (_packageRoot), ".needle", "generated", "needle-bindings.gen.d.ts");
     }
 
     function resolveAssetsDir() {
@@ -86,14 +107,24 @@ export function needleDtsGenerator(_command, _config, _userSettings) {
     /** @type {import('vite').ViteDevServer | undefined} */
     let devServer;
 
-    async function run() {
+    /** @type {Promise<void> | null} */
+    let _runInFlight = null;
+
+    function run() {
+        if (_runInFlight) return _runInFlight;
+        _runInFlight = _doRun().finally(() => { _runInFlight = null; });
+        return _runInFlight;
+    }
+
+    async function _doRun() {
         try {
+            if (!_packageRoot) return;
             const assetsDir = resolveAssetsDir();
             const outputPath = resolveOutputPath();
             const codegenDir = resolveCodegenDir();
             const count = await generateBindingsDts({ assetsDir, outputPath, projectRoot, codegenDir });
-            // Always register HTML custom data — the file is written on every run
-            const htmlDataPath = join(codegenDir, "needle-html-data.json");
+            // HTML custom data sits next to the generated dts in .needle/generated/
+            const htmlDataPath = join(/** @type {string} */ (_packageRoot), ".needle", "generated", "needle-html-data.json");
             ensureVscodeHtmlCustomData(projectRoot, htmlDataPath);
             if (count !== false) {
                 needleLog("needle:dts-generator", `${count} binding(s) → ${outputPath.replace(process.cwd(), ".")}`);
@@ -102,7 +133,7 @@ export function needleDtsGenerator(_command, _config, _userSettings) {
                     hot.send({ type: "full-reload", path: "*" });
                 }
             } else {
-                needleLog("needle:dts-generator", `up-to-date`);
+                needleLog("needle:dts-generator", `up-to-date → ${outputPath.replace(process.cwd(), ".")}`);
             }
         } catch (err) {
             needleLog("needle:dts-generator", "Failed: " + (/** @type {any} */ (err)?.message ?? err));
@@ -118,7 +149,10 @@ export function needleDtsGenerator(_command, _config, _userSettings) {
         },
 
         buildStart() {
-            return run();
+            // In serve mode, the configureServer post-hook runs instead.
+            // Only run here for actual builds (no devServer).
+            if (!devServer) return run();
+            return undefined;
         },
 
         /** @param {import('vite').ViteDevServer} server */

package/plugins/vite/index.d.ts

@@ -19,12 +19,18 @@
  *        ],
  *    }
  * ```
- * @param {"build" | "serve"} command
- * @param {import('../types/needleConfig').needleMeta | null | undefined} config
+ * When used without arguments (e.g. in a SvelteKit `defineConfig({})` plain object),
+ * the command is resolved automatically from Vite's `configResolved` hook.
+ * ```js
+ * // SvelteKit — no command needed:
+ * export default defineConfig({ plugins: [sveltekit(), needlePlugins()] });
+ * ```
+ * @param {"build" | "serve" | undefined} [command]
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} [config]
  * @param {import('../types/index.js').userSettings} [userSettings]
  * @returns {Promise<import('vite').Plugin[]>}
  */
-export function needlePlugins(command: "build" | "serve", config?: import("../types/needleConfig").needleMeta | null | undefined, userSettings?: import("../types/index.js").userSettings): Promise<import("vite").Plugin[]>;
+export function needlePlugins(command?: "build" | "serve" | undefined, config?: import("../types/needleConfig").needleMeta | null | undefined, userSettings?: import("../types/index.js").userSettings): Promise<import("vite").Plugin[]>;
 export { needleAI } from "./ai.js";
 export { needleDtsGenerator } from "./dts-generator.js";
 export { needleAsap } from "./asap.js";

package/plugins/vite/index.js

@@ -116,12 +116,18 @@ const defaultUserSettings = {
  *        ],
  *    }
  * ```
- * @param {"build" | "serve"} command
- * @param {import('../types/needleConfig').needleMeta | null | undefined} config
+ * When used without arguments (e.g. in a SvelteKit `defineConfig({})` plain object),
+ * the command is resolved automatically from Vite's `configResolved` hook.
+ * ```js
+ * // SvelteKit — no command needed:
+ * export default defineConfig({ plugins: [sveltekit(), needlePlugins()] });
+ * ```
+ * @param {"build" | "serve" | undefined} [command]
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} [config]
  * @param {import('../types/index.js').userSettings} [userSettings]
  * @returns {Promise<import('vite').Plugin[]>}
  */
-export async function needlePlugins(command, config = undefined, userSettings = {}) {
+export async function needlePlugins(command = undefined, config = undefined, userSettings = {}) {
 
     if (!config) config = {}
 
@@ -168,14 +174,21 @@ export async function needlePlugins(command, config = undefined, userSettings =
     array.push(await editorConnection(command, config, userSettings, array));
     array.push(needleDependencyWatcher(command, config, userSettings));
 
-    // Ensure the process exits on SIGINT (Ctrl+C) since plugin timers/sockets can keep the event loop alive
-    if (command === "serve") {
+    // Ensure the process exits on SIGINT (Ctrl+C) since plugin timers/sockets can keep the event loop alive.
+    // If command is unknown at call time (e.g. SvelteKit plain defineConfig), defer to configResolved.
+    const registerSigint = () => {
         process.on('SIGINT', () => {
-            // Wait a moment to allow plugins to clean up if needed, then exit
-            setTimeout(() => {
-                console.debug('\nGoodbye!');
-                process.exit();
-            }, 1000);
+            setTimeout(() => { console.debug('\nGoodbye!'); process.exit(); }, 1000);
+        });
+    };
+    if (command === "serve") {
+        registerSigint();
+    } else if (command === undefined) {
+        array.push({
+            name: "needle:sigint",
+            configResolved(config) {
+                if (config.command === "serve") registerSigint();
+            }
         });
     }
 

package/plugins/vite/meta.js

@@ -13,8 +13,7 @@ import { needleGreenBold, needleLog } from './logging.js';
  */
 export function needleMeta(command, config, userSettings) {
 
-    // we can check if this is a build
-    const isBuild = command === 'build';
+    let isBuild = command === 'build';
 
     async function updateConfig() {
         config = await loadConfig();
@@ -25,6 +24,9 @@ export function needleMeta(command, config, userSettings) {
     return {
         // replace meta tags
         name: 'needle:meta',
+        configResolved(resolvedConfig) {
+            isBuild = resolvedConfig.command === 'build';
+        },
         transformIndexHtml: {
             order: 'pre',
             handler(/** @type {string} */ html, /** @type {unknown} */ _ctx) {

package/plugins/vite/poster.d.ts

@@ -1,8 +1,8 @@
 export function getPosterPath(): string;
 /**
- * @param {"build" | "serve"} command
+ * @param {"build" | "serve" | undefined} _command
  * @param {import('../types/needleConfig').needleMeta | null | undefined} config
  * @param {import('../types').userSettings} userSettings
  * @returns {import('vite').Plugin | undefined}
  */
-export function needlePoster(command: "build" | "serve", config: import("../types/needleConfig").needleMeta | null | undefined, userSettings: import("../types").userSettings): import("vite").Plugin | undefined;
+export function needlePoster(_command: "build" | "serve" | undefined, config: import("../types/needleConfig").needleMeta | null | undefined, userSettings: import("../types").userSettings): import("vite").Plugin | undefined;

package/plugins/vite/poster.js

@@ -10,19 +10,17 @@ export function getPosterPath() {
 }
 
 /**
- * @param {"build" | "serve"} command
+ * @param {"build" | "serve" | undefined} _command
  * @param {import('../types/needleConfig').needleMeta | null | undefined} config
  * @param {import('../types').userSettings} userSettings
  * @returns {import('vite').Plugin | undefined}
  */
-export function needlePoster(command, config, userSettings) {
-    // only relevant for local development
-    if (command === 'build') return [];
-
+export function needlePoster(_command, config, userSettings) {
     if (userSettings.noPoster) return;
 
     return {
         name: 'needle:poster',
+        apply: 'serve',
         configureServer(server) {
             const hot = server.hot ?? server.ws;
             hot.on('needle:screenshot', async (data, client) => {

package/plugins/vite/reload.d.ts

@@ -1,7 +1,7 @@
 /**
- * @param {"build" | "serve"} command
+ * @param {"build" | "serve" | undefined} _command
  * @param {import('../types/needleConfig').needleMeta | null} config
  * @param {import('../types').userSettings} userSettings
  * @returns {import('vite').Plugin | undefined}
  */
-export function needleReload(command: "build" | "serve", config: import("../types/needleConfig").needleMeta | null, userSettings: import("../types").userSettings): import("vite").Plugin | undefined;
+export function needleReload(_command: "build" | "serve" | undefined, config: import("../types/needleConfig").needleMeta | null, userSettings: import("../types").userSettings): import("vite").Plugin | undefined;

package/plugins/vite/reload.js

@@ -15,14 +15,12 @@ const filesUsingHotReload = new Set();
 let assetsDirectory = "";
 
 /**
- * @param {"build" | "serve"} command
+ * @param {"build" | "serve" | undefined} _command
  * @param {import('../types/needleConfig').needleMeta | null} config
  * @param {import('../types').userSettings} userSettings
  * @returns {import('vite').Plugin | undefined}
  */
-export function needleReload(command, config, userSettings) {
-    if (command === "build") return undefined;
-
+export function needleReload(_command, config, userSettings) {
     if (userSettings?.noReload === true) return undefined;
 
 
@@ -51,6 +49,7 @@ export function needleReload(command, config, userSettings) {
 
     return {
         name: 'needle:reload',
+        apply: 'serve',
         /** @param {import('vite').UserConfig} config */
         config(config) {
             if (!config.server) config.server = { watch: { ignored: [] } };
@@ -174,7 +173,7 @@ async function handleReload({ file, server, modules: _modules, read, buildDirect
     // meaning if its the first export after the server starts those will not trigger a reload
     // Ignore d.ts
     const shouldCheckIfContentChanged = file.includes("/codegen/") || file.includes("/generated/") || file.endsWith("gen.js");// || file.endsWith(".glb") || file.endsWith(".gltf") || file.endsWith(".bin");
-    if (shouldCheckIfContentChanged && !file.endsWith(".d.ts") && !file.endsWith("needle-html-data.json")) {
+    if (!file.includes("/.svelte-kit/") && !file.endsWith(".d.ts") && !file.endsWith("needle-html-data.json") && shouldCheckIfContentChanged) {
         if (reloadIsScheduled) {
             return [];
         }

package/src/engine/api.ts

@@ -450,4 +450,4 @@ export * from "./xr/api.js"
  * import type { SceneData } from "@needle-tools/engine";
  * type OrbitSettings = SceneData["Camera"]["OrbitControls"];
  */
-export type { SceneData } from "needle:bindings";
+export type { SceneData } from "needle-bindings";

package/src/engine/engine_context.ts

@@ -38,7 +38,7 @@ import { Physics } from './engine_physics.js';
 import { PlayerViewManager } from './engine_playerview.js';
 import { RendererData as SceneLighting } from './engine_scenelighting.js';
 import { getSceneData } from './engine_scenedata.js';
-import type { SceneData } from 'needle:bindings';
+import type { SceneData } from 'needle-bindings';
 import { getTempColor, logHierarchy } from './engine_three_utils.js';
 import { Time } from './engine_time.js';
 import { patchTonemapping } from './engine_tonemapping.js';
@@ -542,8 +542,22 @@ export class Context implements IContext {
 	connection: NetworkConnection;
 	/**  @deprecated AssetDatabase is deprecated */
 	assets: AssetDatabase;
-	/** The main light in the scene */
-	mainLight: ILight | null = null;
+
+	/** All registered lights in the scene, maintained by the Light component */
+	readonly lights: Set<ILight> = new Set();
+
+	/** The brightest registered directional light, or null if none are registered
+	 * @see lights
+	 */
+	get mainLight(): ILight | null {
+		let best: ILight | null = null;
+		for (const light of this.lights) {
+			if (light.type !== "directional") continue;
+			if (!best || light.intensity > best.intensity) best = light;
+		}
+		return best;
+	}
+
 	/** @deprecated Use sceneLighting */
 	get rendererData() { return this.sceneLighting }
 	/** Access the scene lighting manager to control lighting settings in the context */
@@ -858,6 +872,8 @@ export class Context implements IContext {
 		this._onBeforeRenderListeners.clear();
 		this._onAfterRenderListeners.clear();
 
+		this.lights.clear();
+
 		if (!this.isManagedExternally) {
 			if (this.renderer) {
 				this.renderer.renderLists.dispose();

package/src/engine/engine_init.ts

@@ -11,6 +11,8 @@ import { initCameraExtensions } from "./js-extensions/Camera.js";
 import { patchLayers } from "./js-extensions/Layers.js";
 import { initObject3DExtensions } from "./js-extensions/Object3D.js";
 import { initVectorExtensions } from "./js-extensions/Vector.js";
+import { SSR } from "./engine_ssr.js";
+import { initLicense } from "./engine_license.js";
 import { initWebComponents } from "./webcomponents/init.js";
 import { initPhysics } from "./engine_physics_rapier.js";
 import { initXR } from "./xr/init.js";
@@ -28,6 +30,7 @@ let initialized = false;
  */
 export function initEngine() {
     if (initialized) return;
+    if (SSR) return;
     initialized = true;
 
     initWebComponents();
@@ -46,4 +49,5 @@ export function initEngine() {
     initSceneSwitcherAttributes();
     initPhysics();
     initXR();
+    initLicense();
 }

package/src/engine/engine_license.ts

@@ -1,6 +1,3 @@
-import { dof } from "three/src/nodes/TSL.js";
-
-import { isDevEnvironment } from "./debug/index.js";
 import { BUILD_TIME, GENERATOR, PUBLIC_KEY, VERSION } from "./engine_constants.js";
 import { ContextEvent, ContextRegistry } from "./engine_context_registry.js";
 import { onInitialized } from "./engine_lifecycle_api.js";
@@ -8,7 +5,7 @@ import { isLocalNetwork } from "./engine_networking_utils.js";
 import { Context } from "./engine_setup.js";
 import type { IContext } from "./engine_types.js";
 import { getParam } from "./engine_utils.js";
-import { InternalAttributeUtils } from "./engine_utils_attributes.js";
+import { SSR } from "./engine_ssr.js";
 
 const debug = getParam("debuglicense");
 
@@ -90,7 +87,9 @@ export namespace Telemetry {
         });
     }
 
-    onInitialized((ctx => sendPageViewEvent(ctx)), { once: true });
+    export function init() {
+        if(!SSR) onInitialized((ctx => sendPageViewEvent(ctx)), { once: true });
+    }
 
     function sendPageViewEvent(ctx: IContext): Promise<void> | void {
         if (!isAllowed(ctx)) {
@@ -243,11 +242,14 @@ export namespace Telemetry {
 }
 
 
-ContextRegistry.registerCallback(ContextEvent.ContextRegistered, evt => {
-    showLicenseInfo(evt.context);
-    handleForbidden(evt.context);
-    setTimeout(() => sendUsageMessageToAnalyticsBackend(evt.context), 2000);
-});
+export function initLicense() {
+    Telemetry.init();
+    ContextRegistry.registerCallback(ContextEvent.ContextRegistered, evt => {
+        showLicenseInfo(evt.context);
+        handleForbidden(evt.context);
+        setTimeout(() => sendUsageMessageToAnalyticsBackend(evt.context), 2000);
+    });
+}
 
 export let runtimeLicenseCheckPromise: Promise<void> | undefined = undefined;
 let applicationIsForbidden = false;

package/src/engine/engine_lifecycle_functions_internal.ts

@@ -1,5 +1,6 @@
 import { type Context, FrameEvent } from "./engine_context.js";
 import { ContextEvent } from "./engine_context_registry.js";
+import { SSR } from "./engine_ssr.js";
 
 export declare type Event = ContextEvent | FrameEvent;
 
@@ -38,6 +39,12 @@ let methodsWarningCounter = 0;
  * @param evt the event to call the function at
  */
 export function registerFrameEventCallback(cb: LifecycleMethod, evt: Event, opts?: LifecycleMethodOptions) {
+    
+    // Don't register the callback if we are in SSR, because it will never be called and might cause memory leaks
+    if(SSR) {
+        return;
+    }
+
     if (!newMethods.has(evt)) {
         newMethods.set(evt, new Array());
     }

package/src/engine/engine_pmrem.ts

@@ -1,8 +1,8 @@
 import { createLoaders } from "@needle-tools/gltf-progressive";
 import { CubeUVReflectionMapping, EquirectangularRefractionMapping, SRGBColorSpace, Texture, TextureLoader, WebGLRenderer } from "three";
-import { EXRLoader } from "three/examples/jsm/loaders/EXRLoader";
-import { KTX2Loader } from "three/examples/jsm/loaders/KTX2Loader";
-import { RGBELoader } from "three/examples/jsm/loaders/RGBELoader";
+import { EXRLoader } from "three/examples/jsm/loaders/EXRLoader.js";
+import { KTX2Loader } from "three/examples/jsm/loaders/KTX2Loader.js";
+import { RGBELoader } from "three/examples/jsm/loaders/RGBELoader.js";
 
 const running: Map<string, Promise<Texture | null>> = new Map();
 

package/src/engine/engine_scenedata.ts

@@ -1,4 +1,5 @@
-import type { SceneData } from "needle:bindings";
+import type { SceneData } from "needle-bindings";
+export type { SceneData };
 import type { IContext } from "./engine_types.js";
 import { getComponent } from "./engine_components.js";
 import { TypeStore } from "./engine_typestore.js";
@@ -70,36 +71,58 @@ function makeErrorProxy(message: string): object {
     return new Proxy({}, handler);
 }
 
+/**
+ * Returns a proxy for a scene node that exposes `$object`, `$components`,
+ * and child nodes as nested properties.
+ */
+function makeNodeProxy(ctx: IContext, node: import("three").Object3D): object {
+    return new Proxy({}, {
+        get(_t, prop: string) {
+            if (prop === "$object") return node;
+            if (prop === "$components") {
+                return new Proxy({}, {
+                    get(_t2, compName: string) {
+                        if (compName === "then") return undefined;
+                        const ctor = TypeStore.get(compName);
+                        if (!ctor) return makeErrorProxy(`Component type "${compName}" not registered (node "${node.name}")`);
+                        const comp = getComponent(node, ctor);
+                        if (!comp) return makeErrorProxy(`Component "${compName}" not found on node "${node.name}"`);
+                        return comp;
+                    }
+                });
+            }
+            // Child node lookup by name
+            const child = node.children.find(c => c.name === prop) ?? null;
+            if (!child) return makeErrorProxy(`Child "${prop}" not found on node "${node.name}"`);
+            return makeNodeProxy(ctx, child);
+        }
+    });
+}
+
 /**
  * Returns a lazily-resolved proxy typed as {@link SceneData}.
  * The proxy is cached per context — each context gets exactly one instance.
  *
- * Accessing a property traverses the scene graph on demand:
- * - First level  → find Object3D by node name
- * - Second level → getComponent by component name (via TypeStore)
- * - Third level  → read/write a field on the real component instance
- *
- * If a node or component is not found, property accesses log a warning
- * instead of throwing, so chained access never crashes.
+ * Shape mirrors the generated `needle-bindings.gen.d.ts`:
+ *   ctx.sceneData.MyGlb.Camera.$components.OrbitControls.autoRotate = true;
+ *   ctx.sceneData.MyGlb.Camera.$object  // → THREE.Camera
+ *   ctx.sceneData.MyGlb.UI.Button.$components.Button  // → Needle Button component
  *
- * @example
- * ctx.sceneData.Camera.OrbitControls.autoRotate = true;
+ * GLB name is ignored at runtime (scene is already loaded).
+ * Node lookup starts at the scene root.
  */
 export function getSceneData(ctx: IContext): SceneData {
     let proxy = cache.get(ctx);
     if (!proxy) {
         proxy = new Proxy({} as SceneData, {
-            get(_target, nodeName: string) {
+            get(_target, _glbName: string) {
+                // GLB name level — ignored at runtime, return node-name proxy
                 return new Proxy({}, {
-                    get(_target, compName: string) {
+                    get(_target, nodeName: string) {
+                        if (nodeName === "then") return undefined;
                         const node = ctx.scene.getObjectByName(nodeName) ?? null;
                         if (!node) return makeErrorProxy(`Node "${nodeName}" not found in scene`);
-                        if (compName === "$node") return node;
-                        const ctor = TypeStore.get(compName);
-                        if (!ctor) return makeErrorProxy(`Component type "${compName}" not registered (node "${nodeName}")`);
-                        const comp = getComponent(node, ctor);
-                        if (!comp) return makeErrorProxy(`Component "${compName}" not found on node "${nodeName}"`);
-                        return comp;
+                        return makeNodeProxy(ctx, node);
                     }
                 });
             }