Offload functions to worker threads with shared memory primitives for Node.js.
chore: add prettier config and format codebase
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
+311
-108
+7
.prettierrc
+7
.prettierrc
+1
-3
examples/atomics/main.ts
+1
-3
examples/atomics/main.ts
···
9
9
const pool = workerPool(4);
10
10
11
11
// Fire off 100 increments across 4 workers
12
-
await Promise.all(
13
-
Array.from({ length: 100 }, () => pool(increment(counter))),
14
-
);
12
+
await Promise.all(Array.from({ length: 100 }, () => pool(increment(counter))));
15
13
16
14
pool[Symbol.dispose]();
17
15
+1
-4
examples/non-blocking/main.ts
+1
-4
examples/non-blocking/main.ts
···
18
18
19
19
const pool = workerPool(2);
20
20
const start = performance.now();
21
-
const [a, b] = await Promise.all([
22
-
pool(fibonacci(42)),
23
-
pool(fibonacci(41)),
24
-
]);
21
+
const [a, b] = await Promise.all([pool(fibonacci(42)), pool(fibonacci(41))]);
25
22
const elapsed = (performance.now() - start).toFixed(0);
26
23
pool[Symbol.dispose]();
27
24
+3
-1
examples/parallel-batch/heavy-work.ts
+3
-1
examples/parallel-batch/heavy-work.ts
···
3
3
export const heavyWork = mo(import.meta, (item: number): number => {
4
4
// Simulate CPU-bound work (~50ms per item)
5
5
const start = Date.now();
6
-
while (Date.now() - start < 50) { /* busy wait */ }
6
+
while (Date.now() - start < 50) {
7
+
/* busy wait */
8
+
}
7
9
return item * item;
8
10
});
+1
-8
examples/primes/main.ts
+1
-8
examples/primes/main.ts
···
4
4
5
5
import { isPrime } from './is-prime.ts';
6
6
7
-
const candidates = [
8
-
999_999_937,
9
-
1_000_000_007,
10
-
1_000_000_009,
11
-
1_000_000_021,
12
-
1_000_000_033,
13
-
999_999_938,
14
-
];
7
+
const candidates = [999_999_937, 1_000_000_007, 1_000_000_009, 1_000_000_021, 1_000_000_033, 999_999_938];
15
8
16
9
for (const n of candidates) {
17
10
const prime = await isPrime(n);
+49
-8
src/index.ts
+49
-8
src/index.ts
···
5
5
export type { Runner } from './runner.ts';
6
6
export {
7
7
shared,
8
-
int8, uint8, int16, uint16, int32, uint32, int64, uint64, bool,
9
-
int8atomic, uint8atomic, int16atomic, uint16atomic, int32atomic, uint32atomic, int64atomic, uint64atomic, boolatomic,
10
-
mutex, rwlock,
11
-
bytes, string,
8
+
int8,
9
+
uint8,
10
+
int16,
11
+
uint16,
12
+
int32,
13
+
uint32,
14
+
int64,
15
+
uint64,
16
+
bool,
17
+
int8atomic,
18
+
uint8atomic,
19
+
int16atomic,
20
+
uint16atomic,
21
+
int32atomic,
22
+
uint32atomic,
23
+
int64atomic,
24
+
uint64atomic,
25
+
boolatomic,
26
+
mutex,
27
+
rwlock,
28
+
bytes,
29
+
string,
12
30
} from './shared/index.ts';
13
31
export type { Loadable, Descriptor } from './shared/index.ts';
14
32
export type {
15
-
Int8, Uint8, Int16, Uint16, Int32, Uint32, Int64, Uint64, Bool,
16
-
AtomicInt8, AtomicUint8, AtomicInt16, AtomicUint16, AtomicInt32, AtomicUint32, AtomicInt64, AtomicUint64, AtomicBool,
17
-
Mutex, MutexGuard, RwLock, ReadGuard, WriteGuard,
18
-
SharedStruct, Bytes, SharedString, Tuple,
33
+
Int8,
34
+
Uint8,
35
+
Int16,
36
+
Uint16,
37
+
Int32,
38
+
Uint32,
39
+
Int64,
40
+
Uint64,
41
+
Bool,
42
+
AtomicInt8,
43
+
AtomicUint8,
44
+
AtomicInt16,
45
+
AtomicUint16,
46
+
AtomicInt32,
47
+
AtomicUint32,
48
+
AtomicInt64,
49
+
AtomicUint64,
50
+
AtomicBool,
51
+
Mutex,
52
+
MutexGuard,
53
+
RwLock,
54
+
ReadGuard,
55
+
WriteGuard,
56
+
SharedStruct,
57
+
Bytes,
58
+
SharedString,
59
+
Tuple,
19
60
} from './shared/index.ts';
+2
-5
src/mo.ts
+2
-5
src/mo.ts
···
3
3
4
4
const counters = new Map<string, number>();
5
5
6
-
export function mo<A extends unknown[], R>(
7
-
importMeta: ImportMeta,
8
-
fn: (...args: A) => R,
9
-
): (...args: A) => Task<R> {
6
+
export function mo<A extends unknown[], R>(importMeta: ImportMeta, fn: (...args: A) => R): (...args: A) => Task<R> {
10
7
const url = importMeta.url;
11
8
12
9
if (isModuleFrozen(url)) {
13
10
throw new Error(
14
11
`Cannot call mo() for ${url} after a task from this module has been dispatched. ` +
15
-
'All mo() calls must happen at module load time.',
12
+
'All mo() calls must happen at module load time.',
16
13
);
17
14
}
18
15
+6
-9
test/fixtures/sync.ts
+6
-9
test/fixtures/sync.ts
···
17
17
},
18
18
);
19
19
20
-
export const rwlockRead = mo(
21
-
import.meta,
22
-
async (rwlock: RwLock, counter: AtomicInt32): Promise<number> => {
23
-
const guard = await rwlock.readLock();
24
-
const val = counter.load();
25
-
rwlock.readUnlock();
26
-
return val;
27
-
},
28
-
);
20
+
export const rwlockRead = mo(import.meta, async (rwlock: RwLock, counter: AtomicInt32): Promise<number> => {
21
+
const guard = await rwlock.readLock();
22
+
const val = counter.load();
23
+
rwlock.readUnlock();
24
+
return val;
25
+
});
+1
-6
test/pool.test.ts
+1
-6
test/pool.test.ts
···
17
17
it('handles concurrent calls across pool workers', async () => {
18
18
const run = workerPool(2);
19
19
try {
20
-
const results = await Promise.all([
21
-
run(double(1)),
22
-
run(double(2)),
23
-
run(double(3)),
24
-
run(double(4)),
25
-
]);
20
+
const results = await Promise.all([run(double(1)), run(double(2)), run(double(3)), run(double(4))]);
26
21
assert.deepEqual(results, [2, 4, 6, 8]);
27
22
} finally {
28
23
run[Symbol.dispose]();
+8
-2
test/transfer.test.ts
+8
-2
test/transfer.test.ts
···
7
7
it('transfers an ArrayBuffer to a worker (zero-copy)', async () => {
8
8
const buf = new ArrayBuffer(4);
9
9
const view = new Uint8Array(buf);
10
-
view[0] = 1; view[1] = 2; view[2] = 3; view[3] = 4;
10
+
view[0] = 1;
11
+
view[1] = 2;
12
+
view[2] = 3;
13
+
view[3] = 4;
11
14
12
15
const pool = workerPool(1);
13
16
try {
···
50
53
it('without transfer, buffer is copied (not detached)', async () => {
51
54
const buf = new ArrayBuffer(4);
52
55
const view = new Uint8Array(buf);
53
-
view[0] = 1; view[1] = 2; view[2] = 3; view[3] = 4;
56
+
view[0] = 1;
57
+
view[1] = 2;
58
+
view[2] = 3;
59
+
view[3] = 4;
54
60
55
61
const pool = workerPool(1);
56
62
try {