@imgly/codesign-mcp 0.1.5 → 0.1.6

package/assets/docs/guide/import-media/asset-panel/refresh-assets.md

@@ -1,48 +1,38 @@
-> 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).
-
-**Navigation:** [Guides](./guides.md) > [Import Media Assets](./import-media.md) > [Asset Library](./import-media/asset-library.md) > [Refresh Assets](./import-media/asset-panel/refresh-assets.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).
 
 ---
 
-Learn how to refresh asset sources when external changes occur outside CE.SDK.
-
-![Refresh Assets](https://img.ly/docs/cesdk/./assets/browser.hero.webp)
+Learn how to refresh asset sources when external changes occur outside CE.SDK in a server environment.
 
 > **Reading time:** 5 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-import-media-asset-library-refresh-assets-browser)
-> - [Open in StackBlitz](https://stackblitz.com/github/imgly/cesdk-web-examples/tree/v$UBQ_VERSION$/guides-import-media-asset-library-refresh-assets-browser)
-> - [Live demo](https://img.ly/docs/cesdk/examples/guides-import-media-asset-library-refresh-assets-browser/)
-
-CE.SDK automatically refreshes the asset library for built-in operations like uploads and deletions. However, when assets are modified outside of CE.SDK—through a custom CMS, cloud storage, or third-party upload widget—the asset panel won't reflect these changes automatically. Use `engine.asset.assetSourceContentsChanged()` to notify the engine and trigger a refresh.
-
-```typescript file=@cesdk_web_examples/guides-import-media-asset-library-refresh-assets-browser/browser.ts reference-only
-import type {
-  AssetsQueryResult,
-  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';
+>
+> - [View source on GitHub](https://github.com/imgly/cesdk-web-examples/tree/release-$UBQ_VERSION$/guides-import-media-asset-library-refresh-assets-server-js)
+>
+> - [Open in StackBlitz](https://stackblitz.com/github/imgly/cesdk-web-examples/tree/v$UBQ_VERSION$/guides-import-media-asset-library-refresh-assets-server-js)
+
+CE.SDK automatically refreshes the asset library for built-in operations like uploads and deletions. However, when assets are modified outside of CE.SDK—through a custom CMS, cloud storage, or third-party upload widget—the asset source won't reflect these changes automatically. Use `engine.asset.assetSourceContentsChanged()` to notify the engine and trigger a refresh.
+
+```typescript file=@cesdk_web_examples/guides-import-media-asset-library-refresh-assets-server-js/server-js.ts reference-only
+import CreativeEngine, { AssetsQueryResult } from '@cesdk/node';
+import { config } from 'dotenv';
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+
+// Load environment variables
+config();
+
+/**
+ * CE.SDK Server Guide: Refresh Assets
+ *
+ * Demonstrates how to refresh asset sources after external changes:
+ * - Creating custom asset sources
+ * - Simulating external uploads
+ * - Triggering asset refresh with assetSourceContentsChanged()
+ * - Handling external modifications and deletions
+ */
 
 // Simulated external data store (represents Cloudinary, S3, or external CMS)
 const externalAssets = [
@@ -58,164 +48,153 @@ const externalAssets = [
   }
 ];
 
-class Example implements EditorPlugin {
-  name = packageJson.name;
-
-  version = packageJson.version;
+// 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)
+});
 
-  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: {
-        sourceId: 'ly.img.page.presets',
-        assetId: 'ly.img.page.presets.print.iso.a6.landscape'
-      }
-    });
-
-    const engine = cesdk.engine;
-
-    // ===== Section 1: Register a Custom Asset Source =====
-    // Register a custom asset source that fetches from an external system
-    // This source will need manual refresh when external changes occur
-    engine.asset.addSource({
-      id: 'cloudinary-images',
-      async findAssets(queryData): Promise<AssetsQueryResult> {
-        // Fetch current assets from external data store
-        const filteredAssets = externalAssets.filter(
-          (asset) =>
-            !queryData.query ||
-            asset.name.toLowerCase().includes(queryData.query.toLowerCase())
-        );
-
-        return {
-          assets: filteredAssets.map((asset) => ({
-            id: asset.id,
-            label: asset.name,
-            meta: {
-              uri: asset.url,
-              thumbUri: asset.url,
-              blockType: '//ly.img.ubq/graphic'
-            }
-          })),
-          total: filteredAssets.length,
-          currentPage: queryData.page,
-          nextPage: undefined
-        };
-      }
-    });
-
-    // Add the custom source to the asset library
-    cesdk.ui.updateAssetLibraryEntry('ly.img.image', {
-      sourceIds: ['cloudinary-images'],
-      gridColumns: 2,
-      gridItemHeight: 'square',
-      previewLength: 4
-    });
-
-    // ===== Section 2: Simulate External Upload =====
-    // Simulate an external upload widget (e.g., Cloudinary upload widget)
-    // In a real application, this would be triggered by the widget's success callback
-    const simulateExternalUpload = () => {
-      // Add a new asset to the external store
-      const newAsset = {
-        id: `cloud-${Date.now()}`,
-        url: 'https://img.ly/static/ubq_samples/sample_3.jpg',
-        name: `Uploaded Image ${externalAssets.length + 1}`
+try {
+  // Create a design scene
+  engine.scene.create('VerticalStack', {
+    page: { size: { width: 800, height: 600 } }
+  });
+  const page = engine.block.findByType('page')[0];
+
+  // ===== Section 1: Register a Custom Asset Source =====
+  // Register a custom asset source that fetches from an external system
+  // This source will need manual refresh when external changes occur
+  engine.asset.addSource({
+    id: 'cloudinary-images',
+    async findAssets(queryData): Promise<AssetsQueryResult> {
+      // Fetch current assets from external data store
+      const filteredAssets = externalAssets.filter(
+        (asset) =>
+          !queryData.query ||
+          asset.name.toLowerCase().includes(queryData.query.toLowerCase())
+      );
+
+      return {
+        assets: filteredAssets.map((asset) => ({
+          id: asset.id,
+          label: asset.name,
+          meta: {
+            uri: asset.url,
+            thumbUri: asset.url,
+            blockType: '//ly.img.ubq/graphic'
+          }
+        })),
+        total: filteredAssets.length,
+        currentPage: queryData.page,
+        nextPage: undefined
       };
-      externalAssets.push(newAsset);
-
-      // Notify CE.SDK that the source contents have changed
-      engine.asset.assetSourceContentsChanged('cloudinary-images');
-
-      console.log('External upload complete, asset library refreshed');
-    };
-
-    // ===== Section 3: Simulate External Modification =====
-    // Simulate backend modifications (e.g., CMS updates, API changes)
-    const simulateExternalModification = () => {
-      // Modify assets in the external store
-      if (externalAssets.length > 0) {
-        externalAssets[0] = {
-          ...externalAssets[0],
-          name: `Modified: ${externalAssets[0].name}`
-        };
-      }
-
-      // Refresh the asset library to reflect changes
-      engine.asset.assetSourceContentsChanged('cloudinary-images');
-
-      console.log('External modification complete, asset library refreshed');
-    };
-
-    // ===== Section 4: Simulate External Deletion =====
-    // Simulate asset deletion from external system
-    const simulateExternalDeletion = () => {
-      // Remove the last asset from the external store
-      if (externalAssets.length > 2) {
-        const removed = externalAssets.pop();
-        console.log(`Removed asset: ${removed?.name}`);
-
-        // Refresh the asset library to reflect the deletion
-        engine.asset.assetSourceContentsChanged('cloudinary-images');
-
-        console.log('External deletion complete, asset library refreshed');
-      }
-    };
-
-    // Expose functions for demo purposes
-    (window as any).simulateExternalUpload = simulateExternalUpload;
-    (window as any).simulateExternalModification = simulateExternalModification;
-    (window as any).simulateExternalDeletion = simulateExternalDeletion;
-
-    // Automatically trigger an upload to demonstrate the refresh
-    setTimeout(() => {
-      simulateExternalUpload();
-    }, 2000);
-
-    // Open the asset library to show the custom source
-    cesdk.ui.openPanel('//ly.img.panel/assetLibrary', {
-      payload: {
-        entries: ['ly.img.image']
-      }
-    });
+    }
+  });
+
+  console.log('✓ Created custom asset source: cloudinary-images');
+
+  // ===== Section 2: Query Initial Assets =====
+  const initialAssets = await engine.asset.findAssets('cloudinary-images', {
+    page: 0,
+    perPage: 100
+  });
+  console.log(`Initial assets: ${initialAssets.assets.length}`);
+  for (const asset of initialAssets.assets) {
+    console.log(`  - ${asset.id}: ${asset.label}`);
   }
-}
 
-export default Example;
+  // ===== Section 3: Simulate External Upload =====
+  // Simulate an external upload (e.g., from Cloudinary upload widget)
+  // In a real application, this would be triggered by webhook or polling
+  const newAsset = {
+    id: 'cloud-3',
+    url: 'https://img.ly/static/ubq_samples/sample_3.jpg',
+    name: 'Forest Path'
+  };
+  externalAssets.push(newAsset);
+
+  // Notify CE.SDK that the source contents have changed
+  engine.asset.assetSourceContentsChanged('cloudinary-images');
+  console.log('✓ External upload complete, asset source refreshed');
+
+  // Verify the new asset is available
+  const afterUpload = await engine.asset.findAssets('cloudinary-images', {
+    page: 0,
+    perPage: 100
+  });
+  console.log(`Assets after upload: ${afterUpload.assets.length}`);
+
+  // ===== Section 4: Simulate External Modification =====
+  // Simulate backend modifications (e.g., CMS updates, API changes)
+  externalAssets[0] = {
+    ...externalAssets[0],
+    name: 'Modified: Mountain Landscape'
+  };
+
+  // Refresh the asset library to reflect changes
+  engine.asset.assetSourceContentsChanged('cloudinary-images');
+  console.log('✓ External modification complete, asset source refreshed');
+
+  // Verify the modification
+  const afterModification = await engine.asset.findAssets('cloudinary-images', {
+    page: 0,
+    perPage: 100
+  });
+  console.log(
+    `First asset after modification: ${afterModification.assets[0].label}`
+  );
+
+  // ===== Section 5: Simulate External Deletion =====
+  // Simulate asset deletion from external system
+  const removed = externalAssets.pop();
+  console.log(`Removed asset from external store: ${removed?.name}`);
+
+  // Refresh the asset library to reflect the deletion
+  engine.asset.assetSourceContentsChanged('cloudinary-images');
+  console.log('✓ External deletion complete, asset source refreshed');
+
+  // Verify the deletion
+  const afterDeletion = await engine.asset.findAssets('cloudinary-images', {
+    page: 0,
+    perPage: 100
+  });
+  console.log(`Assets after deletion: ${afterDeletion.assets.length}`);
+
+  // ===== Add an Image to the Scene =====
+  // Use an asset from the source to create a block
+  const imageBlock = engine.block.create('graphic');
+  engine.block.setShape(imageBlock, engine.block.createShape('rect'));
+  const imageFill = engine.block.createFill('image');
+  engine.block.setString(
+    imageFill,
+    'fill/image/imageFileURI',
+    'https://img.ly/static/ubq_samples/sample_1.jpg'
+  );
+  engine.block.setFill(imageBlock, imageFill);
+  engine.block.setWidth(imageBlock, 400);
+  engine.block.setHeight(imageBlock, 300);
+  engine.block.setPositionX(imageBlock, 200);
+  engine.block.setPositionY(imageBlock, 150);
+  engine.block.appendChild(page, imageBlock);
+
+  // Export the result to PNG
+  const outputDir = './output';
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+
+  const blob = await engine.block.export(page, { mimeType: 'image/png' });
+  const buffer = Buffer.from(await blob.arrayBuffer());
+  writeFileSync(`${outputDir}/refresh-assets-result.png`, buffer);
+
+  console.log('✓ Exported result to output/refresh-assets-result.png');
+} finally {
+  // Always dispose the engine to free resources
+  engine.dispose();
+}
 ```
 
-This guide covers when manual refresh is needed, how to trigger refreshes programmatically, and integration patterns for external upload widgets.
+This guide covers when manual refresh is needed, how to trigger refreshes programmatically, and integration patterns for server-side asset management.
 
 ## When to Use Asset Refresh
 
@@ -229,154 +208,144 @@ CE.SDK handles asset refresh automatically for built-in operations. Manual refre
 
 **Manual refresh required**:
 
-- External uploads via third-party widgets (Cloudinary, Dropzone)
+- External uploads via third-party services (Cloudinary, S3)
 - Backend modifications through CMS or API updates
-- Sync with external storage (S3, Azure Blob)
-- Real-time collaboration when another user adds assets
+- Sync with external storage (Azure Blob, Google Cloud Storage)
+- Real-time collaboration when another process adds assets
 
 ## Registering a Custom Asset Source
 
-Before refreshing assets, you need a custom asset source that fetches from your external system. The `findAssets` method queries your external data store each time the panel needs to display assets.
+Before refreshing assets, you need a custom asset source that fetches from your external system. The `findAssets` method queries your external data store each time assets are requested.
 
 ```typescript highlight-custom-source
-// Register a custom asset source that fetches from an external system
-// This source will need manual refresh when external changes occur
-engine.asset.addSource({
-  id: 'cloudinary-images',
-  async findAssets(queryData): Promise<AssetsQueryResult> {
-    // Fetch current assets from external data store
-    const filteredAssets = externalAssets.filter(
-      (asset) =>
-        !queryData.query ||
-        asset.name.toLowerCase().includes(queryData.query.toLowerCase())
-    );
-
-    return {
-      assets: filteredAssets.map((asset) => ({
-        id: asset.id,
-        label: asset.name,
-        meta: {
-          uri: asset.url,
-          thumbUri: asset.url,
-          blockType: '//ly.img.ubq/graphic'
-        }
-      })),
-      total: filteredAssets.length,
-      currentPage: queryData.page,
-      nextPage: undefined
-    };
-  }
-});
+  // Register a custom asset source that fetches from an external system
+  // This source will need manual refresh when external changes occur
+  engine.asset.addSource({
+    id: 'cloudinary-images',
+    async findAssets(queryData): Promise<AssetsQueryResult> {
+      // Fetch current assets from external data store
+      const filteredAssets = externalAssets.filter(
+        (asset) =>
+          !queryData.query ||
+          asset.name.toLowerCase().includes(queryData.query.toLowerCase())
+      );
+
+      return {
+        assets: filteredAssets.map((asset) => ({
+          id: asset.id,
+          label: asset.name,
+          meta: {
+            uri: asset.url,
+            thumbUri: asset.url,
+            blockType: '//ly.img.ubq/graphic'
+          }
+        })),
+        total: filteredAssets.length,
+        currentPage: queryData.page,
+        nextPage: undefined
+      };
+    }
+  });
+
+  console.log('✓ Created custom asset source: cloudinary-images');
 ```
 
-This custom source fetches assets from an external data store (simulating Cloudinary, S3, or a CMS). When the external store changes, the asset panel won't update until you call `assetSourceContentsChanged()`.
+This custom source fetches assets from an external data store (simulating Cloudinary, S3, or a CMS). When the external store changes, subsequent queries won't reflect updates until you call `assetSourceContentsChanged()`.
 
 ## Refreshing After External Uploads
 
-When users upload files through a third-party widget, call `assetSourceContentsChanged()` in the success callback. This notifies CE.SDK that the source contents have changed and triggers a re-fetch.
+When your backend receives new uploads from a third-party service, call `assetSourceContentsChanged()` to notify CE.SDK that the source contents have changed.
 
 ```typescript highlight-external-upload
-// Simulate an external upload widget (e.g., Cloudinary upload widget)
-// In a real application, this would be triggered by the widget's success callback
-const simulateExternalUpload = () => {
-  // Add a new asset to the external store
+  // Simulate an external upload (e.g., from Cloudinary upload widget)
+  // In a real application, this would be triggered by webhook or polling
   const newAsset = {
-    id: `cloud-${Date.now()}`,
+    id: 'cloud-3',
     url: 'https://img.ly/static/ubq_samples/sample_3.jpg',
-    name: `Uploaded Image ${externalAssets.length + 1}`
+    name: 'Forest Path'
   };
   externalAssets.push(newAsset);
 
   // Notify CE.SDK that the source contents have changed
   engine.asset.assetSourceContentsChanged('cloudinary-images');
-
-  console.log('External upload complete, asset library refreshed');
-};
+  console.log('✓ External upload complete, asset source refreshed');
 ```
 
-The key is calling `assetSourceContentsChanged('cloudinary-images')` after the external upload completes. This tells CE.SDK to call `findAssets()` again, which fetches the updated asset list from your external store.
+The key is calling `assetSourceContentsChanged('cloudinary-images')` after the external upload completes. This tells CE.SDK to re-fetch assets on the next query.
 
 ## Refreshing After External Modifications
 
-When your backend modifies asset metadata—renaming files, updating tags, or changing thumbnails—call `assetSourceContentsChanged()` to sync the asset panel.
+When your backend modifies asset metadata—renaming files, updating tags, or changing thumbnails—call `assetSourceContentsChanged()` to sync the asset source.
 
 ```typescript highlight-external-modification
-// Simulate backend modifications (e.g., CMS updates, API changes)
-const simulateExternalModification = () => {
-  // Modify assets in the external store
-  if (externalAssets.length > 0) {
-    externalAssets[0] = {
-      ...externalAssets[0],
-      name: `Modified: ${externalAssets[0].name}`
-    };
-  }
+  // Simulate backend modifications (e.g., CMS updates, API changes)
+  externalAssets[0] = {
+    ...externalAssets[0],
+    name: 'Modified: Mountain Landscape'
+  };
 
   // Refresh the asset library to reflect changes
   engine.asset.assetSourceContentsChanged('cloudinary-images');
-
-  console.log('External modification complete, asset library refreshed');
-};
+  console.log('✓ External modification complete, asset source refreshed');
 ```
 
-Any modification to assets in your external store requires a refresh. Without calling `assetSourceContentsChanged()`, the asset panel displays stale data until the user navigates away and returns.
+Any modification to assets in your external store requires a refresh. Without calling `assetSourceContentsChanged()`, subsequent queries may return stale data.
 
 ## Refreshing After External Deletions
 
-When assets are deleted from your external system, call `assetSourceContentsChanged()` to remove them from the asset panel.
+When assets are deleted from your external system, call `assetSourceContentsChanged()` to ensure queries no longer return deleted assets.
 
 ```typescript highlight-external-deletion
-// Simulate asset deletion from external system
-const simulateExternalDeletion = () => {
-  // Remove the last asset from the external store
-  if (externalAssets.length > 2) {
-    const removed = externalAssets.pop();
-    console.log(`Removed asset: ${removed?.name}`);
-
-    // Refresh the asset library to reflect the deletion
-    engine.asset.assetSourceContentsChanged('cloudinary-images');
+  // Simulate asset deletion from external system
+  const removed = externalAssets.pop();
+  console.log(`Removed asset from external store: ${removed?.name}`);
 
-    console.log('External deletion complete, asset library refreshed');
-  }
-};
+  // Refresh the asset library to reflect the deletion
+  engine.asset.assetSourceContentsChanged('cloudinary-images');
+  console.log('✓ External deletion complete, asset source refreshed');
 ```
 
-The refresh ensures deleted assets no longer appear in the panel. If you skip this step, users may try to use assets that no longer exist.
+The refresh ensures deleted assets no longer appear in query results. If you skip this step, the engine may reference assets that no longer exist.
 
 ## Integration Patterns
 
-### Third-Party Upload Widget
+### Webhook Handler
 
-Integrate with upload widgets like Cloudinary by calling `assetSourceContentsChanged()` in the success callback:
+Handle webhooks from external services to trigger refreshes:
 
 ```typescript
-const widget = cloudinary.createUploadWidget(
-  { cloudName: 'my-cloud' },
-  (error, result) => {
-    if (result.event === 'success') {
-      engine.asset.assetSourceContentsChanged('cloudinary-images');
-    }
+app.post('/webhooks/cloudinary', (req, res) => {
+  const { notification_type, public_id } = req.body;
+
+  if (notification_type === 'upload' || notification_type === 'delete') {
+    engine.asset.assetSourceContentsChanged('cloudinary-images');
   }
-);
+
+  res.status(200).send('OK');
+});
 ```
 
-### WebSocket Updates
+### Scheduled Sync
 
-For real-time sync with backend changes:
+For periodic synchronization with external systems:
 
 ```typescript
-socket.on('assets:changed', (sourceId) => {
-  engine.asset.assetSourceContentsChanged(sourceId);
+import cron from 'node-cron';
+
+cron.schedule('*/5 * * * *', () => {
+  // Refresh every 5 minutes
+  engine.asset.assetSourceContentsChanged('external-assets');
 });
 ```
 
-### Polling for Changes
+### Event-Driven Updates
 
-If your backend doesn't support real-time notifications:
+Listen for database changes to trigger refreshes:
 
 ```typescript
-setInterval(() => {
-  engine.asset.assetSourceContentsChanged('my-source');
-}, 30000); // Refresh every 30 seconds
+database.on('assets:changed', (sourceId) => {
+  engine.asset.assetSourceContentsChanged(sourceId);
+});
 ```
 
 ## Troubleshooting
@@ -389,27 +358,29 @@ Verify the source ID passed to `assetSourceContentsChanged()` matches the ID use
 
 Ensure you call `assetSourceContentsChanged()` after the external operation completes. If called before the upload finishes, `findAssets()` may return stale data.
 
-**Stale assets displayed**:
+**Stale assets in queries**:
 
 Check that your `findAssets` implementation fetches fresh data on each call. Avoid caching responses unless you invalidate the cache when calling `assetSourceContentsChanged()`.
 
-**Asset panel not visible**:
+**Memory management**:
 
-The refresh only affects visible panels. If the asset panel is closed, the refresh queues until the user reopens it.
+Always dispose the engine when done processing to free resources. Use try/finally blocks to ensure cleanup happens even when errors occur.
 
 ## API Reference
 
-| Method                                              | Category  | Purpose                                          |
-| --------------------------------------------------- | --------- | ------------------------------------------------ |
+| Method | Category | Purpose |
+|--------|----------|---------|
 | `engine.asset.assetSourceContentsChanged(sourceID)` | Asset API | Notify engine that asset source contents changed |
-| `engine.asset.addSource(source)`                    | Asset API | Register custom asset source                     |
-| `engine.asset.findAssets(sourceID, query)`          | Asset API | Query assets from a source                       |
+| `engine.asset.addSource(source)` | Asset API | Register custom asset source |
+| `engine.asset.findAssets(sourceID, query)` | Asset API | Query assets from a source |
+
+
 
 ---
 
 ## 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