@imgly/codesign-mcp 0.1.5 → 0.1.6

package/assets/docs/guide/export-save-publish/export/size-limits.md

@@ -1,401 +1,306 @@
-> 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) > [Size Limits](./export-save-publish/export/size-limits.md)
 
 ---
 
-Configure size limits to balance quality and performance in CE.SDK applications.
-
-![Size Limits example showing CE.SDK with maxImageSize configuration](https://img.ly/docs/cesdk/./assets/browser.hero.webp)
+Configure size limits to balance quality and performance in headless Node.js workflows.
 
 > **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-size-limits-browser/)
-
-CE.SDK processes images and videos client-side, which means size limits depend on the user's GPU capabilities and available memory. Understanding and configuring these limits helps you build applications that deliver high-quality results while maintaining smooth performance across different devices.
-
-```typescript file=@cesdk_web_examples/guides-export-save-publish-size-limits-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';
-
-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());
-
-    await cesdk.actions.run('scene.create', {
-      page: { width: 800, height: 600, unit: 'Pixel' }
-    });
-
-    const engine = cesdk.engine;
-    const page = engine.block.findByType('page')[0];
-
-    // Add export image action to navigation bar
-    cesdk.ui.insertOrderComponent(
-      { in: 'ly.img.navigation.bar', position: 'end' },
-      {
-        id: 'ly.img.actions.navigationBar',
-        children: ['ly.img.exportImage.navigationBar']
-      }
-    );
 
-    const imageUri = 'https://img.ly/static/ubq_samples/sample_1.jpg';
-
-    // ===== Section 1: Reading Current maxImageSize =====
-    // Get the current maxImageSize setting
-    const currentMaxSize = engine.editor.getSetting('maxImageSize');
-    console.log('Current maxImageSize:', currentMaxSize);
-    // Default is 4096 pixels
-
-    // ===== Section 2: Setting Different maxImageSize Values =====
-    // Configure maxImageSize for different use cases
-    // This must be set BEFORE loading images to ensure they're downscaled
-
-    // Low memory devices (mobile, tablets) - use 2048 for safety
-    engine.editor.setSetting('maxImageSize', 2048);
+CE.SDK processes images and videos in server environments using CPU and GPU resources, which means size limits depend on your server's hardware capabilities and available memory. Understanding and configuring these limits helps you build automation workflows that deliver high-quality results while maintaining efficient resource usage in batch processing, serverless functions, and containerized deployments.
+
+```typescript file=@cesdk_web_examples/guides-export-save-publish-size-limits-server-js/server-js.ts reference-only
+import CreativeEngine from '@cesdk/node';
+import { config } from 'dotenv';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+
+// Load environment variables
+config();
+
+/**
+ * CE.SDK Server Guide: Size Limits
+ *
+ * Demonstrates how to configure and work with image size limits:
+ * - Reading current maxImageSize setting
+ * - Configuring maxImageSize for different scenarios
+ * - Observing settings changes
+ * - Understanding export size constraints
+ */
+
+// 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)
+});
 
-    // High quality (professional workflows, desktop)
-    // engine.editor.setSetting('maxImageSize', 8192);
+try {
+  // Read the current maxImageSize setting
+  const currentMaxImageSize = engine.editor.getSetting('maxImageSize');
+  // eslint-disable-next-line no-console
+  console.log(`Current maxImageSize: ${currentMaxImageSize}px`);
+  // Default is 4096 pixels - safe baseline for universal compatibility
+
+  // Subscribe to settings changes to react to configuration updates
+  const unsubscribe = engine.editor.onSettingsChanged(() => {
+    const newMaxImageSize = engine.editor.getSetting('maxImageSize');
+    // eslint-disable-next-line no-console
+    console.log(`maxImageSize changed to: ${newMaxImageSize}px`);
+  });
+
+  // Configure maxImageSize for low memory environments
+  // This must be set BEFORE loading images to ensure they're downscaled
+  engine.editor.setSetting('maxImageSize', 2048);
+  // eslint-disable-next-line no-console
+  console.log(
+    `Updated maxImageSize: ${engine.editor.getSetting('maxImageSize')}px`
+  );
 
-    console.log(
-      'Updated maxImageSize:',
-      engine.editor.getSetting('maxImageSize')
+  // Create a design scene with specific page dimensions
+  engine.scene.create('VerticalStack', {
+    page: { size: { width: 800, height: 600 } },
+  });
+  const page = engine.block.findByType('page')[0];
+
+  // Use sample image for demonstration
+  const imageUri = 'https://img.ly/static/ubq_samples/sample_1.jpg';
+
+  // Add an image to the page for demonstration
+  // Note: In Node.js, size parameter is required (no DOM Image API)
+  // The size parameter controls display dimensions, while maxImageSize controls texture loading
+  const imageBlock = await engine.block.addImage(imageUri, {
+    size: { width: 800, height: 600 },
+  });
+  engine.block.appendChild(page, imageBlock);
+
+  // Position image to fill the page
+  engine.block.setPositionX(imageBlock, 0);
+  engine.block.setPositionY(imageBlock, 0);
+
+  // Validate export dimensions before processing
+  // Check if dimensions are safe for the server's memory and timeout constraints
+  const exportWidth = engine.block.getWidth(page);
+  const exportHeight = engine.block.getHeight(page);
+  const maxSafeSize = 8192; // Configure based on server capabilities
+
+  // eslint-disable-next-line no-console
+  console.log(`Export dimensions: ${exportWidth}×${exportHeight}`);
+
+  if (exportWidth > maxSafeSize || exportHeight > maxSafeSize) {
+    // eslint-disable-next-line no-console
+    console.warn(
+      `⚠ Export dimensions (${exportWidth}×${exportHeight}) exceed safe limits (${maxSafeSize}×${maxSafeSize})`
+    );
+    // eslint-disable-next-line no-console
+    console.warn(
+      'Consider reducing dimensions or using a higher-memory server'
     );
+  } else {
+    // eslint-disable-next-line no-console
+    console.log('✓ Export dimensions are within safe limits');
+  }
 
-    // ===== Section 3: Observing Settings Changes =====
-    // Subscribe to settings changes to update UI when maxImageSize changes
-    engine.editor.onSettingsChanged(() => {
-      const newMaxSize = engine.editor.getSetting('maxImageSize');
-      console.log('maxImageSize changed to:', newMaxSize);
-      // In a real app, update UI here to reflect the new setting
-    });
-
-    // The subscription returns an unsubscribe function if you need to clean up later
-    // const unsubscribe = engine.editor.onSettingsChanged(() => { ... });
-    // unsubscribe(); // Call when no longer needed
-
-    // ===== Section 4: GPU Capability Detection (Web) =====
-    // Query GPU max texture size to understand export limits
-    const canvas = document.createElement('canvas');
-    const gl = canvas.getContext('webgl2') || canvas.getContext('webgl');
-
-    if (gl) {
-      const maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
-      console.log('GPU Max Texture Size:', maxTextureSize);
-      console.log(
-        'Safe export dimensions: up to',
-        maxTextureSize,
-        '×',
-        maxTextureSize
+  // Export the result to PNG
+  // Note: Export size is not limited by maxImageSize setting
+  // Export may fail if output exceeds server memory or rendering limits
+  const outputDir = './output';
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+
+  try {
+    const blob = await engine.block.export(page, { mimeType: 'image/png' });
+    const buffer = Buffer.from(await blob.arrayBuffer());
+    writeFileSync(`${outputDir}/size-limits-result.png`, buffer);
+
+    // eslint-disable-next-line no-console
+    console.log('✓ Exported result to output/size-limits-result.png');
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    // eslint-disable-next-line no-console
+    console.error('Export failed:', errorMessage);
+
+    // Check if error is size-related
+    if (
+      errorMessage.includes('memory') ||
+      errorMessage.includes('size') ||
+      errorMessage.includes('texture')
+    ) {
+      // eslint-disable-next-line no-console
+      console.error('Size-related export failure detected');
+      // eslint-disable-next-line no-console
+      console.error(
+        'Remediation: Reduce maxImageSize, decrease export dimensions, or use compression'
       );
 
-      // Most modern GPUs support 4096×4096 to 16384×16384
-      // Safe baseline is 4096×4096 for universal compatibility
-    }
+      // Implement automatic retry with reduced settings
+      engine.editor.setSetting('maxImageSize', 2048);
+      // eslint-disable-next-line no-console
+      console.log('Retrying export with reduced maxImageSize: 2048px');
 
-    // ===== Section 5: Pre-Export Size Validation =====
-    // Calculate actual export dimensions including all content
-    // Get bounding box of all content to check actual export size
-    const allBlocks = engine.block.findByType('//ly.img.ubq/graphic');
-    let maxRight = 0;
-    let maxBottom = 0;
-
-    allBlocks.forEach((blockId) => {
-      const x = engine.block.getPositionX(blockId);
-      const y = engine.block.getPositionY(blockId);
-      const width = engine.block.getWidth(blockId);
-      const height = engine.block.getHeight(blockId);
-      maxRight = Math.max(maxRight, x + width);
-      maxBottom = Math.max(maxBottom, y + height);
-    });
-
-    const exportWidth = Math.max(engine.block.getWidth(page), maxRight);
-    const exportHeight = Math.max(engine.block.getHeight(page), maxBottom);
-
-    console.log('Export dimensions:', exportWidth, '×', exportHeight);
-
-    if (gl) {
-      const maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
-      // Use conservative limit (50% of max) for actual VRAM availability
-      const safeTextureSize = Math.floor(maxTextureSize * 0.5);
-
-      if (exportWidth > safeTextureSize || exportHeight > safeTextureSize) {
-        cesdk.ui.showNotification({
-          type: 'warning',
-          message: `Export dimensions (${Math.round(exportWidth)}×${Math.round(
-            exportHeight
-          )}) exceed safe GPU limit (${safeTextureSize}×${safeTextureSize})`
-        });
-      } else {
-        cesdk.ui.showNotification({
-          type: 'success',
-          message: 'Export dimensions are within safe limits'
-        });
-      }
-    }
+      // Retry export with lower quality
+      const retryBlob = await engine.block.export(page, {
+        mimeType: 'image/png',
+      });
+      const retryBuffer = Buffer.from(await retryBlob.arrayBuffer());
+      writeFileSync(`${outputDir}/size-limits-result-reduced.png`, retryBuffer);
 
-    // ===== Section 6: Handling Export Errors =====
-    // Demonstrate proper error handling for size-related export failures
-    try {
-      // Example export operation (not actually exporting in this demo)
-      // const blob = await engine.block.export(page, 'image/png');
-
-      // If export fails, catch and handle the error
-      console.log('Export would proceed here with proper error handling');
-    } catch (error) {
-      console.error('Export failed:', error);
-
-      // Check if error is size-related
-      if (
-        error instanceof Error &&
-        (error.message.includes('texture') ||
-          error.message.includes('size') ||
-          error.message.includes('memory'))
-      ) {
-        console.error('Size-related export error detected');
-        console.error('Suggested remediation:');
-        console.error('1. Reduce output dimensions');
-        console.error('2. Decrease maxImageSize setting');
-        console.error('3. Use export compression options');
-      }
+      // eslint-disable-next-line no-console
+      console.log(
+        '✓ Exported reduced quality result to output/size-limits-result-reduced.png'
+      );
+    } else {
+      throw error; // Re-throw if not size-related
     }
+  }
 
-    // Add an image to the page for demonstration
-    // Note: NOT specifying size here - let maxImageSize control the texture loading
-    const imageBlock = await engine.block.addImage(imageUri);
-    engine.block.appendChild(page, imageBlock);
-
-    // Fit image to page dimensions
-    engine.block.setWidth(imageBlock, 800);
-    engine.block.setHeight(imageBlock, 600);
-
-    // Position image to fill the page (already matches page dimensions)
-    engine.block.setPositionX(imageBlock, 0);
-    engine.block.setPositionY(imageBlock, 0);
-
-    // Zoom to fit the content
-    engine.scene.zoomToBlock(page, { padding: 40 });
-
-    // Display information in console
-    console.log('=== Size Limits Configuration Summary ===');
-    console.log(
-      'Current maxImageSize:',
-      engine.editor.getSetting('maxImageSize')
-    );
-    console.log(
-      'Page dimensions:',
-      engine.block.getWidth(page),
-      '×',
-      engine.block.getHeight(page)
-    );
-    console.log(
-      'Image dimensions:',
-      engine.block.getWidth(imageBlock),
-      '×',
-      engine.block.getHeight(imageBlock)
-    );
+  // Display final configuration summary
+  // eslint-disable-next-line no-console
+  console.log('\n=== Size Limits Configuration Summary ===');
+  // eslint-disable-next-line no-console
+  console.log(
+    `Current maxImageSize: ${engine.editor.getSetting('maxImageSize')}px`
+  );
+  // eslint-disable-next-line no-console
+  console.log(
+    `Page dimensions: ${engine.block.getWidth(page)}×${engine.block.getHeight(page)}`
+  );
+  // eslint-disable-next-line no-console
+  console.log(
+    `Image dimensions: ${engine.block.getWidth(imageBlock)}×${engine.block.getHeight(imageBlock)}`
+  );
 
-    if (gl) {
-      const maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
-      console.log('GPU max texture size:', maxTextureSize);
-    }
-  }
+  // Unsubscribe from settings changes
+  unsubscribe();
+} finally {
+  // Always dispose the engine to free resources
+  engine.dispose();
 }
-
-export default Example;
 ```
 
-This guide covers how to configure the `maxImageSize` setting, query GPU capabilities, validate export dimensions, and handle size-related errors gracefully.
+This guide covers how to configure the `maxImageSize` setting for headless workflows, understand server-side constraints, and implement robust error handling for size-related scenarios in production deployments.
 
 ## Understanding Size Limits
 
-CE.SDK manages size limits at two stages: **input** (when loading images) and **output** (when exporting). The `maxImageSize` setting controls input resolution, automatically downscaling images that exceed the configured limit (default: 4096×4096px). This reduces memory usage and improves performance across devices. Export resolution has no artificial limits—the theoretical maximum is 16,384×16,384 pixels, constrained only by GPU texture size, available VRAM, and platform capabilities (WebGL/WebGPU on web, Metal/OpenGL on native).
+CE.SDK manages size limits at two stages: **input** (when loading images) and **output** (when exporting). The `maxImageSize` setting controls input resolution, automatically downscaling images that exceed the configured limit (default: 4096×4096px). This prevents memory issues in serverless functions and containerized environments. Export resolution has no artificial limits—the theoretical maximum is 16,384×16,384 pixels, constrained by server GPU/CPU capabilities, available RAM, and deployment environment (serverless memory limits, container quotas, VM allocations). Headless environments use software rendering with conservative limits for universal compatibility.
 
 ## Resolution & Duration Limits
 
 ## Configuring maxImageSize
 
-You can read and modify the `maxImageSize` setting using the Settings API to match your application's requirements and target hardware capabilities.
+You can read and modify the `maxImageSize` setting using the Settings API to match your server infrastructure and automation requirements.
 
 ### Reading the Current Setting
 
 To check what `maxImageSize` value is currently configured:
 
 ```typescript highlight-get-max-image-size
-// Get the current maxImageSize setting
-const currentMaxSize = engine.editor.getSetting('maxImageSize');
-console.log('Current maxImageSize:', currentMaxSize);
-// Default is 4096 pixels
+// Read the current maxImageSize setting
+const currentMaxImageSize = engine.editor.getSetting('maxImageSize');
+// eslint-disable-next-line no-console
+console.log(`Current maxImageSize: ${currentMaxImageSize}px`);
+// Default is 4096 pixels - safe baseline for universal compatibility
 ```
 
-This returns the maximum size in pixels as an integer value (e.g., `4096` for the default 4096×4096 limit). You might display this value in your UI to inform users about the current quality settings, or use it to make runtime decisions about asset loading strategies.
+This returns the maximum size in pixels as an integer value (e.g., `4096` for the default 4096×4096 limit). You might log this value during server startup to verify configuration, use it to make runtime decisions about asset loading strategies, or include it in diagnostics when troubleshooting export failures.
 
 ### Setting a New Value
 
-Configure `maxImageSize` to minimize memory usage on constrained devices:
+Configure `maxImageSize` to minimize memory usage in serverless and containerized environments:
 
 ```typescript highlight-set-max-image-size
-// Configure maxImageSize for different use cases
+// Configure maxImageSize for low memory environments
 // This must be set BEFORE loading images to ensure they're downscaled
-
-// Low memory devices (mobile, tablets) - use 2048 for safety
 engine.editor.setSetting('maxImageSize', 2048);
-
-// High quality (professional workflows, desktop)
-// engine.editor.setSetting('maxImageSize', 8192);
-
-console.log('Updated maxImageSize:', engine.editor.getSetting('maxImageSize'));
+// eslint-disable-next-line no-console
+console.log(
+  `Updated maxImageSize: ${engine.editor.getSetting('maxImageSize')}px`
+);
 ```
 
-The setting takes effect immediately for newly loaded images. Images already loaded on the canvas retain their current resolution until reloaded.
+The setting takes effect immediately for newly loaded images. Images already loaded in the scene retain their current resolution until reloaded.
 
 ### Observing Settings Changes
 
-Subscribe to setting changes to update your UI when `maxImageSize` is modified:
+Subscribe to setting changes to log configuration updates or trigger automation workflows:
 
 ```typescript highlight-observe-settings-changes
-// Subscribe to settings changes to update UI when maxImageSize changes
-engine.editor.onSettingsChanged(() => {
-  const newMaxSize = engine.editor.getSetting('maxImageSize');
-  console.log('maxImageSize changed to:', newMaxSize);
-  // In a real app, update UI here to reflect the new setting
+// Subscribe to settings changes to react to configuration updates
+const unsubscribe = engine.editor.onSettingsChanged(() => {
+  const newMaxImageSize = engine.editor.getSetting('maxImageSize');
+  // eslint-disable-next-line no-console
+  console.log(`maxImageSize changed to: ${newMaxImageSize}px`);
 });
-
-// The subscription returns an unsubscribe function if you need to clean up later
-// const unsubscribe = engine.editor.onSettingsChanged(() => { ... });
-// unsubscribe(); // Call when no longer needed
 ```
 
-This callback fires whenever any setting changes through the Settings API. You can use it to update quality indicators in your interface, recalculate memory estimates, or trigger asset reloading with the new size limit.
+This callback fires whenever any setting changes through the Settings API. You can use it to log configuration changes for auditing, update internal metrics tracking, or synchronize settings across distributed processing nodes.
 
 ## GPU Capability Detection
 
-Modern browsers expose GPU capabilities through WebGL, allowing you to determine safe export dimensions for the user's hardware.
+In server environments, rendering capabilities depend on the available hardware rather than browser-based WebGL. CE.SDK automatically detects and uses the best available rendering backend for your server configuration.
 
-```typescript highlight-query-gpu-capabilities
-// Query GPU max texture size to understand export limits
-const canvas = document.createElement('canvas');
-const gl = canvas.getContext('webgl2') || canvas.getContext('webgl');
-
-if (gl) {
-  const maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
-  console.log('GPU Max Texture Size:', maxTextureSize);
-  console.log(
-    'Safe export dimensions: up to',
-    maxTextureSize,
-    '×',
-    maxTextureSize
-  );
-
-  // Most modern GPUs support 4096×4096 to 16384×16384
-  // Safe baseline is 4096×4096 for universal compatibility
-}
-```
-
-The `MAX_TEXTURE_SIZE` parameter returns the maximum width or height (in pixels) for a texture on the current GPU. Most modern GPUs support 4096×4096 to 16384×16384, while older or integrated GPUs may be limited to smaller dimensions.
+When CE.SDK runs in headless Node.js environments, it uses software rendering with conservative limits that provide universal compatibility. On servers with GPU access (such as cloud instances with GPU support), CE.SDK can leverage hardware acceleration for faster processing and larger export dimensions.
 
 You can use this information to:
 
-- Set conservative `maxImageSize` defaults based on detected capabilities
-- Show warnings when users attempt exports that may exceed hardware limits
-- Provide quality presets that match the device's capabilities
-- Calculate safe export dimensions automatically
+- Set conservative `maxImageSize` defaults based on your server's hardware specifications
+- Configure different limits for serverless functions vs. dedicated GPU servers
+- Implement automatic fallback to lower resolutions when memory is constrained
+- Calculate safe export dimensions based on available RAM and processing time limits
+
+For production deployments, test your specific server configuration to determine optimal size limits that balance quality with resource constraints.
 
 ## Troubleshooting
 
-Common issues and solutions when working with size limits:
+Common issues and solutions when working with size limits in server environments:
 
-| Issue                                 | Cause                                | Solution                                                                       |
-| ------------------------------------- | ------------------------------------ | ------------------------------------------------------------------------------ |
-| Images appear blurry/low quality      | `maxImageSize` too low               | Increase `maxImageSize` if GPU supports it (query `MAX_TEXTURE_SIZE` first)    |
-| Out of memory errors during editing   | `maxImageSize` too high              | Decrease `maxImageSize` to reduce memory footprint                             |
-| Export fails with no error message    | Output exceeds GPU texture limit     | Reduce export dimensions or query `MAX_TEXTURE_SIZE` to set safe maximums      |
-| Video export fails                    | Resolution/duration too high         | Export at 1080p instead of 4K, or reduce video duration to under 2 minutes     |
-| Inconsistent results across devices   | Different GPU capabilities           | Set conservative `maxImageSize` (4096) or detect capabilities programmatically |
-| Images load slowly                    | High `maxImageSize` on slow hardware | Lower `maxImageSize` to reduce processing time, especially on mobile devices   |
-| Export succeeds but file is too large | No compression applied               | Use JPEG format with quality settings, or apply PNG compression options        |
+| Issue                                | Cause                                    | Solution                                                                                    |
+| ------------------------------------ | ---------------------------------------- | ------------------------------------------------------------------------------------------- |
+| Images appear blurry in exports      | `maxImageSize` too low                   | Increase `maxImageSize` if server memory supports it (test with monitoring)                 |
+| Out of memory errors during processing | `maxImageSize` too high                | Decrease `maxImageSize` to reduce memory footprint, or increase server memory allocation   |
+| Export fails silently                | Output exceeds rendering backend limits   | Reduce export dimensions or test server's actual rendering capabilities                     |
+| Serverless function timeout          | Export takes too long for large images   | Lower `maxImageSize` to 2048, reduce export dimensions, or use dedicated server             |
+| Inconsistent results across nodes    | Different server configurations          | Set conservative `maxImageSize` (4096) or normalize infrastructure                          |
+| Batch processing runs out of memory  | Concurrent exports exceed available RAM   | Process sequentially, reduce `maxImageSize`, or increase server memory                      |
+| Container OOM killed                 | Export exceeds container memory limit     | Increase container memory quota or reduce `maxImageSize`                                    |
 
 ## API Reference
 
 Core methods for managing size limits and export operations:
 
-| Method                              | Description                              |
-| ----------------------------------- | ---------------------------------------- |
-| `engine.editor.getSetting()`        | Retrieves the current value of a setting |
-| `engine.editor.setSetting()`        | Updates a setting value                  |
-| `engine.editor.onSettingsChanged()` | Subscribes to setting change events      |
-| `engine.block.export()`             | Exports a block as an image or video     |
-| `engine.block.getWidth()`           | Gets the width of a block in pixels      |
-| `engine.block.getHeight()`          | Gets the height of a block in pixels     |
+| Method                          | Description                             |
+| ------------------------------- | --------------------------------------- |
+| `engine.editor.getSetting()`    | Retrieves the current value of a setting |
+| `engine.editor.setSetting()`    | Updates a setting value                 |
+| `engine.editor.onSettingsChanged()` | Subscribes to setting change events     |
+| `engine.block.export()`         | Exports a block as an image or video    |
+| `engine.block.getWidth()`       | Gets the width of a block in pixels     |
+| `engine.block.getHeight()`      | Gets the height of a block in pixels    |
 
 ## Next Steps
 
-Explore related guides to build complete export workflows:
+Explore related guides to build complete server automation workflows:
 
 - [Settings Guide](./settings.md) - Complete Settings API reference and configuration options
 - [File Format Support](./file-format-support.md) - Supported image and video formats with capabilities
 - [Export Overview](./export-save-publish/export/overview.md) - Fundamentals of exporting images and videos from CE.SDK
 - [Export to PDF](./export-save-publish/export/to-pdf.md) - PDF export guide with multi-page support and print optimization
 
+
+
 ---
 
 ## 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