@ringozz/godot 4.7.2-579 → 4.7.2-585

package/src/runtime.ts

@@ -36,22 +36,31 @@ export const GodotVar = _mod.GodotVar as (new (...args: unknown[]) => GodotVar)
  *  - _C(this,    methodId, ...args)    → instance method
  *  - _C(classId, methodId, ...args)    → static method
  *  - _C(null,    methodId, ...args)    → singleton lookup (_getInstance) or internal
- *  - _C(0xHASHn, methodId, ...args)    → utility function (BigInt carries hash + type metadata)
+ *  - _C(0n,      methodId, ...args)    → utility function (BigInt tags the call;
+ *                                         arg types resolve by name at runtime)
  */
 export const _C = _mod._C as (...args: unknown[]) => unknown;
 
 /** Resolve a string name to its integer handle. */
 export const _S = _mod._S as (name: string) => number;
 
-/** Low-level property getter for value type fields. */
-export const _get = _mod._get as (target: GodotVar, nameId: number) => unknown;
-
-/** Low-level property setter for value type fields. */
-export const _set = _mod._set as (target: GodotVar, nameId: number, val: unknown) => void;
-
 /** Register Godot object wrapper. */
 export const _R = _mod._R as (typeId: number, ctor: Function) => string;
 
+/**
+ * Value-type dispatch on tuple receivers: `_V(typeId, methodId, receiver, ...args)`.
+ * `methodId == SX_valueCtor` constructs (`_V(typeId, ctorSentinel, ctorIndex, ...args)`),
+ * negative ids are operators, non-negative ids are builtin methods.
+ */
+export const _V = _mod._V as (...args: unknown[]) => unknown;
+
+/**
+ * Build a typed value-type Variant for a Variant-typed slot by resolving the
+ * property's type from the node; returns a GodotVar carrier the consuming `_C`
+ * unwraps. Used by react-hooks' useTween (tweenProperty final_val).
+ */
+export const toValueType = _mod.toValueType as (node: GodotVar, propName: string, value: unknown) => unknown;
+
 /** Stage bytes into the web MEMFS (Godot's `copyToFS`); undefined on desktop. */
 export const stageFile = (_mod as any).stageFile as ((path: string, bytes: Uint8Array) => void) | undefined;
 
@@ -64,6 +73,15 @@ export const requestAnimationFrame = _mod.requestAnimationFrame as typeof global
 /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/cancelAnimationFrame) */
 export const cancelAnimationFrame = _mod.cancelAnimationFrame as typeof globalThis.cancelAnimationFrame ?? globalThis.cancelAnimationFrame;
 
+// One-shot callbacks of in-flight `_P` awaits. The connection's JSCallable holds
+// only a weak reference to the callback, so without this the function could be
+// GC'd before the signal fires. A module root is the only retention Bun reliably
+// traces: neither `_P`'s closure cells nor a Set attached to the signal's object
+// wrapper survive a full GC while the await is pending (the await machinery
+// discards the promise `_P` returns, and Bun may collect the emitter's wrapper).
+// Removed as soon as the signal fires or the connect fails.
+const pendingCallbacks = new Set<(...args: any[]) => void>();
+
 /** Make a Signal PromiseLike: connects a one-shot callback that resolves with the args tuple. */
 export function _P(signal: any, onfulfilled?: any, onrejected?: any) {
     return new Promise<any>((resolve, reject) => {
@@ -72,11 +90,16 @@ export function _P(signal: any, onfulfilled?: any, onrejected?: any) {
             return;
         }
         const cb = (...args: any[]) => {
+            pendingCallbacks.delete(cb);
             signal.disconnect(cb);
             resolve(args);
         };
+        pendingCallbacks.add(cb);
         const res = signal.connect(cb);
-        if (res !== 0) reject(new Error('Failed to connect signal: error code ' + res));
+        if (res !== 0) {
+            pendingCallbacks.delete(cb);
+            reject(new Error('Failed to connect signal: error code ' + res));
+        }
     }).then(onfulfilled, onrejected);
 }