TC39 decorators: run Symbol.metadata polyfill before decorated classes in all entry styles

The es6 `pure` entry (and any deep import of a decorated class) crashed at
class-definition time with "Cannot convert undefined or null to object" because
`context.metadata` was `void 0`: TypeScript's TC39 emit computes
`_metadata = Symbol.metadata ? ... : void 0` at the top of the class `static {}`
block, so the metadata bag only exists if `Symbol.metadata` was installed BEFORE
the class module evaluated. The polyfill was only imported by `index.ts` (the
barrel), so the `pure` barrel — which eagerly evaluates every decorated FrameGraph
/ node block without importing the polyfill — always threw.

Fix: anchor the polyfill in the decorator infrastructure that every decorated class
already imports. `decorators.functions.ts` now resolves `Symbol.metadata` into an
exported module-load `const MetadataSymbol` (the idempotent `GetMetadataSymbol()`
already performed the polyfill); ES module evaluation order guarantees this runs
before any importing class body. It is a `const` referenced by the retained
decorator helpers so bundlers treating the module as side-effect-free cannot drop
it, and the tree-shaking side-effect detector skips `const X = ...` initializers so
the module stays pure and remains importable from `.pure` modules — no tooling
policy or `sideEffects` allowlist change required. `nodeDecorator.ts` and the smart
filters `editableInPropertyPage` import that symbol, route their metadata reads
through it, and throw an actionable error instead of a cryptic TypeError if the
polyfill somehow did not run.

Fixes the ES6 visualization "pure" scenes and the resulting Playground snapshot
cascade.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: RaananW

packages/dev/core/src/Decorators/nodeDecorator.ts

@@ -1,5 +1,6 @@
 import { type Nullable } from "../types";
 import { type Scene } from "../scene";
+import { MetadataSymbol } from "../Misc/decorators.functions";
 
 /**
  * Enum defining the type of properties that can be edited in the property pages in the node editor
@@ -108,7 +109,16 @@ export function editableInPropertyPage(
     options?: IEditablePropertyOption
 ) {
     return (_value: unknown, context: { name: string | symbol; metadata: DecoratorMetadataObject }) => {
-        const meta = context.metadata;
+        const meta = context.metadata as DecoratorMetadataObject | undefined;
+        if (!meta) {
+            // `context.metadata` is `void 0` when `Symbol.metadata` was not installed before this class
+            // was evaluated. Importing `MetadataSymbol` from decorators.functions runs the polyfill at
+            // module load (before this class body), so this should never happen; referencing it here also
+            // keeps that module-load polyfill anchored against bundler tree-shaking.
+            throw new Error(
+                `editableInPropertyPage: decorator metadata is unavailable; the Symbol.metadata (${String(MetadataSymbol)}) polyfill must run before decorated classes are evaluated.`
+            );
+        }
         let propStore: IPropertyDescriptionForEdition[];
         if (Object.prototype.hasOwnProperty.call(meta, __bjsPropStoreKey)) {
             propStore = meta[__bjsPropStoreKey] as IPropertyDescriptionForEdition[];
@@ -139,7 +149,7 @@ export const __bjsPropStoreKey = "__bjs_prop_store__";
  */
 export function GetEditableProperties(target: any): IPropertyDescriptionForEdition[] {
     const ctor = typeof target === "function" ? target : target?.constructor;
-    const metadata: DecoratorMetadataObject | undefined = ctor?.[Symbol.metadata];
+    const metadata: DecoratorMetadataObject | undefined = ctor?.[MetadataSymbol];
     if (!metadata) {
         return [];
     }

packages/dev/core/src/Misc/decorators.functions.ts

@@ -35,6 +35,24 @@ function GetMetadataSymbol(): symbol {
     return metadataSymbol;
 }
 
+/**
+ * The well-known `Symbol.metadata` symbol, resolved once at module-evaluation time.
+ *
+ * Reading (and thereby resolving) this symbol at module load guarantees that `Symbol.metadata`
+ * exists BEFORE any decorated class which imports the decorator infrastructure evaluates its class
+ * body. TypeScript's TC39 decorator emit captures `context.metadata` from `Symbol.metadata` at the
+ * top of the class `static {}` block (before the decorator factory runs), so if the symbol is not
+ * yet installed the metadata object is `void 0` and every metadata-based decorator throws.
+ *
+ * It is intentionally an exported `const` initialized from a function call: bundlers that treat this
+ * module as side-effect-free may drop bare top-level calls, but they cannot drop a `const` whose
+ * value is referenced by the retained decorator helpers below. The tree-shaking side-effect detector
+ * likewise skips `const X = ...` initializers, so this module stays classified as pure and remains
+ * importable from `.pure` modules.
+ * @internal
+ */
+export const MetadataSymbol: symbol = GetMetadataSymbol();
+
 // Returns the constructor for the provided decorator/serialization target.
 // Experimental decorators pass a prototype; serialization passes an instance or a constructor.
 function GetConstructor(target: any): any {
@@ -47,17 +65,17 @@ function GetOwnMetadata(ctor: any): any {
     if (!ctor) {
         return undefined;
     }
-    if (!HasOwn(ctor, GetMetadataSymbol())) {
+    if (!HasOwn(ctor, MetadataSymbol)) {
         const parent = Object.getPrototypeOf(ctor);
-        const parentMetadata = parent ? parent[GetMetadataSymbol()] : null;
-        Object.defineProperty(ctor, GetMetadataSymbol(), {
+        const parentMetadata = parent ? parent[MetadataSymbol] : null;
+        Object.defineProperty(ctor, MetadataSymbol, {
             value: Object.create(parentMetadata ?? null),
             configurable: true,
             writable: true,
             enumerable: false,
         });
     }
-    return ctor[GetMetadataSymbol()];
+    return ctor[MetadataSymbol];
 }
 
 /**
@@ -66,6 +84,13 @@ function GetOwnMetadata(ctor: any): any {
  * @internal
  */
 export function GetDirectStoreFromMetadata(metadata: DecoratorMetadataObject): Record<string, any> {
+    if (!metadata) {
+        // `metadata` is `context.metadata`, which is `void 0` when `Symbol.metadata` was not installed
+        // before the class was evaluated. Referencing `MetadataSymbol` here (a) produces an actionable
+        // error instead of a cryptic "Cannot convert undefined to object" and (b) keeps the module-load
+        // polyfill anchored so bundlers cannot tree-shake it away on the decorate-time serialize path.
+        throw new Error(`Decorator metadata is unavailable; the Symbol.metadata (${String(MetadataSymbol)}) polyfill must run before decorated classes are evaluated.`);
+    }
     if (!HasOwn(metadata, __bjsSerializableKey)) {
         (metadata as any)[__bjsSerializableKey] = {};
     }
@@ -90,7 +115,7 @@ export function GetDirectStore(target: any): any {
  */
 export function GetMergedStore(target: any): any {
     const ctor = GetConstructor(target);
-    const metadata = ctor ? ctor[GetMetadataSymbol()] : undefined;
+    const metadata = ctor ? ctor[MetadataSymbol] : undefined;
     if (!metadata) {
         return {};
     }

packages/dev/smartFilters/src/editorUtils/editableInPropertyPage.ts

@@ -1,4 +1,5 @@
 import { type Observable } from "core/Misc/observable.js";
+import { MetadataSymbol } from "core/Misc/decorators.functions.js";
 
 /**
  * Enum defining the type of properties that can be edited in the property pages in the node editor
@@ -97,7 +98,16 @@ export function EditableInPropertyPage(
     options?: IEditablePropertyOption
 ) {
     return (_value: unknown, context: { name: string | symbol; metadata: DecoratorMetadataObject }) => {
-        const meta = context.metadata;
+        const meta = context.metadata as DecoratorMetadataObject | undefined;
+        if (!meta) {
+            // `context.metadata` is `void 0` when `Symbol.metadata` was not installed before this class
+            // was evaluated. Importing `MetadataSymbol` from core runs the polyfill at module load (before
+            // this class body), so this should never happen; referencing it here also keeps that
+            // module-load polyfill anchored against bundler tree-shaking.
+            throw new Error(
+                `EditableInPropertyPage: decorator metadata is unavailable; the Symbol.metadata (${String(MetadataSymbol)}) polyfill must run before decorated classes are evaluated.`
+            );
+        }
         let propStore: IPropertyDescriptionForEdition[];
         if (Object.prototype.hasOwnProperty.call(meta, __bjsSmartFilterPropStoreKey)) {
             propStore = meta[__bjsSmartFilterPropStoreKey] as IPropertyDescriptionForEdition[];
@@ -136,7 +146,7 @@ export function EditableInPropertyPage(
  */
 export function GetSmartFilterEditableProperties(target: any): IPropertyDescriptionForEdition[] {
     const ctor = typeof target === "function" ? target : target?.constructor;
-    const metadata: DecoratorMetadataObject | undefined = ctor?.[Symbol.metadata];
+    const metadata: DecoratorMetadataObject | undefined = ctor?.[MetadataSymbol];
     if (!metadata) {
         return [];
     }