@imgly/codesign-mcp 0.1.5 → 0.1.6

package/assets/docs/guide/rules/moderate-content.md

@@ -1,413 +1,346 @@
-> 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) > [Rules](./rules.md) > [Moderate Content](./rules/moderate-content.md)
 
 ---
 
-Use CE.SDK's engine APIs to extract images and text from designs, then integrate with third-party moderation services to detect inappropriate content.
+Use CE.SDK's engine APIs to extract images and text from designs in Node.js, then integrate with third-party moderation services to detect inappropriate content.
 
 > **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-rules-moderate-content-browser)
-> - [Open in StackBlitz](https://stackblitz.com/github/imgly/cesdk-web-examples/tree/v$UBQ_VERSION$/guides-rules-moderate-content-browser)
-> - [Live demo](https://img.ly/docs/cesdk/examples/guides-rules-moderate-content-browser/)
-
-![Content moderation example showing a design with validation results panel displaying moderation checks for images and text](https://img.ly/docs/cesdk/./assets/browser.hero.webp)
+>
+> - [View source on GitHub](https://github.com/imgly/cesdk-web-examples/tree/release-$UBQ_VERSION$/guides-rules-moderate-content-server-js)
+>
+> - [Open in StackBlitz](https://stackblitz.com/github/imgly/cesdk-web-examples/tree/v$UBQ_VERSION$/guides-rules-moderate-content-server-js)
 
 CE.SDK does not provide prebuilt content moderation workflows. Instead, it provides powerful engine APIs that make it straightforward to extract images and text from designs for moderation by third-party services of your choice. This approach is intentional: content moderation requirements are highly specific to each business, including which categories to check, what thresholds to apply, and which services to use. Similarly, when and where to check content (during editing, before export, on upload) varies based on your workflow and user experience goals.
 
 Content moderation helps maintain quality standards and comply with content policies. Unlike built-in validation rules that check technical aspects like resolution or layout, content moderation requires integration with external AI-powered services (Sightengine, AWS Rekognition, OpenAI Moderation API) to analyze visual content (images for weapons, drugs, nudity) and textual content (profanity, hate speech, threats).
 
-```typescript file=@cesdk_web_examples/guides-rules-moderate-content-browser/browser.ts reference-only
-import type {
-  CreativeEngine,
-  EditorPlugin,
-  EditorPluginContext
-} from '@cesdk/cesdk-js';
-import packageJson from './package.json';
-
-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';
-
-// Type definitions for content moderation
-interface ImageBlockData {
-  blockId: number;
-  url: string;
-  blockType: string;
-  blockName: string;
-}
+```javascript file=@cesdk_web_examples/guides-rules-moderate-content-server-js/index.js reference-only
+import CreativeEngine from '@cesdk/node';
 
-interface TextBlockData {
-  blockId: number;
-  text: string;
-  blockType: string;
-  blockName: string;
-}
-
-interface ContentCategory {
-  name: string;
-  description: string;
-  state: 'success' | 'warning' | 'failed';
-}
-
-interface ValidationResult extends ContentCategory {
-  blockId: number;
-  blockType: string;
-  blockName: string;
-  id: string;
-  url?: string; // For image blocks
-  text?: string; // For text blocks
-}
-
-// Mock moderation caches
-const imageCache: Record<string, ContentCategory[]> = {};
-const textCache: Record<string, ContentCategory[]> = {};
+// Mock moderation caches for demonstration
+const imageCache = new Map();
+const textCache = new Map();
 
 /**
- * CE.SDK Plugin: Content Moderation Guide
- *
- * Demonstrates implementing automated content moderation for both images and text
+ * Extracts the image URL from a block's fill property
  */
-class Example implements EditorPlugin {
-  name = packageJson.name;
-  version = packageJson.version;
+function getImageUrl(engine, blockId) {
+  try {
+    const imageFill = engine.block.getFill(blockId);
 
-  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.*'
-        ]
-      })
+    const fillImageURI = engine.block.getString(
+      imageFill,
+      'fill/image/imageFileURI'
     );
-    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: 1200, height: 800, unit: 'Pixel' }
-    });
+    if (fillImageURI) {
+      return fillImageURI;
+    }
 
-    const engine = cesdk.engine;
-    const page = engine.block.findByType('page')[0];
+    const sourceSet = engine.block.getSourceSet(
+      imageFill,
+      'fill/image/sourceSet'
+    );
+    if (sourceSet && sourceSet.length > 0) {
+      return sourceSet[0].uri;
+    }
 
-    const pageHeight = engine.block.getHeight(page);
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
 
-    // Create a single sample image
-    const imageWidth = 500;
-    const imageHeight = 400;
-    const imageUri = 'https://img.ly/static/ubq_samples/sample_1.jpg';
+/**
+ * Extracts text content from a text block
+ */
+function getTextContent(engine, blockId) {
+  try {
+    return engine.block.getString(blockId, 'text/text');
+  } catch (error) {
+    return '';
+  }
+}
 
-    const imageBlock = await engine.block.addImage(imageUri, {
-      size: { width: imageWidth, height: imageHeight }
-    });
+/**
+ * Simulates an image content moderation API call
+ * In production, replace this with your actual moderation service
+ */
+async function checkImageContentAPI(url) {
+  if (imageCache.has(url)) {
+    return imageCache.get(url);
+  }
 
-    // Position image in center-left
-    engine.block.setPositionX(imageBlock, 100);
-    engine.block.setPositionY(imageBlock, (pageHeight - imageHeight) / 2);
+  // Simulate API delay
+  await new Promise((resolve) => setTimeout(resolve, 100));
+
+  const results = [
+    {
+      name: 'Weapons',
+      description: 'Handguns, rifles, machine guns, threatening knives',
+      state: percentageToState(Math.random() * 0.3)
+    },
+    {
+      name: 'Alcohol',
+      description: 'Wine, beer, cocktails, champagne',
+      state: percentageToState(Math.random() * 0.4)
+    },
+    {
+      name: 'Drugs',
+      description: 'Cannabis, syringes, glass pipes, bongs, pills',
+      state: percentageToState(Math.random() * 0.2)
+    },
+    {
+      name: 'Nudity',
+      description: 'Raw or partial nudity',
+      state: percentageToState(Math.random() * 0.3)
+    }
+  ];
 
-    engine.block.appendChild(page, imageBlock);
+  imageCache.set(url, results);
+  return results;
+}
 
-    const textBlock = engine.block.create('text');
-    engine.block.setString(
-      textBlock,
-      'text/text',
-      'Sample text content for moderation testing'
-    );
+/**
+ * Simulates a text content moderation API call
+ * In production, replace this with your actual moderation service
+ */
+async function checkTextContentAPI(text) {
+  if (textCache.has(text)) {
+    return textCache.get(text);
+  }
 
-    // Position text on the right side of the image
-    engine.block.setPositionX(textBlock, 650);
-    engine.block.setPositionY(textBlock, (pageHeight - 120) / 2);
-    engine.block.setWidth(textBlock, 450);
-    engine.block.setHeight(textBlock, 120);
+  // Simulate API delay
+  await new Promise((resolve) => setTimeout(resolve, 100));
+
+  const results = [
+    {
+      name: 'Profanity',
+      description: 'Offensive or vulgar language',
+      state: percentageToState(Math.random() * 0.3)
+    },
+    {
+      name: 'Hate Speech',
+      description: 'Content promoting hatred or discrimination',
+      state: percentageToState(Math.random() * 0.2)
+    },
+    {
+      name: 'Threats',
+      description: 'Threatening or violent language',
+      state: percentageToState(Math.random() * 0.1)
+    }
+  ];
 
-    // Make text larger and more readable
-    engine.block.setFloat(textBlock, 'text/fontSize', 48);
-    engine.block.setEnum(textBlock, 'text/horizontalAlignment', 'Left');
+  textCache.set(text, results);
+  return results;
+}
 
-    engine.block.appendChild(page, textBlock);
+/**
+ * Maps confidence scores to validation states
+ */
+function percentageToState(percentage) {
+  if (percentage > 0.8) {
+    return 'failed';
+  } else if (percentage > 0.4) {
+    return 'warning';
+  } else {
+    return 'success';
+  }
+}
 
-    await this.demonstrateContentModeration(engine);
+/**
+ * Checks all images in the design for inappropriate content
+ */
+async function checkImageContent(engine) {
+  const imageBlockIds = engine.block.findByKind('image');
+  const imageBlocksData = imageBlockIds
+    .map((blockId) => ({
+      blockId,
+      url: getImageUrl(engine, blockId),
+      blockType: engine.block.getType(blockId),
+      blockName: engine.block.getName(blockId)
+    }))
+    .filter((data) => data.url !== null);
+
+  const imagesWithValidity = await Promise.all(
+    imageBlocksData.map(async (imageBlockData) => {
+      const categories = await checkImageContentAPI(imageBlockData.url);
+
+      return categories.map((checkResult) => ({
+        ...checkResult,
+        blockId: imageBlockData.blockId,
+        blockType: imageBlockData.blockType,
+        blockName: imageBlockData.blockName,
+        url: imageBlockData.url,
+        id: `${imageBlockData.blockId}-${checkResult.name}`
+      }));
+    })
+  );
 
-    // Zoom to fit the entire page in the viewport
-    await engine.scene.zoomToBlock(page, {
-      padding: {
-        left: 40,
-        top: 40,
-        right: 40,
-        bottom: 40
-      }
-    });
-  }
+  return imagesWithValidity.flat();
+}
 
-  private async demonstrateContentModeration(
-    engine: CreativeEngine
-  ): Promise<void> {
-    // Check both images and text
-    const imageResults = await this.checkImageContent(engine);
-    const textResults = await this.checkTextContent(engine);
-    const allResults = [...imageResults, ...textResults];
-
-    // eslint-disable-next-line no-console
-    console.log(`Total moderation checks: ${allResults.length}`);
-
-    const failed = allResults.filter((r) => r.state === 'failed');
-    const warnings = allResults.filter((r) => r.state === 'warning');
-    const passed = allResults.filter((r) => r.state === 'success');
-
-    // eslint-disable-next-line no-console
-    console.log('Validation Summary:');
-    // eslint-disable-next-line no-console
-    console.log(`  Violations: ${failed.length}`);
-    // eslint-disable-next-line no-console
-    console.log(`  Warnings: ${warnings.length}`);
-    // eslint-disable-next-line no-console
-    console.log(`  Passed: ${passed.length}`);
-
-    if (failed.length > 0) {
-      const blockToSelect = failed[0].blockId;
-      engine.block
-        .findAllSelected()
-        .forEach((id) => engine.block.setSelected(id, false));
-      engine.block.setSelected(blockToSelect, true);
-    }
-  }
+/**
+ * Checks all text blocks in the design for inappropriate content
+ */
+async function checkTextContent(engine) {
+  const textBlockIds = engine.block.findByType('//ly.img.ubq/text');
+  const textBlocksData = textBlockIds
+    .map((blockId) => ({
+      blockId,
+      text: getTextContent(engine, blockId),
+      blockType: engine.block.getType(blockId),
+      blockName: engine.block.getName(blockId)
+    }))
+    .filter((data) => data.text.trim().length > 0);
+
+  const textsWithValidity = await Promise.all(
+    textBlocksData.map(async (textBlockData) => {
+      const categories = await checkTextContentAPI(textBlockData.text);
+
+      return categories.map((checkResult) => ({
+        ...checkResult,
+        blockId: textBlockData.blockId,
+        blockType: textBlockData.blockType,
+        blockName: textBlockData.blockName,
+        text: textBlockData.text,
+        id: `${textBlockData.blockId}-${checkResult.name}`
+      }));
+    })
+  );
 
-  /**
-   * Extracts the image URL from a block's fill property
-   */
-  private getImageUrl(engine: CreativeEngine, blockId: number): string | null {
-    try {
-      const imageFill = engine.block.getFill(blockId);
+  return textsWithValidity.flat();
+}
 
-      const fillImageURI = engine.block.getString(
-        imageFill,
-        'fill/image/imageFileURI'
+/**
+ * Displays validation results grouped by severity
+ */
+function displayResults(results) {
+  const failed = results.filter((r) => r.state === 'failed');
+  const warnings = results.filter((r) => r.state === 'warning');
+  const passed = results.filter((r) => r.state === 'success');
+
+  console.log('\n=== Content Moderation Results ===\n');
+  console.log(`Total checks: ${results.length}`);
+  console.log(`  Violations: ${failed.length}`);
+  console.log(`  Warnings: ${warnings.length}`);
+  console.log(`  Passed: ${passed.length}\n`);
+
+  if (failed.length > 0) {
+    console.log('❌ VIOLATIONS:');
+    failed.forEach((result) => {
+      const content = result.url || result.text?.substring(0, 50) + '...';
+      console.log(
+        `  - ${result.name}: Block ${result.blockId} (${result.blockType})`
       );
-      if (fillImageURI) {
-        return fillImageURI;
-      }
+      console.log(`    ${result.description}`);
+      console.log(`    Content: ${content}\n`);
+    });
+  }
 
-      const sourceSet = engine.block.getSourceSet(
-        imageFill,
-        'fill/image/sourceSet'
+  if (warnings.length > 0) {
+    console.log('⚠️  WARNINGS:');
+    warnings.forEach((result) => {
+      const content = result.url || result.text?.substring(0, 50) + '...';
+      console.log(
+        `  - ${result.name}: Block ${result.blockId} (${result.blockType})`
       );
-      if (sourceSet && sourceSet.length > 0) {
-        return sourceSet[0].uri;
-      }
-
-      return null;
-    } catch (error) {
-      return null;
-    }
+      console.log(`    ${result.description}`);
+      console.log(`    Content: ${content}\n`);
+    });
   }
 
-  /**
-   * Extracts text content from a text block
-   */
-  private getTextContent(engine: CreativeEngine, blockId: number): string {
-    try {
-      return engine.block.getString(blockId, 'text/text');
-    } catch (error) {
-      return '';
-    }
-  }
+  return { failed, warnings, passed };
+}
 
-  /**
-   * Checks all images in the design for inappropriate content
-   */
-  private async checkImageContent(
-    engine: CreativeEngine
-  ): Promise<ValidationResult[]> {
-    const imageBlockIds = engine.block.findByKind('image');
-    const imageBlocksData: ImageBlockData[] = imageBlockIds
-      .map((blockId) => ({
-        blockId,
-        url: this.getImageUrl(engine, blockId),
-        blockType: engine.block.getType(blockId),
-        blockName: engine.block.getName(blockId)
-      }))
-      .filter((data) => data.url !== null) as ImageBlockData[];
-
-    const imagesWithValidity = await Promise.all(
-      imageBlocksData.map(async (imageBlockData) => {
-        const categories = await this.checkImageContentAPI(imageBlockData.url);
-
-        return categories.map((checkResult) => ({
-          ...checkResult,
-          blockId: imageBlockData.blockId,
-          blockType: imageBlockData.blockType,
-          blockName: imageBlockData.blockName,
-          url: imageBlockData.url,
-          id: `${imageBlockData.blockId}-${checkResult.name}`
-        }));
-      })
-    );
+/**
+ * Validates content before allowing export
+ */
+async function validateForExport(engine) {
+  console.log('Validating design before export...');
 
-    return imagesWithValidity.flat();
-  }
+  const imageResults = await checkImageContent(engine);
+  const textResults = await checkTextContent(engine);
+  const allResults = [...imageResults, ...textResults];
 
-  /**
-   * Checks all text blocks in the design for inappropriate content
-   */
-  private async checkTextContent(
-    engine: CreativeEngine
-  ): Promise<ValidationResult[]> {
-    const textBlockIds = engine.block.findByType('//ly.img.ubq/text');
-    const textBlocksData: TextBlockData[] = textBlockIds
-      .map((blockId) => ({
-        blockId,
-        text: this.getTextContent(engine, blockId),
-        blockType: engine.block.getType(blockId),
-        blockName: engine.block.getName(blockId)
-      }))
-      .filter((data) => data.text.trim().length > 0);
-
-    const textsWithValidity = await Promise.all(
-      textBlocksData.map(async (textBlockData) => {
-        const categories = await this.checkTextContentAPI(textBlockData.text);
-
-        return categories.map((checkResult) => ({
-          ...checkResult,
-          blockId: textBlockData.blockId,
-          blockType: textBlockData.blockType,
-          blockName: textBlockData.blockName,
-          text: textBlockData.text,
-          id: `${textBlockData.blockId}-${checkResult.name}`
-        }));
-      })
-    );
+  const { failed } = displayResults(allResults);
 
-    return textsWithValidity.flat();
+  if (failed.length > 0) {
+    console.error(
+      `\n❌ Export blocked: ${failed.length} policy violation(s) detected.\n`
+    );
+    return false;
   }
 
-  /**
-   * Simulates an image content moderation API call
-   */
-  private async checkImageContentAPI(url: string): Promise<ContentCategory[]> {
-    if (imageCache[url]) {
-      return imageCache[url];
-    }
+  console.log('\n✅ Content validation passed. Export allowed.\n');
+  return true;
+}
 
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    const results: ContentCategory[] = [
-      {
-        name: 'Weapons',
-        description: 'Handguns, rifles, machine guns, threatening knives',
-        state: this.percentageToState(Math.random() * 0.3)
-      },
-      {
-        name: 'Alcohol',
-        description: 'Wine, beer, cocktails, champagne',
-        state: this.percentageToState(Math.random() * 0.4)
-      },
-      {
-        name: 'Drugs',
-        description: 'Cannabis, syringes, glass pipes, bongs, pills',
-        state: this.percentageToState(Math.random() * 0.2)
-      },
-      {
-        name: 'Nudity',
-        description: 'Raw or partial nudity',
-        state: this.percentageToState(Math.random() * 0.3)
+/**
+ * Main demonstration function
+ */
+async function main() {
+  console.log('🚀 Starting CE.SDK Content Moderation Demo...\n');
+
+  // Initialize the engine
+  const config = {
+    baseURL: process.env.IMGLY_LOCAL_ASSETS_URL,
+    license: process.env.CESDK_LICENSE || '',
+    logger: (level, ...args) => {
+      if (level === 'error' || level === 'warn') {
+        console.log(`[${level}]`, ...args);
       }
-    ];
-
-    imageCache[url] = results;
-    return results;
-  }
-
-  /**
-   * Simulates a text content moderation API call
-   */
-  private async checkTextContentAPI(text: string): Promise<ContentCategory[]> {
-    if (textCache[text]) {
-      return textCache[text];
     }
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    const results: ContentCategory[] = [
-      {
-        name: 'Profanity',
-        description: 'Offensive or vulgar language',
-        state: this.percentageToState(Math.random() * 0.3)
-      },
-      {
-        name: 'Hate Speech',
-        description: 'Content promoting hatred or discrimination',
-        state: this.percentageToState(Math.random() * 0.2)
-      },
-      {
-        name: 'Threats',
-        description: 'Threatening or violent language',
-        state: this.percentageToState(Math.random() * 0.1)
-      }
-    ];
-
-    textCache[text] = results;
-    return results;
+  };
+
+  const engine = await CreativeEngine.init(config);
+  console.log('✓ Engine initialized\n');
+
+  // Load a sample scene/template
+  // In production, use your actual scene URL or template
+  const templateURL =
+    'https://cdn.img.ly/packages/imgly/cesdk-js/latest/assets/templates/cesdk_postcard_1.scene';
+  await engine.scene.loadFromURL(templateURL);
+  const page = engine.block.findByType('page')[0];
+  console.log('✓ Scene loaded\n');
+
+  // The loaded scene already contains images and text
+  // In production, you would modify the scene content as needed
+  console.log('✓ Scene contains sample content for moderation\n');
+
+  // Validate content before export
+  const canExport = await validateForExport(engine);
+
+  if (canExport) {
+    // Export the design
+    const blob = await engine.block.export(page, 'image/png');
+    const buffer = Buffer.from(await blob.arrayBuffer());
+
+    // Save to file (optional)
+    const fs = await import('fs/promises');
+    await fs.writeFile('output.png', buffer);
+    console.log('✓ Design exported to output.png\n');
   }
 
-  /**
-   * Maps confidence scores to validation states
-   */
-  private percentageToState(
-    percentage: number
-  ): 'success' | 'warning' | 'failed' {
-    if (percentage > 0.8) {
-      return 'failed';
-    } else if (percentage > 0.4) {
-      return 'warning';
-    } else {
-      return 'success';
-    }
-  }
+  // Clean up
+  engine.dispose();
+  console.log('✓ Engine disposed\n');
+  console.log('Demo complete! 🎉');
 }
 
-export default Example;
+// Run the demo
+main().catch((error) => {
+  console.error('Error:', error);
+  process.exit(1);
+});
 ```
 
-This guide demonstrates how to use CE.SDK's engine APIs to find and extract content from designs, send it to moderation APIs, and display validation results.
+This guide demonstrates how to use CE.SDK's engine APIs to find and extract content from designs in Node.js, send it to moderation APIs, and validate before export in server environments.
 
 ## Finding Content in Designs
 
@@ -415,82 +348,80 @@ Locate all images and text blocks, then extract the data needed for moderation.
 
 **Images**: Use `findByKind('image')` to find image blocks, then extract URLs from fill properties:
 
-```typescript highlight-get-image-url
-  /**
-   * Extracts the image URL from a block's fill property
-   */
-  private getImageUrl(engine: CreativeEngine, blockId: number): string | null {
-    try {
-      const imageFill = engine.block.getFill(blockId);
-
-      const fillImageURI = engine.block.getString(
-        imageFill,
-        'fill/image/imageFileURI'
-      );
-      if (fillImageURI) {
-        return fillImageURI;
-      }
+```javascript highlight-get-image-url
+/**
+ * Extracts the image URL from a block's fill property
+ */
+function getImageUrl(engine, blockId) {
+  try {
+    const imageFill = engine.block.getFill(blockId);
 
-      const sourceSet = engine.block.getSourceSet(
-        imageFill,
-        'fill/image/sourceSet'
-      );
-      if (sourceSet && sourceSet.length > 0) {
-        return sourceSet[0].uri;
-      }
+    const fillImageURI = engine.block.getString(
+      imageFill,
+      'fill/image/imageFileURI'
+    );
+    if (fillImageURI) {
+      return fillImageURI;
+    }
 
-      return null;
-    } catch (error) {
-      return null;
+    const sourceSet = engine.block.getSourceSet(
+      imageFill,
+      'fill/image/sourceSet'
+    );
+    if (sourceSet && sourceSet.length > 0) {
+      return sourceSet[0].uri;
     }
+
+    return null;
+  } catch (error) {
+    return null;
   }
+}
 ```
 
 Process all images by checking each URL against the moderation API:
 
-```typescript highlight-check-all-images
-  /**
-   * Checks all images in the design for inappropriate content
-   */
-  private async checkImageContent(
-    engine: CreativeEngine
-  ): Promise<ValidationResult[]> {
-    const imageBlockIds = engine.block.findByKind('image');
-    const imageBlocksData: ImageBlockData[] = imageBlockIds
-      .map((blockId) => ({
-        blockId,
-        url: this.getImageUrl(engine, blockId),
-        blockType: engine.block.getType(blockId),
-        blockName: engine.block.getName(blockId)
-      }))
-      .filter((data) => data.url !== null) as ImageBlockData[];
-
-    const imagesWithValidity = await Promise.all(
-      imageBlocksData.map(async (imageBlockData) => {
-        const categories = await this.checkImageContentAPI(imageBlockData.url);
-
-        return categories.map((checkResult) => ({
-          ...checkResult,
-          blockId: imageBlockData.blockId,
-          blockType: imageBlockData.blockType,
-          blockName: imageBlockData.blockName,
-          url: imageBlockData.url,
-          id: `${imageBlockData.blockId}-${checkResult.name}`
-        }));
-      })
-    );
+```javascript highlight-check-all-images
+/**
+ * Checks all images in the design for inappropriate content
+ */
+async function checkImageContent(engine) {
+  const imageBlockIds = engine.block.findByKind('image');
+  const imageBlocksData = imageBlockIds
+    .map((blockId) => ({
+      blockId,
+      url: getImageUrl(engine, blockId),
+      blockType: engine.block.getType(blockId),
+      blockName: engine.block.getName(blockId)
+    }))
+    .filter((data) => data.url !== null);
+
+  const imagesWithValidity = await Promise.all(
+    imageBlocksData.map(async (imageBlockData) => {
+      const categories = await checkImageContentAPI(imageBlockData.url);
+
+      return categories.map((checkResult) => ({
+        ...checkResult,
+        blockId: imageBlockData.blockId,
+        blockType: imageBlockData.blockType,
+        blockName: imageBlockData.blockName,
+        url: imageBlockData.url,
+        id: `${imageBlockData.blockId}-${checkResult.name}`
+      }));
+    })
+  );
 
-    return imagesWithValidity.flat();
-  }
+  return imagesWithValidity.flat();
+}
 ```
 
 **Text**: Use `findByType('//ly.img.ubq/text')` to find text blocks, then extract content using `getString()`:
 
-```typescript highlight-get-text-content
+```javascript highlight-get-text-content
 /**
  * Extracts text content from a text block
  */
-private getTextContent(engine: CreativeEngine, blockId: number): string {
+function getTextContent(engine, blockId) {
   try {
     return engine.block.getString(blockId, 'text/text');
   } catch (error) {
@@ -501,138 +432,138 @@ private getTextContent(engine: CreativeEngine, blockId: number): string {
 
 Process all text blocks by checking each text string against the moderation API:
 
-```typescript highlight-check-all-text
-  /**
-   * Checks all text blocks in the design for inappropriate content
-   */
-  private async checkTextContent(
-    engine: CreativeEngine
-  ): Promise<ValidationResult[]> {
-    const textBlockIds = engine.block.findByType('//ly.img.ubq/text');
-    const textBlocksData: TextBlockData[] = textBlockIds
-      .map((blockId) => ({
-        blockId,
-        text: this.getTextContent(engine, blockId),
-        blockType: engine.block.getType(blockId),
-        blockName: engine.block.getName(blockId)
-      }))
-      .filter((data) => data.text.trim().length > 0);
-
-    const textsWithValidity = await Promise.all(
-      textBlocksData.map(async (textBlockData) => {
-        const categories = await this.checkTextContentAPI(textBlockData.text);
-
-        return categories.map((checkResult) => ({
-          ...checkResult,
-          blockId: textBlockData.blockId,
-          blockType: textBlockData.blockType,
-          blockName: textBlockData.blockName,
-          text: textBlockData.text,
-          id: `${textBlockData.blockId}-${checkResult.name}`
-        }));
-      })
-    );
+```javascript highlight-check-all-text
+/**
+ * Checks all text blocks in the design for inappropriate content
+ */
+async function checkTextContent(engine) {
+  const textBlockIds = engine.block.findByType('//ly.img.ubq/text');
+  const textBlocksData = textBlockIds
+    .map((blockId) => ({
+      blockId,
+      text: getTextContent(engine, blockId),
+      blockType: engine.block.getType(blockId),
+      blockName: engine.block.getName(blockId)
+    }))
+    .filter((data) => data.text.trim().length > 0);
+
+  const textsWithValidity = await Promise.all(
+    textBlocksData.map(async (textBlockData) => {
+      const categories = await checkTextContentAPI(textBlockData.text);
+
+      return categories.map((checkResult) => ({
+        ...checkResult,
+        blockId: textBlockData.blockId,
+        blockType: textBlockData.blockType,
+        blockName: textBlockData.blockName,
+        text: textBlockData.text,
+        id: `${textBlockData.blockId}-${checkResult.name}`
+      }));
+    })
+  );
 
-    return textsWithValidity.flat();
-  }
+  return textsWithValidity.flat();
+}
 ```
 
 Both processes use `Promise.all()` to handle multiple items concurrently.
 
 ## Integrating Moderation APIs
 
-Integrate external AI services (Sightengine, AWS Rekognition, OpenAI Moderation API) to analyze content. Always proxy API requests through your backend to protect credentials.
+Integrate external AI services (Sightengine, AWS Rekognition, OpenAI Moderation API) to analyze content. In server environments, you can call moderation APIs directly or proxy through your backend for better security.
 
 **Image Moderation** — This example shows a simulated API call that you'll replace with your actual moderation service. The function returns content categories with confidence scores:
 
-```typescript highlight-image-moderation-api
-  /**
-   * Simulates an image content moderation API call
-   */
-  private async checkImageContentAPI(url: string): Promise<ContentCategory[]> {
-    if (imageCache[url]) {
-      return imageCache[url];
-    }
+```javascript highlight-image-moderation-api
+/**
+ * Simulates an image content moderation API call
+ * In production, replace this with your actual moderation service
+ */
+async function checkImageContentAPI(url) {
+  if (imageCache.has(url)) {
+    return imageCache.get(url);
+  }
 
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    const results: ContentCategory[] = [
-      {
-        name: 'Weapons',
-        description: 'Handguns, rifles, machine guns, threatening knives',
-        state: this.percentageToState(Math.random() * 0.3)
-      },
-      {
-        name: 'Alcohol',
-        description: 'Wine, beer, cocktails, champagne',
-        state: this.percentageToState(Math.random() * 0.4)
-      },
-      {
-        name: 'Drugs',
-        description: 'Cannabis, syringes, glass pipes, bongs, pills',
-        state: this.percentageToState(Math.random() * 0.2)
-      },
-      {
-        name: 'Nudity',
-        description: 'Raw or partial nudity',
-        state: this.percentageToState(Math.random() * 0.3)
-      }
-    ];
+  // Simulate API delay
+  await new Promise((resolve) => setTimeout(resolve, 100));
+
+  const results = [
+    {
+      name: 'Weapons',
+      description: 'Handguns, rifles, machine guns, threatening knives',
+      state: percentageToState(Math.random() * 0.3)
+    },
+    {
+      name: 'Alcohol',
+      description: 'Wine, beer, cocktails, champagne',
+      state: percentageToState(Math.random() * 0.4)
+    },
+    {
+      name: 'Drugs',
+      description: 'Cannabis, syringes, glass pipes, bongs, pills',
+      state: percentageToState(Math.random() * 0.2)
+    },
+    {
+      name: 'Nudity',
+      description: 'Raw or partial nudity',
+      state: percentageToState(Math.random() * 0.3)
+    }
+  ];
 
-    imageCache[url] = results;
-    return results;
-  }
+  imageCache.set(url, results);
+  return results;
+}
 ```
 
-In production, replace the simulated logic with a real API call to your backend endpoint that proxies requests to services like Sightengine or AWS Rekognition.
+In production, replace the simulated logic with a real API call to services like Sightengine or AWS Rekognition. Store API keys securely using environment variables.
 
 **Text Moderation** — Similar to image moderation, this simulates an API call that checks text content. Replace this with your actual text moderation service:
 
-```typescript highlight-text-moderation-api
-  /**
-   * Simulates a text content moderation API call
-   */
-  private async checkTextContentAPI(text: string): Promise<ContentCategory[]> {
-    if (textCache[text]) {
-      return textCache[text];
-    }
+```javascript highlight-text-moderation-api
+/**
+ * Simulates a text content moderation API call
+ * In production, replace this with your actual moderation service
+ */
+async function checkTextContentAPI(text) {
+  if (textCache.has(text)) {
+    return textCache.get(text);
+  }
 
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    const results: ContentCategory[] = [
-      {
-        name: 'Profanity',
-        description: 'Offensive or vulgar language',
-        state: this.percentageToState(Math.random() * 0.3)
-      },
-      {
-        name: 'Hate Speech',
-        description: 'Content promoting hatred or discrimination',
-        state: this.percentageToState(Math.random() * 0.2)
-      },
-      {
-        name: 'Threats',
-        description: 'Threatening or violent language',
-        state: this.percentageToState(Math.random() * 0.1)
-      }
-    ];
+  // Simulate API delay
+  await new Promise((resolve) => setTimeout(resolve, 100));
+
+  const results = [
+    {
+      name: 'Profanity',
+      description: 'Offensive or vulgar language',
+      state: percentageToState(Math.random() * 0.3)
+    },
+    {
+      name: 'Hate Speech',
+      description: 'Content promoting hatred or discrimination',
+      state: percentageToState(Math.random() * 0.2)
+    },
+    {
+      name: 'Threats',
+      description: 'Threatening or violent language',
+      state: percentageToState(Math.random() * 0.1)
+    }
+  ];
 
-    textCache[text] = results;
-    return results;
-  }
+  textCache.set(text, results);
+  return results;
+}
 ```
 
-In production, replace the simulation with calls to services like OpenAI Moderation API or Perspective API through your backend.
+In production, replace the simulation with calls to services like OpenAI Moderation API or Perspective API.
 
 **Processing Results**: Map confidence scores to severity levels (failed > 0.8, warning > 0.4, success ≤ 0.4):
 
-```typescript highlight-threshold-mapping
+```javascript highlight-threshold-mapping
 /**
  * Maps confidence scores to validation states
  */
-private percentageToState(
-  percentage: number
-): 'success' | 'warning' | 'failed' {
+function percentageToState(percentage) {
   if (percentage > 0.8) {
     return 'failed';
   } else if (percentage > 0.4) {
@@ -643,76 +574,153 @@ private percentageToState(
 }
 ```
 
-Implement caching to avoid redundant API calls for the same content.
+Implement caching using Map or Redis to avoid redundant API calls for the same content.
 
 ## Displaying Validation Results
 
-Group results by severity (failed, warning, success) and display them in the UI:
-
-```typescript highlight-display-results
-const failed = allResults.filter((r) => r.state === 'failed');
-const warnings = allResults.filter((r) => r.state === 'warning');
-const passed = allResults.filter((r) => r.state === 'success');
-
-// eslint-disable-next-line no-console
-console.log('Validation Summary:');
-// eslint-disable-next-line no-console
-console.log(`  Violations: ${failed.length}`);
-// eslint-disable-next-line no-console
-console.log(`  Warnings: ${warnings.length}`);
-// eslint-disable-next-line no-console
-console.log(`  Passed: ${passed.length}`);
-```
+Group results by severity (failed, warning, success) and display them in the console:
+
+```javascript highlight-display-results
+/**
+ * Displays validation results grouped by severity
+ */
+function displayResults(results) {
+  const failed = results.filter((r) => r.state === 'failed');
+  const warnings = results.filter((r) => r.state === 'warning');
+  const passed = results.filter((r) => r.state === 'success');
+
+  console.log('\n=== Content Moderation Results ===\n');
+  console.log(`Total checks: ${results.length}`);
+  console.log(`  Violations: ${failed.length}`);
+  console.log(`  Warnings: ${warnings.length}`);
+  console.log(`  Passed: ${passed.length}\n`);
+
+  if (failed.length > 0) {
+    console.log('❌ VIOLATIONS:');
+    failed.forEach((result) => {
+      const content = result.url || result.text?.substring(0, 50) + '...';
+      console.log(
+        `  - ${result.name}: Block ${result.blockId} (${result.blockType})`
+      );
+      console.log(`    ${result.description}`);
+      console.log(`    Content: ${content}\n`);
+    });
+  }
 
-Make results interactive by selecting the corresponding block when users click on a validation result:
+  if (warnings.length > 0) {
+    console.log('⚠️  WARNINGS:');
+    warnings.forEach((result) => {
+      const content = result.url || result.text?.substring(0, 50) + '...';
+      console.log(
+        `  - ${result.name}: Block ${result.blockId} (${result.blockType})`
+      );
+      console.log(`    ${result.description}`);
+      console.log(`    Content: ${content}\n`);
+    });
+  }
 
-```typescript highlight-interactive-results
-if (failed.length > 0) {
-  const blockToSelect = failed[0].blockId;
-  engine.block
-    .findAllSelected()
-    .forEach((id) => engine.block.setSelected(id, false));
-  engine.block.setSelected(blockToSelect, true);
+  return { failed, warnings, passed };
 }
 ```
 
-## Integration Points
+## Export Validation
 
-Choose when to run validation based on your workflow:
+Validate content before allowing export in server workflows:
 
-**Export Validation** — Validate when users export designs using `registerAction`:
+```javascript highlight-export-validation
+/**
+ * Validates content before allowing export
+ */
+async function validateForExport(engine) {
+  console.log('Validating design before export...');
 
-```typescript
-cesdk.ui.registerAction('ly.img.export', async (engine) => {
   const imageResults = await checkImageContent(engine);
   const textResults = await checkTextContent(engine);
-  const violations = [...imageResults, ...textResults].filter(
-    (r) => r.state === 'failed'
-  );
+  const allResults = [...imageResults, ...textResults];
+
+  const { failed } = displayResults(allResults);
 
-  if (violations.length > 0) {
-    alert(`Cannot export: ${violations.length} policy violation(s) detected.`);
-    return;
+  if (failed.length > 0) {
+    console.error(
+      `\n❌ Export blocked: ${failed.length} policy violation(s) detected.\n`
+    );
+    return false;
   }
 
-  const blob = await engine.block.export(engine.scene.get(), 'image/png');
-  downloadBlob(blob, 'design.png');
-});
+  console.log('\n✅ Content validation passed. Export allowed.\n');
+  return true;
+}
 ```
 
-**Other Integration Points**:
+This pattern ensures content is checked at the critical point before generating final outputs.
+
+## Server Environment Setup
+
+**Configuration**: Use environment variables to store API credentials and load scenes from templates:
+
+```javascript highlight-setup
+/**
+ * Main demonstration function
+ */
+async function main() {
+  console.log('🚀 Starting CE.SDK Content Moderation Demo...\n');
+
+  // Initialize the engine
+  const config = {
+    baseURL: process.env.IMGLY_LOCAL_ASSETS_URL,
+    license: process.env.CESDK_LICENSE || '',
+    logger: (level, ...args) => {
+      if (level === 'error' || level === 'warn') {
+        console.log(`[${level}]`, ...args);
+      }
+    }
+  };
+
+  const engine = await CreativeEngine.init(config);
+  console.log('✓ Engine initialized\n');
+
+  // Load a sample scene/template
+  // In production, use your actual scene URL or template
+  const templateURL =
+    'https://cdn.img.ly/packages/imgly/cesdk-js/latest/assets/templates/cesdk_postcard_1.scene';
+  await engine.scene.loadFromURL(templateURL);
+  const page = engine.block.findByType('page')[0];
+  console.log('✓ Scene loaded\n');
+```
 
-- Pre-upload validation: Check before allowing uploads to your platform
-- Review queue: Flag designs with warnings for manual review
-- Batch validation: Check all content on-demand when users click a button
+**Headless Execution**: The server example loads a template scene that already contains content to moderate:
+
+```javascript highlight-create-sample-content
+// The loaded scene already contains images and text
+// In production, you would modify the scene content as needed
+console.log('✓ Scene contains sample content for moderation\n');
+```
+
+**Command-Line Interface**: Run validation checks from the command line:
+
+```javascript highlight-run-validation
+  // Validate content before export
+  const canExport = await validateForExport(engine);
+
+  if (canExport) {
+    // Export the design
+    const blob = await engine.block.export(page, 'image/png');
+    const buffer = Buffer.from(await blob.arrayBuffer());
+
+    // Save to file (optional)
+    const fs = await import('fs/promises');
+    await fs.writeFile('output.png', buffer);
+    console.log('✓ Design exported to output.png\n');
+  }
+```
 
 ## Best Practices
 
-**Security**: Always proxy API requests through your backend to protect credentials. Implement rate limiting and authentication.
+**Security**: Store API keys in environment variables, never in code. Use `.env` files for local development and secret managers in production.
 
-**Performance**: Cache results by URL/text to avoid redundant calls. Process items in parallel with `Promise.all()`.
+**Performance**: Cache results using Redis or similar for production workloads. Process items in parallel with `Promise.all()`.
 
-**User Experience**: Run checks asynchronously without blocking the UI. Provide clear error messages and interactive results.
+**Error Handling**: Implement proper error handling with retries for API calls. Log all checks for compliance and auditing.
 
 **Timing**: Validate at export time for the best balance between policy enforcement and creative freedom.
 
@@ -740,22 +748,23 @@ cesdk.ui.registerAction('ly.img.export', async (engine) => {
 - `engine.block.getString(fill, 'fill/image/imageFileURI')` — Get image URL
 - `engine.block.getSourceSet(fill, 'fill/image/sourceSet')` — Get image source set
 
-**Selection**:
+**Export**:
 
-- `engine.block.setSelected(id, bool)` — Select or deselect a block
-- `engine.block.findAllSelected()` — Get currently selected blocks
+- `engine.block.export(blockId, mimeType)` — Export block as blob
 
 ## Next Steps
 
-Now that you understand content moderation, explore related validation features:
+Now that you understand content moderation in Node.js, explore related features:
 
 - [Rules Overview](./rules/overview.md) — Learn about CE.SDK's comprehensive validation system
 
+
+
 ---
 
 ## 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