@imgly/codesign-mcp 0.1.5 → 0.1.6

package/assets/docs/guide/export-save-publish/export/overview.md

@@ -1,266 +1,200 @@
-> This is one page of the CE.SDK Vanilla JS/TS documentation. For a complete overview, see the [Vanilla JS/TS Documentation Index](https://img.ly/docs/cesdk/js.md). For all docs in one file, see [llms-full.txt](./llms-full.txt.md).
+> This is one page of the CE.SDK Node.js documentation. For a complete overview, see the [Node.js Documentation Index](https://img.ly/docs/cesdk/node.md). For all docs in one file, see [llms-full.txt](./llms-full.txt.md).
 
 **Navigation:** [Guides](./guides.md) > [Export Media Assets](./export-save-publish/export.md) > [Overview](./export-save-publish/export/overview.md)
 
 ---
 
-Export your designs to multiple formats including PNG, JPEG, WebP, SVG, PDF, and MP4. CE.SDK handles all export processing entirely on the client side, giving you fine-grained control over format-specific options like compression, quality, and target dimensions.
-
-![Export overview showing different export format options](https://img.ly/docs/cesdk/./assets/browser.hero.webp)
+Export your designs to multiple formats including PNG, JPEG, WebP, SVG, and PDF.
+CE.SDK handles all export processing entirely on the server side, giving you
+fine-grained control over format-specific options like compression, quality,
+and target dimensions.
 
 > **Reading time:** 10 minutes
 >
 > **Resources:**
 >
 > - [Download examples](https://github.com/imgly/cesdk-web-examples/archive/refs/tags/release-$UBQ_VERSION$.zip)
+>
 > - [View source on GitHub](https://github.com/imgly/cesdk-web-examples)
+>
 > - [Open in StackBlitz](https://stackblitz.com/github/imgly/cesdk-web-examples)
-> - [Live demo](https://img.ly/docs/cesdk/examples/guides-export-save-publish-export-overview-browser/)
-
-Whether you're building a design tool, photo editor, or content automation workflow, understanding export options helps you deliver the right output for each use case. This guide covers supported formats, their options, and how to export programmatically or via the UI.
-
-```typescript file=@cesdk_web_examples/guides-export-save-publish-export-overview-browser/browser.ts reference-only
-import type { EditorPlugin, EditorPluginContext } from '@cesdk/cesdk-js';
-import {
-  BlurAssetSource,
-  ColorPaletteAssetSource,
-  CropPresetsAssetSource,
-  DemoAssetSources,
-  EffectsAssetSource,
-  FiltersAssetSource,
-  PagePresetsAssetSource,
-  StickerAssetSource,
-  TextAssetSource,
-  TextComponentAssetSource,
-  TypefaceAssetSource,
-  UploadAssetSources,
-  VectorShapeAssetSource
-} from '@cesdk/cesdk-js/plugins';
-import { DesignEditorConfig } from './design-editor/plugin';
-import packageJson from './package.json';
+
+Whether you're building a content automation workflow, batch processing system, or server-side rendering pipeline, understanding export options helps you deliver the right output for each use case. This guide covers supported formats, their options, and how to export programmatically.
+
+```typescript file=@cesdk_web_examples/guides-export-save-publish-export-overview-server-js/server-js.ts reference-only
+import CreativeEngine from '@cesdk/node';
+import { config } from 'dotenv';
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import * as readline from 'readline';
+
+// Load environment variables
+config();
 
 /**
- * CE.SDK Plugin: Export Overview Guide
+ * CE.SDK Server Guide: Export Overview
  *
- * This example demonstrates:
- * - Exporting designs to different formats (PNG, JPEG, WebP, PDF)
- * - Configuring export options (compression, quality, target size)
+ * Demonstrates export options and formats:
+ * - Exporting to different image formats (PNG, JPEG, WebP)
+ * - Configuring format-specific options
+ * - Exporting to PDF
  * - Exporting with color masks for print workflows
- * - Downloading exported files to user device
+ * - Checking device export limits
+ * - Target size control
  */
-class Example implements EditorPlugin {
-  name = packageJson.name;
-
-  version = packageJson.version;
-
-  async initialize({ cesdk }: EditorPluginContext): Promise<void> {
-    if (!cesdk) {
-      throw new Error('CE.SDK instance is required for this plugin');
-    }
-
-    await cesdk.addPlugin(new DesignEditorConfig());
-    // Add asset source plugins
-    await cesdk.addPlugin(new BlurAssetSource());
-    await cesdk.addPlugin(new ColorPaletteAssetSource());
-    await cesdk.addPlugin(new CropPresetsAssetSource());
-    await cesdk.addPlugin(
-      new UploadAssetSources({ include: ['ly.img.image.upload'] })
-    );
-    await cesdk.addPlugin(
-      new DemoAssetSources({
-        include: [
-          'ly.img.templates.blank.*',
-          'ly.img.templates.presentation.*',
-          'ly.img.templates.print.*',
-          'ly.img.templates.social.*',
-          'ly.img.image.*'
-        ]
-      })
-    );
-    await cesdk.addPlugin(new EffectsAssetSource());
-    await cesdk.addPlugin(new FiltersAssetSource());
-    await cesdk.addPlugin(new PagePresetsAssetSource());
-    await cesdk.addPlugin(new StickerAssetSource());
-    await cesdk.addPlugin(new TextAssetSource());
-    await cesdk.addPlugin(new TextComponentAssetSource());
-    await cesdk.addPlugin(new TypefaceAssetSource());
-    await cesdk.addPlugin(new VectorShapeAssetSource());
-
-    const engine = cesdk.engine;
-
-    // Load a template scene from a remote URL
-    await engine.scene.loadFromURL(
-      'https://cdn.img.ly/assets/demo/v3/ly.img.template/templates/cesdk_postcard_1.scene'
-    );
 
-    // Get the page
-    const page = engine.scene.getCurrentPage();
-    if (!page) {
-      throw new Error('No page found');
-    }
-
-    // Helper function to download blob
-    const downloadBlob = (blob: Blob, filename: string) => {
-      const url = URL.createObjectURL(blob);
-      const anchor = document.createElement('a');
-      anchor.href = url;
-      anchor.download = filename;
-      anchor.click();
-      URL.revokeObjectURL(url);
-    };
+// Prompt user to select export format
+async function selectFormat(): Promise<string> {
+  const formats = [
+    { key: '1', label: 'PNG', value: 'png' },
+    { key: '2', label: 'JPEG', value: 'jpeg' },
+    { key: '3', label: 'WebP', value: 'webp' },
+    { key: '4', label: 'PDF', value: 'pdf' },
+    { key: '5', label: 'HD PNG (1920x1080)', value: 'hd' },
+    { key: '6', label: 'Color Mask (PNG + alpha)', value: 'mask' },
+    { key: '7', label: 'All formats', value: 'all' }
+  ];
+
+  console.log('\nSelect export format:');
+  formats.forEach((f) => console.log(`  ${f.key}) ${f.label}`));
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question('\nEnter choice (1-7): ', (answer) => {
+      rl.close();
+      const selected = formats.find((f) => f.key === answer.trim());
+      if (!selected) {
+        console.error(
+          `\n✗ Invalid choice: "${answer.trim()}". Please enter 1-7.`
+        );
+        process.exit(1);
+      }
+      resolve(selected.value);
+    });
+  });
+}
+
+// Initialize CE.SDK engine with baseURL for asset loading
+const engine = await CreativeEngine.init({
+  baseURL: process.env.IMGLY_LOCAL_ASSETS_URL
+});
+
+try {
+  // Load a template scene from a remote URL
+  await engine.scene.loadFromURL(
+    'https://cdn.img.ly/assets/demo/v3/ly.img.template/templates/cesdk_postcard_1.scene'
+  );
 
+  const page = engine.block.findByType('page')[0];
+  if (!page) {
+    throw new Error('No page found');
+  }
+  // Create output directory
+  const outputDir = './output';
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+
+  // Get user's format selection
+  const format = await selectFormat();
+  console.log('');
+
+  if (format === 'png' || format === 'all') {
     // Export to PNG with compression
-    const exportToPng = async () => {
-      const pngBlob = await engine.block.export(page, {
-        mimeType: 'image/png',
-        pngCompressionLevel: 5 // 0-9, higher = smaller file, slower
-      });
-      downloadBlob(pngBlob, 'design.png');
-      cesdk.ui.showNotification({
-        message: `PNG exported (${(pngBlob.size / 1024).toFixed(1)} KB)`,
-        type: 'success'
-      });
-    };
+    const pngBlob = await engine.block.export(page, {
+      mimeType: 'image/png',
+      pngCompressionLevel: 5 // 0-9, higher = smaller file, slower
+    });
+    const pngBuffer = Buffer.from(await pngBlob.arrayBuffer());
+    writeFileSync(`${outputDir}/design.png`, pngBuffer);
+    console.log(`✓ PNG exported (${(pngBlob.size / 1024).toFixed(1)} KB)`);
+  }
 
+  if (format === 'jpeg' || format === 'all') {
     // Export to JPEG with quality setting
-    const exportToJpeg = async () => {
-      const jpegBlob = await engine.block.export(page, {
-        mimeType: 'image/jpeg',
-        jpegQuality: 0.9 // 0-1, higher = better quality, larger file
-      });
-      downloadBlob(jpegBlob, 'design.jpg');
-      cesdk.ui.showNotification({
-        message: `JPEG exported (${(jpegBlob.size / 1024).toFixed(1)} KB)`,
-        type: 'success'
-      });
-    };
+    const jpegBlob = await engine.block.export(page, {
+      mimeType: 'image/jpeg',
+      jpegQuality: 0.9 // 0-1, higher = better quality, larger file
+    });
+    const jpegBuffer = Buffer.from(await jpegBlob.arrayBuffer());
+    writeFileSync(`${outputDir}/design.jpg`, jpegBuffer);
+    console.log(`✓ JPEG exported (${(jpegBlob.size / 1024).toFixed(1)} KB)`);
+  }
 
+  if (format === 'webp' || format === 'all') {
     // Export to WebP with lossless quality
-    const exportToWebp = async () => {
-      const webpBlob = await engine.block.export(page, {
-        mimeType: 'image/webp',
-        webpQuality: 1.0 // 1.0 = lossless, smaller files than PNG
-      });
-      downloadBlob(webpBlob, 'design.webp');
-      cesdk.ui.showNotification({
-        message: `WebP exported (${(webpBlob.size / 1024).toFixed(1)} KB)`,
-        type: 'success'
-      });
-    };
+    const webpBlob = await engine.block.export(page, {
+      mimeType: 'image/webp',
+      webpQuality: 1.0 // 1.0 = lossless, smaller files than PNG
+    });
+    const webpBuffer = Buffer.from(await webpBlob.arrayBuffer());
+    writeFileSync(`${outputDir}/design.webp`, webpBuffer);
+    console.log(`✓ WebP exported (${(webpBlob.size / 1024).toFixed(1)} KB)`);
+  }
 
+  if (format === 'pdf' || format === 'all') {
     // Export to PDF
-    const exportToPdf = async () => {
-      const pdfBlob = await engine.block.export(page, {
-        mimeType: 'application/pdf',
-        exportPdfWithHighCompatibility: true // Rasterize for broader viewer support
-      });
-      downloadBlob(pdfBlob, 'design.pdf');
-      cesdk.ui.showNotification({
-        message: `PDF exported (${(pdfBlob.size / 1024).toFixed(1)} KB)`,
-        type: 'success'
-      });
-    };
+    const pdfBlob = await engine.block.export(page, {
+      mimeType: 'application/pdf',
+      exportPdfWithHighCompatibility: true // Rasterize for broader viewer support
+    });
+    const pdfBuffer = Buffer.from(await pdfBlob.arrayBuffer());
+    writeFileSync(`${outputDir}/design.pdf`, pdfBuffer);
+    console.log(`✓ PDF exported (${(pdfBlob.size / 1024).toFixed(1)} KB)`);
+  }
 
+  if (format === 'hd' || format === 'all') {
     // Export with target size
-    const exportWithTargetSize = async () => {
-      const blob = await engine.block.export(page, {
-        mimeType: 'image/png',
-        targetWidth: 1920,
-        targetHeight: 1080
-      });
-      downloadBlob(blob, 'design-hd.png');
-      cesdk.ui.showNotification({
-        message: `HD export complete (${(blob.size / 1024).toFixed(1)} KB)`,
-        type: 'success'
-      });
-    };
-
-    // Export with color mask - removes specified RGB color and creates alpha mask
-    const exportWithColorMask = async () => {
-      // Export with color mask - RGB values are in 0.0-1.0 range
-      // Pure magenta (1.0, 0.0, 1.0) is commonly used for registration marks
-      const [maskedImage, alphaMask] = await engine.block.exportWithColorMask(
-        page,
-        1.0, // maskColorR - red component
-        0.0, // maskColorG - green component
-        1.0, // maskColorB - blue component (RGB: pure magenta)
-        { mimeType: 'image/png' }
-      );
-      downloadBlob(maskedImage, 'design-masked.png');
-      downloadBlob(alphaMask, 'design-alpha-mask.png');
-      cesdk.ui.showNotification({
-        message: `Color mask export: image (${(maskedImage.size / 1024).toFixed(1)} KB) + mask (${(alphaMask.size / 1024).toFixed(1)} KB)`,
-        type: 'success'
-      });
-    };
-
-    // Configure navigation bar with export buttons
-    cesdk.ui.setComponentOrder({ in: 'ly.img.navigation.bar' }, [
-      'ly.img.undoRedo.navigationBar',
-      'ly.img.spacer',
-      {
-        id: 'ly.img.action.navigationBar',
-        onClick: exportToPng,
-        key: 'export-png',
-        label: 'PNG',
-        icon: '@imgly/Save',
-        variant: 'plain'
-      },
-      {
-        id: 'ly.img.action.navigationBar',
-        onClick: exportToJpeg,
-        key: 'export-jpeg',
-        label: 'JPEG',
-        icon: '@imgly/Save',
-        variant: 'plain'
-      },
-      {
-        id: 'ly.img.action.navigationBar',
-        onClick: exportToWebp,
-        key: 'export-webp',
-        label: 'WebP',
-        icon: '@imgly/Save',
-        variant: 'plain'
-      },
-      {
-        id: 'ly.img.action.navigationBar',
-        onClick: exportToPdf,
-        key: 'export-pdf',
-        label: 'PDF',
-        icon: '@imgly/Save',
-        variant: 'plain'
-      },
-      {
-        id: 'ly.img.action.navigationBar',
-        onClick: exportWithTargetSize,
-        key: 'export-hd',
-        label: 'HD',
-        icon: '@imgly/Save',
-        variant: 'plain'
-      },
-      {
-        id: 'ly.img.action.navigationBar',
-        onClick: exportWithColorMask,
-        key: 'export-mask',
-        label: 'Mask',
-        icon: '@imgly/Save',
-        variant: 'plain',
-        color: 'accent'
-      }
-    ]);
-
-    cesdk.ui.showNotification({
-      message: 'Use the export buttons to export in different formats',
-      type: 'info',
-      duration: 'infinite'
+    const hdBlob = await engine.block.export(page, {
+      mimeType: 'image/png',
+      targetWidth: 1920,
+      targetHeight: 1080
     });
+    const hdBuffer = Buffer.from(await hdBlob.arrayBuffer());
+    writeFileSync(`${outputDir}/design-hd.png`, hdBuffer);
+    console.log(`✓ HD export complete (${(hdBlob.size / 1024).toFixed(1)} KB)`);
   }
-}
 
-export default Example;
+  if (format === 'mask' || format === 'all') {
+    // Export with color mask - RGB values are in 0.0-1.0 range
+    // Pure magenta (1.0, 0.0, 1.0) is commonly used for registration marks
+    const [maskedImage, alphaMask] = await engine.block.exportWithColorMask(
+      page,
+      1.0, // maskColorR - red component
+      0.0, // maskColorG - green component
+      1.0, // maskColorB - blue component (RGB: pure magenta)
+      { mimeType: 'image/png' }
+    );
+    const maskedBuffer = Buffer.from(await maskedImage.arrayBuffer());
+    const maskBuffer = Buffer.from(await alphaMask.arrayBuffer());
+    writeFileSync(`${outputDir}/design-masked.png`, maskedBuffer);
+    writeFileSync(`${outputDir}/design-alpha-mask.png`, maskBuffer);
+    console.log(
+      `✓ Color mask export: image (${(maskedImage.size / 1024).toFixed(1)} KB) + mask (${(alphaMask.size / 1024).toFixed(1)} KB)`
+    );
+  }
+
+  // Check device export limits
+  const maxExportSize = engine.editor.getMaxExportSize();
+  const availableMemory = engine.editor.getAvailableMemory();
+  console.log(`\nDevice limits:`);
+  console.log(`  Max export size: ${maxExportSize}px`);
+  console.log(
+    `  Available memory: ${(Number(availableMemory) / 1024 / 1024).toFixed(0)} MB`
+  );
+
+  console.log('\n✓ Export completed successfully');
+  console.log(`  Output files saved to: ${outputDir}/`);
+} finally {
+  // Always dispose the engine to free resources
+  engine.dispose();
+}
 ```
 
-This guide covers how to export designs in different formats, configure format-specific options, check device limits, and download exports to the user's device.
+This guide covers how to export designs in different formats, configure format-specific options, check device limits, and save exports to the file system.
 
 ## Supported Export Formats
 
@@ -273,10 +207,9 @@ CE.SDK supports exporting scenes, pages, groups, or individual blocks in these f
 | WebP   | `image/webp`               | Yes (lossless) | Web delivery, smaller files                       |
 | SVG    | `image/svg+xml`            | Yes            | Scalable graphics, web embedding, post-processing |
 | PDF    | `application/pdf`          | Partial        | Print, documents                                  |
-| MP4    | `video/mp4`                | No             | Video content                                     |
 | Binary | `application/octet-stream` | Yes            | Raw data processing                               |
 
-Each format serves different purposes. PNG preserves transparency and works well for graphics with sharp edges or text. JPEG compresses photographs efficiently but drops transparency. WebP provides excellent compression with optional lossless mode. SVG produces scalable vector output ideal for web embedding and post-processing with standard SVG tooling. PDF preserves vector information for print workflows. MP4 exports animated content as video.
+Each format serves different purposes. PNG preserves transparency and works well for graphics with sharp edges or text. JPEG compresses photographs efficiently but drops transparency. WebP provides excellent compression with optional lossless mode. SVG produces scalable vector output ideal for web embedding and post-processing with standard SVG tooling. PDF preserves vector information for print workflows.
 
 ## Export Images
 
@@ -285,6 +218,7 @@ Each format serves different purposes. PNG preserves transparency and works well
 PNG export uses lossless compression with a configurable compression level. Higher compression produces smaller files but takes longer to encode. Quality is not affected.
 
 ```typescript highlight-export-png
+// Export to PNG with compression
 const pngBlob = await engine.block.export(page, {
   mimeType: 'image/png',
   pngCompressionLevel: 5 // 0-9, higher = smaller file, slower
@@ -298,6 +232,7 @@ The `pngCompressionLevel` ranges from 0 (no compression, fastest) to 9 (maximum
 JPEG export uses lossy compression controlled by the quality setting. Lower quality produces smaller files but introduces visible artifacts.
 
 ```typescript highlight-export-jpeg
+// Export to JPEG with quality setting
 const jpegBlob = await engine.block.export(page, {
   mimeType: 'image/jpeg',
   jpegQuality: 0.9 // 0-1, higher = better quality, larger file
@@ -306,13 +241,16 @@ const jpegBlob = await engine.block.export(page, {
 
 The `jpegQuality` ranges from 0 to 1. Values above 0.9 provide excellent quality for most use cases. The default is 0.9.
 
-> **Caution:** JPEG drops transparency from exports. Transparent areas render with a solid background, which may produce unexpected results for designs relying on alpha channels.
+> **Caution:** JPEG drops transparency from exports. Transparent areas render with a solid
+> background, which may produce unexpected results for designs relying on alpha
+> channels.
 
 ### Export to WebP
 
 WebP provides better compression than PNG or JPEG for web delivery. A quality of 1.0 enables lossless mode.
 
 ```typescript highlight-export-webp
+// Export to WebP with lossless quality
 const webpBlob = await engine.block.export(page, {
   mimeType: 'image/webp',
   webpQuality: 1.0 // 1.0 = lossless, smaller files than PNG
@@ -323,13 +261,15 @@ The `webpQuality` ranges from 0 to 1. At 1.0, WebP uses lossless compression tha
 
 ### Export to SVG
 
-SVG export produces scalable vector graphics that can be embedded directly in web pages, post-processed with standard SVG tooling, or scaled to any resolution without quality loss.
+SVG export produces scalable vector graphics that can be post-processed with standard SVG tooling or scaled to any resolution without quality loss.
 
 ```typescript
 const blob = await engine.block.export(page, {
   mimeType: 'image/svg+xml'
 });
-await cesdk.utils.downloadFile(blob, 'image/svg+xml');
+
+const buffer = Buffer.from(await blob.arrayBuffer());
+writeFileSync('output/design.svg', buffer);
 ```
 
 Text is exported as vector paths to ensure consistent rendering across environments without requiring the original fonts. Shapes, strokes, and gradients are exported as native SVG elements.
@@ -340,41 +280,42 @@ Text is exported as vector paths to ensure consistent rendering across environme
 
 ### Image Export Options
 
-| Option                | Type     | Default | Description                                                                        |
-| --------------------- | -------- | ------- | ---------------------------------------------------------------------------------- |
-| `mimeType`            | `string` | -       | Output format: `'image/png'`, `'image/jpeg'`, `'image/webp'`, or `'image/svg+xml'` |
-| `pngCompressionLevel` | `number` | `5`     | PNG compression level (0-9). Higher = smaller file, slower encoding                |
-| `jpegQuality`         | `number` | `0.9`   | JPEG quality (0-1). Higher = better quality, larger file                           |
-| `webpQuality`         | `number` | `0.8`   | WebP quality (0-1). Set to 1.0 for lossless compression                            |
-| `targetWidth`         | `number` | -       | Target output width in pixels                                                      |
-| `targetHeight`        | `number` | -       | Target output height in pixels                                                     |
+| Option | Type | Default | Description |
+| ------ | ---- | ------- | ----------- |
+| `mimeType` | `string` | - | Output format: `'image/png'`, `'image/jpeg'`, `'image/webp'`, or `'image/svg+xml'` |
+| `pngCompressionLevel` | `number` | `5` | PNG compression level (0-9). Higher = smaller file, slower encoding |
+| `jpegQuality` | `number` | `0.9` | JPEG quality (0-1). Higher = better quality, larger file |
+| `webpQuality` | `number` | `0.8` | WebP quality (0-1). Set to 1.0 for lossless compression |
+| `targetWidth` | `number` | - | Target output width in pixels |
+| `targetHeight` | `number` | - | Target output height in pixels |
 
 ## Export PDF
 
 PDF export preserves vector information and supports print workflows. The high compatibility option rasterizes content for broader viewer support.
 
 ```typescript highlight-export-pdf
+// Export to PDF
 const pdfBlob = await engine.block.export(page, {
   mimeType: 'application/pdf',
   exportPdfWithHighCompatibility: true // Rasterize for broader viewer support
 });
 ```
 
-When `exportPdfWithHighCompatibility` is `true` (the default), images and effects are rasterized according to the scene's DPI setting. Set it to `false` for faster exports, though gradients with transparency may not render correctly in Safari or macOS Preview.
+When `exportPdfWithHighCompatibility` is `true` (the default), images and effects are rasterized according to the scene's DPI setting. Set it to `false` for faster exports, though gradients with transparency may not render correctly in some PDF viewers.
 
 The underlayer options are useful for print workflows where you need a solid base layer (often white ink) beneath the design elements. The `underlayerSpotColorName` should match a spot color defined in your print workflow.
 
 ### PDF Export Options
 
-| Option                           | Type      | Default | Description                                                                                                   |
-| -------------------------------- | --------- | ------- | ------------------------------------------------------------------------------------------------------------- |
-| `mimeType`                       | `string`  | -       | Must be `'application/pdf'`                                                                                   |
-| `exportPdfWithHighCompatibility` | `boolean` | `true`  | Rasterize images and effects (like gradients) according to the scene's DPI setting for broader viewer support |
-| `exportPdfWithUnderlayer`        | `boolean` | `false` | Add an underlayer behind existing elements matching the shape of page content                                 |
-| `underlayerSpotColorName`        | `string`  | `''`    | Spot color name for the underlayer fill (used with print workflows)                                           |
-| `underlayerOffset`               | `number`  | `0`     | Size adjustment for the underlayer shape in design units                                                      |
-| `targetWidth`                    | `number`  | -       | Target output width in pixels                                                                                 |
-| `targetHeight`                   | `number`  | -       | Target output height in pixels                                                                                |
+| Option | Type | Default | Description |
+| ------ | ---- | ------- | ----------- |
+| `mimeType` | `string` | - | Must be `'application/pdf'` |
+| `exportPdfWithHighCompatibility` | `boolean` | `true` | Rasterize images and effects (like gradients) according to the scene's DPI setting for broader viewer support |
+| `exportPdfWithUnderlayer` | `boolean` | `false` | Add an underlayer behind existing elements matching the shape of page content |
+| `underlayerSpotColorName` | `string` | `''` | Spot color name for the underlayer fill (used with print workflows) |
+| `underlayerOffset` | `number` | `0` | Size adjustment for the underlayer shape in design units |
+| `targetWidth` | `number` | - | Target output width in pixels |
+| `targetHeight` | `number` | - | Target output height in pixels |
 
 ## Export with Color Mask
 
@@ -402,102 +343,30 @@ Common mask colors for print workflows:
 
 The method returns a Promise resolving to an array of two Blobs: the masked image (with matched pixels made transparent) and the alpha mask (black pixels for removed areas, white for retained areas).
 
-> **Note:** Color matching is exact. Only pixels with RGB values precisely matching the specified color are removed. Anti-aliased edges or color variations will not be affected.
+> **Note:** Color matching is exact. Only pixels with RGB values precisely matching the
+> specified color are removed. Anti-aliased edges or color variations will not
+> be affected.
 
 ### Color Mask Export Options
 
 The `exportWithColorMask()` method accepts the same options as image export:
 
-| Option                | Type     | Default       | Description                                                     |
-| --------------------- | -------- | ------------- | --------------------------------------------------------------- |
-| `mimeType`            | `string` | `'image/png'` | Output format: `'image/png'`, `'image/jpeg'`, or `'image/webp'` |
-| `pngCompressionLevel` | `number` | `5`           | PNG compression level (0-9)                                     |
-| `jpegQuality`         | `number` | `0.9`         | JPEG quality (0-1)                                              |
-| `webpQuality`         | `number` | `0.8`         | WebP quality (0-1)                                              |
-| `targetWidth`         | `number` | -             | Target output width in pixels                                   |
-| `targetHeight`        | `number` | -             | Target output height in pixels                                  |
-
-## Export Video
-
-Video export uses the H.264 codec and outputs MP4 or QuickTime files. Unlike image exports, video exports accept a progress callback to track encoding status.
-
-```typescript
-const page = engine.scene.getCurrentPage();
-
-const videoBlob = await engine.block.exportVideo(page, {
-  mimeType: 'video/mp4',
-  onProgress: (rendered, encoded, total) => {
-    console.log(`Progress: ${Math.round((encoded / total) * 100)}%`);
-  }
-});
-```
-
-### Video Export Options
-
-Configure video encoding with these options:
-
-| Option              | Type          | Default             | Description                                                               |
-| ------------------- | ------------- | ------------------- | ------------------------------------------------------------------------- | ------------------- |
-| `mimeType`          | `'video/mp4'` | `'video/quicktime'` | `'video/mp4'`                                                             | Output video format |
-| `h264Profile`       | `number`      | `77` (Main)         | H.264 profile: 66=Baseline, 77=Main, 100=High                             |
-| `h264Level`         | `number`      | `52`                | Encoding level (multiply desired level by 10, e.g., 52 = level 5.2)       |
-| `videoBitrate`      | `number`      | `0` (auto)          | Video bitrate in bits/second. Maximum determined by profile and level     |
-| `audioBitrate`      | `number`      | `0` (auto)          | Audio bitrate in bits/second. Default auto-selects 128kbps for stereo AAC |
-| `framerate`         | `number`      | `30`                | Target framerate in Hz                                                    |
-| `targetWidth`       | `number`      | -                   | Output width in pixels                                                    |
-| `targetHeight`      | `number`      | -                   | Output height in pixels                                                   |
-| `timeOffset`        | `number`      | `0`                 | Start time offset in seconds                                              |
-| `duration`          | `number`      | scene duration      | Video duration in seconds                                                 |
-| `allowTextOverhang` | `boolean`     | `false`             | Include text bounding boxes that account for glyph overhangs              |
-| `abortSignal`       | `AbortSignal` | -                   | Signal to cancel export                                                   |
-
-The `h264Profile` determines encoder quality and compatibility:
-
-- **Baseline (66)**: Broadest device compatibility, lowest quality
-- **Main (77)**: Good balance of quality and compatibility (default)
-- **High (100)**: Best quality, may not play on older devices
-
-> **Caution:** H.264 does not support transparency. Transparent areas render with a black background.
-
-## Export Audio
-
-Export audio tracks from pages or audio blocks. Supported formats are WAV (uncompressed) and MP4 (AAC encoded).
-
-```typescript
-const page = engine.scene.getCurrentPage();
-
-const audioBlob = await engine.block.exportAudio(page, {
-  mimeType: 'audio/mp4', // or 'audio/wav'
-  onProgress: (rendered, encoded, total) => {
-    console.log(`Progress: ${Math.round((encoded / total) * 100)}%`);
-  }
-});
-```
-
-### Audio Export Options
-
-Configure audio export with these options:
-
-| Option             | Type          | Default        | Description                                 |
-| ------------------ | ------------- | -------------- | ------------------------------------------- | ------------------- |
-| `mimeType`         | `'audio/wav'` | `'audio/mp4'`  | `'audio/wav'`                               | Output audio format |
-| `sampleRate`       | `number`      | `48000`        | Sample rate in Hz                           |
-| `numberOfChannels` | `number`      | `2`            | Number of audio channels (1=mono, 2=stereo) |
-| `timeOffset`       | `number`      | `0`            | Start time offset in seconds                |
-| `duration`         | `number`      | block duration | Audio duration in seconds                   |
-| `skipEncoding`     | `boolean`     | `false`        | Return raw audio data without encoding      |
-| `abortSignal`      | `AbortSignal` | -              | Signal to cancel export                     |
-
-Use `audio/wav` for lossless quality when file size is not a concern. Use `audio/mp4` (AAC) for compressed output suitable for web delivery.
-
-> **Note:** Audio export extracts and processes audio from all audio-capable blocks within the target block, including video fills with audio tracks and standalone audio blocks.
+| Option | Type | Default | Description |
+| ------ | ---- | ------- | ----------- |
+| `mimeType` | `string` | `'image/png'` | Output format: `'image/png'`, `'image/jpeg'`, or `'image/webp'` |
+| `pngCompressionLevel` | `number` | `5` | PNG compression level (0-9) |
+| `jpegQuality` | `number` | `0.9` | JPEG quality (0-1) |
+| `webpQuality` | `number` | `0.8` | WebP quality (0-1) |
+| `targetWidth` | `number` | - | Target output width in pixels |
+| `targetHeight` | `number` | - | Target output height in pixels |
 
 ## Target Size Control
 
 You can export at specific dimensions regardless of the block's actual size. The `targetWidth` and `targetHeight` options render the block large enough to fill the target size while maintaining aspect ratio.
 
 ```typescript highlight-export-target-size
-const blob = await engine.block.export(page, {
+// Export with target size
+const hdBlob = await engine.block.export(page, {
   mimeType: 'image/png',
   targetWidth: 1920,
   targetHeight: 1080
@@ -508,50 +377,34 @@ If the target aspect ratio differs from the block's aspect ratio, the output fil
 
 ## Device Export Limits
 
-Before exporting large designs, check the device's export capabilities. Memory constraints or GPU limitations may prevent exports that exceed certain dimensions.
+Before exporting large designs, check the device's export capabilities. Memory constraints may prevent exports that exceed certain dimensions.
 
-```typescript
+```typescript highlight-check-limits
+// Check device export limits
 const maxExportSize = engine.editor.getMaxExportSize();
 const availableMemory = engine.editor.getAvailableMemory();
-
-console.log(`Max dimension: ${maxExportSize}px`);
-console.log(`Available memory: ${availableMemory / 1024 / 1024} MB`);
 ```
 
 `getMaxExportSize()` returns the maximum width or height in pixels. Both dimensions must stay below this limit. `getAvailableMemory()` returns available memory in bytes, helping you assess whether large exports are feasible.
 
-> **Note:** The max export size is an upper bound. Exports may still fail due to memory constraints even when within size limits. For high-resolution exports, consider checking available memory first.
-
-## Built-in Export Action
+> **Note:** The max export size is an upper bound. Exports may still fail due to memory
+> constraints even when within size limits. For high-resolution exports,
+> consider checking available memory first.
 
-CE.SDK provides a built-in `exportDesign` action that handles export with progress dialogs and error handling. Use `cesdk.utils.export()` to export and `cesdk.utils.downloadFile()` to download the result.
+## Save to File System
 
-Export an image:
+After exporting, convert the Blob to a Buffer and write to the file system.
 
 ```typescript
-const { blobs, options } = await cesdk.utils.export({
-  mimeType: 'image/png'
+const blob = await engine.block.export(page, {
+  mimeType: 'image/png',
 });
-await cesdk.utils.downloadFile(blobs[0], options.mimeType);
-```
 
-Export a PDF:
-
-```typescript
-const { blobs, options } = await cesdk.utils.export({
-  mimeType: 'application/pdf'
-});
-await cesdk.utils.downloadFile(blobs[0], options.mimeType);
+const buffer = Buffer.from(await blob.arrayBuffer());
+writeFileSync('output/design.png', buffer);
 ```
 
-Export a video:
-
-```typescript
-const { blobs, options } = await cesdk.utils.export({
-  mimeType: 'video/mp4'
-});
-await cesdk.utils.downloadFile(blobs[0], options.mimeType);
-```
+This approach works for all export formats. Adjust the filename extension to match the exported format.
 
 ## API Reference
 
@@ -559,18 +412,16 @@ await cesdk.utils.downloadFile(blobs[0], options.mimeType);
 | ------------------------------------ | ------------------------------------------------------------------------------------- |
 | `engine.block.export()`              | Export a block with format and quality options                                        |
 | `engine.block.exportWithColorMask()` | Export a block with specific RGB color removed, returning masked image and alpha mask |
-| `engine.block.exportVideo()`         | Export a page as video with encoding options                                          |
-| `engine.block.exportAudio()`         | Export audio from a page or audio block                                               |
 | `engine.editor.getMaxExportSize()`   | Get maximum export dimension in pixels                                                |
 | `engine.editor.getAvailableMemory()` | Get available memory in bytes                                                         |
-| `cesdk.utils.export()`               | Export with progress dialog and error handling                                        |
-| `cesdk.utils.downloadFile()`         | Download a blob or string to the user's device                                        |
+
+
 
 ---
 
 ## More Resources
 
-- **[Vanilla JS/TS Documentation Index](https://img.ly/docs/cesdk/js.md)** - Browse all Vanilla JS/TS documentation
+- **[Node.js Documentation Index](https://img.ly/docs/cesdk/node.md)** - Browse all Node.js documentation
 - **[Complete Documentation](./llms-full.txt.md)** - Full documentation in one file (for LLMs)
-- **[Web Documentation](./js.md)** - Interactive documentation with examples
-- **[Support](mailto:support@img.ly)** - Contact IMG.LY support
+- **[Web Documentation](./node.md)** - Interactive documentation with examples
+- **[Support](mailto:support@img.ly)** - Contact IMG.LY support