+9

src/shared/reconstruct.ts

reviewed

··· 1 1 import { SharedStruct } from './shared-struct.ts'; 2 2 import { Bytes } from './bytes.ts'; 3 3 import { SharedString } from './string.ts'; 4 4 + import { Tuple } from './tuple.ts'; 4 5 5 6 const SHARED = Symbol.for('moroutine.shared'); 6 7 ··· 19 20 serializedFields[key] = serializeStructField(data.fields[key]); 20 21 } 21 22 return { __shared__: 'SharedStruct', fields: serializedFields }; 23 23 + } 24 24 + if (data.tag === 'Tuple') { 25 25 + const serializedElements = (data.elements as any[]).map((el: any) => serializeStructField(el)); 26 26 + return { __shared__: 'Tuple', elements: serializedElements }; 22 27 } 23 28 return { __shared__: data.tag, buffer: data.buffer, byteOffset: data.byteOffset, ...(data.size !== undefined && { size: data.size }), ...(data.maxBytes !== undefined && { maxBytes: data.maxBytes }) }; 24 29 } ··· 54 59 reconstructed[key] = deserializeArg(fields[key]); 55 60 } 56 61 return new SharedStruct(reconstructed as any); 62 62 + } 63 63 + if (data.__shared__ === 'Tuple') { 64 64 + const elements = (data.elements as unknown[]).map((el) => deserializeArg(el)); 65 65 + return new Tuple(elements as any); 57 66 } 58 67 const typedData = data as { __shared__: string; buffer: SharedArrayBuffer; byteOffset: number }; 59 68 const ctor = registry.get(typedData.__shared__);

+9

test/fixtures/shared-new.ts

reviewed

··· 1 1 + import { mo } from 'moroutine'; 2 2 + 3 3 + export const readValue = mo(import.meta, (s: any): unknown => { 4 4 + return s.load(); 5 5 + }); 6 6 + 7 7 + export const writeValue = mo(import.meta, (s: any, values: any): void => { 8 8 + s.store(values); 9 9 + });

+83

test/shared/cross-worker-new.test.ts

reviewed

··· 1 1 + import { describe, it } from 'node:test'; 2 2 + import assert from 'node:assert/strict'; 3 3 + import { workerPool, shared, int32, string, bool, bytes } from 'moroutine'; 4 4 + import { readValue, writeValue } from '../fixtures/shared-new.ts'; 5 5 + 6 6 + describe('new types across workers', () => { 7 7 + it('struct via shared() works across workers', async () => { 8 8 + const point = shared({ x: int32, y: int32 }); 9 9 + point.store({ x: 1, y: 2 }); 10 10 + 11 11 + const pool = workerPool(1); 12 12 + try { 13 13 + const result = await pool(readValue(point)); 14 14 + assert.deepEqual(result, { x: 1, y: 2 }); 15 15 + } finally { 16 16 + pool[Symbol.dispose](); 17 17 + } 18 18 + }); 19 19 + 20 20 + it('worker can write to struct via shared()', async () => { 21 21 + const point = shared({ x: int32, y: int32 }); 22 22 + 23 23 + const pool = workerPool(1); 24 24 + try { 25 25 + await pool(writeValue(point, { x: 10, y: 20 })); 26 26 + assert.deepEqual(point.load(), { x: 10, y: 20 }); 27 27 + } finally { 28 28 + pool[Symbol.dispose](); 29 29 + } 30 30 + }); 31 31 + 32 32 + it('tuple via shared() works across workers', async () => { 33 33 + const t = shared([int32, int32]); 34 34 + t.store([1, 2]); 35 35 + 36 36 + const pool = workerPool(1); 37 37 + try { 38 38 + const result = await pool(readValue(t)); 39 39 + assert.deepEqual(result, [1, 2]); 40 40 + } finally { 41 41 + pool[Symbol.dispose](); 42 42 + } 43 43 + }); 44 44 + 45 45 + it('string via shared() works across workers', async () => { 46 46 + const s = shared(string(32)); 47 47 + s.store('hello'); 48 48 + 49 49 + const pool = workerPool(1); 50 50 + try { 51 51 + const result = await pool(readValue(s)); 52 52 + assert.equal(result, 'hello'); 53 53 + } finally { 54 54 + pool[Symbol.dispose](); 55 55 + } 56 56 + }); 57 57 + 58 58 + it('bytes via shared() works across workers', async () => { 59 59 + const b = shared(bytes(4)); 60 60 + b.store(new Uint8Array([1, 2, 3, 4])); 61 61 + 62 62 + const pool = workerPool(1); 63 63 + try { 64 64 + const result = await pool(readValue(b)) as Uint8Array; 65 65 + assert.deepEqual([...result], [1, 2, 3, 4]); 66 66 + } finally { 67 67 + pool[Symbol.dispose](); 68 68 + } 69 69 + }); 70 70 + 71 71 + it('nested struct with string across workers', async () => { 72 72 + const entity = shared({ name: string(16), hp: int32 }); 73 73 + entity.store({ name: 'goblin', hp: 50 }); 74 74 + 75 75 + const pool = workerPool(1); 76 76 + try { 77 77 + const result = await pool(readValue(entity)); 78 78 + assert.deepEqual(result, { name: 'goblin', hp: 50 }); 79 79 + } finally { 80 80 + pool[Symbol.dispose](); 81 81 + } 82 82 + }); 83 83 + });