@imgly/codesign-mcp 0.1.5 → 0.1.6

package/assets/docs/guide/create-video/limitations.md

@@ -1,228 +1,128 @@
-> 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) > [Create and Edit Videos](./create-video.md) > [Limitations](./create-video/limitations.md)
 
 ---
 
-CE.SDK performs video processing client-side, providing privacy and
-responsiveness while introducing hardware-dependent constraints. This
-reference covers resolution limits, codec support, and platform-specific
-restrictions to help you plan video workflows within platform capabilities.
-
-![Video Limitations example showing the CE.SDK video editor](https://img.ly/docs/cesdk/./assets/browser.hero.webp)
+Server-side video processing with CE.SDK operates within hardware and
+WebAssembly memory constraints. This guide covers resolution and duration
+limits, codec support, memory management, and hardware considerations—helping
+you build video workflows that run reliably on your servers.
 
 > **Reading time:** 8 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/tree/release-$UBQ_VERSION$/guides-create-video-limitations-browser)
-> - [Open in StackBlitz](https://stackblitz.com/github/imgly/cesdk-web-examples/tree/v$UBQ_VERSION$/guides-create-video-limitations-browser)
-> - [Live demo](https://img.ly/docs/cesdk/examples/guides-create-video-limitations-browser/)
-
-Client-side video processing provides significant advantages for privacy and user experience, but it operates within the constraints of the user's device. Understanding these limitations helps you build applications that work reliably across different hardware configurations and browsers.
-
-```typescript file=@cesdk_web_examples/guides-create-video-limitations-browser/browser.ts reference-only
-import type { EditorPlugin, EditorPluginContext } from '@cesdk/cesdk-js';
-
-import {
-  BlurAssetSource,
-  CaptionPresetsAssetSource,
-  ColorPaletteAssetSource,
-  CropPresetsAssetSource,
-  DemoAssetSources,
-  EffectsAssetSource,
-  FiltersAssetSource,
-  PagePresetsAssetSource,
-  StickerAssetSource,
-  TextAssetSource,
-  TextComponentAssetSource,
-  TypefaceAssetSource,
-  UploadAssetSources,
-  VectorShapeAssetSource
-} from '@cesdk/cesdk-js/plugins';
-import { VideoEditorConfig } from './video-editor/plugin';
-import packageJson from './package.json';
+>
+> - [View source on GitHub](https://github.com/imgly/cesdk-web-examples/tree/release-$UBQ_VERSION$/guides-create-video-limitations-server-js)
+>
+> - [Open in StackBlitz](https://stackblitz.com/github/imgly/cesdk-web-examples/tree/v$UBQ_VERSION$/guides-create-video-limitations-server-js)
+
+<NodejsVideoExportNotice {...props} />
+
+Server-side video processing with CE.SDK operates within the constraints of the server's hardware and WebAssembly runtime. Understanding these limitations helps you build applications that work reliably and make informed decisions about resource allocation.
+
+```typescript file=@cesdk_web_examples/guides-create-video-limitations-server-js/server-js.ts reference-only
+import CreativeEngine from '@cesdk/node';
+import { config } from 'dotenv';
+
+// Load environment variables
+config();
 
 /**
- * CE.SDK Plugin: Video Limitations Guide
+ * CE.SDK Server Guide: Video Limitations
  *
  * Demonstrates how to query video processing limitations in CE.SDK:
  * - Querying maximum export size
  * - Monitoring memory usage and availability
  * - Understanding resolution and duration constraints
+ * - Validating export feasibility before processing
  */
-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 VideoEditorConfig());
-
-    // Add asset source plugins
-    await cesdk.addPlugin(new BlurAssetSource());
-    await cesdk.addPlugin(new CaptionPresetsAssetSource());
-    await cesdk.addPlugin(new ColorPaletteAssetSource());
-    await cesdk.addPlugin(new CropPresetsAssetSource());
-    await cesdk.addPlugin(
-      new UploadAssetSources({
-        include: [
-          'ly.img.image.upload',
-          'ly.img.video.upload',
-          'ly.img.audio.upload'
-        ]
-      })
-    );
-    await cesdk.addPlugin(
-      new DemoAssetSources({
-        include: [
-          'ly.img.templates.video.*',
-          'ly.img.image.*',
-          'ly.img.audio.*',
-          'ly.img.video.*'
-        ]
-      })
-    );
-    await cesdk.addPlugin(new EffectsAssetSource());
-    await cesdk.addPlugin(new FiltersAssetSource());
-    await cesdk.addPlugin(
-      new PagePresetsAssetSource({
-        include: [
-          'ly.img.page.presets.instagram.*',
-          'ly.img.page.presets.facebook.*',
-          'ly.img.page.presets.x.*',
-          'ly.img.page.presets.linkedin.*',
-          'ly.img.page.presets.pinterest.*',
-          'ly.img.page.presets.tiktok.*',
-          'ly.img.page.presets.youtube.*',
-          'ly.img.page.presets.video.*'
-        ]
-      })
-    );
-    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());
-
-    await cesdk.actions.run('scene.create', {
-      layout: 'DepthStack',
-      page: {
-        sourceId: 'ly.img.page.presets',
-        assetId: 'ly.img.page.presets.instagram.story',
-        color: { r: 0, g: 0, b: 0, a: 1 }
-      }
-    });
-
-    const engine = cesdk.engine;
-
-    // Query the maximum export dimensions supported by this device
-    const maxExportSize = engine.editor.getMaxExportSize();
-    console.log('Maximum export size:', maxExportSize, 'pixels');
-    // The maximum export size depends on the GPU texture size limit
-    // Typical values: 4096, 8192, or 16384 pixels
-
-    // Query current memory consumption
-    const usedMemory = engine.editor.getUsedMemory();
-    const usedMemoryMB = (usedMemory / (1024 * 1024)).toFixed(2);
-    console.log('Memory used:', usedMemoryMB, 'MB');
-
-    // Query available memory for video processing
-    const availableMemory = engine.editor.getAvailableMemory();
-    const availableMemoryMB = (availableMemory / (1024 * 1024)).toFixed(2);
-    console.log('Memory available:', availableMemoryMB, 'MB');
-    // Browser tabs typically cap around 2GB due to WebAssembly's 32-bit address space
-
-    // Calculate memory utilization percentage
-    const totalMemory = usedMemory + availableMemory;
-    const memoryUtilization = ((usedMemory / totalMemory) * 100).toFixed(1);
-    console.log('Memory utilization:', memoryUtilization, '%');
-
-    // Check if a specific export size is feasible
-    const desiredWidth = 3840; // 4K UHD
-    const desiredHeight = 2160;
-    const canExport4K =
-      desiredWidth <= maxExportSize && desiredHeight <= maxExportSize;
-    console.log(
-      'Can export at 4K UHD (3840x2160):',
-      canExport4K ? 'Yes' : 'No'
-    );
-
-    // Add a sample video to demonstrate the editor with video content
-    const videoUri = 'https://img.ly/static/ubq_video_samples/bbb.mp4';
-    const pages = engine.block.findByType('page');
-    const page = pages.length > 0 ? pages[0] : engine.scene.get();
-
-    const pageWidth = engine.block.getWidth(page);
-    const pageHeight = engine.block.getHeight(page);
-
-    // Create a video block that fills the page
-    const videoBlock = await engine.block.addVideo(
-      videoUri,
-      pageWidth,
-      pageHeight
-    );
-
-    // Position the video at the center of the page
-    engine.block.setPositionX(videoBlock, 0);
-    engine.block.setPositionY(videoBlock, 0);
-
-    // Select the video block
-    engine.block.setSelected(videoBlock, true);
-
-    // Re-check memory after loading video content
-    const usedAfterLoad = engine.editor.getUsedMemory();
-    const availableAfterLoad = engine.editor.getAvailableMemory();
-    const usedAfterLoadMB = (usedAfterLoad / (1024 * 1024)).toFixed(2);
-    const availableAfterLoadMB = (availableAfterLoad / (1024 * 1024)).toFixed(
-      2
-    );
-    console.log('After loading video:');
-    console.log('  Memory used:', usedAfterLoadMB, 'MB');
-    console.log('  Memory available:', availableAfterLoadMB, 'MB');
-
-    // Log summary of device capabilities
-    console.log('--- Device Capabilities Summary ---');
-    console.log('Max export dimension:', maxExportSize, 'px');
-    console.log('4K UHD support:', canExport4K ? 'Supported' : 'Not supported');
-    console.log(
-      'Initial memory:',
-      usedMemoryMB,
-      'MB used /',
-      availableMemoryMB,
-      'MB available'
-    );
-    console.log(
-      'Open the browser console to view detailed limitation information.'
-    );
-  }
-}
 
-export default Example;
+// Initialize CE.SDK engine in headless mode
+const engine = await CreativeEngine.init({
+  baseURL: process.env.IMGLY_LOCAL_ASSETS_URL
+  // license: process.env.CESDK_LICENSE, // Optional (trial mode available)
+});
+
+try {
+  // Create a scene to query environment capabilities
+  engine.scene.create('DepthStack');
+
+  // Query the maximum export dimensions supported by this environment
+  const maxExportSize = engine.editor.getMaxExportSize();
+  console.log('Maximum export size:', maxExportSize, 'pixels');
+  // Server environments may have different limits than browser
+  // Typical values: 4096, 8192, or 16384 pixels
+
+  // Query current memory consumption (returns BigInt on Node.js)
+  const usedMemory = engine.editor.getUsedMemory();
+  const usedMemoryMB = (Number(usedMemory) / (1024 * 1024)).toFixed(2);
+  console.log('Memory used:', usedMemoryMB, 'MB');
+
+  // Query available memory for video processing (returns BigInt on Node.js)
+  const availableMemory = engine.editor.getAvailableMemory();
+  const availableMemoryMB = (Number(availableMemory) / (1024 * 1024)).toFixed(
+    2
+  );
+  console.log('Memory available:', availableMemoryMB, 'MB');
+  // Server environments typically have more memory than browser tabs
+
+  // Calculate memory utilization percentage
+  const totalMemory = Number(usedMemory) + Number(availableMemory);
+  const memoryUtilization = ((Number(usedMemory) / totalMemory) * 100).toFixed(
+    1
+  );
+  console.log('Memory utilization:', memoryUtilization, '%');
+
+  // Check if a specific export size is feasible
+  const desiredWidth = 3840; // 4K UHD
+  const desiredHeight = 2160;
+  const canExport4K =
+    desiredWidth <= maxExportSize && desiredHeight <= maxExportSize;
+  console.log('Can export at 4K UHD (3840x2160):', canExport4K ? 'Yes' : 'No');
+
+  // Before loading large resources, check available memory
+  const minRequiredMemory = 500 * 1024 * 1024; // 500 MB minimum
+  const hasEnoughMemory = Number(availableMemory) > minRequiredMemory;
+  console.log(
+    'Has enough memory for large video processing:',
+    hasEnoughMemory ? 'Yes' : 'No'
+  );
+
+  // Log summary of environment capabilities
+  console.log('--- Environment Capabilities Summary ---');
+  console.log('Max export dimension:', maxExportSize, 'px');
+  console.log('4K UHD support:', canExport4K ? 'Supported' : 'Not supported');
+  console.log('Memory available:', availableMemoryMB, 'MB');
+  console.log('Memory utilization:', memoryUtilization, '%');
+
+  console.log('\nVideo limitations check completed successfully.');
+} finally {
+  engine.dispose();
+}
 ```
 
+This guide covers resolution and duration limits, codec support, memory constraints, and how to query these limitations programmatically in server-side video processing workflows.
+
 ## Resolution Limits
 
-Video resolution capabilities depend on hardware resources and WebAssembly memory constraints. CE.SDK supports up to 4K UHD for playback and export on capable hardware.
+Video resolution capabilities depend on hardware resources and WebAssembly memory constraints. CE.SDK supports up to 4K UHD for processing and export on capable hardware.
 
-Import resolution is bounded by WebAssembly's 32-bit address space and browser tab memory limits, which typically cap around 2GB. This means very high resolution video files may exceed available memory during processing. Playback and export at 4K depends on available GPU resources, and higher resolutions require proportionally more memory and processing power.
+Import resolution is bounded by WebAssembly's memory model. Server environments typically have more memory available than browser tabs, but resolution limits still apply. Higher resolutions require proportionally more memory and processing power.
 
 Query the maximum export size before initiating exports to avoid failures:
 
 ```typescript highlight-query-max-export-size
-// Query the maximum export dimensions supported by this device
+// Query the maximum export dimensions supported by this environment
 const maxExportSize = engine.editor.getMaxExportSize();
 console.log('Maximum export size:', maxExportSize, 'pixels');
-// The maximum export size depends on the GPU texture size limit
+// Server environments may have different limits than browser
 // Typical values: 4096, 8192, or 16384 pixels
 ```
 
-The maximum export size varies by device GPU capabilities. Typical values range from 4096 to 16384 pixels depending on the graphics hardware. Before exporting at high resolutions, verify the target dimensions don't exceed this limit:
+The maximum export size varies by hardware capabilities. Before exporting at high resolutions, verify the target dimensions don't exceed this limit:
 
 ```typescript highlight-check-export-feasibility
 // Check if a specific export size is feasible
@@ -235,162 +135,157 @@ console.log('Can export at 4K UHD (3840x2160):', canExport4K ? 'Yes' : 'No');
 
 ## Duration Limits
 
-Video duration affects editing responsiveness and export time. CE.SDK optimizes for short-form content while supporting longer videos with performance trade-offs.
+Video duration affects processing time and memory consumption. CE.SDK optimizes for short-form content while supporting longer videos with performance trade-offs.
 
-Stories and reels up to 2 minutes are fully supported with smooth editing performance. Videos up to 10 minutes work well on modern hardware, with export times typically around 1 minute for this length. Longer videos are technically possible but may impact editing responsiveness on less capable devices.
+Stories and reels up to 2 minutes are fully supported with efficient processing. Videos up to 10 minutes work well on modern hardware. Longer videos are technically possible but may increase memory usage and processing time.
 
 For long-form content, consider these approaches:
 
-- Split longer videos into shorter segments for editing
-- Use lower resolution previews during editing, then export at full quality
-- Test on target devices to establish acceptable duration limits for your use case
+- Split longer videos into shorter segments for processing
+- Use lower resolution for intermediate processing, then export at full quality
+- Monitor memory usage to establish acceptable duration limits for your server configuration
 
 ## Frame Rate Support
 
-Frame rate affects both playback smoothness and export performance. Hardware acceleration significantly impacts high frame rate capabilities.
+Frame rate affects processing time and output quality. Server environments can handle high frame rates without the real-time playback concerns of browser implementations.
 
-30 FPS at 1080p is broadly supported across devices and provides smooth playback on most hardware. 60 FPS and high-resolution combinations benefit from hardware acceleration. When hardware acceleration is unavailable, high frame rate video may drop frames during preview playback, though exports will maintain the correct timing.
+30 FPS at 1080p is broadly supported and provides efficient processing. 60 FPS and high-resolution combinations require more processing time but are well-supported in server environments.
 
-Variable frame rate sources may have timing precision limitations. For best results with variable frame rate content, consider transcoding to constant frame rate before importing into CE.SDK.
+Variable frame rate sources may have timing precision limitations. For best results with variable frame rate content, consider transcoding to constant frame rate before processing.
 
 ## Supported Codecs
 
-CE.SDK supports widely-adopted video and audio codecs, with some platform-specific variations in availability.
+CE.SDK supports widely-adopted video and audio codecs. Server-side codec support depends on the platform's installed codecs and libraries.
 
 ### Video Codecs
 
-H.264/AVC in `.mp4` containers has universal support across all browsers and platforms. This is the most reliable codec choice for broad compatibility.
+H.264/AVC in `.mp4` containers has universal support and is the most reliable codec choice for broad compatibility.
 
-H.265/HEVC in `.mp4` containers has platform-dependent support. Safari on macOS and iOS supports HEVC natively, while Chrome and Firefox support varies by operating system and codec availability.
+H.265/HEVC in `.mp4` containers has platform-dependent support. Availability varies by operating system and installed codec libraries.
 
 ### Audio Codecs
 
-MP3 works in `.mp3` files or within `.mp4` containers, with universal browser support.
-
-AAC in `.m4a`, `.mp4`, or `.mov` containers is widely supported, though some browsers may require system codecs for encoding during export.
-
-## Browser and Platform Restrictions
+MP3 works in `.mp3` files or within `.mp4` containers, with universal support.
 
-Browser capabilities depend on the host operating system, introducing platform-specific limitations that affect video processing.
+AAC in `.m4a`, `.mp4`, or `.mov` containers is widely supported, though some platforms may require additional codec libraries for encoding.
 
-### Windows Limitations
+## Server-Side Video Export
 
-H.265 transparency is not supported on Windows hosts. If your workflow requires alpha channel video with HEVC, consider processing on macOS or using H.264 which supports alpha on all platforms.
+For full video export capabilities in server environments, CE.SDK provides the CE.SDK Renderer. The headless Node.js SDK can query limitations and perform scene manipulation, but complete video rendering and encoding requires the renderer.
 
-### Linux Limitations
+The CE.SDK Renderer runs as a separate process that handles video encoding and export. It supports the same codec options and provides consistent output across server deployments.
 
-Chrome on Linux typically lacks encoder support for H.264 and AAC due to licensing restrictions in the Chrome Linux build. This means video imports and playback may work correctly, but exports may fail.
+For more information about the renderer and its capabilities, see the [CE.SDK Renderer Overview](#broken-link-7f3e9a).
 
-If you're targeting Linux users, consider:
+## Hardware Considerations
 
-- Recommending Firefox, which may have different codec support
-- Providing fallback export options
-- Using server-side export processing for Linux users
+Server capabilities directly affect video processing performance. CE.SDK scales with available hardware resources.
 
-Use the `video.decode.checkSupport` and `video.encode.checkSupport` actions to detect video capabilities programmatically and display appropriate user feedback. Alternatively, use `cesdk.utils.supportsVideoDecode()` and `cesdk.utils.supportsVideoEncode()` to check support silently without showing dialogs. See the [Actions API](./actions.md) for implementation details.
+### Recommended Server Specifications
 
-### Chromium Limitations
-
-Chromium-based browsers (without proprietary codecs) don't include video codecs due to licensing. They may fall back to system libraries on some platforms, such as macOS, but support is not guaranteed. Video editing functionality may not work reliably in pure Chromium builds.
-
-### Mobile Browser Limitations
-
-Video editing is not supported on mobile browsers on any platform due to technical limitations causing performance issues. For mobile video editing capabilities, use the native mobile SDKs for iOS and Android, which provide full video support.
-
-## Hardware Requirements
-
-Device capabilities directly affect video processing performance. CE.SDK scales with available hardware resources.
-
-### Recommended Hardware
-
-| Platform         | Minimum Hardware                                                          |
-| ---------------- | ------------------------------------------------------------------------- |
-| Desktop          | Notebook or desktop released in the last 7 years with at least 4GB memory |
-| Mobile (Apple)   | iPhone 8, iPad (6th gen) or newer                                         |
-| Mobile (Android) | Phones and tablets released in the last 4 years                           |
+| Resource | Minimum | Recommended |
+| -------- | ------- | ----------- |
+| Memory | 4 GB | 8+ GB for 4K content |
+| CPU | 2 cores | 4+ cores for faster processing |
+| Storage | SSD recommended | Fast I/O for video file handling |
 
 ### GPU Considerations
 
-Hardware acceleration improves encoding and decoding performance significantly. High-resolution and high-frame-rate exports benefit most from GPU support. The maximum export size depends on the maximum texture size the device's GPU can allocate.
+GPU acceleration can improve encoding and decoding performance. For server deployments:
 
-Integrated graphics can handle most common video editing tasks. Discrete GPUs provide better performance for 4K content and complex compositions with multiple video layers.
+- Dedicated GPUs provide the best performance for high-resolution content
+- GPU memory limits affect maximum texture size and export dimensions
+- Cloud GPU instances vary in capability; test your target configuration
 
 ## Memory Constraints
 
-Client-side video processing operates within browser memory limits. Use the memory APIs to monitor consumption and make informed decisions about resource loading.
+Server-side video processing operates within Node.js and WebAssembly memory limits. Use the memory APIs to monitor consumption and make informed decisions about resource allocation.
 
-Query current memory usage to understand how much has been consumed:
+Query current memory usage to understand consumption:
 
 ```typescript highlight-query-memory-usage
-// Query current memory consumption
+// Query current memory consumption (returns BigInt on Node.js)
 const usedMemory = engine.editor.getUsedMemory();
-const usedMemoryMB = (usedMemory / (1024 * 1024)).toFixed(2);
+const usedMemoryMB = (Number(usedMemory) / (1024 * 1024)).toFixed(2);
 console.log('Memory used:', usedMemoryMB, 'MB');
 ```
 
-Check how much memory remains available for additional resources:
+Check how much memory remains available:
 
 ```typescript highlight-query-available-memory
-// Query available memory for video processing
+// Query available memory for video processing (returns BigInt on Node.js)
 const availableMemory = engine.editor.getAvailableMemory();
-const availableMemoryMB = (availableMemory / (1024 * 1024)).toFixed(2);
+const availableMemoryMB = (Number(availableMemory) / (1024 * 1024)).toFixed(
+  2
+);
 console.log('Memory available:', availableMemoryMB, 'MB');
-// Browser tabs typically cap around 2GB due to WebAssembly's 32-bit address space
+// Server environments typically have more memory than browser tabs
 ```
 
-WebAssembly uses a 32-bit address space, limiting the maximum addressable memory. Browser tabs typically cap around 2GB of memory, though this varies by browser and system configuration. Multiple video tracks and effects increase memory usage proportionally.
+Calculate memory utilization to monitor resource usage:
+
+```typescript highlight-calculate-memory-percentage
+// Calculate memory utilization percentage
+const totalMemory = Number(usedMemory) + Number(availableMemory);
+const memoryUtilization = ((Number(usedMemory) / totalMemory) * 100).toFixed(
+  1
+);
+console.log('Memory utilization:', memoryUtilization, '%');
+```
 
-Query memory APIs before loading additional video files to avoid out-of-memory conditions:
+Before processing large resources, verify sufficient memory is available:
 
-```typescript highlight-monitor-memory-after-load
-// Re-check memory after loading video content
-const usedAfterLoad = engine.editor.getUsedMemory();
-const availableAfterLoad = engine.editor.getAvailableMemory();
-const usedAfterLoadMB = (usedAfterLoad / (1024 * 1024)).toFixed(2);
-const availableAfterLoadMB = (availableAfterLoad / (1024 * 1024)).toFixed(2);
-console.log('After loading video:');
-console.log('  Memory used:', usedAfterLoadMB, 'MB');
-console.log('  Memory available:', availableAfterLoadMB, 'MB');
+```typescript highlight-check-memory-before-operation
+// Before loading large resources, check available memory
+const minRequiredMemory = 500 * 1024 * 1024; // 500 MB minimum
+const hasEnoughMemory = Number(availableMemory) > minRequiredMemory;
+console.log(
+  'Has enough memory for large video processing:',
+  hasEnoughMemory ? 'Yes' : 'No'
+);
 ```
 
+Server environments typically have more memory than browser tabs, but multiple concurrent operations increase usage proportionally. Consider implementing queue-based processing for high-throughput scenarios.
+
 ## Export Size Limitations
 
-Export dimensions are bounded by GPU texture size limits. Always query `getMaxExportSize()` before initiating exports to ensure the requested dimensions are supported.
+Export dimensions are bounded by hardware texture size limits. Always query `getMaxExportSize()` before initiating exports.
 
-The maximum export size varies by device GPU capabilities. Common limits include:
+The maximum export size varies by hardware capabilities. Common limits include:
 
-- **4096 pixels**: Older integrated graphics
-- **8192 pixels**: Most modern integrated and discrete GPUs
-- **16384 pixels**: High-end discrete GPUs
+- **4096 pixels**: Basic configurations
+- **8192 pixels**: Most modern server hardware
+- **16384 pixels**: High-end GPU configurations
 
-Consider target platform requirements when planning export dimensions. Mobile devices and web playback rarely benefit from resolutions above 1080p or 4K, so exporting at extreme resolutions may not provide practical value.
+Consider target platform requirements when planning export dimensions. Most video content is consumed at 1080p or 4K, so extreme resolutions rarely provide practical value.
 
 ## Troubleshooting
 
-Common issues developers encounter related to video limitations:
+Common issues in server-side video processing:
 
-| Issue                            | Cause                                       | Solution                                         |
-| -------------------------------- | ------------------------------------------- | ------------------------------------------------ |
-| Video export fails on Linux      | Chrome lacks H.264/AAC encoder support      | Use Firefox or implement server-side export      |
-| Slow playback at high resolution | Hardware cannot keep up with decoding       | Reduce preview resolution or use proxy editing   |
-| Export fails with large video    | Memory limits exceeded                      | Reduce resolution or split into shorter segments |
-| H.265 transparency not working   | Windows platform limitation                 | Use H.264 or process on macOS                    |
-| Mobile browser video not working | Mobile browsers don't support video editing | Use native mobile SDK instead                    |
-| Export size rejected             | Exceeds device GPU texture limits           | Query `getMaxExportSize()` and reduce dimensions |
+| Issue | Cause | Solution |
+| ----- | ----- | -------- |
+| Export fails | Memory limits exceeded | Reduce resolution or split into segments |
+| Codec not supported | Missing system codecs | Install required codec libraries |
+| Slow processing | Insufficient hardware resources | Upgrade server specs or optimize content |
+| Export size rejected | Exceeds texture limits | Query `getMaxExportSize()` and reduce dimensions |
+| High memory usage | Large files or many concurrent operations | Implement queue-based processing |
 
 ## API Reference
 
-| Method                               | Description                                                 |
-| ------------------------------------ | ----------------------------------------------------------- |
-| `engine.editor.getMaxExportSize()`   | Query the maximum export dimensions supported by the device |
-| `engine.editor.getAvailableMemory()` | Get available memory in bytes for video processing          |
-| `engine.editor.getUsedMemory()`      | Get current memory usage in bytes                           |
+| Method | Description |
+| ------ | ----------- |
+| `engine.editor.getMaxExportSize()` | Query the maximum export dimensions supported by the environment |
+| `engine.editor.getAvailableMemory()` | Get available memory in bytes for video processing |
+| `engine.editor.getUsedMemory()` | Get current memory usage in bytes |
+
+
 
 ---
 
 ## 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

package/assets/docs/guide/create-video.md

@@ -1,32 +1,33 @@
-> 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) > [Create and Edit Videos](./create-video.md)
 
 ---
 
+
+
+
 ---
 
 ## Related Pages
 
-- [Create Videos Overview](./create-video/overview.md) - Learn how to create and customize videos in CE.SDK using scenes, assets, and time-based editing.
-- [Video and Audio Timeline Web Editor](./create-video/timeline-editor.md) - Use the timeline editor to arrange and edit video clips, audio, and animations frame by frame.
 - [Control Audio and Video](./create-video/control.md) - Learn to play, pause, seek, and preview audio and video content in CE.SDK using playback controls and solo mode.
-- [Trim Video Clips](./edit-video/trim.md) - Learn how to trim video clips in CE.SDK to control which portion of media plays back.
+- [Trim Video Clips](./edit-video/trim.md) - Learn how to trim video clips programmatically using CE.SDK's Engine API in headless mode.
 - [Split Video and Audio](./edit-video/split.md) - Learn how to split video and audio clips at specific time points in CE.SDK, creating two independent segments from a single clip.
 - [Join and Arrange Video Clips](./edit-video/join-and-arrange.md) - Combine multiple video clips into sequences and organize them on the timeline using tracks and time offsets in CE.SDK.
 - [Transform](./edit-video/transform.md) - Documentation for Transform
 - [Add Captions](./edit-video/add-captions.md) - Documentation for adding captions to videos
-- [Update Caption Presets](./create-video/update-caption-presets.md) - Extend video captions with custom caption styles using simple content.json updates
 - [Add Watermark](./edit-video/add-watermark.md) - Add text and image watermarks to videos using CE.SDK for copyright protection, branding, and content attribution with timeline management and visibility controls.
 - [Redact Sensitive Content in Videos](./edit-video/redaction.md) - Redact sensitive video content using blur, pixelization, or solid overlays. Essential for privacy protection when obscuring faces, license plates, or personal information.
-- [Video Editor SDK](./overview.md) - Explore video editing features in CE.SDK including trimming, splitting, captions, and programmatic editing.
-- [Video Limitations](./create-video/limitations.md) - Understand resolution limits, duration constraints, codec support, and browser-specific restrictions when working with video in CE.SDK.
+- [Node.js Video Editor SDK](./overview.md) - Explore video editing features in CE.SDK including trimming, splitting, captions, and programmatic editing.
+- [Limitations](./create-video/limitations.md) - Understand video resolution limits, duration constraints, codec support, and browser-specific restrictions in CE.SDK.
+
 
 ---
 
 ## 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