@cesdk/node-native 1.77.0-rc.4 → 1.77.1-rc.0

package/lib/index.js

@@ -579,6 +579,133 @@ async function downloadAndCheckLicense(config, fetchImpl = globalThis.fetch) {
   );
 }
 
+// ../wasm/js_web/src/EngineActions.ts
+var EngineActions = class {
+  /** @internal */
+  #ubq;
+  /**
+   * Settlers for in-flight `run()` calls so {@link dispose} can reject them
+   * instead of leaking forever-pending promises.
+   * @internal
+   */
+  #pending = /* @__PURE__ */ new Set();
+  /** @internal */
+  #disposed = false;
+  /** @internal */
+  constructor(ubq) {
+    this.#ubq = ubq;
+  }
+  register(id, fn) {
+    const trampoline = (jsonArgs) => {
+      let args;
+      try {
+        const parsed = JSON.parse(jsonArgs);
+        args = Array.isArray(parsed) ? parsed : [parsed];
+      } catch {
+        args = [];
+      }
+      try {
+        const result = fn(...args);
+        if (result != null && typeof result.then === "function") {
+          return result.then(
+            (value) => JSON.stringify(value ?? null)
+          );
+        }
+        return JSON.stringify(result ?? null);
+      } catch (error) {
+        return Promise.reject(
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+    };
+    this.#ubq.actionsRegister(id, trampoline, fn);
+  }
+  get(id) {
+    return this.#ubq.actionsGetLocal(id);
+  }
+  run(id, ...args) {
+    if (this.#disposed) {
+      return Promise.reject(new Error("Engine has been disposed."));
+    }
+    const local = this.#ubq.actionsGetLocal(id);
+    if (local !== void 0) {
+      return new Promise((resolve, reject) => {
+        const settle = (reason) => {
+          this.#pending.delete(settle);
+          reject(reason);
+        };
+        this.#pending.add(settle);
+        let result;
+        try {
+          result = local(...args);
+        } catch (error) {
+          this.#pending.delete(settle);
+          reject(error instanceof Error ? error : new Error(String(error)));
+          return;
+        }
+        Promise.resolve(result).then(
+          (value) => {
+            this.#pending.delete(settle);
+            resolve(value);
+          },
+          (error) => {
+            this.#pending.delete(settle);
+            reject(error instanceof Error ? error : new Error(String(error)));
+          }
+        );
+      });
+    }
+    return new Promise((resolve, reject) => {
+      const settle = (reason) => {
+        this.#pending.delete(settle);
+        reject(reason);
+      };
+      this.#pending.add(settle);
+      this.#ubq.actionsRun(
+        id,
+        JSON.stringify(args),
+        (jsonResult) => {
+          this.#pending.delete(settle);
+          try {
+            resolve(jsonResult === "" ? void 0 : JSON.parse(jsonResult));
+          } catch (error) {
+            reject(error instanceof Error ? error : new Error(String(error)));
+          }
+        },
+        (error) => settle(new Error(error))
+      );
+    });
+  }
+  /** Whether an action with this id is registered (host or engine default). */
+  has(id) {
+    return this.#ubq.actionsHas(id);
+  }
+  /**
+   * Remove a host action, or revert an overridden engine default to its built-in.
+   *
+   * If you override an engine default (such as `select` or `undo`), unregistering the id restores
+   * the default rather than leaving it unhandled. A custom id you registered yourself is removed
+   * entirely. Returns `false` only when the id is unknown.
+   */
+  unregister(id) {
+    return this.#ubq.actionsUnregister(id);
+  }
+  /** List registered actions, optionally filtered by a `*` glob matcher on the id. */
+  list(options) {
+    return this.#ubq.actionsList(options?.matcher ?? null);
+  }
+  /**
+   * Reject all in-flight `run()` promises. Called by the engine's `dispose()`.
+   * @internal
+   */
+  dispose() {
+    this.#disposed = true;
+    const pending = [...this.#pending];
+    this.#pending.clear();
+    pending.forEach((settle) => settle(new Error("Engine has been disposed.")));
+  }
+};
+
 // ts/src/CreativeEngine.ts
 function isRGBAColor2(color) {
   return "r" in color && "a" in color && color.r !== void 0 && color.a !== void 0;
@@ -1277,9 +1404,9 @@ var BlockAPI = class {
         "Color is not in sRGB color space. Use getColor() for non-RGBA colors."
       );
     }
-    return { r: color.r, g: color.g, b: color.b, a: color.a };
+    return [color.r, color.g, color.b, color.a];
   }
-  setColorRGBA(block, property, r, g, b, a) {
+  setColorRGBA(block, property, r, g, b, a = 1) {
     this.setColor(block, property, { r, g, b, a });
   }
   getEnum(block, property) {
@@ -1316,8 +1443,8 @@ var BlockAPI = class {
   getWidth(block) {
     return this.#engine.getWidth(block);
   }
-  setWidth(block, value) {
-    this.#engine.setWidth(block, value);
+  setWidth(block, value, maintainCrop) {
+    this.#engine.setWidth(block, value, maintainCrop ?? false);
   }
   getWidthMode(block) {
     return this.#engine.getWidthMode(block);
@@ -1328,8 +1455,8 @@ var BlockAPI = class {
   getHeight(block) {
     return this.#engine.getHeight(block);
   }
-  setHeight(block, value) {
-    this.#engine.setHeight(block, value);
+  setHeight(block, value, maintainCrop) {
+    this.#engine.setHeight(block, value, maintainCrop ?? false);
   }
   getHeightMode(block) {
     return this.#engine.getHeightMode(block);
@@ -1381,7 +1508,7 @@ var BlockAPI = class {
     this.#engine.fillParent(block);
   }
   resizeContentAware(blocks, width, height) {
-    return this.#engine.resizeContentAware(blocks, width, height);
+    this.#engine.resizeContentAware(blocks, width, height);
   }
   // Global bounding box
   getGlobalBoundingBoxX(block) {
@@ -1416,15 +1543,15 @@ var BlockAPI = class {
     this.#engine.setFillEnabled(block, enabled);
   }
   getFillColorRGBA(block) {
-    const color = this.getFillSolidColor(block);
+    const color = this.#engine.getFillSolidColor(block);
     if (!isRGBAColor2(color)) {
       throw new Error(
         "Fill color is not in sRGB color space. Use getFillSolidColor() for non-RGBA colors."
       );
     }
-    return { r: color.r, g: color.g, b: color.b, a: color.a };
+    return [color.r, color.g, color.b, color.a];
   }
-  setFillColorRGBA(block, r, g, b, a) {
+  setFillColorRGBA(block, r, g, b, a = 1) {
     this.setFillSolidColor(block, r, g, b, a);
   }
   getFill(block) {
@@ -1433,9 +1560,6 @@ var BlockAPI = class {
   setFill(block, fill) {
     this.#engine.setFill(block, fill);
   }
-  getFillEnabled(block) {
-    return this.#engine.getFillEnabled(block);
-  }
   isFillEnabled(block) {
     return this.#engine.getFillEnabled(block);
   }
@@ -1443,7 +1567,8 @@ var BlockAPI = class {
     this.#engine.setFillEnabled(block, enabled);
   }
   getFillSolidColor(block) {
-    return this.#engine.getFillSolidColor(block);
+    const c = this.#engine.getFillSolidColor(block);
+    return [c.r, c.g, c.b, c.a];
   }
   setFillSolidColor(block, r, g, b, a = 1) {
     this.#engine.setFillSolidColor(block, { r, g, b, a });
@@ -1469,15 +1594,9 @@ var BlockAPI = class {
   hasStroke(block) {
     return this.#engine.hasStroke(block);
   }
-  getStroke(block) {
-    return this.#engine.getStroke(block);
-  }
-  setStroke(block, stroke) {
-    this.#engine.setStroke(block, stroke);
-  }
-  getStrokeEnabled(block) {
-    return this.#engine.getStrokeEnabled(block);
-  }
+  // Note: `getStroke`/`setStroke` removed — @cesdk/node has no such API
+  // (strokes are block-level properties); the native stubs only threw.
+  // `getStrokeEnabled` removed as a redundant alias of `isStrokeEnabled`.
   isStrokeEnabled(block) {
     return this.#engine.getStrokeEnabled(block);
   }
@@ -1565,9 +1684,10 @@ var BlockAPI = class {
     return this.#engine.isLineOrigin(block);
   }
   getStrokeColorRGBA(block) {
-    return this.#engine.getStrokeColorRGBA(block);
+    const c = this.#engine.getStrokeColorRGBA(block);
+    return [c.r, c.g, c.b, c.a];
   }
-  setStrokeColorRGBA(block, r, g, b, a) {
+  setStrokeColorRGBA(block, r, g, b, a = 1) {
     this.#engine.setStrokeColorRGBA(block, r, g, b, a);
   }
   // Effects
@@ -1611,9 +1731,6 @@ var BlockAPI = class {
   setBlur(block, blur) {
     this.#engine.setBlur(block, blur);
   }
-  getBlurEnabled(block) {
-    return this.#engine.getBlurEnabled(block);
-  }
   isBlurEnabled(block) {
     return this.#engine.getBlurEnabled(block);
   }
@@ -1704,6 +1821,7 @@ var BlockAPI = class {
   // native stays honest with `: void`.
   adjustCropToFillFrame(block, minScaleRatio) {
     this.#engine.adjustCropToFillFrame(block, minScaleRatio);
+    return void 0;
   }
   getCropRotation(block) {
     return this.#engine.getCropRotation(block);
@@ -1777,9 +1895,10 @@ var BlockAPI = class {
     this.#engine.setDropShadowColor(block, internalColor);
   }
   getDropShadowColorRGBA(block) {
-    return this.#engine.getDropShadowColorRGBA(block);
+    const c = this.#engine.getDropShadowColorRGBA(block);
+    return [c.r, c.g, c.b, c.a];
   }
-  setDropShadowColorRGBA(block, r, g, b, a) {
+  setDropShadowColorRGBA(block, r, g, b, a = 1) {
     this.#engine.setDropShadowColorRGBA(block, r, g, b, a);
   }
   getDropShadowOffsetX(block) {
@@ -1839,18 +1958,12 @@ var BlockAPI = class {
     this.#engine.setOpacity(block, opacity);
   }
   // Visibility
-  getVisible(block) {
-    return this.#engine.getVisible(block);
-  }
   isVisible(block) {
     return this.#engine.getVisible(block);
   }
   setVisible(block, visible) {
     this.#engine.setVisible(block, visible);
   }
-  getClipped(block) {
-    return this.#engine.getClipped(block);
-  }
   isClipped(block) {
     return this.#engine.getClipped(block);
   }
@@ -2118,9 +2231,9 @@ var BlockAPI = class {
     if (!isRGBAColor2(color)) {
       throw new Error("Expected RGBA color for background color");
     }
-    return { r: color.r, g: color.g, b: color.b, a: color.a };
+    return [color.r, color.g, color.b, color.a];
   }
-  setBackgroundColorRGBA(block, r, g, b, a) {
+  setBackgroundColorRGBA(block, r, g, b, a = 1) {
     this.setColor(block, "backgroundColor", { r, g, b, a });
   }
   // Metadata
@@ -2221,7 +2334,11 @@ var BlockAPI = class {
   }
   getTextFontStyles(block, from = -1, to = -1) {
     const range = this.#toGraphemeRange(block, from, to);
-    return this.#engine.getTextFontStyles(block, range.from, range.to);
+    return this.#engine.getTextFontStyles(
+      block,
+      range.from,
+      range.to
+    );
   }
   setTextFontStyle(block, style, from = -1, to = -1) {
     const range = this.#toGraphemeRange(block, from, to);
@@ -2229,7 +2346,11 @@ var BlockAPI = class {
   }
   getTextFontWeights(block, from = -1, to = -1) {
     const range = this.#toGraphemeRange(block, from, to);
-    return this.#engine.getTextFontWeights(block, range.from, range.to);
+    return this.#engine.getTextFontWeights(
+      block,
+      range.from,
+      range.to
+    );
   }
   setTextFontWeight(block, weight, from = -1, to = -1) {
     const range = this.#toGraphemeRange(block, from, to);
@@ -2289,17 +2410,17 @@ var BlockAPI = class {
   setFont(block, fontUri, typeface) {
     this.#engine.setFont(block, fontUri, typeface);
   }
-  canToggleBoldFont(block) {
-    return this.#engine.canToggleBoldFont(block);
+  canToggleBoldFont(block, from = -1, to = -1) {
+    return this.#engine.canToggleBoldFont(block, from, to);
   }
-  toggleBoldFont(block) {
-    this.#engine.toggleBoldFont(block);
+  toggleBoldFont(block, from = -1, to = -1) {
+    this.#engine.toggleBoldFont(block, from, to);
   }
-  canToggleItalicFont(block) {
-    return this.#engine.canToggleItalicFont(block);
+  canToggleItalicFont(block, from = -1, to = -1) {
+    return this.#engine.canToggleItalicFont(block, from, to);
   }
-  toggleItalicFont(block) {
-    this.#engine.toggleItalicFont(block);
+  toggleItalicFont(block, from = -1, to = -1) {
+    this.#engine.toggleItalicFont(block, from, to);
   }
   /**
    * The text block currently being edited, or `undefined` when not in Text
@@ -2359,12 +2480,9 @@ var BlockAPI = class {
     }
     this.#engine.setTextCursorRange(from, to);
   }
-  getTextCursorPositionInScreenSpaceX(block) {
-    return this.#engine.getTextCursorPositionInScreenSpaceX(block);
-  }
-  getTextCursorPositionInScreenSpaceY(block) {
-    return this.#engine.getTextCursorPositionInScreenSpaceY(block);
-  }
+  // getTextCursorPositionInScreenSpaceX/Y moved to the `editor` namespace
+  // (no block argument) to match @cesdk/node, where the text cursor is
+  // editor-level state.
   getTextVisibleLineCount(block) {
     return this.#engine.getTextVisibleLineCount(block);
   }
@@ -2517,9 +2635,8 @@ var BlockAPI = class {
   getTextOnPathFlipped(block) {
     return this.#engine.getTextOnPathFlipped(block);
   }
-  getFontMetrics(fontFileUri) {
-    return this.#engine.getFontMetrics(fontFileUri);
-  }
+  // Note: getFontMetrics lives on the `editor` namespace (matching @cesdk/node);
+  // the duplicate block-namespace copy was removed.
   // Source sets
   getSourceSet(block, property) {
     return this.#engine.getSourceSet(block, property);
@@ -2616,21 +2733,17 @@ var BlockAPI = class {
   findAllProperties(block) {
     return this.#engine.findAllProperties(block);
   }
-  getPropertyType(blockOrProperty, property) {
-    const propName = typeof blockOrProperty === "string" ? blockOrProperty : property;
-    return this.#engine.getPropertyType(propName);
+  getPropertyType(property) {
+    return this.#engine.getPropertyType(property);
   }
-  isPropertyReadable(blockOrProperty, property) {
-    const propName = typeof blockOrProperty === "string" ? blockOrProperty : property;
-    return this.#engine.isPropertyReadable(propName);
+  isPropertyReadable(property) {
+    return this.#engine.isPropertyReadable(property);
   }
-  isPropertyWritable(blockOrProperty, property) {
-    const propName = typeof blockOrProperty === "string" ? blockOrProperty : property;
-    return this.#engine.isPropertyWritable(propName);
+  isPropertyWritable(property) {
+    return this.#engine.isPropertyWritable(property);
   }
-  getEnumValues(blockOrProperty, property) {
-    const propName = typeof blockOrProperty === "string" ? blockOrProperty : property;
-    return this.#engine.getEnumValues(propName);
+  getEnumValues(enumProperty) {
+    return this.#engine.getEnumValues(enumProperty);
   }
   // State
   getState(block) {
@@ -2849,8 +2962,16 @@ var BlockAPI = class {
     }
     return this.#engine.loadBlocksFromArchiveURL(url);
   }
-  saveToString(blocks) {
-    return this.#engine.saveBlocksToString(blocks);
+  saveToString(blocks, allowedResourceSchemes = ["buffer", "http", "https"], onDisallowedResourceScheme) {
+    const persistenceCallback = onDisallowedResourceScheme ? async (url, dataHash, invoke) => {
+      const persistedUrl = await onDisallowedResourceScheme(url, dataHash);
+      invoke(url, persistedUrl);
+    } : void 0;
+    return this.#engine.saveBlocksToString(
+      blocks,
+      allowedResourceSchemes,
+      persistenceCallback
+    );
   }
   // BlockAPI.saveToArchive matches @cesdk/node and returns Promise<Blob>. The
   // raw Uint8Array form remains accessible via the engine binding for
@@ -2949,7 +3070,7 @@ var BlockAPI = class {
    *
    * @public
    */
-  addImage(url, options = {}) {
+  async addImage(url, options = {}) {
     const {
       x,
       y,
@@ -3030,11 +3151,10 @@ var BlockAPI = class {
    *
    * @public
    */
-  addVideo(url, options = {}) {
+  async addVideo(url, width, height, options = {}) {
     const {
       x,
       y,
-      size,
       timeline,
       animation,
       shadow,
@@ -3045,13 +3165,8 @@ var BlockAPI = class {
       loop,
       muted
     } = options;
-    if (size == null) {
-      throw new Error(
-        "[@cesdk/node-native] block.addVideo requires `options.size` in Node (no auto-probe). Pass `{ size: { width, height } }`."
-      );
-    }
-    const finalWidth = typeof size === "number" ? size : size.width;
-    const finalHeight = typeof size === "number" ? size : size.height;
+    const finalWidth = width;
+    const finalHeight = height;
     const pages = this.findByType("//ly.img.ubq/page");
     if (pages.length === 0) {
       throw new Error("No page found. Create a page first.");
@@ -3147,6 +3262,189 @@ var BlockAPI = class {
     const id = this.#engine.subscribeToBlockClicked(callback);
     return () => this.#engine.unsubscribe(id);
   }
+  // --- Audio / video / captions / cutout (parity with @cesdk/node) ---
+  getAudioInfoFromVideo(videoFillBlock) {
+    return this.#engine.getAudioInfoFromVideo(videoFillBlock);
+  }
+  createAudioFromVideo(videoFillBlock, trackIndex, options) {
+    return this.#engine.createAudioFromVideo(videoFillBlock, trackIndex, {
+      keepTrimSettings: options?.keepTrimSettings ?? true,
+      muteOriginalVideo: options?.muteOriginalVideo ?? true
+    });
+  }
+  createAudiosFromVideo(videoFillBlock, options) {
+    return this.#engine.createAudiosFromVideo(videoFillBlock, {
+      keepTrimSettings: options?.keepTrimSettings ?? true,
+      muteOriginalVideo: options?.muteOriginalVideo ?? true
+    });
+  }
+  createCaptionsFromURI(uri) {
+    return this.#engine.createCaptionsFromURI(uri);
+  }
+  createCutoutFromBlocks(ids, vectorizeDistanceThreshold, simplifyDistanceThreshold, useExistingShapeInformation) {
+    return this.#engine.createCutoutFromBlocks(
+      ids,
+      vectorizeDistanceThreshold ?? 2,
+      simplifyDistanceThreshold ?? 4,
+      useExistingShapeInformation ?? true
+    );
+  }
+  createCutoutFromOperation(ids, op) {
+    return this.#engine.createCutoutFromOperation(ids, op);
+  }
+  createCutoutFromPath(pathData) {
+    return this.#engine.createCutoutFromPath(pathData);
+  }
+  /** @deprecated Use `generateVideoThumbnailSequence` instead. */
+  async getVideoFillThumbnail(id, thumbnailHeight) {
+    const data = await this.#engine.getVideoFillThumbnail(id, thumbnailHeight);
+    return new Blob([data], { type: "image/jpeg" });
+  }
+  /** @deprecated Use `generateVideoThumbnailSequence` instead. */
+  async getVideoFillThumbnailAtlas(id, numberOfColumns, numberOfRows, thumbnailHeight) {
+    const data = await this.#engine.getVideoFillThumbnailAtlas(
+      id,
+      numberOfColumns,
+      numberOfRows,
+      thumbnailHeight
+    );
+    return new Blob([data], { type: "image/jpeg" });
+  }
+  /** @deprecated */
+  async getPageThumbnailAtlas(id, numberOfColumns, numberOfRows, thumbnailHeight) {
+    const data = await this.#engine.getPageThumbnailAtlas(
+      id,
+      numberOfColumns,
+      numberOfRows,
+      thumbnailHeight
+    );
+    return new Blob([data], { type: "image/jpeg" });
+  }
+  unstable_isAVResourceLoaded(id) {
+    return this.#engine.unstable_isAVResourceLoaded(id);
+  }
+  referencesAnyVariables(id) {
+    return this.#engine.referencesAnyVariables(id);
+  }
+  /** @deprecated Use `getColor`. */
+  getColorSpotName(id, property) {
+    return this.#engine.getColorSpotName(id, property);
+  }
+  /** @deprecated Use `getColor`. */
+  getColorSpotTint(id, property) {
+    return this.#engine.getColorSpotTint(id, property);
+  }
+  /** @deprecated Use `setColor`. */
+  setColorSpot(id, property, name, tint = 1) {
+    this.#engine.setColorSpot(id, property, name, tint);
+  }
+  setState(id, state) {
+    this.#engine.setState(id, state);
+  }
+  canRevertToOriginalRatio(id) {
+    return this.#engine.canRevertToOriginalRatio(id);
+  }
+  getFillOverprint(id) {
+    return this.#engine.getFillOverprint(id);
+  }
+  setFillOverprint(id, overprint) {
+    this.#engine.setFillOverprint(id, overprint);
+  }
+  getStrokeOverprint(id) {
+    return this.#engine.getStrokeOverprint(id);
+  }
+  setStrokeOverprint(id, overprint) {
+    this.#engine.setStrokeOverprint(id, overprint);
+  }
+  getDominantColors(handle, options) {
+    return this.#engine.getDominantColors(handle, options);
+  }
+  getTextRuns(id, from, to) {
+    const runs = this.#engine.getTextRuns(
+      id,
+      from ?? -1,
+      to ?? -1
+    );
+    return runs.map((run) => ({
+      ...run,
+      color: NativeColorInternal.toColor(run.color)
+    }));
+  }
+  #currentPage() {
+    const scene = this.#engine.findByType("scene")[0];
+    if (scene == null) return null;
+    return this.#engine.getCurrentPage(scene);
+  }
+  getBackgroundTrack() {
+    const page = this.#currentPage();
+    if (page == null) return null;
+    const tracks = this.#engine.findByType("track");
+    return tracks.find((track) => this.#engine.isPageDurationSource(track)) ?? null;
+  }
+  moveToBackgroundTrack(block) {
+    let backgroundTrack = this.getBackgroundTrack();
+    if (backgroundTrack == null) {
+      const page = this.#currentPage();
+      if (page == null) {
+        throw new Error("No current page found");
+      }
+      backgroundTrack = this.#engine.create("//ly.img.ubq/track");
+      this.#engine.appendChild(page, backgroundTrack);
+      this.#engine.setAlwaysOnBottom(backgroundTrack, true);
+      if (this.#engine.supportsPageDurationSource(page, backgroundTrack)) {
+        this.#engine.setPageDurationSource(page, backgroundTrack);
+      }
+    }
+    this.#engine.appendChild(backgroundTrack, block);
+  }
+  /**
+   * Generates a sequence of video thumbnails; `onFrame` is called per frame.
+   * Node has no `ImageData`, so each frame is a raw RGBA `{ data, width,
+   * height }` (see `ThumbnailFrame`).
+   */
+  generateVideoThumbnailSequence(id, thumbnailHeight, timeBegin, timeEnd, numberOfFrames, onFrame) {
+    const handle = this.#engine.generateVideoThumbnailSequence(
+      id,
+      thumbnailHeight,
+      timeBegin,
+      timeEnd,
+      numberOfFrames,
+      (err, frame) => {
+        if (err) {
+          onFrame(0, err);
+          return;
+        }
+        onFrame(frame.frameIndex, {
+          data: new Uint8ClampedArray(frame.data),
+          width: frame.width,
+          height: frame.height
+        });
+      }
+    );
+    return () => this.#engine.cancelVideoThumbnailSequenceGeneration(handle);
+  }
+  /**
+   * Generates a sequence of audio waveform sample chunks. `onChunk` is called
+   * per chunk with a `Float32Array` of samples (matching @cesdk/node).
+   */
+  generateAudioThumbnailSequence(id, samplesPerChunk, timeBegin, timeEnd, numberOfSamples, numberOfChannels, onChunk) {
+    const handle = this.#engine.generateAudioThumbnailSequence(
+      id,
+      samplesPerChunk,
+      timeBegin,
+      timeEnd,
+      numberOfSamples,
+      numberOfChannels,
+      (err, chunk) => {
+        if (err) {
+          onChunk(0, err);
+          return;
+        }
+        onChunk(chunk.chunkIndex, Float32Array.from(chunk.samples));
+      }
+    );
+    return () => this.#engine.cancelAudioThumbnailSequenceGeneration(handle);
+  }
 };
 var SceneAPI = class {
   #engine;
@@ -3286,22 +3584,26 @@ var SceneAPI = class {
       waitForResources
     );
   }
-  /**
-   * Serializes the current scene into a string.
-   *
-   * Optionally accepts a `compression` option to apply Zstd compression to
-   * the output. When compression is enabled the returned string contains
-   * raw compressed bytes (not base64) — pass it back to `loadFromString`
-   * to round-trip.
-   *
-   * @returns A promise that resolves with the serialized scene.
-   */
-  async saveToString(options) {
+  async saveToString(allowedResourceSchemesOrOptions, onDisallowedResourceSchemeParam) {
     const scene = this.get();
     if (scene === null) {
       throw new Error("No scene available.");
     }
-    return this.#engine.saveSceneToString(scene, options);
+    const isOldStyle = Array.isArray(allowedResourceSchemesOrOptions);
+    const options = isOldStyle ? {
+      allowedResourceSchemes: allowedResourceSchemesOrOptions,
+      onDisallowedResourceScheme: onDisallowedResourceSchemeParam
+    } : allowedResourceSchemesOrOptions ?? {};
+    const onDisallowedResourceScheme = options.onDisallowedResourceScheme;
+    const persistenceCallback = onDisallowedResourceScheme ? async (url, dataHash, invoke) => {
+      const persistedUrl = await onDisallowedResourceScheme(url, dataHash);
+      invoke(url, persistedUrl);
+    } : void 0;
+    return this.#engine.saveSceneToString(scene, {
+      resourceSchemesAllowed: options.allowedResourceSchemes,
+      persistenceCallback,
+      compression: options.compression
+    });
   }
   /**
    * Saves the current scene and all of its referenced assets into an archive.
@@ -3499,8 +3801,8 @@ var SceneAPI = class {
    * @returns The current page in the scene or null when there is no scene
    *          available or no current page is set.
    */
-  getCurrentPage(scene) {
-    const sceneId = scene ?? this.get();
+  getCurrentPage() {
+    const sceneId = this.get();
     if (sceneId === null) {
       return null;
     }
@@ -3619,15 +3921,6 @@ var SceneAPI = class {
       );
     }
   }
-  /**
-   * Continually adjust the zoom level to fit the block's bounding box on the
-   * chosen axis. For 'Horizontal'/'Vertical', the second/third arguments are
-   * `paddingBefore`/`paddingAfter` along that axis. For 'Both' the four
-   * arguments map to left/top/right/bottom.
-   *
-   * @param id - The block to follow.
-   * @param axis - 'Horizontal' | 'Vertical' | 'Both'.
-   */
   enableZoomAutoFit(id, axis, paddingBeforeOrLeft = 0, paddingAfterOrTop = 0, paddingRight = 0, paddingBottom = 0) {
     if (axis === "Horizontal") {
       this.#engine.enableZoomAutoFit(
@@ -3693,15 +3986,13 @@ var SceneAPI = class {
       scaledPaddingBottom
     );
   }
-  unstable_disableCameraPositionClamping(block) {
-    const target = block ?? this.get();
-    if (target == null) throw new Error("No scene available.");
-    this.#engine.unstable_disableCameraPositionClamping(target);
+  unstable_disableCameraPositionClamping(blockOrScene = this.get()) {
+    if (blockOrScene == null) throw new Error("No scene available.");
+    this.#engine.unstable_disableCameraPositionClamping(blockOrScene);
   }
-  unstable_isCameraPositionClampingEnabled(block) {
-    const target = block ?? this.get();
-    if (target == null) throw new Error("No scene available.");
-    return this.#engine.unstable_isCameraPositionClampingEnabled(target);
+  unstable_isCameraPositionClampingEnabled(blockOrScene = this.get()) {
+    if (blockOrScene == null) throw new Error("No scene available.");
+    return this.#engine.unstable_isCameraPositionClampingEnabled(blockOrScene);
   }
   /**
    * Continually clamp the camera zoom level to the range
@@ -3720,15 +4011,13 @@ var SceneAPI = class {
       paddingBottom
     );
   }
-  unstable_disableCameraZoomClamping(block) {
-    const target = block ?? this.get();
-    if (target == null) throw new Error("No scene available.");
-    this.#engine.unstable_disableCameraZoomClamping(target);
+  unstable_disableCameraZoomClamping(blockOrScene = this.get()) {
+    if (blockOrScene == null) throw new Error("No scene available.");
+    this.#engine.unstable_disableCameraZoomClamping(blockOrScene);
   }
-  unstable_isCameraZoomClampingEnabled(block) {
-    const target = block ?? this.get();
-    if (target == null) throw new Error("No scene available.");
-    return this.#engine.unstable_isCameraZoomClampingEnabled(target);
+  unstable_isCameraZoomClampingEnabled(blockOrScene = this.get()) {
+    if (blockOrScene == null) throw new Error("No scene available.");
+    return this.#engine.unstable_isCameraZoomClampingEnabled(blockOrScene);
   }
   /**
    * Subscribe to zoom-level changes.
@@ -3757,8 +4046,8 @@ var EditorAPI = class {
   getEditMode() {
     return this.#engine.getEditMode();
   }
-  setEditMode(mode) {
-    this.#engine.setEditMode(mode);
+  setEditMode(mode, baseMode) {
+    this.#engine.setEditMode(mode, baseMode ?? "");
   }
   /**
    * Returns the JWT string of the currently active license. An empty string
@@ -3784,7 +4073,6 @@ var EditorAPI = class {
   unlockWithLicense(license) {
     this.#engine.unlockWithLicense(license);
   }
-  // Settings
   getSettingBool(key) {
     const settingType = this.getSettingType(key);
     if (settingType !== "Bool") {
@@ -3840,12 +4128,12 @@ var EditorAPI = class {
   findAllSettings() {
     return this.#engine.findAllSettings();
   }
-  getSettingType(key) {
+  getSettingType(keypath) {
     const allSettings = this.#engine.findAllSettings();
-    if (!allSettings.includes(key)) {
-      throw new Error(`Setting '${key}' does not exist`);
+    if (!allSettings.includes(keypath)) {
+      throw new Error(`Setting '${keypath}' does not exist`);
     }
-    return this.#engine.getSettingType(key);
+    return this.#engine.getSettingType(keypath);
   }
   getSettingEnumOptions(key) {
     return this.#engine.getSettingEnumOptions(key);
@@ -3854,25 +4142,38 @@ var EditorAPI = class {
    * Generic setting getter that dispatches to the typed getter based on
    * `getSettingType`.
    */
-  getSetting(key) {
+  getSetting(keypath) {
+    const key = keypath;
     const settingType = this.getSettingType(key);
     switch (settingType) {
       case "Bool":
-        return this.#engine.getSettingBool(key);
+        return this.#engine.getSettingBool(
+          key
+        );
       case "Int":
-        return this.#engine.getSettingInt(key);
+        return this.#engine.getSettingInt(
+          key
+        );
       case "Float":
-        return this.#engine.getSettingFloat(key);
+        return this.#engine.getSettingFloat(
+          key
+        );
       case "String":
-        return this.#engine.getSettingString(key);
+        return this.#engine.getSettingString(
+          key
+        );
       case "Color": {
         const internalColor = this.#engine.getSettingColor(
           key
         );
-        return NativeColorInternal.toColor(internalColor);
+        return NativeColorInternal.toColor(
+          internalColor
+        );
       }
       case "Enum":
-        return this.#engine.getSettingEnum(key);
+        return this.#engine.getSettingEnum(
+          key
+        );
       default:
         throw new Error(
           `Unknown setting type for key '${key}': ${settingType}`
@@ -3883,7 +4184,8 @@ var EditorAPI = class {
    * Generic setting setter — dispatches to the typed setter via
    * `getSettingType`.
    */
-  setSetting(key, value) {
+  setSetting(keypath, value) {
+    const key = keypath;
     const settingType = this.getSettingType(key);
     switch (settingType) {
       case "Bool":
@@ -3899,7 +4201,9 @@ var EditorAPI = class {
         this.#engine.setSettingString(key, value);
         return;
       case "Color": {
-        const internalColor = NativeColorInternal.fromColor(value);
+        const internalColor = NativeColorInternal.fromColor(
+          value
+        );
         this.#engine.setSettingColor(key, internalColor);
         return;
       }
@@ -3962,10 +4266,10 @@ var EditorAPI = class {
   // Safe area insets
   setSafeAreaInsets(insets) {
     this.#engine.setSafeAreaInsets(
-      insets.left,
-      insets.top,
-      insets.right,
-      insets.bottom
+      insets.left ?? 0,
+      insets.top ?? 0,
+      insets.right ?? 0,
+      insets.bottom ?? 0
     );
   }
   getSafeAreaInsets() {
@@ -3978,21 +4282,21 @@ var EditorAPI = class {
   getAvailableMemory() {
     return this.#engine.getAvailableMemory();
   }
-  // Color
   convertColorToColorSpace(color, colorSpace) {
     const internalColor = NativeColorInternal.fromColor(color);
     let colorSpaceNum;
-    if (colorSpace === "sRGB") {
-      colorSpaceNum = 0 /* sRGB */;
-    } else if (colorSpace === "CMYK") {
-      colorSpaceNum = 1 /* CMYK */;
-    } else if (colorSpace === "SpotColor") {
-      colorSpaceNum = 2 /* SpotColor */;
-    } else {
-      colorSpaceNum = parseInt(colorSpace, 10);
-      if (Number.isNaN(colorSpaceNum)) {
-        throw new Error(`Unknown color space: ${colorSpace}`);
-      }
+    switch (colorSpace) {
+      case "sRGB":
+        colorSpaceNum = 0 /* sRGB */;
+        break;
+      case "CMYK":
+        colorSpaceNum = 1 /* CMYK */;
+        break;
+      case "SpotColor":
+        colorSpaceNum = 2 /* SpotColor */;
+        break;
+      default:
+        throw new Error(`Unknown color space: ${String(colorSpace)}`);
     }
     const resultInternal = this.#engine.convertColorToColorSpace(
       internalColor,
@@ -4080,49 +4384,118 @@ var EditorAPI = class {
   /**
    * List all transient (in-engine) resources — typically `buffer://` URIs
    * created by importers (psd, pdf, idml) before they're uploaded to a
-   * permanent location. Each entry is `{ uri, size }`.
+   * permanent location. Each entry is `{ URL, size }`, matching `@cesdk/node`.
    *
-   * Note: WASM uses `URL` as the key name; consumers that target both
-   * bindings should accept either (see e.g. psd-importer's
-   * `transient-resource-relocation.test.ts`).
+   * @category Resource Management
+   * @returns The URLs and sizes of transient resources.
    */
   findAllTransientResources() {
     return this.#engine.findAllTransientResources();
   }
+  /**
+   * Reads a resource's bytes in chunks. `onData` is called per chunk with a
+   * `Uint8Array`; return `false` to stop early. Returns once fully streamed.
+   *
+   * @category Resource Management
+   * @param uri - The URL of the resource.
+   * @param chunkSize - Size in bytes of each chunk passed to `onData`.
+   * @param onData - Called with each chunk; return `false` to stop.
+   */
+  getResourceData(uri, chunkSize, onData) {
+    this.#engine.getResourceData(uri, chunkSize, onData);
+  }
+  // --- Parity additions on the editor namespace ---
+  getMaxExportSize() {
+    return this.#engine.getMaxExportSize();
+  }
+  unstable_isInteractionHappening() {
+    return this.#engine.unstable_isInteractionHappening();
+  }
+  isHighlightingEnabled(id) {
+    return this.#engine.isHighlightingEnabled(id);
+  }
+  setHighlightingEnabled(id, enabled) {
+    this.#engine.setHighlightingEnabled(id, enabled);
+  }
+  isSelectionEnabled(id) {
+    return this.#engine.isSelectionEnabled(id);
+  }
+  setSelectionEnabled(id, enabled) {
+    this.#engine.setSelectionEnabled(id, enabled);
+  }
+  getTextCursorPositionInScreenSpaceX() {
+    return this.#engine.getTextCursorPositionInScreenSpaceX();
+  }
+  getTextCursorPositionInScreenSpaceY() {
+    return this.#engine.getTextCursorPositionInScreenSpaceY();
+  }
+  getSpotColorForCutoutType(type) {
+    return this.#engine.getSpotColorForCutoutType(type);
+  }
+  setSpotColorForCutoutType(type, color) {
+    this.#engine.setSpotColorForCutoutType(type, color);
+  }
+  /** @deprecated Use `getSettingColor` instead. */
+  getSettingColorRGBA(keypath) {
+    const c = this.#engine.getSettingColorRGBA(keypath);
+    return [c.r, c.g, c.b, c.a];
+  }
+  /** @deprecated Use `setSettingColor` instead. */
+  setSettingColorRGBA(keypath, r, g, b, a = 1) {
+    this.#engine.setSettingColorRGBA(keypath, r, g, b, a);
+  }
+  // --- Vector edit mode (operates on the interactively selected node/path) ---
+  addVectorNode() {
+    this.#engine.addVectorNode();
+  }
+  deleteVectorNode() {
+    this.#engine.deleteVectorNode();
+  }
+  deleteSelectedVectorControlPoints() {
+    this.#engine.deleteSelectedVectorControlPoints();
+  }
+  getSelectedVectorNodeMirrorMode() {
+    return this.#engine.getSelectedVectorNodeMirrorMode();
+  }
+  setSelectedVectorNodeMirrorMode(mode) {
+    this.#engine.setSelectedVectorNodeMirrorMode(mode);
+  }
+  getVectorEditAddMode() {
+    return this.#engine.getVectorEditAddMode();
+  }
+  setVectorEditAddMode(active) {
+    this.#engine.setVectorEditAddMode(active);
+  }
+  getVectorEditBendMode() {
+    return this.#engine.getVectorEditBendMode();
+  }
+  setVectorEditBendMode(active) {
+    this.#engine.setVectorEditBendMode(active);
+  }
+  getVectorEditDeleteMode() {
+    return this.#engine.getVectorEditDeleteMode();
+  }
+  setVectorEditDeleteMode(active) {
+    this.#engine.setVectorEditDeleteMode(active);
+  }
+  hasSelectedVectorNode() {
+    return this.#engine.hasSelectedVectorNode();
+  }
+  hasSelectedVectorControlPoint() {
+    return this.#engine.hasSelectedVectorControlPoint();
+  }
+  toggleSelectedVectorNodeSmooth() {
+    this.#engine.toggleSelectedVectorNodeSmooth();
+  }
   // Spot colors
   findAllSpotColors() {
     return this.#engine.findAllSpotColors();
   }
   getSpotColorRGBA(name) {
-    const result = this.#engine.getSpotColorRGB(name);
-    const tuple = Array.isArray(result) ? result.slice(0, 4) : [
-      result.r,
-      result.g,
-      result.b,
-      result.a
-    ];
-    const rgba = tuple;
-    rgba.r = tuple[0];
-    rgba.g = tuple[1];
-    rgba.b = tuple[2];
-    rgba.a = tuple[3];
-    return rgba;
+    return this.#engine.getSpotColorRGB(name);
   }
   getSpotColorCMYK(name) {
-    const result = this.#engine.getSpotColorCMYK(name);
-    const tuple = Array.isArray(result) ? result.slice(0, 4) : [
-      result.c,
-      result.m,
-      result.y,
-      result.k
-    ];
-    const cmyk = tuple;
-    cmyk.c = tuple[0];
-    cmyk.m = tuple[1];
-    cmyk.y = tuple[2];
-    cmyk.k = tuple[3];
-    cmyk.tint = !Array.isArray(result) && result.tint !== void 0 ? result.tint : 1;
-    return cmyk;
+    return this.#engine.getSpotColorCMYK(name);
   }
   setSpotColorRGB(name, r, g, b) {
     this.#engine.setSpotColorRGB(name, r, g, b);
@@ -4258,7 +4631,9 @@ var EditorAPI = class {
    * @returns A function that unsubscribes when called.
    */
   onRoleChanged(callback) {
-    const id = this.#engine.subscribeToRoleChange(callback);
+    const id = this.#engine.subscribeToRoleChange(
+      (role) => callback(role)
+    );
     return () => this.#engine.unsubscribe(id);
   }
   // Buffer management (matching WASM/Android EditorAPI)
@@ -4407,17 +4782,25 @@ var AssetAPI = class {
     }
     this.#engine.addLocalAssetSource(id, supportedMimeTypes ?? []);
     if (applyAsset != null) {
-      this.registerApplyMiddleware(id, async (asset, next) => {
-        const result = await applyAsset(asset);
-        if (result !== void 0) return result;
-        return next(asset);
-      });
+      this.registerApplyMiddleware(
+        async (sourceId, assetResult, apply, ctx) => {
+          if (sourceId !== id) return apply(sourceId, assetResult, ctx);
+          const result = await applyAsset(assetResult);
+          if (result !== void 0) return result;
+          return apply(sourceId, assetResult, ctx);
+        }
+      );
     }
     if (applyAssetToBlock != null) {
-      this.registerApplyToBlockMiddleware(id, async (asset, block, next) => {
-        await applyAssetToBlock(asset, block);
-        await next(asset, block);
-      });
+      this.registerApplyToBlockMiddleware(
+        async (sourceId, assetResult, block, applyToBlockNext) => {
+          if (sourceId !== id) {
+            return applyToBlockNext(sourceId, assetResult, block);
+          }
+          await applyAssetToBlock(assetResult, block);
+          await applyToBlockNext(sourceId, assetResult, block);
+        }
+      );
     }
   }
   /**
@@ -4606,8 +4989,11 @@ var AssetAPI = class {
   // them through a TS-level middleware chain so registerApplyMiddleware /
   // registerApplyToBlockMiddleware work.
   // -------------------------------------------------------------------------
-  #applyMiddleware = /* @__PURE__ */ new Map();
-  #applyToBlockMiddleware = /* @__PURE__ */ new Map();
+  // Global middleware sets, matching @cesdk/node's `AssetAPI`. Each middleware
+  // gets the source id, the asset, and the `next` function so it can transform,
+  // short-circuit, or defer to the rest of the chain.
+  #applyAssetMiddlewares = /* @__PURE__ */ new Set();
+  #applyAssetToBlockMiddlewares = /* @__PURE__ */ new Set();
   /**
    * Apply an asset to the current scene. Honors any middleware registered
    * via {@link registerApplyMiddleware} and falls back to
@@ -4615,16 +5001,17 @@ var AssetAPI = class {
    *
    * @public
    */
-  async apply(sourceId, asset) {
-    const tail = (a) => this.defaultApplyAsset(a);
-    const middlewares = this.#applyMiddleware.get(sourceId) ?? [];
-    let next = tail;
-    for (let i = middlewares.length - 1; i >= 0; i--) {
-      const mw = middlewares[i];
-      const prev = next;
-      next = (a) => mw(a, prev);
+  async apply(sourceId, assetResult, options) {
+    const context = { clipType: options?.clipType };
+    const original = (id, asset) => this.defaultApplyAsset(asset);
+    if (this.#applyAssetMiddlewares.size > 0) {
+      const applyAsset = Array.from(this.#applyAssetMiddlewares).reduce(
+        (next, middleware) => (id, asset) => middleware(id, asset, next, context),
+        original
+      );
+      return applyAsset(sourceId, assetResult);
     }
-    return next(asset);
+    return original(sourceId, assetResult);
   }
   /**
    * Apply an asset to a specific block. Honors any middleware registered
@@ -4633,16 +5020,18 @@ var AssetAPI = class {
    *
    * @public
    */
-  async applyToBlock(sourceId, asset, block) {
-    const tail = (a, b) => this.defaultApplyAssetToBlock(a, b);
-    const middlewares = this.#applyToBlockMiddleware.get(sourceId) ?? [];
-    let next = tail;
-    for (let i = middlewares.length - 1; i >= 0; i--) {
-      const mw = middlewares[i];
-      const prev = next;
-      next = (a, b) => mw(a, b, prev);
+  async applyToBlock(sourceId, assetResult, block) {
+    const original = (id, asset, blockId) => this.defaultApplyAssetToBlock(asset, blockId);
+    if (this.#applyAssetToBlockMiddlewares.size > 0) {
+      const applyToBlock = Array.from(
+        this.#applyAssetToBlockMiddlewares
+      ).reduce(
+        (next, middleware) => (id, asset, blockId) => middleware(id, asset, blockId, next),
+        original
+      );
+      return applyToBlock(sourceId, assetResult, block);
     }
-    return next(asset, block);
+    return original(sourceId, assetResult, block);
   }
   /**
    * Apply a property change from an asset payload.
@@ -4650,7 +5039,11 @@ var AssetAPI = class {
    * @public
    */
   async applyProperty(sourceId, asset, property) {
-    return this.#engine.applyAssetSourceProperty(sourceId, asset, property);
+    return this.#engine.applyAssetSourceProperty(
+      sourceId,
+      asset,
+      property
+    );
   }
   /**
    * Default apply-asset implementation (no middleware). Calls the engine's
@@ -4660,7 +5053,9 @@ var AssetAPI = class {
    * @public
    */
   async defaultApplyAsset(asset) {
-    const result = await this.#engine.defaultApplyAsset(asset);
+    const result = await this.#engine.defaultApplyAsset(
+      asset
+    );
     return result === -1 || result == null ? void 0 : result;
   }
   /**
@@ -4670,31 +5065,36 @@ var AssetAPI = class {
    * @public
    */
   async defaultApplyAssetToBlock(asset, block) {
-    await this.#engine.defaultApplyAssetToBlock(asset, block);
+    await this.#engine.defaultApplyAssetToBlock(
+      asset,
+      block
+    );
   }
   /**
-   * Register a middleware in the apply-asset chain for a source.
+   * Register a middleware in the global apply-asset chain, matching
+   * `@cesdk/node`'s `registerApplyMiddleware`. Returns a function that
+   * unregisters it.
    *
-   * @param sourceId - The source to install the middleware on.
-   * @param middleware - Callable that may consume the asset, defer to
-   *   the next middleware, or short-circuit. Returns the created block id
-   *   (or undefined to fall through).
    * @public
    */
-  registerApplyMiddleware(sourceId, middleware) {
-    const arr = this.#applyMiddleware.get(sourceId) ?? [];
-    arr.push(middleware);
-    this.#applyMiddleware.set(sourceId, arr);
+  registerApplyMiddleware(middleware) {
+    this.#applyAssetMiddlewares.add(middleware);
+    return () => {
+      this.#applyAssetMiddlewares.delete(middleware);
+    };
   }
   /**
-   * Register a middleware in the apply-asset-to-block chain for a source.
+   * Register a middleware in the global apply-asset-to-block chain. Mirrors
+   * `@cesdk/node`'s `registerApplyToBlockMiddleware`. Returns a function that
+   * unregisters it.
    *
    * @public
    */
-  registerApplyToBlockMiddleware(sourceId, middleware) {
-    const arr = this.#applyToBlockMiddleware.get(sourceId) ?? [];
-    arr.push(middleware);
-    this.#applyToBlockMiddleware.set(sourceId, arr);
+  registerApplyToBlockMiddleware(middleware) {
+    this.#applyAssetToBlockMiddlewares.add(middleware);
+    return () => {
+      this.#applyAssetToBlockMiddlewares.delete(middleware);
+    };
   }
   /**
    * Whether the named source supports `addAssetToSource` /
@@ -4716,7 +5116,7 @@ var AssetAPI = class {
     }
   }
 };
-var _version = true ? "1.77.0-rc.4" : "0.0.0";
+var _version = true ? "1.77.1-rc.0" : "0.0.0";
 var CreativeEngine = class _CreativeEngine {
   constructor(engine) {
     this.version = _CreativeEngine.version;
@@ -4729,6 +5129,9 @@ var CreativeEngine = class _CreativeEngine {
     this.event = new EventAPI(engine);
     this.scene = new SceneAPI(engine);
     this.variable = new VariableAPI(engine);
+    this.actions = new EngineActions(
+      engine
+    );
     this.#startUpdateLoop();
   }
   static {
@@ -4767,6 +5170,7 @@ var CreativeEngine = class _CreativeEngine {
    */
   dispose() {
     this.#stopUpdateLoop();
+    this.actions.dispose();
     this.#engine.dispose();
     this.#engine = null;
     this.asset = null;
@@ -4775,6 +5179,7 @@ var CreativeEngine = class _CreativeEngine {
     this.event = null;
     this.scene = null;
     this.variable = null;
+    this.actions = null;
   }
   /**
    * Initialize a CreativeEngine.
@@ -4828,8 +5233,11 @@ var CreativeEngine = class _CreativeEngine {
    * `${baseURL}/<source-id>/content.json` for each id in the default set
    * and registers the contents as a local asset source. baseURL defaults
    * to the engine's configured baseURL (`file://<addon>/assets/` if none
-   * was passed to init).
+   * was passed to init), which does not bundle these sources, so pass a
+   * `baseURL` to load them.
    *
+   * @deprecated This method uses legacy v4 asset source IDs and will be removed in a future version.
+   * Please migrate to v5 asset sources using engine.asset.addLocalAssetSourceFromJSONURI().
    * @public
    */
   async addDefaultAssetSources({
@@ -4855,6 +5263,8 @@ var CreativeEngine = class _CreativeEngine {
    * — accepts `sceneMode`, `withUploadAssetSources`, and the full demo
    * source-ID union (templates + textComponents + uploads + media).
    *
+   * @deprecated This method uses legacy v3 demo asset source IDs and will be removed in a future version.
+   * Please migrate to v4 asset sources using engine.asset.addLocalAssetSourceFromJSONURI().
    * @public
    */
   async addDemoAssetSources({