@meonode/canvas 2.0.2 → 2.0.4

package/dist/esm/canvas/root.canvas.js

@@ -6,12 +6,9 @@ import { TextNode } from './text.canvas.js';
 import { ChartNode } from './chart.canvas.js';
 import { GridItemNode, GridNode } from './grid.canvas.js';
 import { Style } from '../constant/common.const.js';
-import { WorkerPreProcessor } from './canvas.helper.js';
 import * as path from 'node:path';
 import * as fs from 'node:fs';
 import { cpus } from 'node:os';
-import { Worker } from 'node:worker_threads';
-import { fileURLToPath } from 'node:url';
 
 /** Registry to track fonts that have already been loaded */
 const registeredFonts = new Map();
@@ -20,14 +17,8 @@ const registeredFonts = new Map();
  * This is a safety net — users should still call .release() explicitly.
  */
 const canvasRegistry = new FinalizationRegistry(heldValue => {
-    // Best-effort cleanup — worker may already be terminated
     try {
-        // Access workers via a public method or make it accessible
-        // For now, just try to send the message and let errors be caught
-        if (_workerPool) {
-            ;
-            _workerPool.workers?.[heldValue.workerIdx]?.postMessage({ type: 'release', canvasId: heldValue.canvasId });
-        }
+        _workerPool?.releaseCanvas(heldValue.workerIdx, heldValue.canvasId);
     }
     catch {
         // Worker already gone — nothing to clean up
@@ -67,7 +58,7 @@ function terminate() {
 class WorkerCanvas {
     width;
     height;
-    _buffer; // pre-encoded PNG for sync use
+    _buffer;
     _pool;
     _workerIdx;
     _canvasId;
@@ -78,12 +69,8 @@ class WorkerCanvas {
         this._pool = opts.pool;
         this._workerIdx = opts.workerIdx;
         this._canvasId = opts.canvasId;
-        // Register for finalizer-based cleanup if user forgets to call .release()
         canvasRegistry.register(this, { workerIdx: opts.workerIdx, canvasId: opts.canvasId }, this);
     }
-    _call(method, ...args) {
-        return this._pool.callOnCanvas(this._workerIdx, this._canvasId, method, args);
-    }
     // --- Sync methods: return from pre-encoded PNG buffer ---
     toBufferSync(_format, _options) {
         return this._buffer;
@@ -91,128 +78,47 @@ class WorkerCanvas {
     toURLSync(_format, _options) {
         return `data:image/png;base64,${this._buffer.toString('base64')}`;
     }
-    // --- Async methods: delegate to worker ---
+    // --- Async methods: delegate to worker via Comlink ---
     toBuffer(format, options) {
-        return this._call('toBuffer', format, options);
+        return this._pool.callOnCanvas(this._workerIdx, this._canvasId, 'toBuffer', [format, options]);
     }
     toURL(format, options) {
-        return this._call('toURL', format, options);
+        return this._pool.callOnCanvas(this._workerIdx, this._canvasId, 'toURL', [format, options]);
     }
     toFile(filename, options) {
-        return this._call('toFile', filename, options);
+        return this._pool.callOnCanvas(this._workerIdx, this._canvasId, 'toFile', [filename, options]);
     }
-    /** Returns a Buffer (Sharp instance cannot be transferred across threads) */
     toSharp(options) {
-        return this._call('toSharp', options);
+        return this._pool.callOnCanvas(this._workerIdx, this._canvasId, 'toSharp', [options]);
     }
     toSharpSync(_options) {
         throw new Error('[canvas] toSharpSync() is not available in worker mode — use toSharp() instead');
     }
     // --- Async convenience getters ---
     get png() {
-        return this._call('toBuffer', 'png');
+        return this.toBuffer('png');
     }
     get webp() {
-        return this._call('toBuffer', 'webp');
+        return this.toBuffer('webp');
     }
     get jpg() {
-        return this._call('toBuffer', 'jpg');
+        return this.toBuffer('jpg');
     }
     get svg() {
-        return this._call('toBuffer', 'svg');
+        return this.toBuffer('svg');
     }
     get pdf() {
-        return this._call('toBuffer', 'pdf');
+        return this.toBuffer('pdf');
     }
     get raw() {
-        return this._call('toBuffer', 'raw');
+        return this.toBuffer('raw');
     }
     /** Release the Canvas from worker memory. Call when done with this object. */
     release() {
         this._pool.releaseCanvas(this._workerIdx, this._canvasId);
-        // Unregister from finalizer since we're explicitly cleaning up
         canvasRegistry.unregister(this);
     }
 }
-/** Worker thread pool — routes render and canvas-call messages */
-class WorkerPool {
-    workers = [];
-    idle = [];
-    queue = [];
-    pending = new Map();
-    nextId = 0;
-    constructor(size) {
-        this.init(size);
-    }
-    init(size) {
-        const workerFile = path.join(path.dirname(fileURLToPath(import.meta.url)), '../worker/render.worker.js');
-        for (let i = 0; i < size; i++) {
-            const workerIdx = i;
-            const worker = new Worker(workerFile);
-            worker.on('message', (msg) => {
-                const task = this.pending.get(msg.taskId);
-                if (!task)
-                    return;
-                this.pending.delete(msg.taskId);
-                if ('error' in msg) {
-                    task.reject(new Error(msg.error));
-                    return;
-                }
-                if ('canvasId' in msg) {
-                    // Render complete — put worker back to idle
-                    this.idle.push(worker);
-                    this.drain();
-                    const result = { buffer: msg.buffer, canvasId: msg.canvasId, workerIdx, width: msg.width, height: msg.height };
-                    task.resolve(result);
-                }
-                else {
-                    // Canvas method call complete
-                    task.resolve(msg.result);
-                }
-            });
-            this.workers.push(worker);
-            this.idle.push(worker);
-        }
-    }
-    drain() {
-        while (this.queue.length > 0 && this.idle.length > 0) {
-            const task = this.queue.shift();
-            const worker = this.idle.pop();
-            const request = { type: 'render', taskId: task.id, props: task.props };
-            worker.postMessage(request);
-        }
-    }
-    render(props) {
-        const sanitizedProps = WorkerPreProcessor.process(props);
-        return new Promise((resolve, reject) => {
-            const id = this.nextId++;
-            this.pending.set(id, { resolve: resolve, reject });
-            if (this.idle.length > 0) {
-                const worker = this.idle.pop();
-                const request = { type: 'render', taskId: id, props: sanitizedProps };
-                worker.postMessage(request);
-            }
-            else {
-                this.queue.push({ id, props: sanitizedProps });
-            }
-        });
-    }
-    callOnCanvas(workerIdx, canvasId, method, args) {
-        return new Promise((resolve, reject) => {
-            const id = this.nextId++;
-            this.pending.set(id, { resolve: resolve, reject });
-            const request = { type: 'call', taskId: id, canvasId, method, args };
-            this.workers[workerIdx].postMessage(request);
-        });
-    }
-    releaseCanvas(workerIdx, canvasId) {
-        const request = { type: 'release', canvasId };
-        this.workers[workerIdx]?.postMessage(request);
-    }
-    terminate() {
-        this.workers.forEach(w => w.terminate());
-    }
-}
 /**
  * Converts a CanvasElement tree into actual BoxNode instances.
  * Used both for non-worker rendering (inline tree building) and inside
@@ -316,12 +222,12 @@ class RootNode extends ColumnNode {
         }
         return imageNodes;
     }
-    /**
-     * Renders the entire node tree to a canvas, handling image loading, layout calculation,
-     * and final drawing
-     * @returns Promise resolving to the rendered Canvas instance
-     */
-    async render() {
+    async render(ctx, offsetX = 0, offsetY = 0) {
+        // If ctx is provided, delegate to parent render (used when called as a child node)
+        if (ctx) {
+            await super.render(ctx, offsetX, offsetY);
+            return;
+        }
         const diskCacheKeys = this.props.useDiskCache ? new Set() : undefined;
         try {
             // Step 1: Load all images with a concurrency limit to avoid overwhelming remote sources.
@@ -355,7 +261,7 @@ class RootNode extends ColumnNode {
             this.ctx = this.canvas.getContext('2d');
             this.ctx.scale(this.scale, this.scale);
             // Step 6: Render content
-            super.render(this.ctx, 0, 0);
+            await super.render(this.ctx, 0, 0);
             if (!this.canvas) {
                 throw new Error('Canvas not initialized');
             }
@@ -373,9 +279,10 @@ async function Root(props) {
     const workerMode = props.workerMode ?? _defaultWorkerMode;
     const workerPoolSize = props.workers ?? _defaultWorkerPoolSize;
     if (workerMode) {
-        // Lazy initialize worker pool
+        // Lazy initialize worker pool — dynamic import to avoid loading Comlink in non-worker contexts
         if (!_workerPool) {
-            _workerPool = new WorkerPool(workerPoolSize);
+            const { ComlinkPool } = await import('../worker/comlink.pool.js');
+            _workerPool = new ComlinkPool(workerPoolSize);
         }
         const result = await _workerPool.render(props);
         return new WorkerCanvas({ ...result, pool: _workerPool });

package/dist/esm/{src/canvas → canvas}/text.canvas.d.ts

@@ -156,7 +156,7 @@ export declare class TextNode extends BoxNode {
      * @param width Content box total width including padding
      * @param height Content box total height including padding
      */
-    protected _renderContent(ctx: CanvasRenderingContext2D, x: number, y: number, width: number, height: number): void;
+    protected _renderContent(ctx: CanvasRenderingContext2D, x: number, y: number, width: number, height: number): Promise<void>;
 }
 /**
  * Creates a new TextNode instance with rich text support

package/dist/esm/canvas/text.canvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.canvas.d.ts","sourceRoot":"","sources":["../../../src/canvas/text.canvas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAe,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACpF,OAAO,EAAU,KAAK,wBAAwB,EAA2B,MAAM,aAAa,CAAA;AAC5F,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAGnD;;;GAGG;AACH,qBAAa,QAAS,SAAQ,OAAO;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoB;IAC7C,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAwC;IACzE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAU;IACxC,OAAO,CAAC,WAAW,CAAe;IAClC,OAAO,CAAC,WAAW,CAAe;IAClC,OAAO,CAAC,kBAAkB,CAAe;IAEjC,KAAK,EAAE,SAAS,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;gBAElC,IAAI,GAAE,MAAM,GAAG,MAAW,EAAE,KAAK,GAAE,SAAc;IAuB7D;;;;;;;;OAQG;WACW,gBAAgB,CAC5B,GAAG,EAAE,wBAAwB,EAC7B,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,GAAE;QACL,UAAU,CAAC,EAAE,MAAM,CAAA;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,UAAU,CAAC,EAAE,SAAS,CAAC,YAAY,CAAC,CAAA;QACpC,SAAS,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,CAAA;QAClC,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,SAAS,CAAC,EAAE,wBAAwB,CAAC,WAAW,CAAC,CAAA;QACjD,YAAY,CAAC,EAAE,wBAAwB,CAAC,cAAc,CAAC,CAAA;KACnD;cAwBW,aAAa,IAAI,IAAI;IAoDxC;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,sBAAsB;IA8B9B;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,aAAa;IA+ErB,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,gBAAgB;IAyBxB;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAM7B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,aAAa;IAiCrB;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAQjC;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,WAAW;IA+NnB;;;;;;;;;OASG;IACH,OAAO,CAAC,YAAY;IA6KpB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IAmErB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAQzB;;;;;;;;;;;;;;;;OAgBG;cACsB,cAAc,CAAC,GAAG,EAAE,wBAAwB,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAkX3H;AAED;;GAEG;AACH,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,GAAG,MAAM,EAAE,QAAQ,SAAS,KAAG,aAI9D,CAAA"}

package/dist/esm/canvas/text.canvas.js

@@ -816,8 +816,8 @@ class TextNode extends BoxNode {
      * @param width Content box total width including padding
      * @param height Content box total height including padding
      */
-    _renderContent(ctx, x, y, width, height) {
-        super._renderContent(ctx, x, y, width, height);
+    async _renderContent(ctx, x, y, width, height) {
+        await super._renderContent(ctx, x, y, width, height);
         ctx.save();
         ctx.textBaseline = 'alphabetic';
         ctx.letterSpacing = this.formatSpacing(this.props.letterSpacing);

package/dist/esm/constant/common.const.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.const.d.ts","sourceRoot":"","sources":["../../../src/constant/common.const.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,KAAK,GAAG,MAAM,aAAa,CAAA;AAExC;;GAEG;AACH,oBAAY,MAAM;IAChB,KAAK,IAAA;IACL,MAAM,IAAA;IACN,MAAM,IAAA;CACP;AAED;;GAEG;AACH,eAAO,MAAM,KAAK,EAAE,OAAO,GAAG,GAAG;IAAE,MAAM,EAAE,OAAO,MAAM,CAAA;CAGvD,CAAA;AAED,cAAc,aAAa,CAAA;AAC3B,eAAe,IAAI,CAAA"}

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA;AAC1C,cAAc,yBAAyB,CAAA;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAC1E,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAA;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAA;AAC9C,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACpE,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAClD,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAA;AAC9C,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAA;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/esm/util/disk.cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disk.cache.d.ts","sourceRoot":"","sources":["../../../src/util/disk.cache.ts"],"names":[],"mappings":"AAaA,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAOvE;AAED,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAO7E;AAED,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAMhE;AAED;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAOpD"}

package/dist/esm/worker/comlink.pool.d.ts

@@ -0,0 +1,30 @@
+import type { RenderResult } from '../worker/worker.types.js';
+import type { RootProps } from '../canvas/canvas.type.js';
+export interface PoolRenderResult extends RenderResult {
+    workerIdx: number;
+}
+/**
+ * Deeply walks an object tree, wraps any function values with Comlink.proxy(),
+ * and tracks wrapped proxies for deterministic cleanup.
+ */
+export declare function wrapFunctions<T>(obj: T, proxies: Set<unknown>): T;
+/**
+ * Pool of Comlink-wrapped worker threads.
+ * Manages idle/queue scheduling and proxy lifecycle.
+ */
+export declare class ComlinkPool {
+    private workers;
+    private endpoints;
+    private idle;
+    private queue;
+    constructor(size: number);
+    private acquire;
+    private release;
+    private drain;
+    private executeRender;
+    render(props: RootProps): Promise<PoolRenderResult>;
+    callOnCanvas(workerIdx: number, canvasId: number, method: string, args: unknown[]): Promise<Buffer | string | void>;
+    releaseCanvas(workerIdx: number, canvasId: number): void;
+    terminate(): void;
+}
+//# sourceMappingURL=comlink.pool.d.ts.map

package/dist/esm/worker/comlink.pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comlink.pool.d.ts","sourceRoot":"","sources":["../../../src/worker/comlink.pool.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAa,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAExD,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD,SAAS,EAAE,MAAM,CAAA;CAClB;AAQD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAuBjE;AAED;;;GAGG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,KAAK,CAAmB;gBAEpB,IAAI,EAAE,MAAM;IAYxB,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,OAAO;IAKf,OAAO,CAAC,KAAK;YAQC,aAAa;IAWrB,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA0CzD,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAInH,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAIxD,SAAS;CAOV"}

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.d.ts

@@ -0,0 +1,4 @@
+import * as Comlink from 'comlink';
+import nodeEndpoint from 'comlink/dist/esm/node-adapter.mjs';
+export { Comlink, nodeEndpoint };
+//# sourceMappingURL=comlink.setup.d.ts.map

package/dist/esm/worker/comlink.setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comlink.setup.d.ts","sourceRoot":"","sources":["../../../src/worker/comlink.setup.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAA;AAKlC,OAAO,YAAY,MAAM,mCAAmC,CAAA;AA2B5D,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,CAAA"}

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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.worker.d.ts","sourceRoot":"","sources":["../../../src/worker/render.worker.ts"],"names":[],"mappings":""}

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/dist/esm/worker/worker.types.d.ts

@@ -0,0 +1,13 @@
+import type { RootProps } from '../canvas/canvas.type.js';
+export interface RenderResult {
+    canvasId: number;
+    buffer: Buffer;
+    width: number;
+    height: number;
+}
+export interface WorkerAPI {
+    render(props: RootProps): Promise<RenderResult>;
+    callOnCanvas(canvasId: number, method: string, args: unknown[]): Promise<Buffer | string | void>;
+    releaseCanvas(canvasId: number): void;
+}
+//# sourceMappingURL=worker.types.d.ts.map

package/dist/esm/worker/worker.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.types.d.ts","sourceRoot":"","sources":["../../../src/worker/worker.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAExD,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;IAC/C,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC,CAAA;IAChG,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CACtC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meonode/canvas",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "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",

package/dist/cjs/src/canvas/canvas.helper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"canvas.helper.d.ts","sourceRoot":"","sources":["../../../../src/canvas/canvas.helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AAC3D,OAAO,KAAK,SAAS,MAAM,aAAa,CAAA;AAExC,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAiF,MAAM,yBAAyB,CAAA;AAEjJ,eAAO,MAAM,WAAW,GAAI,sEAUzB;IACD,GAAG,EAAE,wBAAwB,CAAA;IAC7B,IAAI,EAAE,SAAS,CAAC,IAAI,CAAA;IACpB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE;QACL,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,MAAM,CAAA;QAChB,UAAU,EAAE,MAAM,CAAA;QAClB,WAAW,EAAE,MAAM,CAAA;KACpB,CAAA;IACD,WAAW,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;IACpC,WAAW,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;CACrC,SA8IA,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAC9B,KAAK,wBAAwB,EAC7B,GAAG,MAAM,EACT,GAAG,MAAM,EACT,OAAO,MAAM,EACb,QAAQ,MAAM,EACd,OAAO;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,SAoCtF,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAC5B,YAAY,QAAQ,CAAC,cAAc,CAAC,KACnC;IACD,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;CAYnB,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAQxF;AAED;;;;GAIG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAgF;IAEpH,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS;IAc3C,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAYhC,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAuHrC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IA6C/B,OAAO,CAAC,MAAM,CAAC,aAAa;IAI5B,MAAM,CAAC,oBAAoB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC;CAuB1C"}