@aelionsdk/render-ir 1.2.0 → 2.0.0

package/README.md

@@ -9,7 +9,7 @@ evaluation for AelionSDK.
 npm install @aelionsdk/render-ir
 ```
 
-`latest` currently resolves to `1.2.0`. Product applications should use
+`latest` currently resolves to `2.0.0`. Product applications should use
 `@aelionsdk/sdk`; direct use is for custom renderers, exporters and engine
 instrumentation.
 

package/dist/compiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAGnB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAaV,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAsepB,qBAAa,yBAAyB;;IAcpC;;;;OAIG;IACI,IAAI,IAAI,yBAAyB;IAcxC,4EAA4E;IACrE,KAAK,IAAI,IAAI;IAOb,OAAO,CACZ,OAAO,EAAE,aAAa,EACtB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,uBAAuB,GACnB,oBAAoB,GACpB,mBAAmB,CAAC,OAAO,CAAC,CAAC,gBAAgB,CAAM,GACtD,mBAAmB;CAoOvB"}
+{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAqC,MAAM,2BAA2B,CAAC;AAGlG,OAAO,KAAK,EAaV,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAkgBpB,qBAAa,yBAAyB;;IAcpC;;;;OAIG;IACI,IAAI,IAAI,yBAAyB;IAcxC,4EAA4E;IACrE,KAAK,IAAI,IAAI;IAOb,OAAO,CACZ,OAAO,EAAE,aAAa,EACtB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,uBAAuB,GACnB,oBAAoB,GACpB,mBAAmB,CAAC,OAAO,CAAC,CAAC,gBAAgB,CAAM,GACtD,mBAAmB;CAyOvB"}

package/dist/compiler.js

@@ -1,4 +1,4 @@
-import { canonicalStringify, } from '@aelionsdk/project-schema';
+import {} from '@aelionsdk/project-schema';
 /**
  * Objects `deepFreezePlain` has already frozen, along with everything beneath
  * them.
@@ -24,6 +24,8 @@ const COMPILABLE_ITEM_TYPES = new Set([
     'shape',
     'material-content',
     'adjustment',
+    // Compiles to no clip at all; see the Gap branch in the Track loop below.
+    'gap',
 ]);
 function deepFreezePlain(value, seen = new WeakSet()) {
     if (value === null || typeof value !== 'object')
@@ -32,12 +34,23 @@ function deepFreezePlain(value, seen = new WeakSet()) {
         return value;
     if (seen.has(value))
         return value;
-    const prototype = Object.getPrototypeOf(value);
-    if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null)
-        return value;
-    seen.add(value);
-    for (const entry of Object.values(value))
-        deepFreezePlain(entry, seen);
+    if (Array.isArray(value)) {
+        seen.add(value);
+        for (const entry of value)
+            deepFreezePlain(entry, seen);
+    }
+    else {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null)
+            return value;
+        seen.add(value);
+        // `for...in` over a plain object walks V8's enumeration cache without
+        // materializing a key or value array for every node in the IR, which at a
+        // thousand clips is tens of thousands of throwaway arrays per compile.
+        for (const key in value) {
+            deepFreezePlain(value[key], seen);
+        }
+    }
     // Recorded only after the whole subtree is frozen, so membership never
     // promises more than has actually been done.
     deepFrozen.add(value);
@@ -216,22 +229,37 @@ function nestedSequenceSource(item) {
         boundary: boundary,
     };
 }
+/**
+ * Serializes a value for fingerprint comparison.
+ *
+ * A fingerprint is only ever compared against the fingerprint the previous
+ * compile recorded for the same entity, so it needs one property: two entities
+ * that differ must serialize differently. Canonical ordering buys the stronger
+ * property that two *equal* entities always agree even if their keys were
+ * written in a different order -- which here would at worst cause a recompile
+ * that produces the same clip, and costs a hand-written walk over every value
+ * in the Sequence to avoid. `JSON.stringify` is exact for the plain JSON an
+ * admitted Project contains, and the engine runs it natively.
+ */
+function fingerprintOf(value) {
+    return JSON.stringify(value);
+}
 function clipFingerprint(item, materials, assets) {
     const source = object(item.source ?? {}, `item ${item.id}.source`);
     const sourceAssetId = typeof source.assetId === 'string' ? source.assetId : undefined;
     const sourceAsset = sourceAssetId === undefined ? undefined : assets[sourceAssetId];
     return [
-        canonicalStringify(item),
+        fingerprintOf(item),
         ...(sourceAsset?.kind === 'image-sequence'
-            ? [canonicalStringify(sourceAsset.imageSequence ?? null)]
+            ? [fingerprintOf(sourceAsset.imageSequence ?? null)]
             : []),
         ...item.materialInstanceIds.map(id => materialFingerprint(materials[id])),
     ].join('|');
 }
 function materialFingerprint(instance) {
     if (instance === undefined)
-        return canonicalStringify(null);
-    return canonicalStringify({
+        return 'null';
+    return fingerprintOf({
         id: instance.id,
         definition: {
             packageId: instance.definition.packageId,
@@ -450,7 +478,7 @@ export class IncrementalRenderCompiler {
     /**
      * Track fingerprints keyed by the source track object.
      *
-     * A track fingerprint is `canonicalStringify(track)`, and a track carries every
+     * A track fingerprint serializes the whole Track, and a Track carries every
      * item id on it, so recomputing it for a thousand-clip track dominated the cost
      * of an incremental compile even when nothing on that track changed. Commits
      * share structure: editing one item leaves every untouched track at the same
@@ -471,7 +499,7 @@ export class IncrementalRenderCompiler {
         const cached = this.#trackFingerprints.get(track);
         if (cached !== undefined)
             return cached;
-        const fingerprint = canonicalStringify(track);
+        const fingerprint = fingerprintOf(track);
         this.#trackFingerprints.set(track, fingerprint);
         return fingerprint;
     }
@@ -525,6 +553,12 @@ export class IncrementalRenderCompiler {
                     if (!COMPILABLE_ITEM_TYPES.has(item.type)) {
                         throw new TypeError(`Render IR cannot compile item type ${item.type}`);
                     }
+                    // A Gap is time and nothing else. It still lengthens the Sequence,
+                    // because `contentDuration` reads the Project rather than the clip
+                    // list, but it produces no clip for the renderer or the mixer to
+                    // consider.
+                    if (item.type === 'gap')
+                        continue;
                     const previous = previousClips.get(itemId);
                     if (canReuseByEntity &&
                         previous !== undefined &&
@@ -576,7 +610,7 @@ export class IncrementalRenderCompiler {
                     materialInstanceId: value.materialInstanceId,
                     dependencyEntityIds: [id, value.fromItemId, value.toItemId, value.materialInstanceId],
                     fingerprint: [
-                        canonicalStringify(value),
+                        fingerprintOf(value),
                         materialFingerprint(materials[value.materialInstanceId]),
                     ].join('|'),
                 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aelionsdk/render-ir",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "Incremental render intermediate representation compiler for AelionSDK",
   "license": "MIT",
   "repository": {
@@ -34,9 +34,9 @@
     "provenance": true
   },
   "dependencies": {
-    "@aelionsdk/core": "1.2.0",
-    "@aelionsdk/material-compiler": "1.2.0",
-    "@aelionsdk/project-schema": "1.2.0"
+    "@aelionsdk/core": "2.0.0",
+    "@aelionsdk/material-compiler": "2.0.0",
+    "@aelionsdk/project-schema": "2.0.0"
   },
   "scripts": {
     "build": "tsc -b",