@meonode/canvas 2.0.2 → 2.0.3

package/dist/esm/worker/comlink.pool.js

@@ -0,0 +1,139 @@
+import { Worker } from 'node:worker_threads';
+import { fileURLToPath } from 'node:url';
+import * as path from 'node:path';
+import './comlink.setup.js';
+import * as Comlink from 'comlink';
+import nodeEndpoint from 'comlink/dist/esm/node-adapter.mjs';
+
+/**
+ * Deeply walks an object tree, wraps any function values with Comlink.proxy(),
+ * and tracks wrapped proxies for deterministic cleanup.
+ */
+function wrapFunctions(obj, proxies) {
+    if (obj === null || obj === undefined)
+        return obj;
+    if (typeof obj === 'function') {
+        const wrapped = Comlink.proxy(obj);
+        proxies.add(wrapped);
+        return wrapped;
+    }
+    if (typeof obj !== 'object')
+        return obj;
+    // Preserve binary data types — don't walk into them
+    if (Buffer.isBuffer(obj))
+        return obj;
+    if (obj instanceof ArrayBuffer)
+        return obj;
+    if (ArrayBuffer.isView(obj))
+        return obj;
+    if (Array.isArray(obj)) {
+        return obj.map(item => wrapFunctions(item, proxies));
+    }
+    const result = {};
+    for (const key of Object.keys(obj)) {
+        result[key] = wrapFunctions(obj[key], proxies);
+    }
+    return result;
+}
+/**
+ * Pool of Comlink-wrapped worker threads.
+ * Manages idle/queue scheduling and proxy lifecycle.
+ */
+class ComlinkPool {
+    workers = [];
+    endpoints = [];
+    idle = [];
+    queue = [];
+    constructor(size) {
+        const workerFile = path.join(path.dirname(fileURLToPath(import.meta.url)), '../worker/render.worker.js');
+        for (let i = 0; i < size; i++) {
+            const worker = new Worker(workerFile);
+            const endpoint = Comlink.wrap(nodeEndpoint(worker));
+            this.workers.push(worker);
+            this.endpoints.push(endpoint);
+            this.idle.push(i);
+        }
+    }
+    acquire() {
+        return this.idle.pop() ?? null;
+    }
+    release(idx) {
+        this.idle.push(idx);
+        this.drain();
+    }
+    drain() {
+        while (this.queue.length > 0 && this.idle.length > 0) {
+            const task = this.queue.shift();
+            const idx = this.idle.pop();
+            void this.executeRender(idx, task.props, task.resolve, task.reject);
+        }
+    }
+    async executeRender(idx, props, resolve, reject) {
+        try {
+            const result = await this.endpoints[idx].render(props);
+            resolve({ ...result, workerIdx: idx });
+        }
+        catch (err) {
+            reject(err instanceof Error ? err : new Error(String(err)));
+        }
+        finally {
+            this.release(idx);
+        }
+    }
+    async render(props) {
+        const proxies = new Set();
+        const wrapped = wrapFunctions(props, proxies);
+        const cleanup = () => {
+            for (const p of proxies) {
+                try {
+                    ;
+                    p[Comlink.releaseProxy]?.();
+                }
+                catch {
+                    // Proxy may already be released
+                }
+            }
+        };
+        // Direct path — idle worker available
+        const idx = this.acquire();
+        if (idx !== null) {
+            try {
+                const result = await this.endpoints[idx].render(wrapped);
+                return { ...result, workerIdx: idx };
+            }
+            finally {
+                this.release(idx);
+                cleanup();
+            }
+        }
+        // Queued path — cleanup AFTER the queued task completes, not before
+        return new Promise((resolve, reject) => {
+            this.queue.push({
+                props: wrapped,
+                resolve: result => {
+                    cleanup();
+                    resolve(result);
+                },
+                reject: err => {
+                    cleanup();
+                    reject(err);
+                },
+            });
+        });
+    }
+    callOnCanvas(workerIdx, canvasId, method, args) {
+        return this.endpoints[workerIdx].callOnCanvas(canvasId, method, args);
+    }
+    releaseCanvas(workerIdx, canvasId) {
+        this.endpoints[workerIdx].releaseCanvas(canvasId);
+    }
+    terminate() {
+        this.workers.forEach(w => w.terminate());
+        this.workers = [];
+        this.endpoints = [];
+        this.idle = [];
+        this.queue = [];
+    }
+}
+
+export { ComlinkPool, wrapFunctions };

package/dist/esm/worker/comlink.setup.js

@@ -0,0 +1,30 @@
+import * as Comlink from 'comlink';
+export { Comlink };
+import { MessageChannel } from 'node:worker_threads';
+import nodeEndpoint from 'comlink/dist/esm/node-adapter.mjs';
+export { default as nodeEndpoint } from 'comlink/dist/esm/node-adapter.mjs';
+
+// src/worker/comlink.setup.ts
+/**
+ * Fix Comlink.proxy() for Node.js worker_threads (issue #313).
+ * The built-in proxy transfer handler uses browser MessageChannel.
+ * This override uses Node's MessageChannel instead.
+ *
+ * Must be called on BOTH main thread and worker before any Comlink usage.
+ */
+function installNodeProxyHandler() {
+    Comlink.transferHandlers.set('proxy', {
+        canHandle: (obj) => typeof obj === 'object' && obj !== null && Comlink.proxyMarker in obj,
+        serialize: (obj) => {
+            const { port1, port2 } = new MessageChannel();
+            Comlink.expose(obj, nodeEndpoint(port1));
+            return [port2, [port2]];
+        },
+        deserialize: (port) => {
+            port.start?.();
+            return Comlink.wrap(nodeEndpoint(port));
+        },
+    });
+}
+// Install immediately on import
+installNodeProxyHandler();

package/dist/esm/worker/render.worker.js

@@ -1,70 +1,48 @@
-import { parentPort } from 'worker_threads';
+import { parentPort } from 'node:worker_threads';
+import './comlink.setup.js';
 import { RootNode } from '../canvas/root.canvas.js';
+import * as Comlink from 'comlink';
+import nodeEndpoint from 'comlink/dist/esm/node-adapter.mjs';
 
-/**
- * Worker thread entry point for off-main-thread canvas rendering.
- *
- * Message protocol (main → worker):
- *   { type: 'render', taskId, props }                      — render and keep Canvas alive
- *   { type: 'call',   taskId, canvasId, method, args }     — call a method on a live Canvas
- *   { type: 'release', canvasId }                          — free Canvas from memory
- *
- * Responses (worker → main):
- *   WorkerRenderResponse  — render complete (includes pre-encoded PNG buffer)
- *   WorkerCallResponse    — method call result
- *   WorkerErrorResponse   — any failure
- */
 if (!parentPort) {
     throw new Error('[render.worker] Must be run as a worker thread');
 }
 const canvases = new Map();
 let nextCanvasId = 0;
-function reply(msg) {
-    parentPort.postMessage(msg);
-}
-parentPort.on('message', async (msg) => {
-    if (msg.type === 'render') {
-        try {
-            const canvas = await new RootNode(msg.props).render();
-            const canvasId = nextCanvasId++;
-            canvases.set(canvasId, canvas);
-            reply({ taskId: msg.taskId, canvasId, buffer: canvas.toBufferSync('png'), width: canvas.width, height: canvas.height });
-        }
-        catch (err) {
-            reply({ taskId: msg.taskId, error: String(err) });
-        }
-    }
-    else if (msg.type === 'call') {
-        const canvas = canvases.get(msg.canvasId);
+const api = {
+    async render(props) {
+        const canvas = await new RootNode(props).render();
+        const canvasId = nextCanvasId++;
+        canvases.set(canvasId, canvas);
+        const result = {
+            canvasId,
+            buffer: canvas.toBufferSync('png'),
+            width: canvas.width,
+            height: canvas.height,
+        };
+        return result;
+    },
+    async callOnCanvas(canvasId, method, args) {
+        const canvas = canvases.get(canvasId);
         if (!canvas) {
-            reply({ taskId: msg.taskId, error: `[render.worker] Canvas ${msg.canvasId} not found` });
-            return;
-        }
-        try {
-            let result;
-            switch (msg.method) {
-                case 'toBuffer':
-                    result = await canvas.toBuffer(...msg.args);
-                    break;
-                case 'toURL':
-                    result = await canvas.toURL(...msg.args);
-                    break;
-                case 'toFile':
-                    result = await canvas.toFile(...msg.args);
-                    break;
-                case 'toSharp':
-                    // Sharp instances can't be transferred across threads — serialize to buffer
-                    result = await canvas.toSharp(...msg.args).toBuffer();
-                    break;
-            }
-            reply({ taskId: msg.taskId, result });
+            throw new Error(`[render.worker] Canvas ${canvasId} not found`);
         }
-        catch (err) {
-            reply({ taskId: msg.taskId, error: String(err) });
+        switch (method) {
+            case 'toBuffer':
+                return canvas.toBuffer(...args);
+            case 'toURL':
+                return canvas.toURL(...args);
+            case 'toFile':
+                await canvas.toFile(...args);
+                return;
+            case 'toSharp':
+                return await canvas.toSharp(...args).toBuffer();
+            default:
+                throw new Error(`[render.worker] Unknown method: ${method}`);
         }
-    }
-    else {
-        // type === 'release'
-        canvases.delete(msg.canvasId);
-    }
-});
+    },
+    releaseCanvas(canvasId) {
+        canvases.delete(canvasId);
+    },
+};
+Comlink.expose(api, nodeEndpoint(parentPort));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meonode/canvas",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "A declarative, component-based library for server-side canvas image generation. Write complex visuals with simple functions, similar to the composition style of @meonode/ui.",
   "keywords": [
     "canvas",
@@ -81,6 +81,7 @@
   },
   "packageManager": "yarn@4.11.0",
   "dependencies": {
+    "comlink": "^4.4.2",
     "file-type": "^22.0.0",
     "lodash-es": "^4.17.23",
     "sharp": "^0.34.5",