@imgly/codesign-mcp 0.1.5 → 0.1.6

package/assets/docs/guide/plugins/print-ready-pdf.md

@@ -1,351 +1,263 @@
-> 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:** [Plugins](./plugins.md) > [Print Ready PDFs](./plugins/print-ready-pdf.md)
 
 ---
 
-In this guide, you'll learn how to use the Print Ready PDF plugin to transform
-CE.SDK's standard RGB PDF exports into PDF/X-3 compliant, CMYK-based files
-suitable for professional commercial printing. We'll add a custom export
-button that handles color space conversion, ICC profile embedding, and PDF/X
-compliance—all client-side without any backend infrastructure.
-
-> **Reading time:** 15 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$/plugins-print-ready-pdf-browser)
-> - [Open in StackBlitz](https://stackblitz.com/github/imgly/cesdk-web-examples/tree/v$UBQ_VERSION$/plugins-print-ready-pdf-browser)
-> - [Live demo](https://img.ly/docs/cesdk/examples/plugins-print-ready-pdf-browser/)
+In this guide, you'll learn how to use the Print Ready PDF plugin with CE.SDK
+Engine in Node.js to automate print-ready PDF generation. This is ideal for
+batch processing, server-side PDF generation, CI/CD pipelines, and automated
+workflows that require PDF/X compliant output. By default the plugin produces
+PDF/X-4 (live transparency, vector text preserved); PDF/X-3 is available as
+an opt-in fallback.
 
 ## What You'll Build
 
-A complete print-ready PDF export workflow that:
+A server-side PDF conversion workflow that:
 
-- Adds a custom "Export Print-Ready PDF" button to CE.SDK
-- Exports designs as standard PDFs using CE.SDK's engine
-- Converts RGB PDFs to CMYK with professional ICC profiles
-- Adds PDF/X-3:2003 compliance for commercial printing
-- Handles transparency flattening automatically
-- Downloads print-ready files directly in the browser
+- Initializes CE.SDK Engine in headless mode
+- Loads design scenes from files or APIs
+- Exports PDFs using CE.SDK's engine
+- Converts to PDF/X-4 (default) or PDF/X-3 with CMYK profiles
+- Saves print-ready files to the filesystem
+- Supports batch processing multiple files
 
 ## Prerequisites
 
-- Modern browser with WebAssembly support (Chrome 90+, Firefox 88+, Safari 14+)
-- Basic knowledge of JavaScript/TypeScript and CE.SDK
-- Optional: CE.SDK license to remove watermark - [Get a free trial](https://img.ly/forms/free-trial)
+- CE.SDK license with Design Editor features - [Get a free trial](https://img.ly/forms/free-trial)
+- Node.js 22+ installed (required by `@cesdk/node`)
+- Basic knowledge of Node.js and async/await
 
-## Step 1: Install the Plugin
+## Step 1: Install Dependencies
 
-First, add the Print Ready PDF plugin to your project alongside CE.SDK:
+Add CE.SDK Engine and the Print Ready PDF plugin to your Node.js project:
 
 ```bash
-npm install @cesdk/cesdk-js@$UBQ_VERSION$ @imgly/plugin-print-ready-pdfs-web@1.0.0
+npm install @cesdk/node@$UBQ_VERSION$ @imgly/plugin-print-ready-pdfs-web@1.0.0
 ```
 
-The plugin is a standalone npm package that works with any CE.SDK integration.
-
 **Package details:**
 
-- `@cesdk/cesdk-js`: CE.SDK core library
-- `@imgly/plugin-print-ready-pdfs-web`: Print-ready PDF conversion plugin
+- `@cesdk/node`: CE.SDK Node.js package for server-side rendering (requires Node.js >=22)
+- `@imgly/plugin-print-ready-pdfs-web`: Print-ready PDF conversion (works in Node.js despite the name)
+
+The plugin works in Node.js because it's built on WebAssembly, which Node.js supports.
 
 **Try it yourself:**
 
-1. Run `npm install` in your project
+1. Run `npm install` in your project directory
 2. Verify packages appear in `package.json`
-3. Check node_modules contains both packages
+3. Check `node_modules` contains both packages
 
-## Step 2: Set Up CE.SDK with Custom Export Button
+## Step 2: Initialize CE.SDK Engine in Headless Mode
 
-Initialize CE.SDK and add a custom export button to the navigation bar:
+Set up CE.SDK Engine for server-side processing:
 
 ```typescript
-// Initialize CE.SDK
-const cesdk = await CreativeEditorSDK.create('#cesdk-container', config);
-
-// Add custom export button to navigation bar
-cesdk.ui.insertOrderComponent(
-  { in: 'ly.img.navigation.bar', position: 'end' },
-  {
-    id: 'ly.img.actions.navigationBar',
-    children: [
-      {
-        key: 'export-print-ready-pdf',
-        id: 'ly.img.action.navigationBar',
-        label: 'Export Print-Ready PDF',
-        iconName: '@imgly/Download',
-        onClick: async () => {
-          await exportPrintReadyPDF();
-        }
-      }
-    ]
-  }
-);
+import CreativeEngine from '@cesdk/node';
+
+const config = {
+  license: 'YOUR_CESDK_LICENSE_KEY',
+  baseURL: `https://cdn.img.ly/packages/imgly/cesdk-node/${CreativeEngine.version}/assets`,
+};
+
+const engine = await CreativeEngine.init(config);
+console.log('Engine initialized:', engine.isInitialized());
 ```
 
 **CE.SDK concepts explained:**
 
-- **`insertOrderComponent()`**: Dynamically adds UI components to the navigation bar
-- **`position: 'end'`**: Position for the button (can be `'first'`, `'last'`, or after specific components)
-- **`iconName`**: Uses CE.SDK's built-in icon library (`@imgly/icons/`)
-- **`onClick`**: Function executed when button is clicked
-
-The custom action button integrates seamlessly with CE.SDK's UI, appearing alongside built-in export options.
+- **`CreativeEngine.init()`**: Initializes the engine in headless mode (no browser required)
+- **`license`**: Activates CE.SDK features including PDF export
+- **`baseURL`**: Points to the required assets for the engine to function
+- **Headless mode**: Runs without UI for automated workflows
 
-**Verify the integration:**
+**Verify initialization:**
 
-1. Start your development server
-2. Open CE.SDK in the browser
-3. Look for "Export Print-Ready PDF" button in the navigation bar
-4. Button should be clickable (even if export isn't implemented yet)
+1. Run your Node.js script: `node script.js`
+2. Check console shows "Engine initialized: true"
+3. No license errors should appear
 
-## Step 3: Export PDF from CE.SDK
+## Step 3: Load and Export Scenes as PDF
 
-Now implement the export logic to get the PDF from CE.SDK's engine:
+Load design scenes and export them as PDFs:
 
 ```typescript
-// Get current scene ID
-const scene = cesdk.engine.scene.get();
+import { readFileSync } from 'fs';
 
-// Get all pages in the scene
-const pages = cesdk.engine.block.findByType('page');
+// Load scene from file
+const sceneString = readFileSync('design.scene', 'utf-8');
+await engine.scene.loadFromString(sceneString);
 
-// Export first page as PDF
-const pdfBlob = await cesdk.engine.block.export(pages[0], {
-  mimeType: 'application/pdf'
-});
+// Get scene ID
+const sceneId = engine.scene.get();
+
+// Export as PDF
+const pdfBlob = await engine.block.export(sceneId, 'application/pdf');
+
+console.log('PDF exported:', pdfBlob.size, 'bytes');
 ```
 
 **CE.SDK export methods in detail:**
 
-- **`engine.scene.get()`**: Returns the ID of the current scene (the design being edited)
-- **`engine.block.export()`**: Exports a specific block (in this case, the entire scene) as a Blob
-- **`'application/pdf'`**: MIME type specifying PDF format output
+- **`engine.scene.loadFromString()`**: Loads a saved CE.SDK scene from JSON string
+- **`engine.scene.get()`**: Returns the ID of the currently loaded scene
+- **`engine.block.export()`**: Exports a block (the entire scene) as a specified format
+
+The `.scene` file format is CE.SDK's native scene format. You can create these from CE.SDK Editor or generate them programmatically.
+
+**Alternative: Load from URL or API:**
 
-The `engine.block.export()` method is the recommended approach for PDF export. CE.SDK handles all PDF generation internally.
+```typescript
+// Fetch scene from API
+await engine.scene.loadFromURL('https://api.example.com/scenes/123');
+```
 
 **Test your implementation:**
 
-- Open CE.SDK and create a simple design
-- Click the custom export button
-- Check browser console shows no errors
-- Verify PDF blob has `size > 0`
+- Run script with a valid `.scene` file
+- Check console shows PDF size > 0
+- No export errors should appear
 
 ## Step 4: Convert to Print-Ready Format
 
-Use the plugin to convert CE.SDK's RGB PDF to CMYK PDF/X-3 format:
+Use the plugin to convert CE.SDK's PDF to PDF/X:
 
 ```typescript
-// Convert to print-ready PDF/X-3 format
-const printReadyPDF = await convertToPDFX3(pdfBlob, {
-  outputProfile: 'fogra39', // European printing standard
-  title: 'Print-Ready Export'
+import { convertToPDFX } from '@imgly/plugin-print-ready-pdfs-web';
+
+// PDF/X-4 by default — live transparency, vector text preserved.
+// Pass `outputStandard: 'PDF/X-3'` if your pipeline requires the older standard.
+const printReadyPDF = await convertToPDFX(pdfBlob, {
+  outputProfile: 'fogra39',
+  title: 'Automated Print Export',
 });
+
+console.log('Conversion complete:', printReadyPDF.size, 'bytes');
 ```
 
 **How this integrates with CE.SDK:**
 
-- CE.SDK exports standard RGB PDF (optimized for screens)
-- Plugin intercepts the PDF blob
-- Converts RGB colors to CMYK using professional ICC profiles
-- Adds PDF/X-3:2003 compliance markers
-- Embeds color profile for consistent printing
+- CE.SDK Engine exports standard RGB PDF
+- Plugin converts to CMYK with ICC profiles
+- Adds PDF/X-4 (ISO 15930-7) compliance markers by default
+- Keeps live transparency on transparent pages
 
 **Color profile selection:**
 
-The `outputProfile` parameter determines the color space and printing standard:
-
-- **`'fogra39'`**: European offset printing (ISO Coated v2 ECI)
+- **`'fogra39'`**: European offset printing (ISO Coated v2)
 - **`'gracol'`**: USA commercial printing (GRACoL 2013)
 - **`'srgb'`**: Digital distribution (keeps RGB)
-- **`'custom'`**: Use your own ICC profile file
-
-Choose the profile that matches your print region or vendor requirements.
+- **`'custom'`**: Use printer-specific ICC profile
 
 **Verify the conversion:**
 
-1. Conversion should complete in 2-5 seconds
-2. Output PDF is larger than input (~400-500KB for ICC profile)
-3. No error messages in console
-4. Blob size increased indicates successful conversion
+- Conversion completes in 2-5 seconds
+- Output size increased by ~400-500KB (ICC profile)
+- No error messages in console
 
-## Step 5: Download Print-Ready PDF
+## Step 5: Save to Filesystem
 
-Trigger the browser download for the converted PDF:
+Save the print-ready PDF to disk:
 
 ```typescript
-// Download the print-ready PDF
-const url = URL.createObjectURL(printReadyPDF);
-const link = document.createElement('a');
-link.href = url;
-link.download = 'design-print-ready.pdf';
-link.click();
-URL.revokeObjectURL(url);
+import { writeFileSync } from 'fs';
+
+// Convert Blob to Buffer for Node.js filesystem
+const buffer = Buffer.from(await printReadyPDF.arrayBuffer());
+
+// Save to file
+writeFileSync('output-print-ready.pdf', buffer);
+
+console.log('File saved: output-print-ready.pdf');
 ```
 
-**Browser download pattern explained:**
+**Node.js file handling explained:**
 
-- **`URL.createObjectURL()`**: Creates temporary URL for the Blob
-- **`document.createElement('a')`**: Creates download link element
-- **`link.click()`**: Triggers browser's download dialog
-- **`URL.revokeObjectURL()`**: Cleans up temporary URL (prevents memory leaks)
+- **`Blob.arrayBuffer()`**: Gets raw binary data from Blob
+- **`Buffer.from()`**: Converts ArrayBuffer to Node.js Buffer
+- **`writeFileSync()`**: Writes Buffer to filesystem synchronously
 
-This pattern works in all modern browsers without requiring server endpoints.
+For production systems, use `writeFile()` (async) instead of `writeFileSync()`.
 
 **Test the complete workflow:**
 
-1. Create a design in CE.SDK
-2. Click "Export Print-Ready PDF" button
-3. Browser should prompt to save file
-4. Downloaded PDF should open in PDF viewers
-5. Check file properties for PDF/X-3:2003 compliance
+1. Run your script: `node script.js`
+2. Check `output-print-ready.pdf` exists
+3. Open PDF in viewer (Adobe Acrobat, Preview, etc.)
+4. Verify file properties show PDF/X-3:2003 compliance
 
 ## Complete Implementation
 
-Here's the full integration combining all steps:
-
-```typescript file=@cesdk_web_examples/plugins-print-ready-pdf-browser/src/index.ts reference-only
-import CreativeEditorSDK from '@cesdk/cesdk-js';
-// @ts-expect-error - Plugin types will be available in future release
-import { convertToPDFX3 } from '@imgly/plugin-print-ready-pdfs-web';
-import {
-  BlurAssetSource,
-  CaptionPresetsAssetSource,
-  ColorPaletteAssetSource,
-  CropPresetsAssetSource,
-  DemoAssetSources,
-  EffectsAssetSource,
-  FiltersAssetSource,
-  PagePresetsAssetSource,
-  StickerAssetSource,
-  TextAssetSource,
-  TypefaceAssetSource,
-  VectorShapeAssetSource
-} from '@cesdk/cesdk-js/plugins';
-
-let cesdk: CreativeEditorSDK;
-
-const config = {
-  // By default, CE.SDK runs with a watermark.
-  // Get a free trial license at https://img.ly/forms/free-trial to remove it.
-  // Uncomment the line below and add your license key:
-  // license: 'your-license-key-here',
-  // baseURL: `https://cdn.img.ly/packages/imgly/cesdk-js/${CreativeEditorSDK.version}/assets`,
-  // Use local assets when developing with local packages
-  ...((import.meta as any).env?.CESDK_USE_LOCAL && {
-    baseURL: import.meta.env.VITE_CESDK_ASSETS_BASE_URL
-  })
-};
+Here's a full server-side PDF conversion script:
 
-async function init() {
-  // Initialize CE.SDK
-  cesdk = await CreativeEditorSDK.create('#cesdk-container', config);
-
-  cesdk.ui.insertOrderComponent(
-    { in: 'ly.img.navigation.bar', position: 'end' },
-    {
-      id: 'ly.img.actions.navigationBar',
-      children: [
-        {
-          key: 'export-print-ready-pdf',
-          id: 'ly.img.action.navigationBar',
-          label: 'Export Print-Ready PDF',
-          iconName: '@imgly/Download',
-          onClick: async () => {
-            await exportPrintReadyPDF();
-          }
-        }
-      ]
-    }
-  );
-
-  // Load default scene
-  await cesdk.actions.run('scene.create', {
-    page: {
-      sourceId: 'ly.img.page.presets',
-      assetId: 'ly.img.page.presets.print.iso.a6.landscape'
-    }
+```typescript
+import CreativeEngine from '@cesdk/node';
+import { convertToPDFX } from '@imgly/plugin-print-ready-pdfs-web';
+import { readFileSync, writeFileSync } from 'fs';
+
+async function convertToPrintReady() {
+  // Initialize CE.SDK Engine
+  const engine = await CreativeEngine.init({
+    license: 'YOUR_CESDK_LICENSE_KEY',
+    baseURL: `https://cdn.img.ly/packages/imgly/cesdk-node/${CreativeEngine.version}/assets`,
   });
-  await cesdk.addPlugin(new BlurAssetSource());
-  await cesdk.addPlugin(new CaptionPresetsAssetSource());
-  await cesdk.addPlugin(new ColorPaletteAssetSource());
-  await cesdk.addPlugin(new CropPresetsAssetSource());
-  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 TypefaceAssetSource());
-  await cesdk.addPlugin(new VectorShapeAssetSource());
-  await cesdk.addPlugin(new DemoAssetSources());
-}
-
-async function exportPrintReadyPDF() {
-  try {
-    // Check if CE.SDK is initialized
-    if (!cesdk) {
-      throw new Error('CE.SDK not initialized');
-    }
-
-    // Get current scene ID
-    const scene = cesdk.engine.scene.get();
 
-    if (scene == null) {
-      throw new Error('No scene loaded');
-    }
+  // Load scene from file
+  const sceneString = readFileSync('design.scene', 'utf-8');
+  await engine.scene.loadFromString(sceneString);
 
-    // Get all pages in the scene
-    const pages = cesdk.engine.block.findByType('page');
+  // Export as PDF
+  const sceneId = engine.scene.get();
+  const pdfBlob = await engine.block.export(sceneId, 'application/pdf');
 
-    if (pages.length === 0) {
-      throw new Error('No pages found in scene');
-    }
+  // Convert to print-ready
+  const printReadyPDF = await convertToPDFX(pdfBlob, {
+    outputProfile: 'fogra39',
+    title: 'Automated Print Export',
+  });
 
-    // Export first page as PDF
-    const pdfBlob = await cesdk.engine.block.export(pages[0], {
-      mimeType: 'application/pdf'
-    });
+  // Save to disk
+  const buffer = Buffer.from(await printReadyPDF.arrayBuffer());
+  writeFileSync('output-print-ready.pdf', buffer);
 
-    // Convert to print-ready PDF/X-3 format
-    const printReadyPDF = await convertToPDFX3(pdfBlob, {
-      outputProfile: 'fogra39', // European printing standard
-      title: 'Print-Ready Export'
-    });
+  console.log('Print-ready PDF created successfully');
 
-    // Download the print-ready PDF
-    const url = URL.createObjectURL(printReadyPDF);
-    const link = document.createElement('a');
-    link.href = url;
-    link.download = 'design-print-ready.pdf';
-    link.click();
-    URL.revokeObjectURL(url);
-
-    console.log('Print-ready PDF exported successfully!');
-  } catch (error) {
-    console.error('Export failed:', error);
-    alert('Failed to export print-ready PDF. Please try again.');
-  }
+  // Don't forget to dispose when done
+  engine.dispose();
 }
 
-// Initialize when page loads
-init().catch((error) => {
-  console.error('Failed to initialize CE.SDK:', error);
-});
+convertToPrintReady().catch(console.error);
 ```
 
-This implementation adds a complete print-ready PDF export workflow to CE.SDK with just a few lines of code.
-
-Find the complete working example in the [GitHub repository](https://github.com/imgly/cesdk-web-examples/tree/release-$UBQ_VERSION$/plugins-print-ready-pdf-browser).
+This implementation provides a complete automated workflow for generating print-ready PDFs from CE.SDK scenes.
 
 ## Transparency Handling
 
-PDF/X-3:2003 is based on PDF 1.3 which does not support transparency. By default, the plugin flattens all transparency to ensure compliance.
+The default output is PDF/X-4, which is based on PDF 1.6 and supports live transparency natively. Vector text and gradients on transparent pages are preserved without flattening, so no special handling is required.
+
+```typescript
+// Default — PDF/X-4 with live transparency preserved
+const printReadyPDF = await convertToPDFX(pdfBlob, {
+  outputProfile: 'fogra39',
+  title: 'Automated Print Export',
+});
+```
+
+## Fallback: PDF/X-3
 
-**Why Flattening is Required:**
+If your downstream pipeline does not accept PDF/X-4, opt back into the older PDF/X-3 standard with `outputStandard: 'PDF/X-3'`:
+
+```typescript
+// PDF/X-3 fallback (PDF 1.4, no live transparency)
+const printReadyPDF = await convertToPDFX(pdfBlob, {
+  outputStandard: 'PDF/X-3',
+  outputProfile: 'fogra39',
+  title: 'Automated Print Export (X-3)',
+});
+```
 
-Transparency flattening is mandatory for PDF/X-3 compliance—this is a requirement of the standard itself, not a limitation of the tooling. Any PDF with transparency must have those elements composited into opaque equivalents before it can be a valid PDF/X-3 file.
+PDF/X-3:2003 is based on PDF 1.3 which does not support transparency. The plugin flattens transparency by default on this path so the output is strictly compliant.
 
 **What happens during flattening:**
 
@@ -355,195 +267,188 @@ Transparency flattening is mandatory for PDF/X-3 compliance—this is a requirem
 
 ### Known Issue: Black Backgrounds During Flattening
 
-During the flattening process, certain elements with transparency may render with black backgrounds instead of their intended appearance. Affected elements include:
+During flattening, certain elements may render with black backgrounds instead of their intended appearance:
 
 - Gradients that fade to transparent
 - PNG images with alpha channels (e.g., stickers, icons)
 - Text with emoji characters
 - Overlapping semi-transparent elements
 
-### Workaround: Preserve Transparency
+If you hit any of these, switch back to the PDF/X-4 default — X-4 preserves transparency live and avoids the flattening artifacts entirely.
 
-If visual fidelity is more important than strict PDF/X-3 compliance, you can disable transparency flattening:
+### Workaround: Preserve Transparency on X-3
+
+If you must stay on X-3 but visual fidelity matters more than strict compliance, disable flattening:
 
 ```typescript
-// Preserve transparency for better visual fidelity
-const printReadyPDF = await convertToPDFX3(pdfBlob, {
+// X-3 output with live transparency — non-strict
+const printReadyPDF = await convertToPDFX(pdfBlob, {
+  outputStandard: 'PDF/X-3',
   outputProfile: 'fogra39',
-  title: 'Visual Fidelity Preserved',
-  flattenTransparency: false // Preserves appearance but may not be strictly PDF/X-3 compliant
+  title: 'X-3 with Preserved Transparency',
+  flattenTransparency: false,
 });
 ```
 
-### Trade-offs
-
-| Setting                               | Visual Fidelity    | PDF/X-3 Compliance                      |
-| ------------------------------------- | ------------------ | --------------------------------------- |
-| `flattenTransparency: true` (default) | May have artifacts | Strictly compliant                      |
-| `flattenTransparency: false`          | Preserved          | May not validate if transparency exists |
+| Setting | Visual Fidelity | PDF/X-3 Compliance |
+|---------|----------------|-------------------|
+| `flattenTransparency: true` (default for X-3) | May have artifacts | Strictly compliant |
+| `flattenTransparency: false` | Preserved | May not validate if transparency exists |
 
-### Designing for Print Compatibility
-
-To ensure best results with PDF/X-3, design without transparency:
-
-- Use 100% opacity for all elements
-- Avoid PNG images with alpha channels
-- Use solid fills instead of gradients with opacity
-- Avoid gradients that fade to transparent
-- Export without blend modes
+The `flattenTransparency` option is ignored when `outputStandard` is `'PDF/X-4'` — X-4 keeps transparency live by definition.
 
 ## Advanced: Opting Out of ICC Profile Embedding
 
-If a downstream prepress pipeline (e.g. ZePrA, PitStop) handles ICC profile embedding and color normalization, you can keep the RGB→CMYK color conversion from the plugin and skip the embedded OutputIntent so the downstream tool can add its own:
+If a downstream prepress pipeline (e.g. ZePrA, PitStop) applies its own ICC profile and color normalization, you can keep the RGB→CMYK color conversion from the plugin and skip the embedded OutputIntent so the downstream tool can add its own:
 
 ```typescript
-// Convert to CMYK without embedding the ICC profile or PDF/X-3 metadata
-const cmykPDF = await convertToPDFX3(pdfBlob, {
+// Convert to CMYK without embedding the ICC profile or PDF/X metadata
+const cmykPDF = await convertToPDFX(pdfBlob, {
   outputProfile: 'fogra39',
   embedICCProfile: false,
-  title: 'CMYK for Downstream Pipeline'
+  title: 'CMYK for Downstream Pipeline',
 });
 ```
 
 **What changes when `embedICCProfile` is `false`:**
 
 - The selected `outputProfile` still determines whether the output is device CMYK (for `fogra39`, `gracol`, or a custom CMYK profile) or RGB (for `srgb`).
-- The output PDF does not include the ICC profile, the `OutputIntent`, or the `GTS_PDFXVersion`/`GTS_PDFXConformance` markers.
-- The resulting file is a plain CMYK PDF, not PDF/X-3 compliant. Your downstream prepress tool is responsible for assigning the final ICC profile and applying any color normalization.
+- The output PDF does not include the ICC profile, the `OutputIntent`, or the PDF/X conformance markers.
+- The resulting file is a plain CMYK PDF, not PDF/X compliant. Your downstream prepress tool is responsible for assigning the final ICC profile and applying any color normalization.
 
 Use this when your existing pipeline already enforces ICC profile embedding and color normalization rules you need to preserve.
 
-## Advanced: Custom ICC Profiles
+## Advanced: Batch Processing Multiple Files
 
-Use printer-specific ICC profiles:
+Process multiple scenes in a batch:
 
 ```typescript
-// Load custom ICC profile from your server
-const customProfile = await fetch('/path/to/custom.icc').then((r) => r.blob());
-
-const printReadyPDF = await convertToPDFX3(pdfBlob, {
-  outputProfile: 'custom',
-  customProfile: customProfile,
-  title: 'Custom Profile Export',
-  outputConditionIdentifier: 'Custom_CMYK_Profile',
-  outputCondition: 'Custom profile for specialized printing'
-});
-```
+import { readdirSync } from 'fs';
 
-This allows you to meet specific print vendor requirements that may not be covered by standard profiles.
+async function batchConvert() {
+  const engine = await CreativeEngine.init({
+    license: 'YOUR_CESDK_LICENSE_KEY',
+    baseURL: `https://cdn.img.ly/packages/imgly/cesdk-node/${CreativeEngine.version}/assets`,
+  });
 
-## Troubleshooting
+  // Find all .scene files
+  const sceneFiles = readdirSync('.').filter(f => f.endsWith('.scene'));
 
-### "Input must be a Blob" Error
+  console.log(`Processing ${sceneFiles.length} files...`);
 
-**Problem:** Plugin reports invalid input type
+  for (const file of sceneFiles) {
+    console.log(`Converting ${file}...`);
 
-**Solution:** Ensure CE.SDK export returns a Blob:
+    // Load scene
+    const sceneString = readFileSync(file, 'utf-8');
+    await engine.scene.loadFromString(sceneString);
 
-```typescript
-const blob = await cesdk.engine.block.export(sceneId, 'application/pdf');
-console.log(blob instanceof Blob); // Should be true
-console.log(blob.size); // Should be > 0
-```
+    // Export and convert
+    const sceneId = engine.scene.get();
+    const pdfBlob = await engine.block.export(sceneId, 'application/pdf');
+    const printReadyPDF = await convertToPDFX(pdfBlob, {
+      outputProfile: 'fogra39',
+      title: file.replace('.scene', ''),
+    });
 
-If `blob.size === 0`, the CE.SDK export failed. Check for scene errors.
+    // Save with print-ready suffix
+    const outputName = file.replace('.scene', '-print-ready.pdf');
+    const buffer = Buffer.from(await printReadyPDF.arrayBuffer());
+    writeFileSync(outputName, buffer);
 
-### Converted PDF is Much Larger
+    console.log(`✓ Saved ${outputName}`);
+  }
 
-**Problem:** Output file is significantly larger than input
+  console.log('Batch processing complete!');
+}
 
-**Solution:** This is expected behavior:
+batchConvert().catch(console.error);
+```
 
-- ICC profiles add ~400-500KB (FOGRA39/GRACoL)
-- Transparency flattening may rasterize content
-- For smaller files, use `srgb` profile (digital-only)
-- Disable transparency flattening if no transparency exists: `flattenTransparency: false`
+This processes all `.scene` files in a directory and generates print-ready PDFs for each.
 
-### Text Becomes Rasterized
+## Troubleshooting
 
-**Problem:** Text appears pixelated or blurry in output
+### "Cannot find module" Error
 
-**Solution:** Transparency flattening converts transparent pages to bitmaps. See [Transparency Handling](#transparency-handling) for details.
+**Problem:** Import errors for CE.SDK or plugin
 
-- Avoid transparency in CE.SDK designs (use 100% opacity)
-- Don't use alpha channel PNG images
-- Use solid fills instead of gradients with opacity
-- Or disable flattening: `flattenTransparency: false` if visual fidelity is more important than strict compliance
+**Solution:** Verify package installation:
+
+```bash
+npm list @cesdk/node @imgly/plugin-print-ready-pdfs-web
+```
 
-### Colors Look Different
+If missing, reinstall:
 
-**Problem:** Colors appear different in exported PDF
+```bash
+npm install @cesdk/node@$UBQ_VERSION$ @imgly/plugin-print-ready-pdfs-web@1.0.0
+```
 
-**Solution:** This is expected when converting RGB to CMYK:
+### Memory Issues with Large Files
 
-- CMYK has a smaller color gamut than RGB
-- Some bright RGB colors cannot be reproduced in CMYK
-- Preview in CMYK-capable viewer (Adobe Acrobat) for accurate representation
-- For color-critical work, use CMYK values directly in CE.SDK designs
+**Problem:** Node.js crashes with "out of memory" errors
 
-### Custom Button Doesn't Appear
+**Solution:** Increase Node.js memory limit:
 
-**Problem:** Export button not visible in UI
+```bash
+node --max-old-space-size=4096 script.js
+```
 
-**Solution:** Verify your button insertion code:
+Or use streaming for large batch operations:
 
 ```typescript
-cesdk.ui.insertOrderComponent(
-  { in: 'ly.img.navigation.bar', position: 'end' },
-  {
-    id: 'ly.img.actions.navigationBar',
-    children: [
-      {
-        key: 'export-print-ready-pdf',
-        id: 'ly.img.action.navigationBar',
-        label: 'Export Print-Ready PDF',
-        iconName: '@imgly/Download',
-        onClick: async () => {
-          /* ... */
-        }
-      }
-    ]
-  }
-);
+// Process files sequentially instead of in parallel
+for (const file of sceneFiles) {
+  await processFile(file);
+  // Allow garbage collection between files
+  await new Promise(resolve => setTimeout(resolve, 100));
+}
 ```
 
-Check browser console for configuration errors. Ensure the button is added after CE.SDK initialization completes.
-
-## Validating PDF/X-3 Compliance
+### AGPL License Concerns
 
-Verify your exported PDFs meet print standards:
+**Problem:** Worried about AGPL compliance for server-side processing
 
-**Adobe Acrobat Pro:**
+**Solution:** Consult legal counsel if:
 
-1. Open converted PDF
-2. File → Properties → Description
-3. Should show "PDF version: 1.3 (PDF/X-3:2003)"
-4. File → Properties → Advanced
-5. Should show OutputIntent with ICC profile name
+- You're modifying the plugin's WASM binaries
+- You're offering PDF conversion as a network service
+- You're bundling the plugin in closed-source server software
 
-**Free online validators:**
+For most use cases (internal automation, CI/CD, batch processing), server-side execution is acceptable. The plugin uses Ghostscript under AGPL-3.0.
 
-- [PDF/A-X Validator](https://www.pdf-online.com/osa/validate.aspx) - Upload and validate compliance
-- Check for PDF/X-3:2003 standard confirmation
+## Validating Output
 
-**Command-line verification:**
+Verify generated PDFs meet print standards:
 
-```bash
-# Check PDF version
-pdfinfo output.pdf | grep "PDF version"
+```typescript
+import { execSync } from 'child_process';
 
-# Validate structure
-qpdf --check output.pdf
+// Check PDF version
+const version = execSync(
+  'pdfinfo output-print-ready.pdf | grep "PDF version"',
+).toString();
+console.log(version); // Should show PDF 1.3 (PDF/X-3:2003)
 
-# Search for PDF/X markers
-grep -a "PDF/X-3" output.pdf
+// Validate structure
+execSync('qpdf --check output-print-ready.pdf');
+console.log('PDF structure is valid');
 ```
 
+Or use Adobe Acrobat Pro:
+
+1. Open PDF → File → Properties → Description
+2. Should show "PDF/X-3:2003"
+3. Check Advanced tab for OutputIntent with ICC profile
+
+
+
 ---
 
 ## 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