@cesdk/node-native 1.77.0-nightly.20260610

package/lib/index.js

@@ -0,0 +1,4922 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ts/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ANIMATION_TYPES: () => ANIMATION_TYPES,
+  BLUR_TYPES: () => BLUR_TYPES,
+  CompressionFormat: () => CompressionFormat,
+  CompressionLevel: () => CompressionLevel,
+  DESIGN_BLOCK_TYPES: () => DESIGN_BLOCK_TYPES,
+  EFFECT_TYPES: () => EFFECT_TYPES,
+  FILL_TYPES: () => FILL_TYPES,
+  LogLevel: () => LogLevel,
+  MimeType: () => MimeType,
+  SHAPE_TYPES: () => SHAPE_TYPES,
+  default: () => index_default,
+  defaultLogger: () => defaultLogger,
+  isCMYKColor: () => isCMYKColor,
+  isRGBAColor: () => isRGBAColor,
+  isSpotColor: () => isSpotColor
+});
+module.exports = __toCommonJS(index_exports);
+
+// ts/src/CreativeEngine.ts
+var path = __toESM(require("node:path"));
+var fs2 = __toESM(require("node:fs"));
+var crypto = __toESM(require("node:crypto"));
+var import_node_url2 = require("node:url");
+
+// ../shared/ts/src/types.ts
+var MimeType = {
+  Png: "image/png",
+  Jpeg: "image/jpeg",
+  WebP: "image/webp",
+  Tga: "image/x-tga",
+  Svg: "image/svg+xml",
+  Wav: "audio/wav",
+  Mp4Audio: "audio/mp4",
+  Mp4: "video/mp4",
+  QuickTime: "video/quicktime",
+  Binary: "application/octet-stream",
+  Pdf: "application/pdf",
+  Zip: "application/zip"
+};
+
+// ../shared/ts/src/blockTypes.ts
+var DESIGN_BLOCK_TYPES = [
+  "scene",
+  "stack",
+  "camera",
+  "page",
+  "graphic",
+  "audio",
+  "text",
+  "group",
+  "cutout",
+  "track",
+  "caption",
+  "captionTrack"
+];
+var SHAPE_TYPES = [
+  "rect",
+  "line",
+  "ellipse",
+  "polygon",
+  "star",
+  "vector_path"
+];
+var FILL_TYPES = [
+  "color",
+  "gradient/linear",
+  "gradient/radial",
+  "gradient/conical",
+  "image",
+  "video",
+  "pixelStream"
+];
+var EFFECT_TYPES = [
+  "adjustments",
+  "cross_cut",
+  "dot_pattern",
+  "duotone_filter",
+  "extrude_blur",
+  "glow",
+  "green_screen",
+  "half_tone",
+  "linocut",
+  "liquid",
+  "lut_filter",
+  "mirror",
+  "outliner",
+  "pixelize",
+  "posterize",
+  "radial_pixel",
+  "recolor",
+  "sharpie",
+  "shifter",
+  "tilt_shift",
+  "tv_glitch",
+  "vignette"
+];
+var BLUR_TYPES = ["uniform", "linear", "mirrored", "radial"];
+var ANIMATION_TYPES = [
+  "slide",
+  "pan",
+  "fade",
+  "blur",
+  "grow",
+  "zoom",
+  "pop",
+  "wipe",
+  "baseline",
+  "crop_zoom",
+  "spin",
+  "spin_loop",
+  "fade_loop",
+  "blur_loop",
+  "pulsating_loop",
+  "breathing_loop",
+  "jump_loop",
+  "squeeze_loop",
+  "sway_loop",
+  "scale_loop",
+  "typewriter_text",
+  "block_swipe_text",
+  "spread_text",
+  "merge_text",
+  "ken_burns"
+];
+
+// ../shared/ts/src/color-guards.ts
+function isRGBAColor(color) {
+  return "r" in color && "a" in color && color.r !== void 0 && color.a !== void 0;
+}
+function isSpotColor(color) {
+  return "name" in color && color.name !== void 0;
+}
+function isCMYKColor(color) {
+  return "c" in color && "m" in color && "y" in color && "k" in color && color.c !== void 0 && color.m !== void 0 && color.y !== void 0 && color.k !== void 0;
+}
+
+// ../shared/ts/src/Logger.ts
+var LogLevel = {
+  Info: "Info",
+  Warning: "Warning",
+  Error: "Error"
+};
+
+// ../shared/ts/src/defaultLogger.ts
+function defaultLogger(message, level) {
+  const prefixedMessage = `[UBQ] ${message}`;
+  switch (level) {
+    case "Warning": {
+      console.warn(prefixedMessage);
+      break;
+    }
+    case "Error": {
+      console.error(prefixedMessage);
+      break;
+    }
+    case "Info": {
+      console.info(prefixedMessage);
+      break;
+    }
+    default: {
+      console.log(prefixedMessage);
+    }
+  }
+}
+
+// ../shared/ts/src/api/VariableAPI.ts
+var VariableAPI = class {
+  #engine;
+  constructor(engine) {
+    this.#engine = engine;
+  }
+  /**
+   * Get all text variable names currently stored in the engine.
+   * @returns List of variable names.
+   */
+  findAll() {
+    return this.#engine.findAllVariables();
+  }
+  /**
+   * Set a text variable's value. Creates the variable if it doesn't exist.
+   * @param key - The variable's key.
+   * @param value - The text value to assign.
+   */
+  setString(key, value) {
+    this.#engine.setVariableString(key, value);
+  }
+  /**
+   * Get a text variable's value.
+   * @param key - The variable's key.
+   * @returns The text value of the variable.
+   */
+  getString(key) {
+    return this.#engine.getVariableString(key);
+  }
+  /**
+   * Remove a text variable from the engine.
+   * @param key - The variable's key to remove.
+   */
+  remove(key) {
+    this.#engine.removeVariable(key);
+  }
+};
+
+// ts/src/platform-packages.ts
+var PLATFORM_PACKAGES = Object.freeze({
+  "darwin-arm64": "@cesdk/node-native-darwin-arm64",
+  "darwin-x64": "@cesdk/node-native-darwin-x64",
+  "linux-x64": "@cesdk/node-native-linux-x64"
+});
+function platformPackageFor(platform, arch) {
+  return PLATFORM_PACKAGES[`${platform}-${arch}`];
+}
+
+// ts/src/builtin-typeface.ts
+var BUILTIN_TYPEFACE_SOURCE_ID = "ly.img.typeface.builtin";
+var BUILTIN_TYPEFACE_JSON = JSON.stringify({
+  version: "6.0.0",
+  id: BUILTIN_TYPEFACE_SOURCE_ID,
+  assets: [
+    {
+      id: "ly.img.typeface.builtin.inter",
+      label: { en: "Inter" },
+      payload: {
+        typeface: {
+          name: "Inter",
+          fonts: [
+            {
+              uri: "bundle://ly.img.cesdk/fonts/imgly_font_inter_semibold.otf",
+              subFamily: "Semi Bold",
+              weight: "semiBold",
+              style: "normal"
+            }
+          ]
+        }
+      }
+    }
+  ]
+});
+
+// ts/src/addDefaultAssetSources.ts
+var fs = __toESM(require("node:fs/promises"));
+var import_node_url = require("node:url");
+var DEFAULT_SOURCE_IDS = [
+  "ly.img.sticker",
+  "ly.img.vectorpath",
+  "ly.img.colors.defaultPalette",
+  "ly.img.filter.lut",
+  "ly.img.filter.duotone",
+  "ly.img.effect",
+  "ly.img.blur",
+  "ly.img.typeface",
+  "ly.img.page.presets",
+  "ly.img.page.presets.video",
+  "ly.img.crop.presets",
+  "ly.img.text"
+];
+var DEMO_CONTENT_JSON_IDS = [
+  "ly.img.image",
+  "ly.img.video",
+  "ly.img.audio"
+];
+async function readContentJSON(url) {
+  if (url.startsWith("file://")) {
+    return fs.readFile((0, import_node_url.fileURLToPath)(url), "utf8");
+  }
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    const res = await fetch(url);
+    if (!res.ok) {
+      throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
+    }
+    return res.text();
+  }
+  return fs.readFile(url, "utf8");
+}
+async function loadOne(asset, sourceId, baseURL) {
+  const normalizedBase = baseURL.replace(/\/+$/, "");
+  const contentURL = `${normalizedBase}/${sourceId}/content.json`;
+  try {
+    const json = await readContentJSON(contentURL);
+    await asset.addLocalAssetSourceFromJSONString(json, normalizedBase);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.warn(
+      `[@cesdk/node-native] Failed to load asset source '${sourceId}' from ${contentURL}: ${msg}. Skipping.`
+    );
+  }
+}
+async function loadDefaultAssetSources(asset, baseURL, exclude) {
+  const tasks = DEFAULT_SOURCE_IDS.filter((id) => !exclude.has(id)).map(
+    (id) => loadOne(asset, id, baseURL)
+  );
+  if (!exclude.has("ly.img.captionPresets")) {
+    tasks.push(loadOne(asset, "ly.img.captionPresets", baseURL));
+  }
+  await Promise.all(tasks);
+}
+var UPLOAD_MIMES = {
+  image: {
+    Design: ["image/jpeg", "image/png", "image/webp", "image/svg+xml", "image/bmp", "image/gif", "image/apng"],
+    Video: ["image/jpeg", "image/png", "image/webp", "image/svg+xml", "image/bmp"]
+  },
+  video: ["application/json", "video/mp4", "video/quicktime", "video/webm", "video/matroska", "image/gif", "image/apng"],
+  audio: ["audio/mpeg", "audio/mp3", "audio/x-m4a", "audio/wav"]
+};
+async function loadDemoAssetSources(asset, baseURL, exclude, options = {}) {
+  const {
+    withUploadAssetSources = false,
+    sceneMode = "Design",
+    sceneAPI
+  } = options;
+  const manager = asset;
+  const existing = new Set(manager.findAllSources?.() ?? []);
+  if (withUploadAssetSources) {
+    if (!exclude.has("ly.img.image.upload") && !existing.has("ly.img.image.upload")) {
+      manager.addLocalSource("ly.img.image.upload", [...UPLOAD_MIMES.image[sceneMode]]);
+    }
+    if (sceneMode === "Video" && !exclude.has("ly.img.video.upload") && !existing.has("ly.img.video.upload")) {
+      manager.addLocalSource("ly.img.video.upload", [...UPLOAD_MIMES.video]);
+    }
+    if (sceneMode === "Video" && !exclude.has("ly.img.audio.upload") && !existing.has("ly.img.audio.upload")) {
+      manager.addLocalSource("ly.img.audio.upload", [...UPLOAD_MIMES.audio]);
+    }
+  }
+  const contentJsonIds = DEMO_CONTENT_JSON_IDS.filter((id) => {
+    if (exclude.has(id)) return false;
+    if (sceneMode === "Design" && (id === "ly.img.video" || id === "ly.img.audio")) {
+    }
+    return true;
+  });
+  const registerTemplateSource = (id) => {
+    if (exclude.has(id) || existing.has(id)) return;
+    if (!sceneAPI) {
+      console.warn(
+        `[@cesdk/node-native] Cannot register ${id} without a sceneAPI handle. Templates will be visible but applying them will be a no-op. Pass \`{ sceneAPI: engine.scene }\` to engine.addDemoAssetSources().`
+      );
+      manager.addLocalSource(id);
+      return;
+    }
+    manager.addLocalSource(id, void 0, async (assetForApply) => {
+      const meta = assetForApply.meta;
+      const sceneUri = meta?.uri;
+      if (!sceneUri) return void 0;
+      if (sceneUri.startsWith("UBQ1")) {
+        await sceneAPI.applyTemplateFromString(sceneUri);
+      } else {
+        await sceneAPI.applyTemplateFromURL(sceneUri);
+      }
+      return void 0;
+    });
+  };
+  registerTemplateSource("ly.img.template");
+  if (sceneMode === "Video") {
+    registerTemplateSource("ly.img.video.template");
+  }
+  if (!exclude.has("ly.img.textComponents") && !existing.has("ly.img.textComponents")) {
+    contentJsonIds.push("ly.img.textComponents");
+  }
+  await Promise.all(contentJsonIds.map((id) => loadOne(asset, id, baseURL)));
+}
+
+// ts/src/configureEngine.ts
+var KNOWN_FEATURE_FLAGS = /* @__PURE__ */ new Set([
+  "preventScrolling",
+  "singlePageMode",
+  "fileSystemUsageEnabled"
+]);
+var REMOVED_KEYS = [
+  { key: "scene" },
+  { key: "page" },
+  { key: "initialSceneURL" },
+  { key: "initialSceneString" },
+  { key: "initialSceneFile" },
+  { key: "initialSceneBlob" },
+  { key: "initialImageURL" }
+];
+function configureEngine(engine, config, _options) {
+  const rawLogger = config?.logger ?? defaultLog;
+  const logger = (message, level) => {
+    try {
+      rawLogger(message, level);
+    } catch {
+    }
+  };
+  const role = config?.role ?? "Creator";
+  try {
+    engine.editor.setRole(role);
+  } catch (err) {
+    logger(`setRole failed: ${describeError(err)}`, "Warning");
+  }
+  if (config?.featureFlags) {
+    const flags = config.featureFlags;
+    for (const flag of Object.keys(flags)) {
+      if (!KNOWN_FEATURE_FLAGS.has(flag)) {
+        logger(
+          `Unknown featureFlag '${flag}' will be ignored. Known flags: ${[
+            ...KNOWN_FEATURE_FLAGS
+          ].join(", ")}.`,
+          "Warning"
+        );
+      }
+    }
+    if (flags.preventScrolling) {
+      tryWarnOnFail(
+        () => engine.editor.setSettingBool("touch/singlePointPanning", false),
+        logger
+      );
+      tryWarnOnFail(
+        () => engine.editor.setSettingBool("touch/dragStartCanSelect", false),
+        logger
+      );
+    }
+    const singlePageMode = !!flags.singlePageMode;
+    tryWarnOnFail(
+      () => engine.editor.setSettingBool(
+        "features/singlePageModeEnabled",
+        singlePageMode
+      ),
+      logger
+    );
+    const fileSystemUsageEnabled = flags.fileSystemUsageEnabled !== false;
+    tryWarnOnFail(
+      () => engine.editor.setSettingBool(
+        "features/fileSystemUsageEnabled",
+        fileSystemUsageEnabled
+      ),
+      logger
+    );
+  }
+  try {
+    engine.editor.startTracking(
+      config?.license ?? "",
+      config?.userId ?? "",
+      ""
+    );
+  } catch (err) {
+    logger(`startTracking failed: ${describeError(err)}`, "Warning");
+  }
+  if (config) {
+    const seen = config;
+    for (const entry of REMOVED_KEYS) {
+      if (entry.key in seen) {
+        logger(
+          `Configuration.${entry.key} is no longer supported and will be ignored.`,
+          "Warning"
+        );
+      }
+    }
+  }
+  if (config?.presets?.typefaces && Object.keys(config.presets.typefaces).length > 0) {
+    logger(
+      "Configuration.presets.typefaces is deprecated. Register typefaces via engine.asset.addLocalSource / addLocalAssetSourceFromJSONString instead.",
+      "Warning"
+    );
+  }
+}
+function tryWarnOnFail(fn, _logger) {
+  try {
+    fn();
+  } catch {
+  }
+}
+function describeError(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+function defaultLog(message, level) {
+  const prefixed = `[UBQ] ${message}`;
+  switch (level) {
+    case "Warning":
+      console.warn(prefixed);
+      break;
+    case "Error":
+      console.error(prefixed);
+      break;
+    case "Info":
+      console.info(prefixed);
+      break;
+    default:
+      console.log(prefixed);
+  }
+}
+
+// ts/src/license.ts
+var LICENSE_ENDPOINT_PRODUCTION = "https://api.img.ly/activate";
+var LICENSE_ENDPOINT_STAGING = "https://api.staging.img.ly/activate";
+var LICENSE_ACTIVATION_TIMEOUT_MS = 1e4;
+function pickEndpoint() {
+  if (process.env.CESDK_LICENSE_ENDPOINT) return process.env.CESDK_LICENSE_ENDPOINT;
+  if (process.env.NODE_ENV === "development" || process.env.CESDK_STAGING === "1") {
+    return LICENSE_ENDPOINT_STAGING;
+  }
+  return LICENSE_ENDPOINT_PRODUCTION;
+}
+async function downloadAndCheckLicense(config, fetchImpl = globalThis.fetch) {
+  if (!config.license || config.license.length === 0 || config.license === "evaluation-license") {
+    return "";
+  }
+  if (config.license.length >= 128) {
+    return config.license;
+  }
+  if (!fetchImpl) {
+    throw new Error(
+      "No global `fetch` available. Pass a `fetch` polyfill or use Node 18+."
+    );
+  }
+  const endpoint = pickEndpoint();
+  const controller = new AbortController();
+  const timer = setTimeout(
+    () => controller.abort(),
+    LICENSE_ACTIVATION_TIMEOUT_MS
+  );
+  let response;
+  try {
+    response = await fetchImpl(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        apiKey: config.license,
+        userId: config.userId
+      }),
+      signal: controller.signal
+    });
+  } catch (e) {
+    if (controller.signal.aborted) {
+      throw new Error(
+        `License activation timed out after ${LICENSE_ACTIVATION_TIMEOUT_MS}ms (${endpoint}). Check network connectivity or set CESDK_LICENSE_ENDPOINT.`
+      );
+    }
+    throw e;
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!response.ok) {
+    throw new Error(
+      "Unfortunately we are experiencing a server down time and your License key cannot be validated. We're already working on a fix and will restore service soon. Should services not restore within the hour, kindly get in touch with our support team."
+    );
+  }
+  const data = await response.json();
+  if (data.status === "valid") return data.license;
+  if (data.status === "expired") {
+    throw new Error(
+      "Thanks for using IMG.LY for creative editing. Please note that your license file or commercial use is expired. Please get in touch with our sales team to discuss extension of your commercial license."
+    );
+  }
+  throw new Error(
+    "The License Key (API Key) you are using to access the IMG.LY SDK is invalid. Please ensure that you are using the license key tied to your subscription and get in touch with our support team."
+  );
+}
+
+// ts/src/CreativeEngine.ts
+function isRGBAColor2(color) {
+  return "r" in color && "a" in color && color.r !== void 0 && color.a !== void 0;
+}
+function isSpotColor2(color) {
+  return "name" in color && color.name !== void 0;
+}
+function isCMYKColor2(color) {
+  return "c" in color && "m" in color && "y" in color && "k" in color && color.c !== void 0 && color.m !== void 0 && color.y !== void 0 && color.k !== void 0;
+}
+var NativeColorInternal;
+((NativeColorInternal2) => {
+  let ColorSpace;
+  ((ColorSpace2) => {
+    ColorSpace2[ColorSpace2["sRGB"] = 0] = "sRGB";
+    ColorSpace2[ColorSpace2["CMYK"] = 1] = "CMYK";
+    ColorSpace2[ColorSpace2["SpotColor"] = 2] = "SpotColor";
+  })(ColorSpace = NativeColorInternal2.ColorSpace || (NativeColorInternal2.ColorSpace = {}));
+  function toColor(color) {
+    switch (color.colorSpace) {
+      case 0 /* sRGB */:
+        return {
+          r: color.components.x,
+          g: color.components.y,
+          b: color.components.z,
+          a: color.components.w
+        };
+      case 2 /* SpotColor */: {
+        return {
+          name: color.spotColorName,
+          tint: color.tint,
+          externalReference: color.externalReference
+        };
+      }
+      case 1 /* CMYK */:
+        return {
+          c: color.components.x,
+          m: color.components.y,
+          y: color.components.z,
+          k: color.components.w,
+          tint: color.tint
+        };
+      default:
+        throw new Error("Unknown color space!");
+    }
+  }
+  NativeColorInternal2.toColor = toColor;
+  function fromColor(color) {
+    if (isRGBAColor2(color)) {
+      return {
+        colorSpace: 0 /* sRGB */,
+        components: { x: color.r, y: color.g, z: color.b, w: color.a },
+        spotColorName: "",
+        tint: 1,
+        externalReference: ""
+      };
+    } else if (isCMYKColor2(color)) {
+      return {
+        colorSpace: 1 /* CMYK */,
+        components: { x: color.c, y: color.m, z: color.y, w: color.k },
+        spotColorName: "",
+        tint: color.tint ?? 1,
+        externalReference: ""
+      };
+    } else if (isSpotColor2(color)) {
+      return {
+        colorSpace: 2 /* SpotColor */,
+        components: { x: 0, y: 0, z: 0, w: 0 },
+        spotColorName: color.name,
+        tint: color.tint,
+        externalReference: color.externalReference
+      };
+    }
+    throw new Error("Unknown color space!");
+  }
+  NativeColorInternal2.fromColor = fromColor;
+})(NativeColorInternal || (NativeColorInternal = {}));
+function convertUTF16ToGraphemeRange(text, from, to) {
+  if (from < 0 && to < 0) {
+    return { from, to };
+  }
+  const segmenter = new Intl.Segmenter("en");
+  const codeUnitToGrapheme = new Array(text.length + 1);
+  let codeUnit = 0;
+  let graphemeIdx = 0;
+  for (const seg of segmenter.segment(text)) {
+    for (let i = codeUnit; i <= seg.index; i++) {
+      codeUnitToGrapheme[i] = graphemeIdx;
+    }
+    codeUnit = seg.index + 1;
+    graphemeIdx++;
+  }
+  for (let i = codeUnit; i <= text.length; i++) {
+    codeUnitToGrapheme[i] = graphemeIdx;
+  }
+  const fromGrapheme = from < 0 ? from : codeUnitToGrapheme[Math.min(from, text.length)];
+  const toGrapheme = to < 0 ? to : codeUnitToGrapheme[Math.min(to, text.length)];
+  return { from: fromGrapheme, to: toGrapheme };
+}
+function convertGraphemeToUTF16Range(text, from, to) {
+  if (from < 0 && to < 0) {
+    return { from, to };
+  }
+  const segmenter = new Intl.Segmenter("en");
+  const graphemeStarts = [];
+  for (const seg of segmenter.segment(text)) {
+    graphemeStarts.push(seg.index);
+  }
+  graphemeStarts.push(text.length);
+  const fromUtf16 = from < 0 ? from : from >= graphemeStarts.length ? text.length : graphemeStarts[from];
+  const toUtf16 = to < 0 ? to : to >= graphemeStarts.length ? text.length : graphemeStarts[to];
+  return { from: fromUtf16, to: toUtf16 };
+}
+var NATIVE_DEBUG_ENABLED = process.env.CESDK_DEBUG === "1" || /(^|,)cesdk(:native)?(,|$)/.test(process.env.DEBUG ?? "");
+function nativeDebug(message) {
+  if (NATIVE_DEBUG_ENABLED) {
+    console.error(`[cesdk:native] ${message}`);
+  }
+}
+async function verifyAddonSha256(addonPath) {
+  if (process.env.CESDK_SKIP_BINARY_VERIFY === "1") {
+    nativeDebug("SHA-256 verification disabled via CESDK_SKIP_BINARY_VERIFY=1");
+    return;
+  }
+  const shaPath = `${addonPath}.sha256`;
+  if (!fs2.existsSync(shaPath)) {
+    return;
+  }
+  const shaContents = (await fs2.promises.readFile(shaPath, "utf8")).trim();
+  const expected = shaContents.split(/\s+/)[0];
+  if (!/^[0-9a-f]{64}$/i.test(expected)) {
+    const err = new Error(
+      `@cesdk/node-native: malformed SHA-256 sidecar at ${shaPath} \u2014 expected a 64-char hex digest. Likely a corrupted or incomplete install. Re-install @cesdk/node-native (verify the package signature with \`npm audit signatures\`), or set CESDK_SKIP_BINARY_VERIFY=1 to bypass (not recommended in production).`
+    );
+    err.code = "ERR_CESDK_BINARY_TAMPERED";
+    throw err;
+  }
+  const hasher = crypto.createHash("sha256");
+  await new Promise((resolve, reject) => {
+    const stream = fs2.createReadStream(addonPath, { highWaterMark: 64 * 1024 });
+    stream.on("data", (chunk) => hasher.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve());
+  });
+  const actual = hasher.digest("hex");
+  if (actual !== expected.toLowerCase()) {
+    const err = new Error(
+      `@cesdk/node-native: SHA-256 mismatch for native binary at ${addonPath}.
+  expected ${expected}
+  actual   ${actual}
+The binary does not match its checksum sidecar \u2014 likely a corrupted or incomplete install. Re-install @cesdk/node-native (and verify the package signature with \`npm audit signatures\`), or set CESDK_SKIP_BINARY_VERIFY=1 to bypass (not recommended in production).`
+    );
+    err.code = "ERR_CESDK_BINARY_TAMPERED";
+    throw err;
+  }
+  nativeDebug(`SHA-256 verified for ${addonPath}`);
+}
+function recordLoadError(bucket, source, e) {
+  if (e instanceof Error) {
+    const maybeCoded = e;
+    bucket.push({
+      source,
+      message: e.message,
+      code: typeof maybeCoded.code === "string" ? maybeCoded.code : void 0
+    });
+  } else {
+    bucket.push({ source, message: String(e) });
+  }
+}
+function rethrowIfTampered(e) {
+  if (e?.code === "ERR_CESDK_BINARY_TAMPERED") {
+    throw e;
+  }
+}
+function assertSupportedRuntime() {
+  const g = globalThis;
+  if (typeof g.Bun !== "undefined") {
+    throw new Error(
+      "@cesdk/node-native is not supported on Bun. Use @cesdk/node (WASM) instead."
+    );
+  }
+  if (typeof g.Deno !== "undefined") {
+    throw new Error(
+      "@cesdk/node-native is not supported on Deno. Use @cesdk/node (WASM) instead."
+    );
+  }
+}
+async function resolveFromEnvOverride() {
+  const envOverride = process.env.CESDK_NATIVE_BINARY_PATH;
+  if (envOverride === void 0 || envOverride === "") {
+    return void 0;
+  }
+  nativeDebug(`CESDK_NATIVE_BINARY_PATH override -> ${envOverride}`);
+  if (!path.isAbsolute(envOverride)) {
+    throw new Error(
+      `CESDK_NATIVE_BINARY_PATH must be an absolute path (got '${envOverride}').`
+    );
+  }
+  if (!envOverride.endsWith(".node")) {
+    throw new Error(
+      `CESDK_NATIVE_BINARY_PATH must point to a .node file (got '${envOverride}').`
+    );
+  }
+  let resolvedPath;
+  try {
+    resolvedPath = fs2.realpathSync(envOverride);
+  } catch (e) {
+    throw new Error(
+      `CESDK_NATIVE_BINARY_PATH at '${envOverride}' cannot be resolved: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+  if (!resolvedPath.endsWith(".node")) {
+    throw new Error(
+      `CESDK_NATIVE_BINARY_PATH symlink target '${resolvedPath}' is not a .node file (override path: '${envOverride}').`
+    );
+  }
+  await verifyAddonSha256(resolvedPath);
+  try {
+    const addon = require(resolvedPath);
+    return { addon, addonPath: resolvedPath };
+  } catch (e) {
+    throw new Error(
+      `Failed to load CESDK_NATIVE_BINARY_PATH override at '${resolvedPath}': ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+}
+async function resolveFromSiblingPackage(siblingPkg, errors) {
+  try {
+    const pkgJsonPath = require.resolve(`${siblingPkg}/package.json`);
+    const loadPath = path.join(path.dirname(pkgJsonPath), "cesdk_native.node");
+    nativeDebug(`trying sibling package -> ${loadPath}`);
+    await verifyAddonSha256(loadPath);
+    const addon = require(loadPath);
+    return { addon, addonPath: loadPath };
+  } catch (e) {
+    rethrowIfTampered(e);
+    recordLoadError(errors, `${siblingPkg}/cesdk_native.node`, e);
+    return void 0;
+  }
+}
+async function resolveFromInPackage(errors) {
+  const inPkgPath = path.join(__dirname, "cesdk_native.node");
+  nativeDebug(`trying in-package -> ${inPkgPath}`);
+  try {
+    await verifyAddonSha256(inPkgPath);
+    const addon = require(inPkgPath);
+    return { addon, addonPath: inPkgPath };
+  } catch (e) {
+    rethrowIfTampered(e);
+    recordLoadError(errors, inPkgPath, e);
+    return void 0;
+  }
+}
+function buildLoadFailureError(key, siblingPkg, isProductionInstall, productionErrors, devErrors) {
+  const recovery = siblingPkg !== void 0 ? [
+    `Recovery:`,
+    `  npm install --include=optional ${siblingPkg}`,
+    `  (or re-run the install with optional dependencies enabled)`,
+    `  Or use @cesdk/node (WASM) for broader install coverage.`
+  ].join("\n") : [
+    `Your platform/arch '${key}' is not supported by @cesdk/node-native.`,
+    `Use @cesdk/node (WASM) for broader platform coverage.`
+  ].join("\n");
+  const visibleErrors = isProductionInstall ? productionErrors : [...productionErrors, ...devErrors];
+  const message = [
+    `Failed to load the @cesdk/node-native addon for ${key}.`,
+    ``,
+    recovery,
+    ``,
+    `Tried:`,
+    ...visibleErrors.map(
+      (e) => `  - ${e.source}: ${e.message}${e.code ? ` [${e.code}]` : ""}`
+    )
+  ].join("\n");
+  const err = new Error(message);
+  const codedError = visibleErrors.find((e) => e.code !== void 0);
+  if (codedError?.code) {
+    err.code = codedError.code;
+  }
+  return err;
+}
+async function loadNativeAddon() {
+  assertSupportedRuntime();
+  const platform = process.platform;
+  const arch = process.arch;
+  const key = `${platform}-${arch}`;
+  nativeDebug(`platform=${platform} arch=${arch} key=${key}`);
+  const fromEnv = await resolveFromEnvOverride();
+  if (fromEnv !== void 0) {
+    return fromEnv;
+  }
+  const isProductionInstall = __dirname.includes(
+    `${path.sep}node_modules${path.sep}`
+  );
+  const productionErrors = [];
+  const devErrors = [];
+  const siblingPkg = platformPackageFor(platform, arch);
+  if (siblingPkg !== void 0) {
+    const fromSibling = await resolveFromSiblingPackage(
+      siblingPkg,
+      productionErrors
+    );
+    if (fromSibling !== void 0) {
+      return fromSibling;
+    }
+  }
+  const fromInPackage = await resolveFromInPackage(devErrors);
+  if (fromInPackage !== void 0) {
+    return fromInPackage;
+  }
+  throw buildLoadFailureError(
+    key,
+    siblingPkg,
+    isProductionInstall,
+    productionErrors,
+    devErrors
+  );
+}
+var _loadedAddon;
+function getNativeAddon() {
+  if (_loadedAddon === void 0) {
+    _loadedAddon = loadNativeAddon().catch((e) => {
+      _loadedAddon = void 0;
+      throw e;
+    });
+  }
+  return _loadedAddon;
+}
+function resolveDefaultAssetsDir(addonPath) {
+  const candidates = [
+    path.join(__dirname, "..", "assets"),
+    path.join(__dirname, "..", "..", "assets"),
+    path.join(path.dirname(addonPath), "assets")
+  ];
+  for (const dir of candidates) {
+    try {
+      if (fs2.statSync(dir).isDirectory()) {
+        nativeDebug(`resolveDefaultAssetsDir -> ${dir}`);
+        return dir;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function convertFontSizeToPoints(value, unit, dpi) {
+  switch (unit) {
+    case "Point":
+      return value;
+    case "Pixel":
+      return 72 * value / dpi;
+    case "Millimeter":
+      return value * 72 / 25.4;
+    case "Inch":
+      return value * 72;
+    default:
+      return value;
+  }
+}
+function convertFontSizeFromPoints(valueInPoints, unit, dpi) {
+  switch (unit) {
+    case "Point":
+      return valueInPoints;
+    case "Pixel":
+      return valueInPoints * dpi / 72;
+    case "Millimeter":
+      return valueInPoints * 25.4 / 72;
+    case "Inch":
+      return valueInPoints / 72;
+    default:
+      return valueInPoints;
+  }
+}
+function normalizeBaseURL(raw) {
+  if (!raw) return raw;
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) {
+    return raw.endsWith("/") ? raw : `${raw}/`;
+  }
+  try {
+    const asUrl = (0, import_node_url2.pathToFileURL)(raw).href;
+    return asUrl.endsWith("/") ? asUrl : `${asUrl}/`;
+  } catch {
+    return raw.endsWith("/") ? raw : `${raw}/`;
+  }
+}
+function resolveEngineDevice(config) {
+  return config?.device ?? (process.env.CESDK_FORCE_CPU === "1" ? "cpu" : "auto");
+}
+function resolveEngineBaseURL(config, nativeAddonPath) {
+  let baseURL;
+  if (config?.baseURL !== void 0) {
+    baseURL = normalizeBaseURL(config.baseURL);
+  } else {
+    const assetsDir = resolveDefaultAssetsDir(nativeAddonPath);
+    baseURL = assetsDir ? `${(0, import_node_url2.pathToFileURL)(assetsDir).href}/` : "";
+  }
+  let enginePath = baseURL;
+  if (enginePath.startsWith("file://")) {
+    try {
+      enginePath = (0, import_node_url2.fileURLToPath)(enginePath);
+    } catch {
+    }
+  }
+  return { baseURL, enginePath };
+}
+async function registerBuiltinTypeface(engine) {
+  if (process.env.CESDK_SUPPRESS_BUILTIN_TYPEFACE === "1") {
+    return;
+  }
+  try {
+    await engine.asset.addLocalAssetSourceFromJSONString(BUILTIN_TYPEFACE_JSON);
+  } catch {
+  }
+}
+var BlockAPI = class {
+  #engine;
+  constructor(engine) {
+    this.#engine = engine;
+  }
+  // ==========================================================================
+  // Block Lifecycle
+  // ==========================================================================
+  /**
+   * Create a new block of the specified type.
+   * @param type - The block type (e.g., 'graphic', 'text', 'page', 'audio').
+   * @returns The ID of the newly created block.
+   */
+  create(type) {
+    return this.#engine.create(type);
+  }
+  /**
+   * Create a new fill block of the specified type.
+   * @param type - The fill type (e.g., 'color', 'gradient/linear', 'gradient/radial', 'image', 'video').
+   * @returns The ID of the newly created fill block.
+   */
+  createFill(type) {
+    return this.#engine.createFill(type);
+  }
+  /**
+   * Create a new shape block of the specified type.
+   * @param type - The shape type (e.g., 'rect', 'ellipse', 'polygon', 'star', 'line').
+   * @returns The ID of the newly created shape block.
+   */
+  createShape(type) {
+    return this.#engine.createShape(type);
+  }
+  /**
+   * Create a new effect block of the specified type.
+   * @param type - The effect type (e.g., 'adjustments', 'pixelize', 'glow', 'half_tone').
+   * @returns The ID of the newly created effect block.
+   */
+  createEffect(type) {
+    return this.#engine.createEffect(type);
+  }
+  /**
+   * Create a new blur block of the specified type.
+   * @param type - The blur type (e.g., 'uniform', 'linear', 'mirrored', 'radial').
+   * @returns The ID of the newly created blur block.
+   */
+  createBlur(type) {
+    return this.#engine.createBlur(type);
+  }
+  /**
+   * Create a new animation block of the specified type.
+   * @param type - The animation type.
+   * @returns The ID of the newly created animation block.
+   */
+  createAnimation(type) {
+    return this.#engine.createAnimation(type);
+  }
+  /**
+   * Duplicate an existing block.
+   * @param block - The ID of the block to duplicate.
+   * @param attachToParent - Whether to attach the duplicate to the same parent (default: true).
+   * @returns The ID of the duplicated block.
+   */
+  duplicate(block, attachToParent = true) {
+    return this.#engine.duplicate(block, attachToParent);
+  }
+  /**
+   * Destroy a block and release its resources.
+   * @param block - The ID of the block to destroy.
+   */
+  destroy(block) {
+    this.#engine.destroy(block);
+  }
+  /**
+   * Check if a block ID refers to a valid, existing block.
+   * @param block - The ID to check.
+   * @returns True if the block exists and is valid, false otherwise.
+   */
+  isValid(block) {
+    return this.#engine.isValid(block);
+  }
+  // ==========================================================================
+  // Find Methods
+  // ==========================================================================
+  /**
+   * Find all blocks in the scene.
+   * @returns Array of all block IDs.
+   */
+  findAll() {
+    return this.#engine.findAll();
+  }
+  /**
+   * Find all placeholder blocks in the scene.
+   * @returns Array of placeholder block IDs.
+   */
+  findAllPlaceholders() {
+    return this.#engine.findAllPlaceholders();
+  }
+  /**
+   * Find all blocks that are not part of the active scene tree (orphans).
+   * Useful for diagnosing leaks where blocks are created with `create(...)`
+   * but never appended to a parent.
+   * @returns Array of unreferenced block IDs.
+   */
+  findAllUnused() {
+    return this.#engine.findAllUnused();
+  }
+  /**
+   * Find blocks by their name.
+   * @param name - The name to search for.
+   * @returns Array of matching block IDs.
+   */
+  findByName(name) {
+    return this.#engine.findByName(name);
+  }
+  /**
+   * Find blocks by their type.
+   * @param type - The type to search for (e.g., '//ly.img.ubq/graphic').
+   * @returns Array of matching block IDs.
+   */
+  findByType(type) {
+    return this.#engine.findByType(type);
+  }
+  /**
+   * Find blocks by their kind.
+   * @param kind - The kind to search for (e.g., 'image', 'text', 'sticker').
+   * @returns Array of matching block IDs.
+   */
+  findByKind(kind) {
+    return this.#engine.findByKind(kind);
+  }
+  /**
+   * Find all currently selected blocks.
+   * @returns Array of selected block IDs.
+   */
+  findAllSelected() {
+    return this.#engine.findAllSelected();
+  }
+  // ==========================================================================
+  // Hierarchy
+  // ==========================================================================
+  /**
+   * Get the parent of a block.
+   * @param block - The ID of the block.
+   * @returns The ID of the parent block, or null if no parent.
+   */
+  getParent(block) {
+    if (!this.#engine.hasParent(block)) {
+      return null;
+    }
+    return this.#engine.getParent(block);
+  }
+  /**
+   * Check if a block has a parent.
+   * @param block - The ID of the block.
+   * @returns True if the block has a parent.
+   */
+  hasParent(block) {
+    return this.#engine.hasParent(block);
+  }
+  /**
+   * Get all children of a block.
+   * @param block - The ID of the parent block.
+   * @returns Array of child block IDs.
+   */
+  getChildren(block) {
+    return this.#engine.getChildren(block);
+  }
+  /**
+   * Insert a child block at a specific index.
+   * @param parent - The ID of the parent block.
+   * @param child - The ID of the child block to insert.
+   * @param index - The index at which to insert the child.
+   */
+  insertChild(parent, child, index) {
+    this.#engine.insertChild(parent, child, index);
+  }
+  /**
+   * Append a child block to the end of the parent's children.
+   * @param parent - The ID of the parent block.
+   * @param child - The ID of the child block to append.
+   */
+  appendChild(parent, child) {
+    this.#engine.appendChild(parent, child);
+  }
+  // ==========================================================================
+  // Properties - Generic
+  // ==========================================================================
+  /**
+   * Get the type of a block.
+   * @param block - The ID of the block.
+   * @returns The block type string (e.g., '//ly.img.ubq/graphic').
+   */
+  getType(block) {
+    return this.#engine.getType(block);
+  }
+  /**
+   * Get the kind of a block.
+   * @param block - The ID of the block.
+   * @returns The block kind string (e.g., 'image', 'text', 'sticker').
+   */
+  getKind(block) {
+    return this.#engine.getKind(block);
+  }
+  /**
+   * Set the kind of a block.
+   * @param block - The ID of the block.
+   * @param kind - The new kind value.
+   */
+  setKind(block, kind) {
+    this.#engine.setKind(block, kind);
+  }
+  /**
+   * Get the name of a block.
+   * @param block - The ID of the block.
+   * @returns The block name.
+   */
+  getName(block) {
+    return this.#engine.getName(block);
+  }
+  /**
+   * Set the name of a block.
+   * @param block - The ID of the block.
+   * @param name - The new name.
+   */
+  setName(block, name) {
+    this.#engine.setName(block, name);
+  }
+  /**
+   * Get the UUID of a block.
+   * @param block - The ID of the block.
+   * @returns The block's UUID string.
+   */
+  getUUID(block) {
+    return this.#engine.getUUID(block);
+  }
+  // Properties - typed
+  getBool(block, property) {
+    return this.#engine.getBool(block, property);
+  }
+  setBool(block, property, value) {
+    this.#engine.setBool(block, property, value);
+  }
+  getInt(block, property) {
+    return this.#engine.getInt(block, property);
+  }
+  setInt(block, property, value) {
+    this.#engine.setInt(block, property, value);
+  }
+  getFloat(block, property) {
+    return this.#engine.getFloat(block, property);
+  }
+  setFloat(block, property, value) {
+    this.#engine.setFloat(block, property, value);
+  }
+  getDouble(block, property) {
+    return this.#engine.getDouble(block, property);
+  }
+  setDouble(block, property, value) {
+    this.#engine.setDouble(block, property, value);
+  }
+  getString(block, property) {
+    return this.#engine.getString(block, property);
+  }
+  setString(block, property, value) {
+    this.#engine.setString(block, property, value);
+  }
+  getColor(block, property) {
+    const internalColor = this.#engine.getColor(
+      block,
+      property
+    );
+    return NativeColorInternal.toColor(internalColor);
+  }
+  setColor(block, property, value) {
+    const internalColor = NativeColorInternal.fromColor(value);
+    this.#engine.setColor(block, property, internalColor);
+  }
+  getColorRGBA(block, property) {
+    const color = this.getColor(block, property);
+    if (!isRGBAColor2(color)) {
+      throw new Error(
+        "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 };
+  }
+  setColorRGBA(block, property, r, g, b, a) {
+    this.setColor(block, property, { r, g, b, a });
+  }
+  getEnum(block, property) {
+    return this.#engine.getEnum(block, property);
+  }
+  setEnum(block, property, value) {
+    this.#engine.setEnum(block, property, value);
+  }
+  // Transform
+  getPositionX(block) {
+    return this.#engine.getPositionX(block);
+  }
+  setPositionX(block, value) {
+    this.#engine.setPositionX(block, value);
+  }
+  getPositionY(block) {
+    return this.#engine.getPositionY(block);
+  }
+  setPositionY(block, value) {
+    this.#engine.setPositionY(block, value);
+  }
+  getPositionXMode(block) {
+    return this.#engine.getPositionXMode(block);
+  }
+  setPositionXMode(block, mode) {
+    this.#engine.setPositionXMode(block, mode);
+  }
+  getPositionYMode(block) {
+    return this.#engine.getPositionYMode(block);
+  }
+  setPositionYMode(block, mode) {
+    this.#engine.setPositionYMode(block, mode);
+  }
+  getWidth(block) {
+    return this.#engine.getWidth(block);
+  }
+  setWidth(block, value) {
+    this.#engine.setWidth(block, value);
+  }
+  getWidthMode(block) {
+    return this.#engine.getWidthMode(block);
+  }
+  setWidthMode(block, mode) {
+    this.#engine.setWidthMode(block, mode);
+  }
+  getHeight(block) {
+    return this.#engine.getHeight(block);
+  }
+  setHeight(block, value) {
+    this.#engine.setHeight(block, value);
+  }
+  getHeightMode(block) {
+    return this.#engine.getHeightMode(block);
+  }
+  setHeightMode(block, mode) {
+    this.#engine.setHeightMode(block, mode);
+  }
+  getRotation(block) {
+    return this.#engine.getRotation(block);
+  }
+  setRotation(block, value) {
+    this.#engine.setRotation(block, value);
+  }
+  // Flip - WASM API has separate getters (no combined getFlip)
+  getFlipHorizontal(block) {
+    return this.#engine.getFlip(block).horizontal;
+  }
+  getFlipVertical(block) {
+    return this.#engine.getFlip(block).vertical;
+  }
+  setFlipHorizontal(block, flip) {
+    this.#engine.setFlipHorizontal(block, flip);
+  }
+  setFlipVertical(block, flip) {
+    this.#engine.setFlipVertical(block, flip);
+  }
+  // WASM API convenience method for position
+  setPosition(block, x, y, options) {
+    if (options?.positionMode) {
+      this.#engine.setPositionXMode(block, options.positionMode);
+      this.#engine.setPositionYMode(block, options.positionMode);
+    }
+    this.#engine.setPositionX(block, x);
+    this.#engine.setPositionY(block, y);
+  }
+  // WASM API convenience method for size
+  setSize(block, width, height, options) {
+    if (options?.sizeMode) {
+      this.#engine.setWidthMode(block, options.sizeMode);
+      this.#engine.setHeightMode(block, options.sizeMode);
+    }
+    this.#engine.setWidth(block, width);
+    this.#engine.setHeight(block, height);
+  }
+  scale(block, scale, anchorX, anchorY) {
+    this.#engine.scale(block, scale, anchorX, anchorY);
+  }
+  fillParent(block) {
+    this.#engine.fillParent(block);
+  }
+  resizeContentAware(blocks, width, height) {
+    return this.#engine.resizeContentAware(blocks, width, height);
+  }
+  // Global bounding box
+  getGlobalBoundingBoxX(block) {
+    return this.#engine.getGlobalBoundingBoxX(block);
+  }
+  getGlobalBoundingBoxY(block) {
+    return this.#engine.getGlobalBoundingBoxY(block);
+  }
+  getGlobalBoundingBoxWidth(block) {
+    return this.#engine.getGlobalBoundingBoxWidth(block);
+  }
+  getGlobalBoundingBoxHeight(block) {
+    return this.#engine.getGlobalBoundingBoxHeight(block);
+  }
+  getScreenSpaceBoundingBoxXYWH(blocks) {
+    return this.#engine.getScreenSpaceBoundingBoxXYWH(blocks);
+  }
+  // Fill - WASM also has hasFillColor and isFillColorEnabled
+  supportsFill(block) {
+    return this.#engine.supportsFill(block);
+  }
+  hasFill(block) {
+    return this.#engine.hasFill(block);
+  }
+  hasFillColor(block) {
+    return this.hasFill(block);
+  }
+  isFillColorEnabled(block) {
+    return this.#engine.getFillEnabled(block);
+  }
+  setFillColorEnabled(block, enabled) {
+    this.#engine.setFillEnabled(block, enabled);
+  }
+  getFillColorRGBA(block) {
+    const color = this.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 };
+  }
+  setFillColorRGBA(block, r, g, b, a) {
+    this.setFillSolidColor(block, r, g, b, a);
+  }
+  getFill(block) {
+    return this.#engine.getFill(block);
+  }
+  setFill(block, fill) {
+    this.#engine.setFill(block, fill);
+  }
+  getFillEnabled(block) {
+    return this.#engine.getFillEnabled(block);
+  }
+  isFillEnabled(block) {
+    return this.#engine.getFillEnabled(block);
+  }
+  setFillEnabled(block, enabled) {
+    this.#engine.setFillEnabled(block, enabled);
+  }
+  getFillSolidColor(block) {
+    return this.#engine.getFillSolidColor(block);
+  }
+  setFillSolidColor(block, r, g, b, a = 1) {
+    this.#engine.setFillSolidColor(block, { r, g, b, a });
+  }
+  getGradientColorStops(block, property) {
+    const raw = this.#engine.getGradientColorStops(block, property);
+    return raw.map((s) => ({
+      color: NativeColorInternal.toColor(s.color),
+      stop: s.stop
+    }));
+  }
+  setGradientColorStops(block, property, stops) {
+    const engineStops = stops.map((s) => ({
+      color: NativeColorInternal.fromColor(s.color),
+      stop: s.stop
+    }));
+    this.#engine.setGradientColorStops(block, property, engineStops);
+  }
+  // Stroke
+  supportsStroke(block) {
+    return this.#engine.supportsStroke(block);
+  }
+  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);
+  }
+  isStrokeEnabled(block) {
+    return this.#engine.getStrokeEnabled(block);
+  }
+  setStrokeEnabled(block, enabled) {
+    this.#engine.setStrokeEnabled(block, enabled);
+  }
+  getStrokeColor(block) {
+    const internalColor = this.#engine.getStrokeColor(
+      block
+    );
+    return NativeColorInternal.toColor(internalColor);
+  }
+  setStrokeColor(block, color) {
+    const internalColor = NativeColorInternal.fromColor(color);
+    this.#engine.setStrokeColor(block, internalColor);
+  }
+  getStrokeWidth(block) {
+    return this.#engine.getStrokeWidth(block);
+  }
+  setStrokeWidth(block, width) {
+    this.#engine.setStrokeWidth(block, width);
+  }
+  getStrokeStyle(block) {
+    return this.#engine.getStrokeStyle(block);
+  }
+  setStrokeStyle(block, style) {
+    this.#engine.setStrokeStyle(block, style);
+  }
+  getStrokePosition(block) {
+    return this.#engine.getStrokePosition(block);
+  }
+  setStrokePosition(block, position) {
+    this.#engine.setStrokePosition(block, position);
+  }
+  getStrokeCornerGeometry(block) {
+    return this.#engine.getStrokeCornerGeometry(block);
+  }
+  setStrokeCornerGeometry(block, geometry) {
+    this.#engine.setStrokeCornerGeometry(block, geometry);
+  }
+  // ─── Stroke caps + dash pattern (line shapes / dashed strokes) ──────────────
+  getStrokeCap(block) {
+    return this.#engine.getStrokeCap(block);
+  }
+  setStrokeCap(block, cap) {
+    this.#engine.setStrokeCap(block, cap);
+  }
+  getStrokeStartCap(block) {
+    return this.#engine.getStrokeStartCap(block);
+  }
+  setStrokeStartCap(block, cap) {
+    this.#engine.setStrokeStartCap(block, cap);
+  }
+  getStrokeEndCap(block) {
+    return this.#engine.getStrokeEndCap(block);
+  }
+  setStrokeEndCap(block, cap) {
+    this.#engine.setStrokeEndCap(block, cap);
+  }
+  getStrokeDashStartCap(block) {
+    return this.#engine.getStrokeDashStartCap(block);
+  }
+  setStrokeDashStartCap(block, cap) {
+    this.#engine.setStrokeDashStartCap(block, cap);
+  }
+  getStrokeDashEndCap(block) {
+    return this.#engine.getStrokeDashEndCap(block);
+  }
+  setStrokeDashEndCap(block, cap) {
+    this.#engine.setStrokeDashEndCap(block, cap);
+  }
+  getStrokeDashArray(block) {
+    return this.#engine.getStrokeDashArray(block);
+  }
+  setStrokeDashArray(block, dashArray) {
+    this.#engine.setStrokeDashArray(block, dashArray);
+  }
+  getStrokeDashOffset(block) {
+    return this.#engine.getStrokeDashOffset(block);
+  }
+  setStrokeDashOffset(block, dashOffset) {
+    this.#engine.setStrokeDashOffset(block, dashOffset);
+  }
+  isLineOrigin(block) {
+    return this.#engine.isLineOrigin(block);
+  }
+  getStrokeColorRGBA(block) {
+    return this.#engine.getStrokeColorRGBA(block);
+  }
+  setStrokeColorRGBA(block, r, g, b, a) {
+    this.#engine.setStrokeColorRGBA(block, r, g, b, a);
+  }
+  // Effects
+  supportsEffects(block) {
+    return this.#engine.supportsEffects(block);
+  }
+  hasEffects(block) {
+    return this.#engine.hasEffects(block);
+  }
+  getEffects(block) {
+    return this.#engine.getEffects(block);
+  }
+  appendEffect(block, effect) {
+    this.#engine.appendEffect(block, effect);
+  }
+  insertEffect(block, effect, index) {
+    this.#engine.insertEffect(block, effect, index);
+  }
+  removeEffect(block, index) {
+    this.#engine.removeEffect(block, index);
+  }
+  isEffectEnabled(effect) {
+    return this.#engine.isEffectEnabled(effect);
+  }
+  hasEffectEnabled(effect) {
+    return this.isEffectEnabled(effect);
+  }
+  setEffectEnabled(effect, enabled) {
+    this.#engine.setEffectEnabled(effect, enabled);
+  }
+  // Blur - WASM API uses isBlurEnabled
+  supportsBlur(block) {
+    return this.#engine.supportsBlur(block);
+  }
+  hasBlur(block) {
+    return this.#engine.hasBlur(block);
+  }
+  getBlur(block) {
+    return this.#engine.getBlur(block);
+  }
+  setBlur(block, blur) {
+    this.#engine.setBlur(block, blur);
+  }
+  getBlurEnabled(block) {
+    return this.#engine.getBlurEnabled(block);
+  }
+  isBlurEnabled(block) {
+    return this.#engine.getBlurEnabled(block);
+  }
+  setBlurEnabled(block, enabled) {
+    this.#engine.setBlurEnabled(block, enabled);
+  }
+  // Shape
+  supportsShape(block) {
+    return this.#engine.supportsShape(block);
+  }
+  getShape(block) {
+    return this.#engine.getShape(block);
+  }
+  setShape(block, shape) {
+    this.#engine.setShape(block, shape);
+  }
+  hasShape(block) {
+    return this.supportsShape(block);
+  }
+  // Animation
+  supportsAnimation(block) {
+    return this.#engine.supportsAnimation(block);
+  }
+  getInAnimation(block) {
+    return this.#engine.getInAnimation(block);
+  }
+  setInAnimation(block, animation) {
+    this.#engine.setInAnimation(block, animation);
+  }
+  getOutAnimation(block) {
+    return this.#engine.getOutAnimation(block);
+  }
+  setOutAnimation(block, animation) {
+    this.#engine.setOutAnimation(block, animation);
+  }
+  getLoopAnimation(block) {
+    return this.#engine.getLoopAnimation(block);
+  }
+  setLoopAnimation(block, animation) {
+    this.#engine.setLoopAnimation(block, animation);
+  }
+  // Content fill mode - WASM also has hasContentFillMode
+  supportsContentFillMode(block) {
+    return this.#engine.supportsContentFillMode(block);
+  }
+  hasContentFillMode(block) {
+    return this.supportsContentFillMode(block);
+  }
+  getContentFillMode(block) {
+    return this.#engine.getContentFillMode(block);
+  }
+  setContentFillMode(block, mode) {
+    this.#engine.setContentFillMode(block, mode);
+  }
+  // Content-fill alignment — applies to `Contain` / `Cover` fill modes.
+  // Has no visible effect in `Crop`.
+  setContentFillHorizontalAlignment(block, alignment) {
+    this.#engine.setContentFillHorizontalAlignment(block, alignment);
+  }
+  getContentFillHorizontalAlignment(block) {
+    return this.#engine.getContentFillHorizontalAlignment(
+      block
+    );
+  }
+  setContentFillVerticalAlignment(block, alignment) {
+    this.#engine.setContentFillVerticalAlignment(block, alignment);
+  }
+  getContentFillVerticalAlignment(block) {
+    return this.#engine.getContentFillVerticalAlignment(
+      block
+    );
+  }
+  // Crop - WASM also has hasCrop
+  supportsCrop(block) {
+    return this.#engine.supportsCrop(block);
+  }
+  hasCrop(block) {
+    return this.supportsCrop(block);
+  }
+  resetCrop(block) {
+    this.#engine.resetCrop(block);
+  }
+  // Match @cesdk/node — accept the `minScaleRatio` argument. The C++ binding
+  // already forwards it (defaults to 1.0 when omitted, see
+  // engine_binding_impl/appearance.cpp). The engine returns void; the WASM
+  // wrapper's `: number` declaration is a typing artefact (it forwards an
+  // `unpackResult` of a `Result<void>`, which is `undefined` at runtime), so
+  // native stays honest with `: void`.
+  adjustCropToFillFrame(block, minScaleRatio) {
+    this.#engine.adjustCropToFillFrame(block, minScaleRatio);
+  }
+  getCropRotation(block) {
+    return this.#engine.getCropRotation(block);
+  }
+  setCropRotation(block, rotation) {
+    this.#engine.setCropRotation(block, rotation);
+  }
+  getCropScaleX(block) {
+    return this.#engine.getCropScaleX(block);
+  }
+  setCropScaleX(block, scale) {
+    this.#engine.setCropScaleX(block, scale);
+  }
+  getCropScaleY(block) {
+    return this.#engine.getCropScaleY(block);
+  }
+  setCropScaleY(block, scale) {
+    this.#engine.setCropScaleY(block, scale);
+  }
+  getCropScaleRatio(block) {
+    return this.#engine.getCropScaleRatio(block);
+  }
+  setCropScaleRatio(block, ratio) {
+    this.#engine.setCropScaleRatio(block, ratio);
+  }
+  getCropTranslationX(block) {
+    return this.#engine.getCropTranslationX(block);
+  }
+  setCropTranslationX(block, translation) {
+    this.#engine.setCropTranslationX(block, translation);
+  }
+  getCropTranslationY(block) {
+    return this.#engine.getCropTranslationY(block);
+  }
+  setCropTranslationY(block, translation) {
+    this.#engine.setCropTranslationY(block, translation);
+  }
+  isCropAspectRatioLocked(block) {
+    return this.#engine.isCropAspectRatioLocked(block);
+  }
+  setCropAspectRatioLocked(block, locked) {
+    this.#engine.setCropAspectRatioLocked(block, locked);
+  }
+  flipCropHorizontal(block) {
+    this.#engine.flipCropHorizontal(block);
+  }
+  flipCropVertical(block) {
+    this.#engine.flipCropVertical(block);
+  }
+  // Drop shadow
+  supportsDropShadow(block) {
+    return this.#engine.supportsDropShadow(block);
+  }
+  hasDropShadow(block) {
+    return this.supportsDropShadow(block);
+  }
+  isDropShadowEnabled(block) {
+    return this.#engine.isDropShadowEnabled(block);
+  }
+  setDropShadowEnabled(block, enabled) {
+    this.#engine.setDropShadowEnabled(block, enabled);
+  }
+  getDropShadowColor(block) {
+    const internalColor = this.#engine.getDropShadowColor(
+      block
+    );
+    return NativeColorInternal.toColor(internalColor);
+  }
+  setDropShadowColor(block, color) {
+    const internalColor = NativeColorInternal.fromColor(color);
+    this.#engine.setDropShadowColor(block, internalColor);
+  }
+  getDropShadowColorRGBA(block) {
+    return this.#engine.getDropShadowColorRGBA(block);
+  }
+  setDropShadowColorRGBA(block, r, g, b, a) {
+    this.#engine.setDropShadowColorRGBA(block, r, g, b, a);
+  }
+  getDropShadowOffsetX(block) {
+    return this.#engine.getDropShadowOffsetX(block);
+  }
+  setDropShadowOffsetX(block, offset) {
+    this.#engine.setDropShadowOffsetX(block, offset);
+  }
+  getDropShadowOffsetY(block) {
+    return this.#engine.getDropShadowOffsetY(block);
+  }
+  setDropShadowOffsetY(block, offset) {
+    this.#engine.setDropShadowOffsetY(block, offset);
+  }
+  getDropShadowBlurRadiusX(block) {
+    return this.#engine.getDropShadowBlurRadiusX(block);
+  }
+  setDropShadowBlurRadiusX(block, radius) {
+    this.#engine.setDropShadowBlurRadiusX(block, radius);
+  }
+  getDropShadowBlurRadiusY(block) {
+    return this.#engine.getDropShadowBlurRadiusY(block);
+  }
+  setDropShadowBlurRadiusY(block, radius) {
+    this.#engine.setDropShadowBlurRadiusY(block, radius);
+  }
+  getDropShadowClip(block) {
+    return this.#engine.getDropShadowClip(block);
+  }
+  setDropShadowClip(block, clip) {
+    this.#engine.setDropShadowClip(block, clip);
+  }
+  // Blend mode
+  supportsBlendMode(block) {
+    return this.#engine.supportsBlendMode(block);
+  }
+  getBlendMode(block) {
+    return this.#engine.getBlendMode(block);
+  }
+  setBlendMode(block, mode) {
+    this.#engine.setBlendMode(block, mode);
+  }
+  hasBlendMode(block) {
+    return this.supportsBlendMode(block);
+  }
+  // Opacity
+  supportsOpacity(block) {
+    return this.#engine.supportsOpacity(block);
+  }
+  hasOpacity(block) {
+    return this.supportsOpacity(block);
+  }
+  getOpacity(block) {
+    return this.#engine.getOpacity(block);
+  }
+  setOpacity(block, opacity) {
+    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);
+  }
+  setClipped(block, clipped) {
+    this.#engine.setClipped(block, clipped);
+  }
+  // Selection
+  setSelected(block, selected) {
+    this.#engine.setSelected(block, selected);
+  }
+  isSelected(block) {
+    return this.#engine.isSelected(block);
+  }
+  select(block) {
+    this.#engine.select(block);
+  }
+  // Ordering
+  bringToFront(block) {
+    this.#engine.bringToFront(block);
+  }
+  sendToBack(block) {
+    this.#engine.sendToBack(block);
+  }
+  bringForward(block) {
+    this.#engine.bringForward(block);
+  }
+  sendBackward(block) {
+    this.#engine.sendBackward(block);
+  }
+  setAlwaysOnTop(block, enabled) {
+    this.#engine.setAlwaysOnTop(block, enabled);
+  }
+  setAlwaysOnBottom(block, enabled) {
+    this.#engine.setAlwaysOnBottom(block, enabled);
+  }
+  isAlwaysOnTop(block) {
+    return this.#engine.isAlwaysOnTop(block);
+  }
+  isAlwaysOnBottom(block) {
+    return this.#engine.isAlwaysOnBottom(block);
+  }
+  // Alignment and distribution
+  alignHorizontally(blocks, alignment) {
+    this.#engine.alignHorizontally(blocks, alignment);
+  }
+  alignVertically(blocks, alignment) {
+    this.#engine.alignVertically(blocks, alignment);
+  }
+  isAlignable(blocks) {
+    return this.#engine.isAlignable(blocks);
+  }
+  distributeHorizontally(blocks) {
+    this.#engine.distributeHorizontally(blocks);
+  }
+  distributeVertically(blocks) {
+    this.#engine.distributeVertically(blocks);
+  }
+  isDistributable(blocks) {
+    return this.#engine.isDistributable(blocks);
+  }
+  // Grouping
+  group(blocks) {
+    return this.#engine.group(blocks);
+  }
+  ungroup(group) {
+    this.#engine.ungroup(group);
+  }
+  isGroupable(blocks) {
+    return this.#engine.isGroupable(blocks);
+  }
+  enterGroup(group) {
+    this.#engine.enterGroup(group);
+  }
+  exitGroup(block) {
+    this.#engine.exitGroup(block);
+  }
+  // Combine
+  combine(blocks, operation) {
+    const validOps = ["Union", "Difference", "Intersection", "XOR"];
+    if (!validOps.includes(operation)) {
+      throw new Error(`Unknown boolean operation: ${operation}`);
+    }
+    return this.#engine.combine(blocks, operation);
+  }
+  isCombinable(blocks) {
+    return this.#engine.isCombinable(blocks);
+  }
+  // Duration/Timeline
+  supportsDuration(block) {
+    return this.#engine.supportsDuration(block);
+  }
+  hasDuration(block) {
+    return this.supportsDuration(block);
+  }
+  getDuration(block) {
+    return this.#engine.getDuration(block);
+  }
+  setDuration(block, duration) {
+    this.#engine.setDuration(block, duration);
+  }
+  supportsTimeOffset(block) {
+    return this.#engine.supportsTimeOffset(block);
+  }
+  hasTimeOffset(block) {
+    return this.supportsTimeOffset(block);
+  }
+  getTimeOffset(block) {
+    return this.#engine.getTimeOffset(block);
+  }
+  setTimeOffset(block, offset) {
+    this.#engine.setTimeOffset(block, offset);
+  }
+  supportsTrim(block) {
+    return this.#engine.supportsTrim(block);
+  }
+  hasTrim(block) {
+    return this.supportsTrim(block);
+  }
+  getTrimOffset(block) {
+    return this.#engine.getTrimOffset(block);
+  }
+  setTrimOffset(block, offset) {
+    this.#engine.setTrimOffset(block, offset);
+  }
+  getTrimLength(block) {
+    return this.#engine.getTrimLength(block);
+  }
+  setTrimLength(block, length) {
+    this.#engine.setTrimLength(block, length);
+  }
+  // Playback
+  supportsPlaybackControl(block) {
+    return this.#engine.supportsPlaybackControl(block);
+  }
+  hasPlaybackControl(block) {
+    return this.supportsPlaybackControl(block);
+  }
+  supportsPlaybackTime(block) {
+    return this.#engine.supportsPlaybackTime(block);
+  }
+  hasPlaybackTime(block) {
+    return this.supportsPlaybackTime(block);
+  }
+  getPlaybackTime(block) {
+    return this.#engine.getPlaybackTime(block);
+  }
+  setPlaybackTime(block, time) {
+    this.#engine.setPlaybackTime(block, time);
+  }
+  isPlaying(block) {
+    return this.#engine.isPlaying(block);
+  }
+  setPlaying(block, playing) {
+    this.#engine.setPlaying(block, playing);
+  }
+  isLooping(block) {
+    return this.#engine.isLooping(block);
+  }
+  setLooping(block, looping) {
+    this.#engine.setLooping(block, looping);
+  }
+  getPlaybackSpeed(block) {
+    return this.#engine.getPlaybackSpeed(block);
+  }
+  setPlaybackSpeed(block, speed) {
+    this.#engine.setPlaybackSpeed(block, speed);
+  }
+  isMuted(block) {
+    return this.#engine.isMuted(block);
+  }
+  setMuted(block, muted) {
+    this.#engine.setMuted(block, muted);
+  }
+  getVolume(block) {
+    return this.#engine.getVolume(block);
+  }
+  setVolume(block, volume) {
+    this.#engine.setVolume(block, volume);
+  }
+  isSoloPlaybackEnabled(block) {
+    return this.#engine.isSoloPlaybackEnabled(block);
+  }
+  setSoloPlaybackEnabled(block, enabled) {
+    this.#engine.setSoloPlaybackEnabled(block, enabled);
+  }
+  isForceMuted(block) {
+    return this.#engine.isForceMuted(block);
+  }
+  getTotalSceneDuration(scene) {
+    return this.#engine.getTotalSceneDuration(scene);
+  }
+  isVisibleAtCurrentPlaybackTime(block) {
+    return this.#engine.isVisibleAtCurrentPlaybackTime(block);
+  }
+  // Locking
+  isTransformLocked(block) {
+    return this.#engine.isTransformLocked(block);
+  }
+  setTransformLocked(block, locked) {
+    this.#engine.setTransformLocked(block, locked);
+  }
+  // Include in export
+  isIncludedInExport(block) {
+    return this.#engine.isIncludedInExport(block);
+  }
+  setIncludedInExport(block, included) {
+    this.#engine.setIncludedInExport(block, included);
+  }
+  // Placeholder
+  isPlaceholderEnabled(block) {
+    return this.#engine.isPlaceholderEnabled(block);
+  }
+  setPlaceholderEnabled(block, enabled) {
+    this.#engine.setPlaceholderEnabled(block, enabled);
+  }
+  supportsPlaceholderBehavior(block) {
+    return this.#engine.supportsPlaceholderBehavior(block);
+  }
+  hasPlaceholderBehavior(block) {
+    return this.supportsPlaceholderBehavior(block);
+  }
+  isPlaceholderBehaviorEnabled(block) {
+    return this.#engine.isPlaceholderBehaviorEnabled(block);
+  }
+  setPlaceholderBehaviorEnabled(block, enabled) {
+    this.#engine.setPlaceholderBehaviorEnabled(block, enabled);
+  }
+  supportsPlaceholderControls(block) {
+    return this.#engine.supportsPlaceholderControls(block);
+  }
+  hasPlaceholderControls(block) {
+    return this.supportsPlaceholderControls(block);
+  }
+  isPlaceholderControlsOverlayEnabled(block) {
+    return this.#engine.isPlaceholderControlsOverlayEnabled(block);
+  }
+  setPlaceholderControlsOverlayEnabled(block, enabled) {
+    this.#engine.setPlaceholderControlsOverlayEnabled(block, enabled);
+  }
+  isPlaceholderControlsButtonEnabled(block) {
+    return this.#engine.isPlaceholderControlsButtonEnabled(block);
+  }
+  setPlaceholderControlsButtonEnabled(block, enabled) {
+    this.#engine.setPlaceholderControlsButtonEnabled(block, enabled);
+  }
+  // Background color - WASM also has hasBackgroundColor and RGBA methods
+  supportsBackgroundColor(block) {
+    return this.#engine.supportsBackgroundColor(block);
+  }
+  hasBackgroundColor(block) {
+    return this.supportsBackgroundColor(block);
+  }
+  isBackgroundColorEnabled(block) {
+    return this.#engine.isBackgroundColorEnabled(block);
+  }
+  setBackgroundColorEnabled(block, enabled) {
+    this.#engine.setBackgroundColorEnabled(block, enabled);
+  }
+  getBackgroundColorRGBA(block) {
+    const internalColor = this.#engine.getColor(
+      block,
+      "backgroundColor"
+    );
+    const color = NativeColorInternal.toColor(internalColor);
+    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 };
+  }
+  setBackgroundColorRGBA(block, r, g, b, a) {
+    this.setColor(block, "backgroundColor", { r, g, b, a });
+  }
+  // Metadata
+  hasMetadata(block, key) {
+    return this.#engine.hasMetadata(block, key);
+  }
+  getMetadata(block, key) {
+    return this.#engine.getMetadata(block, key);
+  }
+  setMetadata(block, key, value) {
+    this.#engine.setMetadata(block, key, value);
+  }
+  removeMetadata(block, key) {
+    this.#engine.removeMetadata(block, key);
+  }
+  findAllMetadata(block) {
+    return this.#engine.findAllMetadata(block);
+  }
+  // ==========================================================================
+  // Text — range-aware methods accept UTF-16 indices (`from`/`to`) like WASM.
+  // The wrapper looks up the current text and converts to grapheme indices via
+  // `convertUTF16ToGraphemeRange` before forwarding to the engine.
+  // ==========================================================================
+  /**
+   * Resolve UTF-16 `from`/`to` to engine grapheme range. Returns the original
+   * range when both ends are negative ("fall back to current selection / full
+   * text"), so we avoid the engine round-trip when the caller didn't ask for
+   * a sub-range.
+   */
+  #toGraphemeRange(block, from, to) {
+    if (from < 0 && to < 0) return { from, to };
+    let text = "";
+    try {
+      text = this.#engine.getString(block, "text/text");
+    } catch {
+      return { from, to };
+    }
+    return convertUTF16ToGraphemeRange(text, from, to);
+  }
+  replaceText(block, text, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    this.#engine.replaceText(block, text, range.from, range.to);
+  }
+  removeText(block, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    this.#engine.removeText(block, range.from, range.to);
+  }
+  getTextFontSizes(block, fromOrOptions, to = -1) {
+    let from = -1;
+    let optTo = to;
+    let unit = "Point";
+    if (typeof fromOrOptions === "object" && fromOrOptions !== null) {
+      from = fromOrOptions.from ?? -1;
+      optTo = fromOrOptions.to ?? -1;
+      unit = fromOrOptions.unit ?? "Point";
+    } else if (typeof fromOrOptions === "number") {
+      from = fromOrOptions;
+    }
+    const range = this.#toGraphemeRange(block, from, optTo);
+    const sizesInPoints = this.#engine.getTextFontSizes(
+      block,
+      range.from,
+      range.to
+    );
+    if (unit === "Point") return sizesInPoints;
+    const scenes = this.findByType("//ly.img.ubq/scene");
+    if (scenes.length === 0) {
+      throw new Error("No scene found for unit conversion");
+    }
+    const dpi = this.getFloat(scenes[0], "scene/dpi");
+    return sizesInPoints.map((s) => convertFontSizeFromPoints(s, unit, dpi));
+  }
+  setTextFontSize(block, size, fromOrOptions, to = -1) {
+    let fontSizeInPoints = size;
+    let from = -1;
+    let optTo = to;
+    if (typeof fromOrOptions === "object" && fromOrOptions !== null) {
+      const {
+        unit = "Point",
+        from: optFrom = -1,
+        to: optionsTo = -1
+      } = fromOrOptions;
+      from = optFrom;
+      optTo = optionsTo;
+      if (unit !== "Point") {
+        const scenes = this.findByType("//ly.img.ubq/scene");
+        if (scenes.length === 0) {
+          throw new Error("No scene found for unit conversion");
+        }
+        const dpi = this.getFloat(scenes[0], "scene/dpi");
+        fontSizeInPoints = convertFontSizeToPoints(size, unit, dpi);
+      }
+    } else if (typeof fromOrOptions === "number") {
+      from = fromOrOptions;
+    }
+    const range = this.#toGraphemeRange(block, from, optTo);
+    this.#engine.setTextFontSize(block, fontSizeInPoints, range.from, range.to);
+  }
+  getTextFontStyles(block, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    return this.#engine.getTextFontStyles(block, range.from, range.to);
+  }
+  setTextFontStyle(block, style, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    this.#engine.setTextFontStyle(block, style, range.from, range.to);
+  }
+  getTextFontWeights(block, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    return this.#engine.getTextFontWeights(block, range.from, range.to);
+  }
+  setTextFontWeight(block, weight, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    this.#engine.setTextFontWeight(block, weight, range.from, range.to);
+  }
+  getTextColors(block, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    const internalColors = this.#engine.getTextColors(
+      block,
+      range.from,
+      range.to
+    );
+    return internalColors.map((c) => NativeColorInternal.toColor(c));
+  }
+  setTextColor(block, color, from = -1, to = -1) {
+    const internalColor = NativeColorInternal.fromColor(color);
+    const range = this.#toGraphemeRange(block, from, to);
+    this.#engine.setTextColor(block, internalColor, range.from, range.to);
+  }
+  getTextCases(block, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    return this.#engine.getTextCases(block, range.from, range.to);
+  }
+  setTextCase(block, textCase, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    this.#engine.setTextCase(block, textCase, range.from, range.to);
+  }
+  getTypefaces(block, from, to) {
+    const range = this.#toGraphemeRange(block, from ?? -1, to ?? -1);
+    return this.#engine.getTypefaces(block, range.from, range.to);
+  }
+  setTypeface(block, typeface, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    this.#engine.setTypeface(block, typeface, range.from, range.to);
+  }
+  getTypeface(block) {
+    return this.#engine.getTypeface(block);
+  }
+  /**
+   * Set extra character-level kerning offset for a grapheme range. The
+   * value is in em units (1.0 = one full em); 0.0 resets to no extra
+   * offset. Matches the node wasm binding's `BlockAPI.setTextKerning`.
+   */
+  setTextKerning(block, kerning, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    this.#engine.setTextKerning(block, kerning, range.from, range.to);
+  }
+  /**
+   * Return the unique kerning values seen across the grapheme range.
+   * Mirrors `getTextFontSizes` / `getTextFontStyles` — `[0]` for a clean
+   * block, `[v1, v2, …]` when the range spans multiple distinct values.
+   */
+  getTextKernings(block, from, to) {
+    const range = this.#toGraphemeRange(block, from ?? -1, to ?? -1);
+    return this.#engine.getTextKernings(block, range.from, range.to);
+  }
+  setFont(block, fontUri, typeface) {
+    this.#engine.setFont(block, fontUri, typeface);
+  }
+  canToggleBoldFont(block) {
+    return this.#engine.canToggleBoldFont(block);
+  }
+  toggleBoldFont(block) {
+    this.#engine.toggleBoldFont(block);
+  }
+  canToggleItalicFont(block) {
+    return this.#engine.canToggleItalicFont(block);
+  }
+  toggleItalicFont(block) {
+    this.#engine.toggleItalicFont(block);
+  }
+  /**
+   * The text block currently being edited, or `undefined` when not in Text
+   * edit mode. Used to convert between UTF-16 and grapheme indices when
+   * exposing cursor ranges.
+   */
+  #findActiveTextBlock() {
+    try {
+      const editMode = this.#engine.getEditMode();
+      if (editMode !== "Text") return void 0;
+    } catch {
+      return void 0;
+    }
+    const selected = this.#engine.findAllSelected();
+    for (const block of selected) {
+      try {
+        if (this.#engine.getType(block) === "//ly.img.ubq/text") {
+          return block;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Returns the current text cursor range as UTF-16 indices. When no block
+   * is currently being edited, returns `{ from: -1, to: -1 }`.
+   */
+  getTextCursorRange() {
+    const grapheme = this.#engine.getTextCursorRange();
+    if (grapheme.from < 0 && grapheme.to < 0) return grapheme;
+    const block = this.#findActiveTextBlock();
+    if (block == null) return grapheme;
+    let text = "";
+    try {
+      text = this.#engine.getString(block, "text/text");
+    } catch {
+      return grapheme;
+    }
+    return convertGraphemeToUTF16Range(text, grapheme.from, grapheme.to);
+  }
+  /**
+   * Sets the text cursor range. `from`/`to` are UTF-16 indices. Negative
+   * values mean "from start" / "to end" (so `{ from: -1, to: -1 }` selects
+   * the entire text).
+   */
+  setTextCursorRange(range) {
+    const block = this.#findActiveTextBlock();
+    if (block == null) {
+      throw new Error("No text block is currently being edited.");
+    }
+    let { from, to } = range;
+    if (from >= 0 || to >= 0) {
+      const text = this.#engine.getString(block, "text/text");
+      ({ from, to } = convertUTF16ToGraphemeRange(text, from, to));
+    }
+    this.#engine.setTextCursorRange(from, to);
+  }
+  getTextCursorPositionInScreenSpaceX(block) {
+    return this.#engine.getTextCursorPositionInScreenSpaceX(block);
+  }
+  getTextCursorPositionInScreenSpaceY(block) {
+    return this.#engine.getTextCursorPositionInScreenSpaceY(block);
+  }
+  getTextVisibleLineCount(block) {
+    return this.#engine.getTextVisibleLineCount(block);
+  }
+  getTextVisibleLineContent(block, lineIndex) {
+    return this.#engine.getTextVisibleLineContent(block, lineIndex);
+  }
+  getTextVisibleLineGlobalBoundingBoxXYWH(block, lineIndex) {
+    return this.#engine.getTextVisibleLineGlobalBoundingBoxXYWH(
+      block,
+      lineIndex
+    );
+  }
+  /**
+   * Returns the tight ink-paint bounding box for each grapheme in the
+   * range. One entry per grapheme in [from, to). Non-printable graphemes
+   * (e.g. newline) get a zero-rect entry. Coordinates are in global
+   * scene space.
+   *
+   * @param block - The text block to query.
+   * @param from - Start UTF-16 index (-1 = start of cursor selection or 0).
+   * @param to   - End UTF-16 index (-1 = end of cursor selection or text length).
+   */
+  getTextCharacterInkBoxes(block, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    return this.#engine.getTextCharacterInkBoxes(block, range.from, range.to);
+  }
+  getTextEffectiveHorizontalAlignment(block) {
+    return this.#engine.getTextEffectiveHorizontalAlignment(block);
+  }
+  /**
+   * Returns the horizontal alignment override for a specific paragraph, or
+   * the block-level alignment for negative paragraph indices. Returns
+   * `undefined` when no override is set for the given paragraph.
+   * @param block - The text block to query.
+   * @param paragraphIndex - 0-based paragraph index. Negative values return
+   *                         the block-level `text/horizontalAlignment` setting.
+   */
+  getTextHorizontalAlignment(block, paragraphIndex = -1) {
+    return this.#engine.getTextHorizontalAlignment(block, paragraphIndex);
+  }
+  /**
+   * Sets the horizontal alignment override for a specific paragraph of a text
+   * block. Pass `undefined` for `alignment` to clear the paragraph-level
+   * override. Negative `paragraphIndex` clears all paragraph overrides and
+   * applies the alignment block-wide.
+   */
+  setTextHorizontalAlignment(block, alignment, paragraphIndex = -1) {
+    this.#engine.setTextHorizontalAlignment(block, alignment, paragraphIndex);
+  }
+  /**
+   * Returns the ordered list of unique text-decoration configurations within
+   * the given grapheme range. `from` / `to` are UTF-16 indices and are
+   * converted to grapheme indices to match WASM semantics.
+   */
+  getTextDecorations(block, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    const raw = this.#engine.getTextDecorations(
+      block,
+      range.from,
+      range.to
+    );
+    return raw.map((c) => {
+      const result = { lines: c.lines ?? [] };
+      if (c.style != null) result.style = c.style;
+      if (c.underlineColor != null)
+        result.underlineColor = NativeColorInternal.toColor(c.underlineColor);
+      if (c.underlineThickness != null)
+        result.underlineThickness = c.underlineThickness;
+      if (c.underlineOffset != null) result.underlineOffset = c.underlineOffset;
+      if (c.skipInk != null) result.skipInk = c.skipInk;
+      return result;
+    });
+  }
+  /**
+   * Sets the given text-decoration config for the given grapheme range. Set
+   * `lines: ['None']` to clear all decorations.
+   */
+  setTextDecoration(block, config, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    const internal = {
+      lines: config.lines,
+      style: config.style,
+      underlineColor: config.underlineColor != null ? NativeColorInternal.fromColor(config.underlineColor) : void 0,
+      underlineThickness: config.underlineThickness,
+      underlineOffset: config.underlineOffset,
+      skipInk: config.skipInk
+    };
+    this.#engine.setTextDecoration(block, internal, range.from, range.to);
+  }
+  toggleTextDecorationUnderline(block, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    this.#engine.toggleTextDecorationUnderline(block, range.from, range.to);
+  }
+  toggleTextDecorationStrikethrough(block, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    this.#engine.toggleTextDecorationStrikethrough(block, range.from, range.to);
+  }
+  toggleTextDecorationOverline(block, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    this.#engine.toggleTextDecorationOverline(block, range.from, range.to);
+  }
+  // Text lists
+  getTextListStyle(block, paragraphIndex) {
+    return this.#engine.getTextListStyle(block, paragraphIndex);
+  }
+  setTextListStyle(block, listStyle, paragraphIndex = -1, listLevel) {
+    this.#engine.setTextListStyle(block, listStyle, paragraphIndex, listLevel);
+  }
+  getTextListLevel(block, paragraphIndex) {
+    return this.#engine.getTextListLevel(block, paragraphIndex);
+  }
+  setTextListLevel(block, listLevel, paragraphIndex = -1) {
+    this.#engine.setTextListLevel(block, listLevel, paragraphIndex);
+  }
+  /**
+   * Returns the 0-based paragraph indices that overlap the given UTF-16 range.
+   * Range is half-open: `from` inclusive, `to` exclusive. Negative values mean
+   * "all paragraphs". When `from === to`, returns the paragraph containing the
+   * cursor at `from`.
+   */
+  getTextParagraphIndices(block, from = -1, to = -1) {
+    const range = this.#toGraphemeRange(block, from, to);
+    return this.#engine.getTextParagraphIndices(block, range.from, range.to);
+  }
+  getTextLineHeight(block, paragraphIndex) {
+    return this.#engine.getTextLineHeight(block, paragraphIndex);
+  }
+  setTextLineHeight(block, lineHeight, paragraphIndex = -1) {
+    this.#engine.setTextLineHeight(
+      block,
+      lineHeight ?? void 0,
+      paragraphIndex
+    );
+  }
+  getFontMetrics(fontFileUri) {
+    return this.#engine.getFontMetrics(fontFileUri);
+  }
+  // Source sets
+  getSourceSet(block, property) {
+    return this.#engine.getSourceSet(block, property);
+  }
+  setSourceSet(block, property, sources) {
+    this.#engine.setSourceSet(block, property, sources);
+  }
+  addImageFileURIToSourceSet(block, property, uri) {
+    return this.#engine.addImageFileURIToSourceSet(block, property, uri);
+  }
+  addVideoFileURIToSourceSet(block, property, uri) {
+    return this.#engine.addVideoFileURIToSourceSet(block, property, uri);
+  }
+  // Video/Audio info
+  getVideoWidth(block) {
+    return this.#engine.getVideoWidth(block);
+  }
+  getVideoHeight(block) {
+    return this.#engine.getVideoHeight(block);
+  }
+  getAudioTrackCountFromVideo(block) {
+    return this.#engine.getAudioTrackCountFromVideo(block);
+  }
+  getAVResourceTotalDuration(block) {
+    return this.#engine.getAVResourceTotalDuration(block);
+  }
+  /**
+   * Splits the block at the given time. The original block keeps the
+   * leading portion; the trailing portion is returned as a newly
+   * created block id (matches `@cesdk/node`'s return contract).
+   *
+   * @remarks Matches `@cesdk/node`'s `SplitOptions` shape:
+   * `attachToParent` and `selectNewBlock` default to `true`,
+   * `createParentTrackIfNeeded` defaults to `false`. Non-default values
+   * are accepted for shape parity but not yet plumbed to the C++ binding
+   * — when set, a warning is emitted so callers can detect the gap.
+   *
+   * @param block - The block to split.
+   * @param atTime - The time (seconds) at which to split.
+   * @param options - Split-behavior overrides.
+   * @returns The id of the newly created trailing block.
+   * @public
+   */
+  split(block, atTime, options = {}) {
+    const {
+      attachToParent = true,
+      createParentTrackIfNeeded = false,
+      selectNewBlock = true
+    } = options;
+    if (attachToParent !== true || createParentTrackIfNeeded !== false || selectNewBlock !== true) {
+      console.warn(
+        "[@cesdk/node-native] block.split() options are accepted for shape parity but not yet plumbed through the C++ binding. The engine will use defaults (attachToParent: true, createParentTrackIfNeeded: false, selectNewBlock: true)."
+      );
+    }
+    return this.#engine.split(block, atTime);
+  }
+  // Frame position/size - WASM API uses getFrameX/Y/Width/Height
+  getFrameX(block) {
+    return this.#engine.getLastFrameX(block);
+  }
+  getFrameY(block) {
+    return this.#engine.getLastFrameY(block);
+  }
+  getFrameWidth(block) {
+    return this.#engine.getLastFrameWidth(block);
+  }
+  getFrameHeight(block) {
+    return this.#engine.getLastFrameHeight(block);
+  }
+  // Page duration source
+  supportsPageDurationSource(page, block) {
+    return this.#engine.supportsPageDurationSource(page, block);
+  }
+  setPageDurationSource(page, block) {
+    this.#engine.setPageDurationSource(page, block);
+  }
+  removePageDurationSource(page) {
+    this.#engine.removePageDurationSource(page);
+  }
+  isPageDurationSource(block) {
+    return this.#engine.isPageDurationSource(block);
+  }
+  // Scope - block-level methods only (findAllScopes, getGlobalScope, setGlobalScope are on EditorAPI)
+  isScopeEnabled(block, scope) {
+    return this.#engine.isScopeEnabled(block, scope);
+  }
+  setScopeEnabled(block, scope, enabled) {
+    this.#engine.setScopeEnabled(block, scope, enabled);
+  }
+  isAllowedByScope(block, scope) {
+    return this.#engine.isAllowedByScope(block, scope);
+  }
+  // Properties
+  findAllProperties(block) {
+    return this.#engine.findAllProperties(block);
+  }
+  getPropertyType(blockOrProperty, property) {
+    const propName = typeof blockOrProperty === "string" ? blockOrProperty : property;
+    return this.#engine.getPropertyType(propName);
+  }
+  isPropertyReadable(blockOrProperty, property) {
+    const propName = typeof blockOrProperty === "string" ? blockOrProperty : property;
+    return this.#engine.isPropertyReadable(propName);
+  }
+  isPropertyWritable(blockOrProperty, property) {
+    const propName = typeof blockOrProperty === "string" ? blockOrProperty : property;
+    return this.#engine.isPropertyWritable(propName);
+  }
+  getEnumValues(blockOrProperty, property) {
+    const propName = typeof blockOrProperty === "string" ? blockOrProperty : property;
+    return this.#engine.getEnumValues(propName);
+  }
+  // State
+  getState(block) {
+    return this.#engine.getState(block);
+  }
+  async export(block, mimeTypeOrOptions, optionsOrUndefined) {
+    let mimeType;
+    let options;
+    if (typeof mimeTypeOrOptions === "string") {
+      mimeType = mimeTypeOrOptions;
+      options = optionsOrUndefined;
+    } else {
+      options = mimeTypeOrOptions;
+      mimeType = options?.mimeType ?? "image/png";
+    }
+    const buffer = await this.exportToBuffer(block, mimeType, options);
+    return new Blob([buffer], { type: mimeType });
+  }
+  exportToBuffer(block, mimeType, options) {
+    const exportOptions = {
+      targetWidth: options?.targetWidth ?? 0,
+      targetHeight: options?.targetHeight ?? 0,
+      useTargetSize: options?.targetWidth != null && options?.targetHeight != null,
+      jpegQuality: options?.jpegQuality ?? 0.9,
+      webpQuality: options?.webpQuality ?? 1,
+      pngCompressionLevel: options?.pngCompressionLevel ?? 5,
+      exportPdfWithHighCompatibility: options?.exportPdfWithHighCompatibility ?? true,
+      exportPdfWithDeviceCMYK: options?.exportPdfWithDeviceCMYK ?? false,
+      exportPdfWithUnderlayer: options?.exportPdfWithUnderlayer ?? false,
+      underlayerSpotColorName: options?.underlayerSpotColorName ?? "",
+      underlayerOffset: options?.underlayerOffset ?? 0,
+      underlayerRenderRatio: options?.underlayerRenderRatio ?? 1,
+      underlayerMaxError: options?.underlayerMaxError ?? 2,
+      allowTextOverhang: options?.allowTextOverhang ?? false
+    };
+    return this.#engine.exportToBuffer(block, mimeType, exportOptions);
+  }
+  async exportWithColorMask(block, arg2, arg3, arg4, arg5, arg6) {
+    let mimeType;
+    let maskColorR;
+    let maskColorG;
+    let maskColorB;
+    let options;
+    if (typeof arg2 === "number") {
+      maskColorR = arg2;
+      maskColorG = arg3;
+      maskColorB = arg4;
+      options = typeof arg5 === "number" ? void 0 : arg5;
+      mimeType = options?.mimeType ?? "image/png";
+    } else {
+      mimeType = arg2 ?? "image/png";
+      maskColorR = arg3;
+      maskColorG = arg4;
+      maskColorB = arg5 ?? 0;
+      options = arg6;
+    }
+    const exportOptions = {
+      targetWidth: options?.targetWidth ?? 0,
+      targetHeight: options?.targetHeight ?? 0,
+      useTargetSize: options?.targetWidth != null && options?.targetHeight != null,
+      jpegQuality: options?.jpegQuality ?? 0.9,
+      webpQuality: options?.webpQuality ?? 1,
+      pngCompressionLevel: options?.pngCompressionLevel ?? 5,
+      exportPdfWithHighCompatibility: options?.exportPdfWithHighCompatibility ?? true,
+      exportPdfWithDeviceCMYK: options?.exportPdfWithDeviceCMYK ?? false,
+      exportPdfWithUnderlayer: options?.exportPdfWithUnderlayer ?? false,
+      underlayerSpotColorName: options?.underlayerSpotColorName ?? "",
+      underlayerOffset: options?.underlayerOffset ?? 0,
+      underlayerRenderRatio: options?.underlayerRenderRatio ?? 1,
+      underlayerMaxError: options?.underlayerMaxError ?? 2,
+      allowTextOverhang: options?.allowTextOverhang ?? false
+    };
+    const buffers = await this.#engine.exportWithColorMaskToBuffer(
+      block,
+      mimeType,
+      maskColorR,
+      maskColorG,
+      maskColorB,
+      exportOptions
+    );
+    return buffers.map((buf) => new Blob([buf], { type: mimeType }));
+  }
+  async exportVideo(block, mimeTypeOrOptions, progressCallbackOrUndefined, optionsOrUndefined) {
+    let mimeType;
+    let progressCallback;
+    let options;
+    if (typeof mimeTypeOrOptions === "string") {
+      mimeType = mimeTypeOrOptions;
+      progressCallback = progressCallbackOrUndefined;
+      options = optionsOrUndefined;
+    } else {
+      const bag = mimeTypeOrOptions;
+      mimeType = bag?.mimeType ?? "video/mp4";
+      progressCallback = bag?.onProgress;
+      options = bag;
+    }
+    const buffer = await this.exportVideoToBuffer(
+      block,
+      mimeType,
+      options,
+      progressCallback
+    );
+    return new Blob([buffer], { type: mimeType });
+  }
+  exportVideoToBuffer(block, mimeType, options, progressCallback) {
+    return new Promise((resolve, reject) => {
+      const defaultOptions = {
+        h264Profile: 77,
+        // Main (H264VideoProfile::Main = 77)
+        h264Level: 52,
+        videoBitrate: 0,
+        audioBitrate: 0,
+        framerate: 30,
+        useTargetSize: false,
+        targetWidth: 0,
+        targetHeight: 0,
+        allowTextOverhang: false,
+        ...options
+      };
+      this.#engine.exportVideoToBuffer(
+        block,
+        options?.timeOffset ?? 0,
+        options?.duration ?? this.getDuration(block),
+        mimeType,
+        progressCallback ?? (() => {
+        }),
+        (errorOrNull, data) => {
+          if (errorOrNull) {
+            reject(
+              errorOrNull instanceof Error ? errorOrNull : new Error(String(errorOrNull))
+            );
+          } else if (data) {
+            resolve(data);
+          } else {
+            reject(new Error("Video export returned no data"));
+          }
+        },
+        defaultOptions
+      );
+    });
+  }
+  async exportAudio(block, mimeTypeOrOptions, optionsOrUndefined) {
+    let mimeType;
+    let options;
+    if (typeof mimeTypeOrOptions === "string") {
+      mimeType = mimeTypeOrOptions;
+      options = optionsOrUndefined;
+    } else {
+      options = mimeTypeOrOptions;
+      mimeType = options?.mimeType ?? "audio/wav";
+    }
+    const buffer = await this.exportAudioToBuffer(block, mimeType, options);
+    return new Blob([buffer], { type: mimeType });
+  }
+  exportAudioToBuffer(block, mimeType, options) {
+    return new Promise((resolve, reject) => {
+      const defaultOptions = {
+        sampleRate: 48e3,
+        numberOfChannels: 2,
+        skipEncoding: false,
+        ...options
+      };
+      this.#engine.exportAudioToBuffer(
+        block,
+        options?.timeOffset ?? 0,
+        options?.duration ?? this.getDuration(block),
+        mimeType,
+        options?.onProgress ?? (() => {
+        }),
+        (errorOrNull, data) => {
+          if (errorOrNull) {
+            reject(
+              errorOrNull instanceof Error ? errorOrNull : new Error(String(errorOrNull))
+            );
+          } else if (data) {
+            resolve(data);
+          } else {
+            reject(new Error("Audio export returned no data"));
+          }
+        },
+        defaultOptions
+      );
+    });
+  }
+  // Loading/Saving blocks
+  loadFromString(content) {
+    if (content.length === 0) {
+      return Promise.reject(new Error("Cannot load from empty string"));
+    }
+    return this.#engine.loadBlocksFromString(content);
+  }
+  loadFromURL(url) {
+    return this.#engine.loadBlocksFromURL(url);
+  }
+  /**
+   * Load blocks from an archive URL.
+   * Also supports data URIs (data:application/zip;base64,...) which are converted to buffer:// protocol internally.
+   * @param url - The URL of the archive file, or a data URI containing base64-encoded archive data.
+   * @returns A promise that resolves with an array of block IDs.
+   */
+  async loadFromArchiveURL(url) {
+    if (url.startsWith("data:")) {
+      const matches = url.match(/^data:([^;,]+)?(?:;base64)?,(.*)$/);
+      if (!matches) {
+        throw new Error("Invalid data URI format");
+      }
+      const base64Data = matches[2];
+      const buffer = Buffer.from(base64Data, "base64");
+      const bufferUri = this.#engine.createBuffer();
+      this.#engine.setBufferData(bufferUri, 0, new Uint8Array(buffer));
+      try {
+        return await this.#engine.loadBlocksFromArchiveURL(bufferUri);
+      } finally {
+        this.#engine.destroyBuffer(bufferUri);
+      }
+    }
+    return this.#engine.loadBlocksFromArchiveURL(url);
+  }
+  saveToString(blocks) {
+    return this.#engine.saveBlocksToString(blocks);
+  }
+  // BlockAPI.saveToArchive matches @cesdk/node and returns Promise<Blob>. The
+  // raw Uint8Array form remains accessible via the engine binding for
+  // power-users that want to skip the wrapper.
+  async saveToArchive(blocks) {
+    const buffer = await this.#engine.saveBlocksToArchive(blocks);
+    return new Blob([buffer]);
+  }
+  /**
+   * Force-load the audio/video resource for an audio block or video-fill block.
+   * Resolves once the asset is fully fetched and demuxed (so subsequent
+   * `exportVideo` calls have data immediately available on frame 0). Without
+   * this prime, the encoder can race ahead of the HTTP fetch and produce
+   * silent audio / black-frame video segments.
+   */
+  forceLoadAVResource(block) {
+    return this.#engine.forceLoadAVResource(block);
+  }
+  /**
+   * Force-load every resource referenced by `blocks`. Useful before
+   * `exportVideo` on a scene with multiple remote assets — saves N network
+   * round-trips compared to calling `forceLoadAVResource` per block.
+   */
+  forceLoadResources(blocks) {
+    return this.#engine.forceLoadResources(blocks);
+  }
+  // -------------------------------------------------------------------------
+  // Composition helpers (parity with @cesdk/node's `addImage` / `addVideo` /
+  // `applyAnimation` / `applyDropShadow`).
+  //
+  // These are TS-level convenience wrappers, not engine primitives. WASM
+  // ships them on its BlockAPI; native must too so a drop-in `addImage`
+  // call doesn't throw `TypeError: not a function`.
+  // -------------------------------------------------------------------------
+  /**
+   * Apply an animation set (in/loop/out) to a block. Mirrors
+   * `@cesdk/node`'s `BlockAPI.applyAnimation` exactly.
+   *
+   * @public
+   */
+  applyAnimation(block, animation = {}) {
+    const apply = (entry, setter) => {
+      if (entry == null) return;
+      const animBlock = this.createAnimation(entry.type);
+      setter(block, animBlock);
+      if (entry.duration !== void 0) {
+        this.setDuration(animBlock, entry.duration);
+      }
+      if (entry.easing != null) {
+        try {
+          const enumValues = this.getEnumValues("animationEasing");
+          if (enumValues.includes(entry.easing)) {
+            this.setEnum(animBlock, "animationEasing", entry.easing);
+          }
+        } catch {
+        }
+      }
+    };
+    apply(animation.in, (b, a) => this.setInAnimation(b, a));
+    apply(animation.out, (b, a) => this.setOutAnimation(b, a));
+    apply(animation.loop, (b, a) => this.setLoopAnimation(b, a));
+  }
+  /**
+   * Apply a drop shadow effect to a block. Mirrors `@cesdk/node`'s
+   * `BlockAPI.applyDropShadow` exactly.
+   *
+   * @public
+   */
+  applyDropShadow(block, options = {}) {
+    this.setDropShadowEnabled(block, true);
+    if (options.color != null) {
+      this.setDropShadowColor(block, options.color);
+    }
+    if (options.offset != null) {
+      if (options.offset.x != null)
+        this.setDropShadowOffsetX(block, options.offset.x);
+      if (options.offset.y != null)
+        this.setDropShadowOffsetY(block, options.offset.y);
+    }
+    if (options.blur != null) {
+      if (options.blur.x != null)
+        this.setDropShadowBlurRadiusX(block, options.blur.x);
+      if (options.blur.y != null)
+        this.setDropShadowBlurRadiusY(block, options.blur.y);
+    }
+  }
+  /**
+   * Add an image to the current page as a graphic block with an image fill.
+   * Mirrors `@cesdk/node`'s `BlockAPI.addImage` shape — same options bag,
+   * same chained-call sequence.
+   *
+   * @remarks Unlike WASM (which uses `new Image()` to auto-detect size when
+   * `options.size` is omitted), Node has no DOM `Image` global. In Node,
+   * `options.size` must be supplied; calling without it throws a clear
+   * error with the suggested fix.
+   *
+   * @public
+   */
+  addImage(url, options = {}) {
+    const {
+      x,
+      y,
+      size,
+      timeline,
+      animation,
+      shadow,
+      cornerRadius,
+      sizeMode = "Absolute",
+      positionMode = "Absolute"
+    } = options;
+    let finalWidth;
+    let finalHeight;
+    if (size != null) {
+      if (typeof size === "number") {
+        finalWidth = size;
+        finalHeight = size;
+      } else {
+        finalWidth = size.width;
+        finalHeight = size.height;
+      }
+    } else {
+      throw new Error(
+        "[@cesdk/node-native] block.addImage requires `options.size` in Node (no DOM Image global for auto-sizing). Pass `{ size: { width, height } }` or `{ size: <px> }`."
+      );
+    }
+    const scenes = this.findByType("//ly.img.ubq/scene");
+    if (scenes.length === 0) {
+      throw new Error("No scene found. Call engine.scene.create() first.");
+    }
+    const pages = this.findByType("//ly.img.ubq/page");
+    if (pages.length === 0) {
+      throw new Error("No page found in scene. Create a page first.");
+    }
+    const page = pages[0];
+    const graphicBlock = this.create("graphic");
+    this.appendChild(page, graphicBlock);
+    this.setPositionXMode(graphicBlock, positionMode);
+    this.setPositionYMode(graphicBlock, positionMode);
+    this.setWidthMode(graphicBlock, sizeMode);
+    this.setHeightMode(graphicBlock, sizeMode);
+    if (finalWidth != null) this.setWidth(graphicBlock, finalWidth);
+    if (finalHeight != null) this.setHeight(graphicBlock, finalHeight);
+    if (x != null) {
+      this.setPositionX(graphicBlock, x);
+    } else {
+      this.alignHorizontally([graphicBlock], "Center");
+    }
+    if (y != null) {
+      this.setPositionY(graphicBlock, y);
+    } else {
+      this.alignVertically([graphicBlock], "Center");
+    }
+    const shapeBlock = this.createShape("rect");
+    this.setShape(graphicBlock, shapeBlock);
+    if (cornerRadius != null) {
+      this.setFloat(shapeBlock, "shape/rect/cornerRadiusBL", cornerRadius);
+      this.setFloat(shapeBlock, "shape/rect/cornerRadiusBR", cornerRadius);
+      this.setFloat(shapeBlock, "shape/rect/cornerRadiusTL", cornerRadius);
+      this.setFloat(shapeBlock, "shape/rect/cornerRadiusTR", cornerRadius);
+    }
+    const fillBlock = this.createFill("image");
+    this.setFill(graphicBlock, fillBlock);
+    this.setString(fillBlock, "fill/image/imageFileURI", url);
+    if (shadow != null) this.applyDropShadow(graphicBlock, shadow);
+    if (timeline?.timeOffset != null)
+      this.setTimeOffset(graphicBlock, timeline.timeOffset);
+    if (timeline?.duration != null)
+      this.setDuration(graphicBlock, timeline.duration);
+    if (animation != null) this.applyAnimation(graphicBlock, animation);
+    return graphicBlock;
+  }
+  /**
+   * Add a video to the current page as a graphic block with a video fill.
+   * Mirrors `@cesdk/node`'s `BlockAPI.addVideo` shape.
+   *
+   * @remarks Like `addImage`, requires explicit `options.size` in Node.
+   *
+   * @public
+   */
+  addVideo(url, options = {}) {
+    const {
+      x,
+      y,
+      size,
+      timeline,
+      animation,
+      shadow,
+      cornerRadius,
+      sizeMode = "Absolute",
+      positionMode = "Absolute",
+      trimOffset,
+      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 pages = this.findByType("//ly.img.ubq/page");
+    if (pages.length === 0) {
+      throw new Error("No page found. Create a page first.");
+    }
+    const page = pages[0];
+    const graphicBlock = this.create("graphic");
+    this.appendChild(page, graphicBlock);
+    this.setPositionXMode(graphicBlock, positionMode);
+    this.setPositionYMode(graphicBlock, positionMode);
+    this.setWidthMode(graphicBlock, sizeMode);
+    this.setHeightMode(graphicBlock, sizeMode);
+    this.setWidth(graphicBlock, finalWidth);
+    this.setHeight(graphicBlock, finalHeight);
+    if (x != null) this.setPositionX(graphicBlock, x);
+    else this.alignHorizontally([graphicBlock], "Center");
+    if (y != null) this.setPositionY(graphicBlock, y);
+    else this.alignVertically([graphicBlock], "Center");
+    const shapeBlock = this.createShape("rect");
+    this.setShape(graphicBlock, shapeBlock);
+    if (cornerRadius != null) {
+      this.setFloat(shapeBlock, "shape/rect/cornerRadiusBL", cornerRadius);
+      this.setFloat(shapeBlock, "shape/rect/cornerRadiusBR", cornerRadius);
+      this.setFloat(shapeBlock, "shape/rect/cornerRadiusTL", cornerRadius);
+      this.setFloat(shapeBlock, "shape/rect/cornerRadiusTR", cornerRadius);
+    }
+    const fillBlock = this.createFill("video");
+    this.setFill(graphicBlock, fillBlock);
+    this.setString(fillBlock, "fill/video/fileURI", url);
+    if (loop !== void 0) {
+      try {
+        this.setBool(fillBlock, "fill/video/looping", loop);
+      } catch {
+      }
+    }
+    if (muted !== void 0) {
+      try {
+        this.setBool(fillBlock, "fill/video/muted", muted);
+      } catch {
+      }
+    }
+    if (trimOffset !== void 0) {
+      try {
+        this.setFloat(fillBlock, "fill/video/trimOffset", trimOffset);
+      } catch {
+      }
+    }
+    if (shadow != null) this.applyDropShadow(graphicBlock, shadow);
+    if (timeline?.timeOffset != null)
+      this.setTimeOffset(graphicBlock, timeline.timeOffset);
+    if (timeline?.duration != null)
+      this.setDuration(graphicBlock, timeline.duration);
+    if (animation != null) this.applyAnimation(graphicBlock, animation);
+    return graphicBlock;
+  }
+  /**
+   * Subscribe to state changes on a set of blocks. Matches WASM's
+   * `engine.block.onStateChanged(ids, callback)` contract — pass an empty
+   * array to monitor every block in the scene. The native C++ side
+   * already implements this via `subscribeToBlockState`; this wrapper
+   * exposes it on `engine.block` so portable consumers (e.g.
+   * `@imgly/psd-importer`'s transient-relocation tests) can subscribe the
+   * same way on both bindings.
+   *
+   * @returns A function to unsubscribe.
+   */
+  onStateChanged(ids, callback) {
+    const id = this.#engine.subscribeToBlockState(ids ?? [], callback);
+    return () => this.#engine.unsubscribe(id);
+  }
+  /**
+   * Subscribe to selection changes. Matches WASM's
+   * `engine.block.onSelectionChanged(callback)` contract — fires when the
+   * set of selected blocks changes. The native C++ side already implements
+   * this via `subscribeToSelectionChange`; this wrapper exposes it so
+   * portable consumers (selection-reactive UI) work on both bindings.
+   *
+   * @returns A function to unsubscribe.
+   */
+  onSelectionChanged(callback) {
+    const id = this.#engine.subscribeToSelectionChange(callback);
+    return () => this.#engine.unsubscribe(id);
+  }
+  /**
+   * Subscribe to block clicks. Matches WASM's
+   * `engine.block.onClicked((id) => …)` contract. In a headless Node
+   * context the engine never fires this event (no UI input), but the
+   * subscription surface exists for API parity so the same code compiles
+   * and runs against both bindings.
+   *
+   * @returns A function to unsubscribe.
+   */
+  onClicked(callback) {
+    const id = this.#engine.subscribeToBlockClicked(callback);
+    return () => this.#engine.unsubscribe(id);
+  }
+};
+var SceneAPI = class {
+  #engine;
+  constructor(engine) {
+    this.#engine = engine;
+  }
+  /**
+   * Create a new design scene, along with its own camera.
+   * @param sceneLayout - The layout of the scene.
+   * @returns The scene's handle.
+   */
+  create(sceneLayout = "Free", options) {
+    const scene = this.#engine.createScene(sceneLayout);
+    if (options) {
+      this.#createSceneElements(scene, options);
+    }
+    return scene;
+  }
+  /**
+   * Create a new scene in video mode, along with its own camera.
+   * @returns The scene's handle.
+   */
+  createVideo(options) {
+    const scene = this.#engine.createVideoScene();
+    this.#engine.setSceneMode(scene, "Video");
+    if (options) {
+      this.#createSceneElements(scene, options);
+    }
+    return scene;
+  }
+  #createSceneElements(scene, options) {
+    if (options.designUnit != null) {
+      this.#engine.setDesignUnit(scene, options.designUnit);
+      const pairedFontUnit = options.designUnit === "Pixel" ? "Pixel" : "Point";
+      this.#engine.setFontSizeUnit(
+        scene,
+        options.fontSizeUnit ?? pairedFontUnit
+      );
+    } else if (options.fontSizeUnit != null) {
+      this.#engine.setFontSizeUnit(scene, options.fontSizeUnit);
+    }
+    if (!options.page) {
+      return;
+    }
+    let finalWidth = 0;
+    let finalHeight = 0;
+    if (typeof options.page.size === "number") {
+      finalWidth = options.page.size;
+      finalHeight = options.page.size;
+    } else if (typeof options.page.size === "object") {
+      finalWidth = options.page.size.width;
+      finalHeight = options.page.size.height;
+    } else {
+      return;
+    }
+    const page = this.#engine.create("page");
+    this.#engine.appendChild(scene, page);
+    this.#engine.setWidth(page, finalWidth);
+    this.#engine.setHeight(page, finalHeight);
+    if (options.page.color) {
+      const fill = this.#engine.createFill("color");
+      this.#engine.setFill(page, fill);
+      this.#engine.setColor(
+        page,
+        "fill/solid/color",
+        NativeColorInternal.fromColor(options.page.color)
+      );
+    }
+  }
+  /**
+   * Return the currently active scene.
+   * @returns The scene or null, if none was created yet.
+   */
+  get() {
+    const scenes = this.#engine.findByType("scene");
+    return scenes.length > 0 ? scenes[0] : null;
+  }
+  /**
+   * Load the contents of a scene file.
+   * @param sceneContent - The scene file contents, a base64 string.
+   * @param overrideEditorConfig - Whether to override editor configuration.
+   * @param waitForResources - Whether to wait for all resources to finish loading.
+   * @returns A handle to the loaded scene.
+   */
+  async loadFromString(sceneContent, overrideEditorConfig = false, waitForResources = false) {
+    return this.#engine.loadSceneFromString(
+      sceneContent,
+      overrideEditorConfig,
+      waitForResources
+    );
+  }
+  /**
+   * Load a scene from the URL to the scene file.
+   * @param url - The URL of the scene file.
+   * @param overrideEditorConfig - Whether to override editor configuration.
+   * @param waitForResources - Whether to wait for all resources to finish loading.
+   * @returns A promise that resolves with the scene ID.
+   */
+  async loadFromURL(url, overrideEditorConfig = false, waitForResources = false) {
+    return this.#engine.loadSceneFromURL(
+      url,
+      overrideEditorConfig,
+      waitForResources
+    );
+  }
+  /**
+   * Load a previously archived scene from the URL to the scene file.
+   * Also supports data URIs (data:application/zip;base64,...) which are converted to buffer:// protocol internally.
+   * @param url - The URL of the scene archive file, or a data URI containing base64-encoded archive data.
+   * @param overrideEditorConfig - Whether to override editor configuration.
+   * @param waitForResources - Whether to wait for all resources to finish loading.
+   * @returns A promise that resolves with the scene ID.
+   */
+  async loadFromArchiveURL(url, overrideEditorConfig = false, waitForResources = false) {
+    if (url.startsWith("data:")) {
+      const matches = url.match(/^data:([^;,]+)?(?:;base64)?,(.*)$/);
+      if (!matches) {
+        throw new Error("Invalid data URI format");
+      }
+      const base64Data = matches[2];
+      const buffer = Buffer.from(base64Data, "base64");
+      const bufferUri = this.#engine.createBuffer();
+      this.#engine.setBufferData(bufferUri, 0, new Uint8Array(buffer));
+      try {
+        return await this.#engine.loadSceneFromArchiveURL(
+          bufferUri,
+          overrideEditorConfig,
+          waitForResources
+        );
+      } finally {
+        this.#engine.destroyBuffer(bufferUri);
+      }
+    }
+    return this.#engine.loadSceneFromArchiveURL(
+      url,
+      overrideEditorConfig,
+      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) {
+    const scene = this.get();
+    if (scene === null) {
+      throw new Error("No scene available.");
+    }
+    return this.#engine.saveSceneToString(scene, options);
+  }
+  /**
+   * Saves the current scene and all of its referenced assets into an archive.
+   * @returns A promise that resolves with a Uint8Array.
+   */
+  async saveToArchive() {
+    const scene = this.get();
+    if (scene === null) {
+      throw new Error("No scene available.");
+    }
+    const buffer = await this.#engine.saveSceneToArchive(scene);
+    return new Blob([buffer]);
+  }
+  /**
+   * Loads the given image and creates a scene with a single page showing the image.
+   * @param url - The image URL.
+   * @param dpi - The scene's DPI.
+   * @param pixelScaleFactor - The display's pixel scale factor.
+   * @returns A promise that resolves with the scene ID.
+   */
+  /**
+   * Loads the given image and creates a scene with a single page showing the image.
+   *
+   * @remarks The 4th/5th/6th args (`sceneLayout`, `spacing`,
+   * `spacingInScreenSpace`) are part of `@cesdk/node`'s signature and
+   * accepted here for shape parity. The C++ binding currently hardcodes
+   * `Free`/`0.f`/`false`; non-default values are not yet plumbed
+   * through. A warning is emitted when a caller passes a non-default
+   * value so the discrepancy is visible.
+   *
+   * @public
+   */
+  async createFromImage(url, dpi = 300, pixelScaleFactor = 1, sceneLayout, spacing, spacingInScreenSpace) {
+    if (sceneLayout !== void 0 && sceneLayout !== "Free" || spacing !== void 0 && spacing !== 0 || spacingInScreenSpace !== void 0 && spacingInScreenSpace !== false) {
+      console.warn(
+        `[@cesdk/node-native] scene.createFromImage() arguments 'sceneLayout' / 'spacing' / 'spacingInScreenSpace' are accepted for shape parity but not yet plumbed through the C++ binding. The engine will use defaults (Free / 0 / false).`
+      );
+    }
+    return this.#engine.createSceneFromImage(url, dpi, pixelScaleFactor);
+  }
+  /**
+   * Loads the given video and creates a scene with a single page showing the video.
+   * @param url - The video URL.
+   * @returns A promise that resolves with the scene ID.
+   */
+  async createFromVideo(url) {
+    return this.#engine.createSceneFromVideo(url);
+  }
+  /**
+   * Applies the contents of the given template scene to the currently loaded scene.
+   * @param content - The template scene file contents, a base64 string.
+   * @returns A Promise that resolves once the template was applied.
+   */
+  async applyTemplateFromString(content) {
+    return this.#engine.applyTemplateFromString(content);
+  }
+  /**
+   * Applies the contents of the given template scene to the currently loaded scene.
+   * @param url - The url to the template scene file.
+   * @returns A Promise that resolves once the template was applied.
+   */
+  async applyTemplateFromURL(url) {
+    return this.#engine.applyTemplateFromURL(url);
+  }
+  /**
+   * Get the current scene mode.
+   * @deprecated Scene mode no longer affects engine behavior. All features work regardless of mode.
+   * @returns The current mode of the scene, or null if no mode has been set.
+   */
+  getMode() {
+    const scene = this.get();
+    if (scene === null) {
+      return null;
+    }
+    try {
+      return this.#engine.getSceneMode(scene);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Set the mode of the current scene.
+   * @param mode - The new mode for the scene ('Design' or 'Video').
+   */
+  setMode(mode) {
+    const scene = this.get();
+    if (scene === null) {
+      throw new Error("No scene available.");
+    }
+    this.#engine.setSceneMode(scene, mode);
+  }
+  /**
+   * Converts all values of the current scene into the given design unit.
+   * @param designUnit - The new design unit of the scene.
+   */
+  setDesignUnit(designUnit) {
+    const scene = this.get();
+    if (scene === null) {
+      throw new Error("No scene available.");
+    }
+    this.#engine.setDesignUnit(scene, designUnit);
+  }
+  /**
+   * Returns the design unit of the current scene.
+   * @returns The current design unit.
+   */
+  getDesignUnit() {
+    const scene = this.get();
+    if (scene === null) {
+      throw new Error("No scene available.");
+    }
+    return this.#engine.getDesignUnit(scene);
+  }
+  /**
+   * Sets the unit ('Pixel' | 'Point') in which the current scene's font sizes
+   * are interpreted at the API boundary (setTextFontSize / getTextFontSizes).
+   * The engine stores font sizes in points internally.
+   * @param unit - The new font-size unit.
+   */
+  setFontSizeUnit(unit) {
+    const scene = this.get();
+    if (scene === null) {
+      throw new Error("No scene available.");
+    }
+    this.#engine.setFontSizeUnit(scene, unit);
+  }
+  /**
+   * Returns the font-size unit of the current scene ('Pixel' | 'Point').
+   * @returns The current font-size unit.
+   */
+  getFontSizeUnit() {
+    const scene = this.get();
+    if (scene === null) {
+      throw new Error("No scene available.");
+    }
+    return this.#engine.getFontSizeUnit(scene);
+  }
+  /** Start or stop playback of the current page. */
+  setPlaying(play) {
+    const page = this.getCurrentPage();
+    if (page == null) {
+      throw new Error("No page to play");
+    }
+    this.#engine.setPlaying(page, play);
+  }
+  /**
+   * Get the layout of the current scene.
+   * @returns The current layout of the scene.
+   */
+  getLayout() {
+    const scene = this.get();
+    if (scene === null) {
+      throw new Error("No scene available.");
+    }
+    return this.#engine.getSceneLayout(scene);
+  }
+  /**
+   * Set the layout of the current scene.
+   * @param layout - The new layout for the scene.
+   */
+  setLayout(layout) {
+    const scene = this.get();
+    if (scene === null) {
+      throw new Error("No scene available.");
+    }
+    this.#engine.setSceneLayout(scene, layout);
+  }
+  /**
+   * Get the sorted list of pages in the scene.
+   * @returns The sorted list of pages in the scene.
+   */
+  getPages() {
+    const scene = this.get();
+    if (scene === null) {
+      return [];
+    }
+    return this.#engine.getPages(scene);
+  }
+  /**
+   * Add a new page to the scene.
+   * @param scene - Optional scene ID. If not provided, uses the current scene.
+   * @returns The ID of the newly created page.
+   */
+  addPage(scene) {
+    const sceneId = scene ?? this.get();
+    if (sceneId === null) {
+      throw new Error("No scene available.");
+    }
+    const page = this.#engine.create("page");
+    this.#engine.appendChild(sceneId, page);
+    return page;
+  }
+  /**
+   * Get the current page.
+   * @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();
+    if (sceneId === null) {
+      return null;
+    }
+    return this.#engine.getCurrentPage(sceneId);
+  }
+  /**
+   * Find all blocks with the given type sorted by the distance to viewport center.
+   * @param type - The type to search for.
+   * @returns A list of block ids sorted by distance to viewport center.
+   */
+  findNearestToViewPortCenterByType(type) {
+    const scene = this.get();
+    if (scene === null) {
+      return [];
+    }
+    return this.#engine.findNearestToViewPortCenterByType(scene, type) || [];
+  }
+  /**
+   * Find all blocks with the given kind sorted by the distance to viewport center.
+   * @param kind - The kind to search for.
+   * @returns A list of block ids sorted by distance to viewport center.
+   */
+  findNearestToViewPortCenterByKind(kind) {
+    const scene = this.get();
+    if (scene === null) {
+      return [];
+    }
+    return this.#engine.findNearestToViewPortCenterByKind(scene, kind) || [];
+  }
+  /**
+   * Set the zoom level of the scene.
+   * @param zoomLevel - The new zoom level.
+   */
+  setZoomLevel(zoomLevel = 1) {
+    const scene = this.get();
+    if (scene === null) {
+      throw new Error("No scene available.");
+    }
+    this.#engine.setZoomLevel(scene, zoomLevel);
+  }
+  /**
+   * Get the zoom level of the scene.
+   * @returns The zoom level of the scene.
+   */
+  getZoomLevel() {
+    const scene = this.get();
+    if (scene === null) {
+      throw new Error("No scene available.");
+    }
+    return this.#engine.getZoomLevel(scene);
+  }
+  async zoomToBlock(id, paddingLeftOrOptions, paddingTop, paddingRight, paddingBottom) {
+    const options = typeof paddingLeftOrOptions === "object" ? paddingLeftOrOptions : {
+      padding: {
+        left: paddingLeftOrOptions ?? 0,
+        top: paddingTop ?? 0,
+        right: paddingRight ?? 0,
+        bottom: paddingBottom ?? 0
+      }
+    };
+    const paddings = {
+      left: 0,
+      top: 0,
+      right: 0,
+      bottom: 0
+    };
+    if (options.padding != null) {
+      if (typeof options.padding === "number") {
+        paddings.left = options.padding;
+        paddings.top = options.padding;
+        paddings.right = options.padding;
+        paddings.bottom = options.padding;
+      } else {
+        if ("x" in options.padding || "y" in options.padding) {
+          paddings.left = options.padding.x ?? paddings.left;
+          paddings.right = options.padding.x ?? paddings.right;
+          paddings.top = options.padding.y ?? paddings.top;
+          paddings.bottom = options.padding.y ?? paddings.bottom;
+        }
+        if ("left" in options.padding || "top" in options.padding || "right" in options.padding || "bottom" in options.padding) {
+          paddings.left = options.padding.left ?? paddings.left;
+          paddings.top = options.padding.top ?? paddings.top;
+          paddings.right = options.padding.right ?? paddings.right;
+          paddings.bottom = options.padding.bottom ?? paddings.bottom;
+        }
+      }
+    }
+    if (options.animate) {
+      const animationOptions = {
+        duration: 0.5,
+        easing: "EaseInOut",
+        interruptible: false
+      };
+      if (typeof options.animate === "object") {
+        animationOptions.duration = options.animate.duration ?? animationOptions.duration;
+        animationOptions.easing = options.animate.easing ?? animationOptions.easing;
+        animationOptions.interruptible = options.animate.interruptible ?? animationOptions.interruptible;
+      }
+      return this.#engine.zoomToBlockWithAnimation(
+        id,
+        paddings.left,
+        paddings.top,
+        paddings.right,
+        paddings.bottom,
+        animationOptions.duration,
+        animationOptions.easing,
+        animationOptions.interruptible
+      );
+    } else {
+      return this.#engine.zoomToBlock(
+        id,
+        paddings.left,
+        paddings.top,
+        paddings.right,
+        paddings.bottom
+      );
+    }
+  }
+  /**
+   * 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(
+        id,
+        axis,
+        paddingBeforeOrLeft,
+        0,
+        paddingAfterOrTop,
+        0
+      );
+      return;
+    }
+    if (axis === "Vertical") {
+      this.#engine.enableZoomAutoFit(
+        id,
+        axis,
+        0,
+        paddingBeforeOrLeft,
+        0,
+        paddingAfterOrTop
+      );
+      return;
+    }
+    this.#engine.enableZoomAutoFit(
+      id,
+      axis,
+      paddingBeforeOrLeft,
+      paddingAfterOrTop,
+      paddingRight,
+      paddingBottom
+    );
+  }
+  /**
+   * Disables any previously set zoom auto-fit.
+   * @param blockOrScene - The scene or a block in the scene.
+   */
+  disableZoomAutoFit(blockOrScene) {
+    this.#engine.disableZoomAutoFit(blockOrScene);
+  }
+  /**
+   * Queries whether zoom auto-fit is enabled for the given block.
+   * @param blockOrScene - The scene or a block in the scene.
+   * @returns True if auto-fit is set, false otherwise.
+   */
+  isZoomAutoFitEnabled(blockOrScene) {
+    return this.#engine.isZoomAutoFitEnabled(blockOrScene);
+  }
+  /**
+   * Continually clamp the camera position so that the given blocks stay
+   * within view (with optional padding).
+   * @experimental
+   */
+  unstable_enableCameraPositionClamping(blocks, paddingLeft = 0, paddingTop = 0, paddingRight = 0, paddingBottom = 0, scaledPaddingLeft = 0, scaledPaddingTop = 0, scaledPaddingRight = 0, scaledPaddingBottom = 0) {
+    this.#engine.unstable_enableCameraPositionClamping(
+      blocks,
+      paddingLeft,
+      paddingTop,
+      paddingRight,
+      paddingBottom,
+      scaledPaddingLeft,
+      scaledPaddingTop,
+      scaledPaddingRight,
+      scaledPaddingBottom
+    );
+  }
+  unstable_disableCameraPositionClamping(block) {
+    const target = block ?? this.get();
+    if (target == null) throw new Error("No scene available.");
+    this.#engine.unstable_disableCameraPositionClamping(target);
+  }
+  unstable_isCameraPositionClampingEnabled(block) {
+    const target = block ?? this.get();
+    if (target == null) throw new Error("No scene available.");
+    return this.#engine.unstable_isCameraPositionClampingEnabled(target);
+  }
+  /**
+   * Continually clamp the camera zoom level to the range
+   * `[minZoomLimit, maxZoomLimit]` while showing the given blocks (with
+   * optional padding).
+   * @experimental
+   */
+  unstable_enableCameraZoomClamping(blocks, minZoomLimit = -1, maxZoomLimit = -1, paddingLeft = 0, paddingTop = 0, paddingRight = 0, paddingBottom = 0) {
+    this.#engine.unstable_enableCameraZoomClamping(
+      blocks,
+      minZoomLimit,
+      maxZoomLimit,
+      paddingLeft,
+      paddingTop,
+      paddingRight,
+      paddingBottom
+    );
+  }
+  unstable_disableCameraZoomClamping(block) {
+    const target = block ?? this.get();
+    if (target == null) throw new Error("No scene available.");
+    this.#engine.unstable_disableCameraZoomClamping(target);
+  }
+  unstable_isCameraZoomClampingEnabled(block) {
+    const target = block ?? this.get();
+    if (target == null) throw new Error("No scene available.");
+    return this.#engine.unstable_isCameraZoomClampingEnabled(target);
+  }
+  /**
+   * Subscribe to zoom-level changes.
+   * @param callback - Called whenever the zoom level changes.
+   * @returns A function that unsubscribes when called.
+   */
+  onZoomLevelChanged(callback) {
+    const id = this.#engine.subscribeToZoomLevel(callback);
+    return () => this.#engine.unsubscribe(id);
+  }
+  /**
+   * Subscribe to active-scene changes.
+   * @param callback - Called whenever the active scene changes.
+   * @returns A function that unsubscribes when called.
+   */
+  onActiveChanged(callback) {
+    const id = this.#engine.subscribeToActiveSceneChange(callback);
+    return () => this.#engine.unsubscribe(id);
+  }
+};
+var EditorAPI = class {
+  #engine;
+  constructor(engine) {
+    this.#engine = engine;
+  }
+  getEditMode() {
+    return this.#engine.getEditMode();
+  }
+  setEditMode(mode) {
+    this.#engine.setEditMode(mode);
+  }
+  /**
+   * Returns the JWT string of the currently active license. An empty string
+   * indicates the engine is in Evaluation mode (the trial license created
+   * when init() is called with an empty/null/undefined license). Throws if
+   * the engine has no active license at all.
+   *
+   * Mirrors @cesdk/node's `engine.editor.getActiveLicense()`.
+   * @internal
+   */
+  getActiveLicense() {
+    return this.#engine.getActiveLicense();
+  }
+  /**
+   * Activate (or re-activate) the engine with a license key. Pass an empty
+   * string to drop into Evaluation mode. Mirrors
+   * `@cesdk/node`'s `engine.editor.unlockWithLicense()`.
+   *
+   * Most callers should pass `license` via `CreativeEngine.init({ license })`
+   * — `init` calls this internally. Use this method only to switch licenses
+   * at runtime (e.g. trial → paid upgrade in place).
+   */
+  unlockWithLicense(license) {
+    this.#engine.unlockWithLicense(license);
+  }
+  // Settings
+  getSettingBool(key) {
+    const settingType = this.getSettingType(key);
+    if (settingType !== "Bool") {
+      throw new Error(
+        `Setting '${key}' is of type '${settingType}', not 'Bool'`
+      );
+    }
+    return this.#engine.getSettingBool(key);
+  }
+  setSettingBool(key, value) {
+    this.#engine.setSettingBool(key, value);
+  }
+  getSettingInt(key) {
+    return this.#engine.getSettingInt(key);
+  }
+  setSettingInt(key, value) {
+    this.#engine.setSettingInt(key, value);
+  }
+  getSettingFloat(key) {
+    return this.#engine.getSettingFloat(key);
+  }
+  setSettingFloat(key, value) {
+    this.#engine.setSettingFloat(key, value);
+  }
+  getSettingString(key) {
+    return this.#engine.getSettingString(key);
+  }
+  setSettingString(key, value) {
+    this.#engine.setSettingString(key, value);
+  }
+  getSettingColor(key) {
+    const internalColor = this.#engine.getSettingColor(
+      key
+    );
+    return NativeColorInternal.toColor(internalColor);
+  }
+  setSettingColor(key, value) {
+    const internalColor = NativeColorInternal.fromColor(value);
+    this.#engine.setSettingColor(key, internalColor);
+  }
+  getSettingEnum(key) {
+    return this.#engine.getSettingEnum(key);
+  }
+  setSettingEnum(key, value) {
+    const settingType = this.getSettingType(key);
+    if (settingType !== "Enum") {
+      throw new Error(
+        `Setting '${key}' is of type '${settingType}', not 'Enum'`
+      );
+    }
+    this.#engine.setSettingEnum(key, value);
+  }
+  findAllSettings() {
+    return this.#engine.findAllSettings();
+  }
+  getSettingType(key) {
+    const allSettings = this.#engine.findAllSettings();
+    if (!allSettings.includes(key)) {
+      throw new Error(`Setting '${key}' does not exist`);
+    }
+    return this.#engine.getSettingType(key);
+  }
+  getSettingEnumOptions(key) {
+    return this.#engine.getSettingEnumOptions(key);
+  }
+  /**
+   * Generic setting getter that dispatches to the typed getter based on
+   * `getSettingType`.
+   */
+  getSetting(key) {
+    const settingType = this.getSettingType(key);
+    switch (settingType) {
+      case "Bool":
+        return this.#engine.getSettingBool(key);
+      case "Int":
+        return this.#engine.getSettingInt(key);
+      case "Float":
+        return this.#engine.getSettingFloat(key);
+      case "String":
+        return this.#engine.getSettingString(key);
+      case "Color": {
+        const internalColor = this.#engine.getSettingColor(
+          key
+        );
+        return NativeColorInternal.toColor(internalColor);
+      }
+      case "Enum":
+        return this.#engine.getSettingEnum(key);
+      default:
+        throw new Error(
+          `Unknown setting type for key '${key}': ${settingType}`
+        );
+    }
+  }
+  /**
+   * Generic setting setter — dispatches to the typed setter via
+   * `getSettingType`.
+   */
+  setSetting(key, value) {
+    const settingType = this.getSettingType(key);
+    switch (settingType) {
+      case "Bool":
+        this.#engine.setSettingBool(key, value);
+        return;
+      case "Int":
+        this.#engine.setSettingInt(key, value);
+        return;
+      case "Float":
+        this.#engine.setSettingFloat(key, value);
+        return;
+      case "String":
+        this.#engine.setSettingString(key, value);
+        return;
+      case "Color": {
+        const internalColor = NativeColorInternal.fromColor(value);
+        this.#engine.setSettingColor(key, internalColor);
+        return;
+      }
+      case "Enum":
+        this.#engine.setSettingEnum(key, value);
+        return;
+      default:
+        throw new Error(
+          `Unknown setting type for key '${key}': ${settingType}`
+        );
+    }
+  }
+  /** Get the font metrics for a font URI. */
+  getFontMetrics(fontFileUri) {
+    return this.#engine.getFontMetrics(fontFileUri);
+  }
+  /**
+   * Set one or more rules limiting how far blocks may be moved outside their
+   * parent page during user interactions.
+   */
+  setMovementConstraint(rules) {
+    const list = Array.isArray(rules) ? rules : [rules];
+    for (const rule of list) {
+      const targets = "block" in rule ? [rule.block] : "blockType" in rule ? [rule.blockType] : [];
+      this.#engine.setMovementConstraint(targets, rule.overshoot);
+    }
+  }
+  /**
+   * Get the effective movement constraint for a block (most specific rule
+   * wins: block > parent page > blockType > scene-wide). Returns `null`
+   * when unconstrained.
+   */
+  getMovementConstraint(id) {
+    const value = this.#engine.getMovementConstraint(id);
+    return value < 0 ? null : { overshoot: value };
+  }
+  /**
+   * Remove movement constraints. No argument removes the scene-wide default.
+   * `{ block }` / `{ blockType }` (or array) removes the matching scope(s).
+   */
+  removeMovementConstraint(scopes) {
+    if (scopes === void 0) {
+      this.#engine.removeMovementConstraint([]);
+      return;
+    }
+    const list = Array.isArray(scopes) ? scopes : [scopes];
+    if (list.length === 0) return;
+    const targets = list.map(
+      (scope) => "block" in scope ? scope.block : scope.blockType
+    );
+    this.#engine.removeMovementConstraint(targets);
+  }
+  // Cursor
+  getCursorType() {
+    return this.#engine.getCursorType();
+  }
+  getCursorRotation() {
+    return this.#engine.getCursorRotation();
+  }
+  // Safe area insets
+  setSafeAreaInsets(insets) {
+    this.#engine.setSafeAreaInsets(
+      insets.left,
+      insets.top,
+      insets.right,
+      insets.bottom
+    );
+  }
+  getSafeAreaInsets() {
+    return this.#engine.getSafeAreaInsets();
+  }
+  // Memory
+  getUsedMemory() {
+    return this.#engine.getUsedMemory();
+  }
+  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}`);
+      }
+    }
+    const resultInternal = this.#engine.convertColorToColorSpace(
+      internalColor,
+      colorSpaceNum
+    );
+    return NativeColorInternal.toColor(resultInternal);
+  }
+  supportsP3() {
+    return this.#engine.supportsP3();
+  }
+  // URI
+  getAbsoluteURI(relativeUri) {
+    return this.#engine.getAbsoluteURI(relativeUri);
+  }
+  getMimeType(uri) {
+    return this.#engine.getMimeType(uri);
+  }
+  defaultURIResolver(relativePath) {
+    return this.#engine.defaultURIResolver(relativePath);
+  }
+  /**
+   * Register a synchronous URI resolver. Matches `@cesdk/node`'s
+   * `(uri, defaultResolver) => string` signature
+   * (`bindings/wasm/js_web/src/EditorAPI.ts`). The
+   * `defaultResolver` argument is the engine's built-in resolver — call
+   * it to delegate the lookup chain.
+   *
+   * @public
+   */
+  setURIResolver(resolver) {
+    if (resolver == null) {
+      this.#engine.setURIResolver(
+        (uri) => this.defaultURIResolver(uri)
+      );
+      return;
+    }
+    const wrapped = (uri) => {
+      const defaultFn = (u) => this.defaultURIResolver(u);
+      return resolver(uri, defaultFn);
+    };
+    this.#engine.setURIResolver(wrapped);
+  }
+  /**
+   * Register an asynchronous URI resolver. Matches `@cesdk/node`'s
+   * `(uri, defaultResolver) => Promise<string> | string` signature
+   * (`bindings/wasm/js_web/src/EditorAPI.ts`). Bridges to the
+   * native callback-style binding by adapting the returned Promise.
+   *
+   * Pass `null` to restore the default resolver.
+   *
+   * @public
+   */
+  setURIResolverAsync(resolver) {
+    if (resolver == null) {
+      this.#engine.setURIResolverAsync(
+        (uri, cb) => {
+          this.getAbsoluteURI(uri).then(
+            (resolved) => cb(resolved),
+            (err) => cb(err instanceof Error ? err : new Error(String(err)))
+          );
+        }
+      );
+      return;
+    }
+    const defaultFn = async (uri) => this.getAbsoluteURI(uri);
+    const adapter = (uri, cb) => {
+      try {
+        const out = resolver(uri, defaultFn);
+        Promise.resolve(out).then(
+          (resolved) => cb(resolved),
+          (err) => cb(err instanceof Error ? err : new Error(String(err)))
+        );
+      } catch (err) {
+        cb(err instanceof Error ? err : new Error(String(err)));
+      }
+    };
+    this.#engine.setURIResolverAsync(adapter);
+  }
+  relocateResource(currentUri, newUri) {
+    this.#engine.relocateResource(currentUri, newUri);
+  }
+  findAllMediaURIs() {
+    return this.#engine.findAllMediaURIs();
+  }
+  /**
+   * 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 }`.
+   *
+   * 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`).
+   */
+  findAllTransientResources() {
+    return this.#engine.findAllTransientResources();
+  }
+  // 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;
+  }
+  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;
+  }
+  setSpotColorRGB(name, r, g, b) {
+    this.#engine.setSpotColorRGB(name, r, g, b);
+  }
+  setSpotColorCMYK(name, c, m, y, k) {
+    this.#engine.setSpotColorCMYK(name, c, m, y, k);
+  }
+  removeSpotColor(name) {
+    this.#engine.removeSpotColor(name);
+  }
+  // Role and scope - WASM EditorAPI methods
+  getRole() {
+    return this.#engine.getRole();
+  }
+  setRole(role) {
+    this.#engine.setRole(role);
+  }
+  /**
+   * Start the engine's analytics tracking pipeline. Mirrors
+   * `@cesdk/node`'s `editor.startTracking(license, userId)`; invoked
+   * automatically from {@link CreativeEngine.init} when `license` and/or
+   * `userId` are passed in the Configuration. Safe to call multiple times.
+   *
+   * The C++ binding accepts a third `deviceId` argument that the engine
+   * itself uses for tracking-pipeline disambiguation; WASM always passes
+   * `''` (see `bindings/wasm/js_web/src/EditorAPI.ts`) — we
+   * mirror that here so the no-args / "engine picks a default device id"
+   * path is honored.
+   *
+   * @public
+   */
+  startTracking(license, userId, deviceId = "") {
+    this.#engine.startTracking(license, userId, deviceId);
+  }
+  findAllScopes() {
+    return this.#engine.findAllScopes();
+  }
+  getGlobalScope(scope) {
+    return this.#engine.getGlobalScope(scope);
+  }
+  setGlobalScope(scope, value) {
+    this.#engine.setGlobalScope(scope, value);
+  }
+  // History management (matches WASM EditorAPI)
+  createHistory() {
+    return this.#engine.createHistory();
+  }
+  destroyHistory(history) {
+    this.#engine.destroyHistory(history);
+  }
+  getActiveHistory() {
+    return this.#engine.getActiveHistory();
+  }
+  setActiveHistory(history) {
+    this.#engine.setActiveHistory(history);
+  }
+  /**
+   * Undo one step in the active history if an undo step is available.
+   * Use {@link canUndo} beforehand to determine whether a step is available.
+   */
+  undo() {
+    this.#engine.undo();
+  }
+  /**
+   * Redo one step in the active history if a redo step is available.
+   * Use {@link canRedo} beforehand to determine whether a step is available.
+   */
+  redo() {
+    this.#engine.redo();
+  }
+  canUndo() {
+    return this.#engine.canUndo();
+  }
+  canRedo() {
+    return this.#engine.canRedo();
+  }
+  addUndoStep() {
+    this.#engine.addUndoStep();
+  }
+  removeUndoStep() {
+    this.#engine.removeUndoStep();
+  }
+  /**
+   * Subscribe to editor-state changes.
+   * @param callback - Called whenever the editor state changes.
+   * @returns A function that unsubscribes when called.
+   */
+  onStateChanged(callback) {
+    const id = this.#engine.subscribeToEditorState(callback);
+    return () => this.#engine.unsubscribe(id);
+  }
+  /**
+   * Subscribe to editor settings changes. Matches WASM's
+   * `engine.editor.onSettingsChanged(callback)`. The native C++ side
+   * implements this via `subscribeToSettings`; this wrapper exposes it on
+   * the editor API so portable consumers (settings-reactive UI) work on
+   * both bindings.
+   * @returns A function that unsubscribes when called.
+   */
+  onSettingsChanged(callback) {
+    const id = this.#engine.subscribeToSettings(callback);
+    return () => this.#engine.unsubscribe(id);
+  }
+  /**
+   * Subscribe to history updates.
+   * @deprecated Use {@link onHistoryUpdatedWithKind} instead, which also
+   * reports the kind of update.
+   * @param callback - Called when the undo/redo history changes.
+   * @returns A function that unsubscribes when called.
+   */
+  onHistoryUpdated(callback) {
+    return this.onHistoryUpdatedWithKind(() => callback());
+  }
+  /**
+   * Subscribe to history updates. The callback receives a `HistoryUpdate`
+   * describing what kind of update happened (matches the node wasm
+   * binding's `EditorAPI` surface) so consumers can distinguish a
+   * snapshot mutation from an `Activated` event triggered by
+   * `setActiveHistory` — important for save-button logic that should NOT
+   * fire on activation alone.
+   * @param callback - Called with the kind of update.
+   * @returns A function that unsubscribes when called.
+   */
+  onHistoryUpdatedWithKind(callback) {
+    const id = this.#engine.subscribeToHistoryWithKind((value) => {
+      callback(value === 1 ? "Activated" : "Updated");
+    });
+    return () => this.#engine.unsubscribe(id);
+  }
+  /**
+   * Subscribe to role changes.
+   * @param callback - Called with the new role when it changes.
+   * @returns A function that unsubscribes when called.
+   */
+  onRoleChanged(callback) {
+    const id = this.#engine.subscribeToRoleChange(callback);
+    return () => this.#engine.unsubscribe(id);
+  }
+  // Buffer management (matching WASM/Android EditorAPI)
+  /**
+   * Create a new buffer and return its URI.
+   * @returns A URI to identify the created buffer (buffer://N format).
+   */
+  createBuffer() {
+    return this.#engine.createBuffer();
+  }
+  /**
+   * Destroy a buffer and free its resources.
+   * @param uri - The URI of the buffer to destroy.
+   */
+  destroyBuffer(uri) {
+    this.#engine.destroyBuffer(uri);
+  }
+  /**
+   * Set the data of a buffer at a given offset.
+   * @param uri - The URI of the buffer to update.
+   * @param offset - The offset in bytes at which to start writing.
+   * @param data - The data to write.
+   */
+  setBufferData(uri, offset, data) {
+    this.#engine.setBufferData(uri, offset, data);
+  }
+  /**
+   * Get the data of a buffer at a given offset.
+   * @param uri - The URI of the buffer to query.
+   * @param offset - The offset in bytes at which to start reading.
+   * @param length - The number of bytes to read.
+   * @returns The data at the given offset.
+   */
+  getBufferData(uri, offset, length) {
+    return this.#engine.getBufferData(uri, offset, length);
+  }
+  /**
+   * Get the length of a buffer.
+   * @param uri - The URI of the buffer to query.
+   * @returns The length of the buffer in bytes.
+   */
+  getBufferLength(uri) {
+    return this.#engine.getBufferLength(uri);
+  }
+  /**
+   * Resize a buffer. Truncates if `length` is smaller than the current
+   * size; zero-extends if larger. Matches the WASM `editor.setBufferLength`
+   * shape used by psd/pdf/idml importers to pre-allocate a buffer before
+   * writing data with `setBufferData`.
+   */
+  setBufferLength(uri, length) {
+    this.#engine.setBufferLength(uri, length);
+  }
+};
+var EventAPI = class {
+  constructor(engine) {
+    /**
+     * Subscribe to block lifecycle events.
+     * Events are bundled and delivered at the end of each engine update cycle.
+     * @param blocks - List of blocks to filter events by. If empty, events for all blocks are sent.
+     * @param callback - Function called with bundled events.
+     * @returns A method to unsubscribe from the events.
+     */
+    this.subscribe = (blocks, callback) => {
+      const safeCallback = (events) => {
+        try {
+          callback(events);
+        } catch (err) {
+          console.error("[cesdk_native] block-event subscriber threw:", err);
+        }
+      };
+      const subscription = this.#engine.subscribe(blocks, safeCallback);
+      return () => {
+        this.#engine.unsubscribe(subscription);
+      };
+    };
+    this.#engine = engine;
+  }
+  #engine;
+};
+var AssetAPI = class {
+  #engine;
+  constructor(engine) {
+    this.#engine = engine;
+  }
+  /**
+   * Add a custom asset source with callbacks.
+   *
+   * This allows you to provide custom implementations for finding, fetching,
+   * and applying assets from any data source.
+   *
+   * @param source - The asset source configuration with callbacks.
+   */
+  addSource(source) {
+    this.#engine.addAssetSource({
+      id: source.id,
+      findAssets: (query, resultCb) => {
+        Promise.resolve(source.findAssets(query)).then(
+          (result) => resultCb(
+            null,
+            result ?? { assets: [], currentPage: 0, total: 0, nextPage: -1 }
+          )
+        ).catch((err) => resultCb(err));
+      },
+      fetchAsset: source.fetchAsset ? (id, params, resultCb) => {
+        Promise.resolve(source.fetchAsset(id, params)).then((result) => resultCb(null, result)).catch((err) => resultCb(err));
+      } : void 0,
+      getGroups: source.getGroups ? (resultCb) => {
+        Promise.resolve(source.getGroups()).then((result) => resultCb(null, result)).catch((err) => resultCb(err));
+      } : void 0,
+      credits: source.credits,
+      license: source.license,
+      getSupportedMimeTypes: source.getSupportedMimeTypes,
+      applyAsset: source.applyAsset ? (asset, resultCb) => {
+        Promise.resolve(source.applyAsset(asset)).then((result) => resultCb(null, result)).catch((err) => resultCb(err));
+      } : void 0,
+      applyAssetToBlock: source.applyAssetToBlock ? (asset, block, resultCb) => {
+        Promise.resolve(source.applyAssetToBlock(asset, block)).then(() => resultCb(null)).catch((err) => resultCb(err));
+      } : void 0,
+      applyAssetProperty: source.applyAssetProperty ? (asset, property, resultCb) => {
+        Promise.resolve(source.applyAssetProperty(asset, property)).then(() => resultCb(null)).catch((err) => resultCb(err));
+      } : void 0,
+      addAsset: source.addAsset,
+      removeAsset: source.removeAsset
+    });
+  }
+  /**
+   * Add a local asset source.
+   *
+   * Mirrors `@cesdk/node`'s 4-argument shape
+   * (`bindings/wasm/js_web/src/AssetAPI.ts`): when `applyAsset`
+   * or `applyAssetToBlock` is supplied, we wrap the local source as a
+   * synthetic `AssetSource` via {@link addSource} so the callbacks are
+   * honored. Without callbacks we go through the cheap `addLocalSource`
+   * fast path.
+   *
+   * @param id - Unique identifier for the asset source.
+   * @param supportedMimeTypes - The mime types of assets that are allowed to be added.
+   * @param applyAsset - Optional callback invoked when the asset is applied to a new block.
+   * @param applyAssetToBlock - Optional callback invoked when the asset is applied to an existing block.
+   */
+  addLocalSource(id, supportedMimeTypes, applyAsset, applyAssetToBlock) {
+    if (applyAsset == null && applyAssetToBlock == null) {
+      this.#engine.addLocalAssetSource(id, supportedMimeTypes ?? []);
+      return;
+    }
+    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);
+      });
+    }
+    if (applyAssetToBlock != null) {
+      this.registerApplyToBlockMiddleware(id, async (asset, block, next) => {
+        await applyAssetToBlock(asset, block);
+        await next(asset, block);
+      });
+    }
+  }
+  /**
+   * Creates a new local asset source from a JSON string.
+   * @param contentJSON - The JSON string containing the asset definitions.
+   * @param basePath - Optional base path for resolving relative URLs.
+   * @param options - Optional configuration with matcher patterns.
+   * @returns The ID of the created asset source.
+   */
+  addLocalAssetSourceFromJSONString(contentJSON, basePath, options) {
+    try {
+      const sourceId = this.#engine.addLocalAssetSourceFromJSONString(
+        contentJSON,
+        basePath,
+        options?.matcher
+      );
+      return Promise.resolve(sourceId);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Creates a new local asset source from a JSON URI.
+   * @param contentURI - The URI for the JSON file to load.
+   * @param options - Optional configuration with matcher patterns.
+   * @returns The ID of the created asset source.
+   */
+  addLocalAssetSourceFromJSONURI(contentURI, options) {
+    return this.#engine.addLocalAssetSourceFromJSONURI(
+      contentURI,
+      options?.matcher
+    );
+  }
+  /**
+   * Remove a registered asset source.
+   * @param id - The ID of the asset source to remove.
+   */
+  removeSource(id) {
+    this.#engine.removeAssetSource(id);
+  }
+  /**
+   * Get all registered asset source IDs.
+   * @returns A list with the IDs of all registered asset sources.
+   */
+  findAllSources() {
+    return this.#engine.findAllAssetSources();
+  }
+  /**
+   * Search for assets in a specific source.
+   *
+   * @param sourceId - The ID of the asset source.
+   * @param query - Query options to filter and sort the search results.
+   * @returns Promise resolving to paginated search results.
+   */
+  async findAssets(sourceId, query) {
+    const q = query;
+    const tagsRaw = q?.tags;
+    const tags = Array.isArray(tagsRaw) ? tagsRaw : typeof tagsRaw === "string" ? [tagsRaw] : tagsRaw && typeof tagsRaw === "object" ? tagsRaw : [];
+    const normalizedQuery = {
+      perPage: q?.perPage ?? 0,
+      page: q?.page ?? 0,
+      query: q?.query ?? "",
+      tags,
+      groups: q?.groups ?? [],
+      excludeGroups: q?.excludeGroups ?? [],
+      locale: q?.locale ?? "",
+      sortingOrder: q?.sortingOrder ?? "None",
+      sortKey: q?.sortKey ?? "",
+      sortActiveFirst: q?.sortActiveFirst ?? false,
+      filter: q?.filter ?? []
+    };
+    const result = await this.#engine.findAssetSourceAssets(
+      sourceId,
+      normalizedQuery
+    );
+    const r = result;
+    return {
+      ...result,
+      nextPage: r.nextPage === -1 ? void 0 : r.nextPage
+    };
+  }
+  /**
+   * Fetch a specific asset by id from an asset source.
+   * Returns `null` when the asset is not found.
+   */
+  async fetchAsset(sourceId, assetId, params = {}) {
+    const fetchParams = { locale: params.locale ?? "" };
+    return this.#engine.fetchAssetSourceAsset(sourceId, assetId, fetchParams);
+  }
+  /**
+   * Get available asset groups from a source.
+   * @param id - The ID of the asset source.
+   * @returns Promise resolving to list of available group names.
+   */
+  async getGroups(id) {
+    return this.#engine.getAssetSourceGroups(id);
+  }
+  /**
+   * Get license information for an asset source.
+   * @param sourceId - The ID of the asset source.
+   * @returns The asset source's license info.
+   */
+  getLicense(sourceId) {
+    const license = this.#engine.getAssetSourceLicense(sourceId);
+    if (!license || !license.name && !license.url) {
+      return void 0;
+    }
+    return { name: license.name, url: license.url || void 0 };
+  }
+  /**
+   * Get attribution credits for an asset source.
+   * @param sourceId - The ID of the asset source.
+   * @returns The asset source's credits info.
+   */
+  getCredits(sourceId) {
+    const credits = this.#engine.getAssetSourceCredits(sourceId);
+    if (!credits || !credits.name && !credits.url) {
+      return void 0;
+    }
+    return { name: credits.name, url: credits.url || void 0 };
+  }
+  /**
+   * Get supported MIME types for an asset source.
+   * @param sourceId - The ID of the asset source.
+   * @returns Array of supported MIME type strings.
+   */
+  getSupportedMimeTypes(sourceId) {
+    return this.#engine.getAssetSourceSupportedMimeTypes(sourceId);
+  }
+  /**
+   * Add an asset to a local asset source.
+   * @param sourceId - The local asset source ID.
+   * @param asset - The asset definition to add.
+   */
+  addAssetToSource(sourceId, asset) {
+    this.#engine.addAssetToSource(sourceId, asset);
+  }
+  /**
+   * Remove an asset from a local asset source.
+   * @param sourceId - The ID of the local asset source.
+   * @param assetId - The ID of the asset to remove.
+   */
+  removeAssetFromSource(sourceId, assetId) {
+    this.#engine.removeAssetFromSource(sourceId, assetId);
+  }
+  /**
+   * Notify the engine that an asset source's contents have changed.
+   * @param sourceID - The asset source whose contents changed.
+   */
+  assetSourceContentsChanged(sourceID) {
+    this.#engine.assetSourceContentsChanged(sourceID);
+  }
+  /**
+   * Subscribe to "asset source added" events.
+   * @param callback - Called with the source ID whenever a new asset source is registered.
+   * @returns A function that unsubscribes when called.
+   */
+  onAssetSourceAdded(callback) {
+    const id = this.#engine.subscribeToAssetSourceAdded(callback);
+    return () => this.#engine.unsubscribe(id);
+  }
+  /**
+   * Subscribe to "asset source removed" events.
+   * @param callback - Called with the source ID whenever an asset source is removed.
+   * @returns A function that unsubscribes when called.
+   */
+  onAssetSourceRemoved(callback) {
+    const id = this.#engine.subscribeToAssetSourceRemoved(callback);
+    return () => this.#engine.unsubscribe(id);
+  }
+  /**
+   * Subscribe to "asset source updated" events.
+   * @param callback - Called with the source ID whenever an asset source's contents change.
+   * @returns A function that unsubscribes when called.
+   */
+  onAssetSourceUpdated(callback) {
+    const id = this.#engine.subscribeToAssetSourceUpdated(callback);
+    return () => this.#engine.unsubscribe(id);
+  }
+  // -------------------------------------------------------------------------
+  // Apply-asset surface (parity with @cesdk/node's AssetAPI:955-1195).
+  //
+  // The C++ binding already exposes the four primitives (`applyAssetSourceAsset`,
+  // `applyAssetSourceAssetToBlock`, `applyAssetSourceProperty`,
+  // `defaultApplyAsset`, `defaultApplyAssetToBlock`) — we only need to bridge
+  // them through a TS-level middleware chain so registerApplyMiddleware /
+  // registerApplyToBlockMiddleware work.
+  // -------------------------------------------------------------------------
+  #applyMiddleware = /* @__PURE__ */ new Map();
+  #applyToBlockMiddleware = /* @__PURE__ */ new Map();
+  /**
+   * Apply an asset to the current scene. Honors any middleware registered
+   * via {@link registerApplyMiddleware} and falls back to
+   * {@link defaultApplyAsset}.
+   *
+   * @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);
+    }
+    return next(asset);
+  }
+  /**
+   * Apply an asset to a specific block. Honors any middleware registered
+   * via {@link registerApplyToBlockMiddleware} and falls back to
+   * {@link defaultApplyAssetToBlock}.
+   *
+   * @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);
+    }
+    return next(asset, block);
+  }
+  /**
+   * Apply a property change from an asset payload.
+   *
+   * @public
+   */
+  async applyProperty(sourceId, asset, property) {
+    return this.#engine.applyAssetSourceProperty(sourceId, asset, property);
+  }
+  /**
+   * Default apply-asset implementation (no middleware). Calls the engine's
+   * built-in apply logic; used as the tail of the middleware chain in
+   * {@link apply}.
+   *
+   * @public
+   */
+  async defaultApplyAsset(asset) {
+    const result = await this.#engine.defaultApplyAsset(asset);
+    return result === -1 || result == null ? void 0 : result;
+  }
+  /**
+   * Default apply-to-block implementation (no middleware). Used as the
+   * tail of the middleware chain in {@link applyToBlock}.
+   *
+   * @public
+   */
+  async defaultApplyAssetToBlock(asset, block) {
+    await this.#engine.defaultApplyAssetToBlock(asset, block);
+  }
+  /**
+   * Register a middleware in the apply-asset chain for a source.
+   *
+   * @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);
+  }
+  /**
+   * Register a middleware in the apply-asset-to-block chain for a source.
+   *
+   * @public
+   */
+  registerApplyToBlockMiddleware(sourceId, middleware) {
+    const arr = this.#applyToBlockMiddleware.get(sourceId) ?? [];
+    arr.push(middleware);
+    this.#applyToBlockMiddleware.set(sourceId, arr);
+  }
+  /**
+   * Whether the named source supports `addAssetToSource` /
+   * `removeAssetFromSource`. Local sources return `true` by default; custom
+   * sources return whatever they declared via `canManageAssets` in their
+   * registration object.
+   *
+   * @public
+   */
+  canManageAssets(sourceId) {
+    try {
+      this.#engine.removeAssetFromSource(
+        sourceId,
+        "__cesdk_probe_does_not_exist__"
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var _version = true ? "1.77.0-nightly.20260610" : "0.0.0";
+var CreativeEngine = class _CreativeEngine {
+  constructor(engine) {
+    this.version = _CreativeEngine.version;
+    this.#updateInterval = null;
+    this.#baseURL = "";
+    this.#engine = engine;
+    this.asset = new AssetAPI(engine);
+    this.block = new BlockAPI(engine);
+    this.editor = new EditorAPI(engine);
+    this.event = new EventAPI(engine);
+    this.scene = new SceneAPI(engine);
+    this.variable = new VariableAPI(engine);
+    this.#startUpdateLoop();
+  }
+  static {
+    this.version = _version;
+  }
+  #engine;
+  #updateInterval;
+  #baseURL;
+  #startUpdateLoop() {
+    if (this.#updateInterval) return;
+    const updateLoop = () => {
+      let needsUpdate = false;
+      if (this.#engine) {
+        needsUpdate = this.update();
+      }
+      this.#updateInterval = needsUpdate ? setImmediate(updateLoop) : setTimeout(updateLoop, 16);
+    };
+    this.#updateInterval = setImmediate(updateLoop);
+  }
+  #stopUpdateLoop() {
+    if (this.#updateInterval) {
+      clearTimeout(this.#updateInterval);
+      clearImmediate(this.#updateInterval);
+      this.#updateInterval = null;
+    }
+  }
+  /**
+   * Update the engine's internal state
+   * @returns Whether the engine needed an update.
+   */
+  update() {
+    return this.#engine.update();
+  }
+  /**
+   * Dispose the engine and clean up all resources
+   */
+  dispose() {
+    this.#stopUpdateLoop();
+    this.#engine.dispose();
+    this.#engine = null;
+    this.asset = null;
+    this.block = null;
+    this.editor = null;
+    this.event = null;
+    this.scene = null;
+    this.variable = null;
+  }
+  /**
+   * Initialize a CreativeEngine.
+   *
+   * Mirrors `@cesdk/node`'s {@link Configuration} shape exactly. The
+   * native-only `device` field selects the render backend
+   * (`'auto'` | `'cpu'` | `'gpu'`); web/WASM Node accept the field for shape
+   * parity but ignore non-`'auto'` values.
+   *
+   * @param config - Engine configuration. All fields optional; defaults
+   *   match `@cesdk/node` + `'auto'` device selection.
+   * @returns A ready-to-use engine instance.
+   * @public
+   */
+  static async init(config) {
+    const { addon: nativeAddon, addonPath: nativeAddonPath } = await getNativeAddon();
+    const engineDevice = resolveEngineDevice(config);
+    const { baseURL, enginePath } = resolveEngineBaseURL(
+      config,
+      nativeAddonPath
+    );
+    const engine = nativeAddon.createEngine(enginePath, engineDevice);
+    let resolvedLicense = "";
+    try {
+      resolvedLicense = await downloadAndCheckLicense(config ?? {});
+    } catch (err) {
+      try {
+        engine.dispose();
+      } catch {
+      }
+      throw err;
+    }
+    engine.unlockWithLicense(resolvedLicense);
+    const creativeEngine = new _CreativeEngine(engine);
+    creativeEngine.#baseURL = baseURL;
+    configureEngine(creativeEngine, config, { baseURL });
+    await registerBuiltinTypeface(creativeEngine);
+    return creativeEngine;
+  }
+  /**
+   * Get the base URL for engine assets
+   */
+  getBaseURL() {
+    return this.#baseURL;
+  }
+  /**
+   * Register a set of default asset sources containing default assets.
+   *
+   * Mirrors `@cesdk/node`'s instance method
+   * (bindings/wasm/js_node/src/CreativeEngine.ts). Loads
+   * `${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).
+   *
+   * @public
+   */
+  async addDefaultAssetSources({
+    baseURL,
+    excludeAssetSourceIds = []
+  } = {}) {
+    const resolvedBaseURL = baseURL ?? this.#baseURL;
+    if (!resolvedBaseURL) {
+      throw new Error(
+        "addDefaultAssetSources: no baseURL configured. Pass { baseURL } or set baseURL on init."
+      );
+    }
+    await loadDefaultAssetSources(
+      this.asset,
+      resolvedBaseURL,
+      new Set(excludeAssetSourceIds)
+    );
+  }
+  /**
+   * Register a set of demo asset sources containing example assets.
+   *
+   * Mirrors `@cesdk/node`'s `bindings/wasm/js_web/src/addDemoAssetSources.ts`
+   * — accepts `sceneMode`, `withUploadAssetSources`, and the full demo
+   * source-ID union (templates + textComponents + uploads + media).
+   *
+   * @public
+   */
+  async addDemoAssetSources({
+    baseURL,
+    excludeAssetSourceIds = [],
+    sceneMode = "Design",
+    withUploadAssetSources = false
+  } = {}) {
+    const resolvedBaseURL = baseURL ?? this.#baseURL;
+    if (!resolvedBaseURL) {
+      throw new Error(
+        "addDemoAssetSources: no baseURL configured. Pass { baseURL } or set baseURL on init."
+      );
+    }
+    await loadDemoAssetSources(
+      this.asset,
+      resolvedBaseURL,
+      new Set(excludeAssetSourceIds),
+      {
+        sceneMode,
+        withUploadAssetSources,
+        // Pass the scene API so template sources have something to call.
+        sceneAPI: {
+          applyTemplateFromString: (s) => this.scene.applyTemplateFromString(s),
+          applyTemplateFromURL: (u) => this.scene.applyTemplateFromURL(u)
+        }
+      }
+    );
+  }
+};
+
+// ts/src/types.ts
+var CompressionFormat = /* @__PURE__ */ ((CompressionFormat2) => {
+  CompressionFormat2[CompressionFormat2["None"] = 0] = "None";
+  CompressionFormat2[CompressionFormat2["Zstd"] = 1] = "Zstd";
+  return CompressionFormat2;
+})(CompressionFormat || {});
+var CompressionLevel = /* @__PURE__ */ ((CompressionLevel2) => {
+  CompressionLevel2[CompressionLevel2["Fastest"] = 0] = "Fastest";
+  CompressionLevel2[CompressionLevel2["Default"] = 1] = "Default";
+  CompressionLevel2[CompressionLevel2["Best"] = 2] = "Best";
+  return CompressionLevel2;
+})(CompressionLevel || {});
+
+// ts/src/index.ts
+var index_default = CreativeEngine;
+module.exports = CreativeEngine;
+Object.defineProperty(module.exports, "__esModule", { value: true });
+Object.defineProperty(module.exports, "default", { value: CreativeEngine });
+Object.defineProperties(module.exports, {
+  MimeType: { value: MimeType, enumerable: true },
+  LogLevel: { value: LogLevel, enumerable: true },
+  defaultLogger: { value: defaultLogger, enumerable: true },
+  isRGBAColor: { value: isRGBAColor, enumerable: true },
+  isCMYKColor: { value: isCMYKColor, enumerable: true },
+  isSpotColor: { value: isSpotColor, enumerable: true },
+  ANIMATION_TYPES: { value: ANIMATION_TYPES, enumerable: true },
+  DESIGN_BLOCK_TYPES: { value: DESIGN_BLOCK_TYPES, enumerable: true },
+  SHAPE_TYPES: { value: SHAPE_TYPES, enumerable: true },
+  FILL_TYPES: { value: FILL_TYPES, enumerable: true },
+  EFFECT_TYPES: { value: EFFECT_TYPES, enumerable: true },
+  BLUR_TYPES: { value: BLUR_TYPES, enumerable: true },
+  CompressionFormat: { value: CompressionFormat, enumerable: true },
+  CompressionLevel: { value: CompressionLevel, enumerable: true }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ANIMATION_TYPES,
+  BLUR_TYPES,
+  CompressionFormat,
+  CompressionLevel,
+  DESIGN_BLOCK_TYPES,
+  EFFECT_TYPES,
+  FILL_TYPES,
+  LogLevel,
+  MimeType,
+  SHAPE_TYPES,
+  defaultLogger,
+  isCMYKColor,
+  isRGBAColor,
+  isSpotColor
+});
+//# sourceMappingURL=index.js.map