sabcom 0.0.1

package/build/index.cjs

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get HEADER_SIZE () {
+        return HEADER_SIZE;
+    },
+    get HEADER_VALUES () {
+        return HEADER_VALUES;
+    },
+    get Handshake () {
+        return Handshake;
+    },
+    get Header () {
+        return Header;
+    },
+    get SEMAPHORE () {
+        return SEMAPHORE;
+    },
+    get Semaphore () {
+        return Semaphore;
+    },
+    get read () {
+        return read;
+    },
+    get write () {
+        return write;
+    }
+});
+const _nodev8 = require("node:v8");
+const SEMAPHORE = 0;
+var Semaphore = /*#__PURE__*/ function(Semaphore) {
+    Semaphore[Semaphore["READY"] = 0] = "READY";
+    Semaphore[Semaphore["HANDSHAKE"] = 1] = "HANDSHAKE";
+    Semaphore[Semaphore["PAYLOAD"] = 2] = "PAYLOAD";
+    return Semaphore;
+}({});
+var Handshake = /*#__PURE__*/ function(Handshake) {
+    Handshake[Handshake["TOTAL_SIZE"] = 1] = "TOTAL_SIZE";
+    Handshake[Handshake["TOTAL_CHUNKS"] = 2] = "TOTAL_CHUNKS";
+    return Handshake;
+}({});
+var Header = /*#__PURE__*/ function(Header) {
+    Header[Header["CHUNK_INDEX"] = 1] = "CHUNK_INDEX";
+    Header[Header["CHUNK_OFFSET"] = 2] = "CHUNK_OFFSET";
+    Header[Header["CHUNK_SIZE"] = 3] = "CHUNK_SIZE";
+    return Header;
+}({});
+const HEADER_VALUES = 1 + Math.max(Object.values(Handshake).length, Object.values(Header).length) / 2;
+const HEADER_SIZE = Uint32Array.BYTES_PER_ELEMENT * HEADER_VALUES;
+const write = (data, buffer, timeout = 5000)=>{
+    const serialized = (0, _nodev8.serialize)(data);
+    const chunkSize = buffer.byteLength - HEADER_SIZE;
+    const totalSize = serialized.length;
+    const totalChunks = Math.ceil(totalSize / chunkSize);
+    const header = new Int32Array(buffer);
+    header[1] = totalSize;
+    header[2] = totalChunks;
+    Atomics.store(header, SEMAPHORE, 1);
+    Atomics.notify(header, SEMAPHORE);
+    try {
+        if (Atomics.wait(header, SEMAPHORE, 1, timeout) === "timed-out") {
+            throw new Error("Reader handshake timeout");
+        }
+        const payload = new Uint8Array(buffer, HEADER_SIZE);
+        for(let i = 0; i < totalChunks; i++){
+            const start = i * chunkSize;
+            const end = Math.min(start + chunkSize, totalSize);
+            const size = end - start;
+            payload.set(serialized.subarray(start, end), 0);
+            header[1] = i;
+            header[2] = start;
+            header[3] = size;
+            Atomics.store(header, SEMAPHORE, 2);
+            Atomics.notify(header, SEMAPHORE);
+            if (Atomics.wait(header, SEMAPHORE, 2, timeout) === "timed-out") {
+                throw new Error(`Reader timeout on chunk ${i}/${totalChunks - 1}`);
+            }
+        }
+    } finally{
+        Atomics.store(header, SEMAPHORE, 0);
+    }
+};
+const read = (buffer, timeout = 5000)=>{
+    const header = new Int32Array(buffer);
+    if (Atomics.wait(header, SEMAPHORE, 0, timeout) === "timed-out") {
+        throw new Error("Handshake timeout");
+    }
+    if (header[SEMAPHORE] !== 1) {
+        throw new Error("Invalid handshake state");
+    }
+    const totalSize = header[1];
+    const totalChunks = header[2];
+    const data = new Uint8Array(totalSize);
+    Atomics.store(header, SEMAPHORE, 0);
+    Atomics.notify(header, SEMAPHORE);
+    const payload = new Uint8Array(buffer, HEADER_SIZE);
+    for(let i = 0; i < totalChunks; i++){
+        if (Atomics.wait(header, SEMAPHORE, 0, timeout) === "timed-out") {
+            throw new Error(`Writer timeout waiting for chunk ${i}`);
+        }
+        if (header[SEMAPHORE] !== 2) {
+            throw new Error(`Expected payload header, received ${Semaphore[header[SEMAPHORE]]}`);
+        }
+        const chunkIndex = header[1];
+        if (i !== chunkIndex) {
+            throw new Error(`Reader integrity failure for chunk ${chunkIndex} expected ${i}`);
+        }
+        const offset = header[2];
+        const size = header[3];
+        data.set(payload.subarray(0, size), offset);
+        Atomics.store(header, SEMAPHORE, 0);
+        Atomics.notify(header, SEMAPHORE);
+    }
+    return (0, _nodev8.deserialize)(data);
+};
+
+//# sourceMappingURL=index.cjs.map

package/build/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { serialize, deserialize } from \"node:v8\";\n\nexport const SEMAPHORE = 0;\n\nexport enum Semaphore {\n  READY,\n  HANDSHAKE,\n  PAYLOAD,\n}\n\nexport enum Handshake {\n  TOTAL_SIZE = 1,\n  TOTAL_CHUNKS,\n}\n\nexport enum Header {\n  CHUNK_INDEX = 1,\n  CHUNK_OFFSET,\n  CHUNK_SIZE,\n}\n\nexport const HEADER_VALUES =\n  1 +\n  Math.max(Object.values(Handshake).length, Object.values(Header).length) / 2;\nexport const HEADER_SIZE = Uint32Array.BYTES_PER_ELEMENT * HEADER_VALUES;\n\nexport const write = (\n  data: unknown,\n  buffer: SharedArrayBuffer,\n  timeout = 5000,\n) => {\n  const serialized = serialize(data);\n  const chunkSize = buffer.byteLength - HEADER_SIZE;\n  const totalSize = serialized.length;\n  const totalChunks = Math.ceil(totalSize / chunkSize);\n\n  const header = new Int32Array(buffer);\n  header[Handshake.TOTAL_SIZE] = totalSize;\n  header[Handshake.TOTAL_CHUNKS] = totalChunks;\n\n  Atomics.store(header, SEMAPHORE, Semaphore.HANDSHAKE);\n  Atomics.notify(header, SEMAPHORE);\n\n  try {\n    if (\n      Atomics.wait(header, SEMAPHORE, Semaphore.HANDSHAKE, timeout) ===\n      \"timed-out\"\n    ) {\n      throw new Error(\"Reader handshake timeout\");\n    }\n\n    const payload = new Uint8Array(buffer, HEADER_SIZE);\n\n    for (let i = 0; i < totalChunks; i++) {\n      const start = i * chunkSize;\n      const end = Math.min(start + chunkSize, totalSize);\n      const size = end - start;\n\n      payload.set(serialized.subarray(start, end), 0);\n\n      header[Header.CHUNK_INDEX] = i;\n      header[Header.CHUNK_OFFSET] = start;\n      header[Header.CHUNK_SIZE] = size;\n\n      Atomics.store(header, SEMAPHORE, Semaphore.PAYLOAD);\n      Atomics.notify(header, SEMAPHORE);\n\n      if (\n        Atomics.wait(header, SEMAPHORE, Semaphore.PAYLOAD, timeout) ===\n        \"timed-out\"\n      ) {\n        throw new Error(`Reader timeout on chunk ${i}/${totalChunks - 1}`);\n      }\n    }\n  } finally {\n    Atomics.store(header, SEMAPHORE, Semaphore.READY);\n  }\n};\n\nexport const read = (buffer: SharedArrayBuffer, timeout = 5000): unknown => {\n  const header = new Int32Array(buffer);\n  if (\n    Atomics.wait(header, SEMAPHORE, Semaphore.READY, timeout) === \"timed-out\"\n  ) {\n    throw new Error(\"Handshake timeout\");\n  }\n  if (header[SEMAPHORE] !== Semaphore.HANDSHAKE) {\n    throw new Error(\"Invalid handshake state\");\n  }\n\n  const totalSize = header[Handshake.TOTAL_SIZE];\n  const totalChunks = header[Handshake.TOTAL_CHUNKS];\n  const data = new Uint8Array(totalSize);\n\n  Atomics.store(header, SEMAPHORE, Semaphore.READY);\n  Atomics.notify(header, SEMAPHORE);\n\n  const payload = new Uint8Array(buffer, HEADER_SIZE);\n  for (let i = 0; i < totalChunks; i++) {\n    if (\n      Atomics.wait(header, SEMAPHORE, Semaphore.READY, timeout) === \"timed-out\"\n    ) {\n      throw new Error(`Writer timeout waiting for chunk ${i}`);\n    }\n    // @ts-expect-error does not infer number\n    if (header[SEMAPHORE] !== Semaphore.PAYLOAD) {\n      throw new Error(\n        `Expected payload header, received ${Semaphore[header[SEMAPHORE]]}`,\n      );\n    }\n    const chunkIndex = header[Header.CHUNK_INDEX];\n    if (i !== chunkIndex) {\n      throw new Error(\n        `Reader integrity failure for chunk ${chunkIndex} expected ${i}`,\n      );\n    }\n    const offset = header[Header.CHUNK_OFFSET];\n    const size = header[Header.CHUNK_SIZE];\n    data.set(payload.subarray(0, size), offset);\n    Atomics.store(header, SEMAPHORE, Semaphore.READY);\n    Atomics.notify(header, SEMAPHORE);\n  }\n  return deserialize(data);\n};\n"],"names":["HEADER_SIZE","HEADER_VALUES","Handshake","Header","SEMAPHORE","Semaphore","read","write","Math","max","Object","values","length","Uint32Array","BYTES_PER_ELEMENT","data","buffer","timeout","serialized","serialize","chunkSize","byteLength","totalSize","totalChunks","ceil","header","Int32Array","Atomics","store","notify","wait","Error","payload","Uint8Array","i","start","end","min","size","set","subarray","chunkIndex","offset","deserialize"],"mappings":"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"}

package/build/index.d.ts

@@ -0,0 +1,19 @@
+export declare const SEMAPHORE = 0;
+export declare enum Semaphore {
+    READY = 0,
+    HANDSHAKE = 1,
+    PAYLOAD = 2
+}
+export declare enum Handshake {
+    TOTAL_SIZE = 1,
+    TOTAL_CHUNKS = 2
+}
+export declare enum Header {
+    CHUNK_INDEX = 1,
+    CHUNK_OFFSET = 2,
+    CHUNK_SIZE = 3
+}
+export declare const HEADER_VALUES: number;
+export declare const HEADER_SIZE: number;
+export declare const write: (data: unknown, buffer: SharedArrayBuffer, timeout?: number) => void;
+export declare const read: (buffer: SharedArrayBuffer, timeout?: number) => unknown;

package/build/index.js

@@ -0,0 +1,89 @@
+import { serialize, deserialize } from "node:v8";
+export const SEMAPHORE = 0;
+export var Semaphore = /*#__PURE__*/ function(Semaphore) {
+    Semaphore[Semaphore["READY"] = 0] = "READY";
+    Semaphore[Semaphore["HANDSHAKE"] = 1] = "HANDSHAKE";
+    Semaphore[Semaphore["PAYLOAD"] = 2] = "PAYLOAD";
+    return Semaphore;
+}({});
+export var Handshake = /*#__PURE__*/ function(Handshake) {
+    Handshake[Handshake["TOTAL_SIZE"] = 1] = "TOTAL_SIZE";
+    Handshake[Handshake["TOTAL_CHUNKS"] = 2] = "TOTAL_CHUNKS";
+    return Handshake;
+}({});
+export var Header = /*#__PURE__*/ function(Header) {
+    Header[Header["CHUNK_INDEX"] = 1] = "CHUNK_INDEX";
+    Header[Header["CHUNK_OFFSET"] = 2] = "CHUNK_OFFSET";
+    Header[Header["CHUNK_SIZE"] = 3] = "CHUNK_SIZE";
+    return Header;
+}({});
+export const HEADER_VALUES = 1 + Math.max(Object.values(Handshake).length, Object.values(Header).length) / 2;
+export const HEADER_SIZE = Uint32Array.BYTES_PER_ELEMENT * HEADER_VALUES;
+export const write = (data, buffer, timeout = 5000)=>{
+    const serialized = serialize(data);
+    const chunkSize = buffer.byteLength - HEADER_SIZE;
+    const totalSize = serialized.length;
+    const totalChunks = Math.ceil(totalSize / chunkSize);
+    const header = new Int32Array(buffer);
+    header[1] = totalSize;
+    header[2] = totalChunks;
+    Atomics.store(header, SEMAPHORE, 1);
+    Atomics.notify(header, SEMAPHORE);
+    try {
+        if (Atomics.wait(header, SEMAPHORE, 1, timeout) === "timed-out") {
+            throw new Error("Reader handshake timeout");
+        }
+        const payload = new Uint8Array(buffer, HEADER_SIZE);
+        for(let i = 0; i < totalChunks; i++){
+            const start = i * chunkSize;
+            const end = Math.min(start + chunkSize, totalSize);
+            const size = end - start;
+            payload.set(serialized.subarray(start, end), 0);
+            header[1] = i;
+            header[2] = start;
+            header[3] = size;
+            Atomics.store(header, SEMAPHORE, 2);
+            Atomics.notify(header, SEMAPHORE);
+            if (Atomics.wait(header, SEMAPHORE, 2, timeout) === "timed-out") {
+                throw new Error(`Reader timeout on chunk ${i}/${totalChunks - 1}`);
+            }
+        }
+    } finally{
+        Atomics.store(header, SEMAPHORE, 0);
+    }
+};
+export const read = (buffer, timeout = 5000)=>{
+    const header = new Int32Array(buffer);
+    if (Atomics.wait(header, SEMAPHORE, 0, timeout) === "timed-out") {
+        throw new Error("Handshake timeout");
+    }
+    if (header[SEMAPHORE] !== 1) {
+        throw new Error("Invalid handshake state");
+    }
+    const totalSize = header[1];
+    const totalChunks = header[2];
+    const data = new Uint8Array(totalSize);
+    Atomics.store(header, SEMAPHORE, 0);
+    Atomics.notify(header, SEMAPHORE);
+    const payload = new Uint8Array(buffer, HEADER_SIZE);
+    for(let i = 0; i < totalChunks; i++){
+        if (Atomics.wait(header, SEMAPHORE, 0, timeout) === "timed-out") {
+            throw new Error(`Writer timeout waiting for chunk ${i}`);
+        }
+        if (header[SEMAPHORE] !== 2) {
+            throw new Error(`Expected payload header, received ${Semaphore[header[SEMAPHORE]]}`);
+        }
+        const chunkIndex = header[1];
+        if (i !== chunkIndex) {
+            throw new Error(`Reader integrity failure for chunk ${chunkIndex} expected ${i}`);
+        }
+        const offset = header[2];
+        const size = header[3];
+        data.set(payload.subarray(0, size), offset);
+        Atomics.store(header, SEMAPHORE, 0);
+        Atomics.notify(header, SEMAPHORE);
+    }
+    return deserialize(data);
+};
+
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { serialize, deserialize } from \"node:v8\";\n\nexport const SEMAPHORE = 0;\n\nexport enum Semaphore {\n  READY,\n  HANDSHAKE,\n  PAYLOAD,\n}\n\nexport enum Handshake {\n  TOTAL_SIZE = 1,\n  TOTAL_CHUNKS,\n}\n\nexport enum Header {\n  CHUNK_INDEX = 1,\n  CHUNK_OFFSET,\n  CHUNK_SIZE,\n}\n\nexport const HEADER_VALUES =\n  1 +\n  Math.max(Object.values(Handshake).length, Object.values(Header).length) / 2;\nexport const HEADER_SIZE = Uint32Array.BYTES_PER_ELEMENT * HEADER_VALUES;\n\nexport const write = (\n  data: unknown,\n  buffer: SharedArrayBuffer,\n  timeout = 5000,\n) => {\n  const serialized = serialize(data);\n  const chunkSize = buffer.byteLength - HEADER_SIZE;\n  const totalSize = serialized.length;\n  const totalChunks = Math.ceil(totalSize / chunkSize);\n\n  const header = new Int32Array(buffer);\n  header[Handshake.TOTAL_SIZE] = totalSize;\n  header[Handshake.TOTAL_CHUNKS] = totalChunks;\n\n  Atomics.store(header, SEMAPHORE, Semaphore.HANDSHAKE);\n  Atomics.notify(header, SEMAPHORE);\n\n  try {\n    if (\n      Atomics.wait(header, SEMAPHORE, Semaphore.HANDSHAKE, timeout) ===\n      \"timed-out\"\n    ) {\n      throw new Error(\"Reader handshake timeout\");\n    }\n\n    const payload = new Uint8Array(buffer, HEADER_SIZE);\n\n    for (let i = 0; i < totalChunks; i++) {\n      const start = i * chunkSize;\n      const end = Math.min(start + chunkSize, totalSize);\n      const size = end - start;\n\n      payload.set(serialized.subarray(start, end), 0);\n\n      header[Header.CHUNK_INDEX] = i;\n      header[Header.CHUNK_OFFSET] = start;\n      header[Header.CHUNK_SIZE] = size;\n\n      Atomics.store(header, SEMAPHORE, Semaphore.PAYLOAD);\n      Atomics.notify(header, SEMAPHORE);\n\n      if (\n        Atomics.wait(header, SEMAPHORE, Semaphore.PAYLOAD, timeout) ===\n        \"timed-out\"\n      ) {\n        throw new Error(`Reader timeout on chunk ${i}/${totalChunks - 1}`);\n      }\n    }\n  } finally {\n    Atomics.store(header, SEMAPHORE, Semaphore.READY);\n  }\n};\n\nexport const read = (buffer: SharedArrayBuffer, timeout = 5000): unknown => {\n  const header = new Int32Array(buffer);\n  if (\n    Atomics.wait(header, SEMAPHORE, Semaphore.READY, timeout) === \"timed-out\"\n  ) {\n    throw new Error(\"Handshake timeout\");\n  }\n  if (header[SEMAPHORE] !== Semaphore.HANDSHAKE) {\n    throw new Error(\"Invalid handshake state\");\n  }\n\n  const totalSize = header[Handshake.TOTAL_SIZE];\n  const totalChunks = header[Handshake.TOTAL_CHUNKS];\n  const data = new Uint8Array(totalSize);\n\n  Atomics.store(header, SEMAPHORE, Semaphore.READY);\n  Atomics.notify(header, SEMAPHORE);\n\n  const payload = new Uint8Array(buffer, HEADER_SIZE);\n  for (let i = 0; i < totalChunks; i++) {\n    if (\n      Atomics.wait(header, SEMAPHORE, Semaphore.READY, timeout) === \"timed-out\"\n    ) {\n      throw new Error(`Writer timeout waiting for chunk ${i}`);\n    }\n    // @ts-expect-error does not infer number\n    if (header[SEMAPHORE] !== Semaphore.PAYLOAD) {\n      throw new Error(\n        `Expected payload header, received ${Semaphore[header[SEMAPHORE]]}`,\n      );\n    }\n    const chunkIndex = header[Header.CHUNK_INDEX];\n    if (i !== chunkIndex) {\n      throw new Error(\n        `Reader integrity failure for chunk ${chunkIndex} expected ${i}`,\n      );\n    }\n    const offset = header[Header.CHUNK_OFFSET];\n    const size = header[Header.CHUNK_SIZE];\n    data.set(payload.subarray(0, size), offset);\n    Atomics.store(header, SEMAPHORE, Semaphore.READY);\n    Atomics.notify(header, SEMAPHORE);\n  }\n  return deserialize(data);\n};\n"],"names":["serialize","deserialize","SEMAPHORE","Semaphore","Handshake","Header","HEADER_VALUES","Math","max","Object","values","length","HEADER_SIZE","Uint32Array","BYTES_PER_ELEMENT","write","data","buffer","timeout","serialized","chunkSize","byteLength","totalSize","totalChunks","ceil","header","Int32Array","Atomics","store","notify","wait","Error","payload","Uint8Array","i","start","end","min","size","set","subarray","read","chunkIndex","offset"],"mappings":"AAAA,SAASA,SAAS,EAAEC,WAAW,QAAQ,UAAU;AAEjD,OAAO,MAAMC,YAAY,EAAE;AAE3B,OAAO,IAAA,AAAKC,mCAAAA;;;;WAAAA;MAIX;AAED,OAAO,IAAA,AAAKC,mCAAAA;;;WAAAA;MAGX;AAED,OAAO,IAAA,AAAKC,gCAAAA;;;;WAAAA;MAIX;AAED,OAAO,MAAMC,gBACX,IACAC,KAAKC,GAAG,CAACC,OAAOC,MAAM,CAACN,WAAWO,MAAM,EAAEF,OAAOC,MAAM,CAACL,QAAQM,MAAM,IAAI,EAAE;AAC9E,OAAO,MAAMC,cAAcC,YAAYC,iBAAiB,GAAGR,cAAc;AAEzE,OAAO,MAAMS,QAAQ,CACnBC,MACAC,QACAC,UAAU,IAAI;IAEd,MAAMC,aAAanB,UAAUgB;IAC7B,MAAMI,YAAYH,OAAOI,UAAU,GAAGT;IACtC,MAAMU,YAAYH,WAAWR,MAAM;IACnC,MAAMY,cAAchB,KAAKiB,IAAI,CAACF,YAAYF;IAE1C,MAAMK,SAAS,IAAIC,WAAWT;IAC9BQ,MAAM,GAAsB,GAAGH;IAC/BG,MAAM,GAAwB,GAAGF;IAEjCI,QAAQC,KAAK,CAACH,QAAQvB;IACtByB,QAAQE,MAAM,CAACJ,QAAQvB;IAEvB,IAAI;QACF,IACEyB,QAAQG,IAAI,CAACL,QAAQvB,cAAgCgB,aACrD,aACA;YACA,MAAM,IAAIa,MAAM;QAClB;QAEA,MAAMC,UAAU,IAAIC,WAAWhB,QAAQL;QAEvC,IAAK,IAAIsB,IAAI,GAAGA,IAAIX,aAAaW,IAAK;YACpC,MAAMC,QAAQD,IAAId;YAClB,MAAMgB,MAAM7B,KAAK8B,GAAG,CAACF,QAAQf,WAAWE;YACxC,MAAMgB,OAAOF,MAAMD;YAEnBH,QAAQO,GAAG,CAACpB,WAAWqB,QAAQ,CAACL,OAAOC,MAAM;YAE7CX,MAAM,GAAoB,GAAGS;YAC7BT,MAAM,GAAqB,GAAGU;YAC9BV,MAAM,GAAmB,GAAGa;YAE5BX,QAAQC,KAAK,CAACH,QAAQvB;YACtByB,QAAQE,MAAM,CAACJ,QAAQvB;YAEvB,IACEyB,QAAQG,IAAI,CAACL,QAAQvB,cAA8BgB,aACnD,aACA;gBACA,MAAM,IAAIa,MAAM,CAAC,wBAAwB,EAAEG,EAAE,CAAC,EAAEX,cAAc,GAAG;YACnE;QACF;IACF,SAAU;QACRI,QAAQC,KAAK,CAACH,QAAQvB;IACxB;AACF,EAAE;AAEF,OAAO,MAAMuC,OAAO,CAACxB,QAA2BC,UAAU,IAAI;IAC5D,MAAMO,SAAS,IAAIC,WAAWT;IAC9B,IACEU,QAAQG,IAAI,CAACL,QAAQvB,cAA4BgB,aAAa,aAC9D;QACA,MAAM,IAAIa,MAAM;IAClB;IACA,IAAIN,MAAM,CAACvB,UAAU,QAA0B;QAC7C,MAAM,IAAI6B,MAAM;IAClB;IAEA,MAAMT,YAAYG,MAAM,GAAsB;IAC9C,MAAMF,cAAcE,MAAM,GAAwB;IAClD,MAAMT,OAAO,IAAIiB,WAAWX;IAE5BK,QAAQC,KAAK,CAACH,QAAQvB;IACtByB,QAAQE,MAAM,CAACJ,QAAQvB;IAEvB,MAAM8B,UAAU,IAAIC,WAAWhB,QAAQL;IACvC,IAAK,IAAIsB,IAAI,GAAGA,IAAIX,aAAaW,IAAK;QACpC,IACEP,QAAQG,IAAI,CAACL,QAAQvB,cAA4BgB,aAAa,aAC9D;YACA,MAAM,IAAIa,MAAM,CAAC,iCAAiC,EAAEG,GAAG;QACzD;QAEA,IAAIT,MAAM,CAACvB,UAAU,QAAwB;YAC3C,MAAM,IAAI6B,MACR,CAAC,kCAAkC,EAAE5B,SAAS,CAACsB,MAAM,CAACvB,UAAU,CAAC,EAAE;QAEvE;QACA,MAAMwC,aAAajB,MAAM,GAAoB;QAC7C,IAAIS,MAAMQ,YAAY;YACpB,MAAM,IAAIX,MACR,CAAC,mCAAmC,EAAEW,WAAW,UAAU,EAAER,GAAG;QAEpE;QACA,MAAMS,SAASlB,MAAM,GAAqB;QAC1C,MAAMa,OAAOb,MAAM,GAAmB;QACtCT,KAAKuB,GAAG,CAACP,QAAQQ,QAAQ,CAAC,GAAGF,OAAOK;QACpChB,QAAQC,KAAK,CAACH,QAAQvB;QACtByB,QAAQE,MAAM,CAACJ,QAAQvB;IACzB;IACA,OAAOD,YAAYe;AACrB,EAAE"}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "sabcom",
+  "version": "0.0.1",
+  "description": "",
+  "type": "module",
+  "types": "build/index.d.ts",
+  "main": "build/index.cjs",
+  "module": "build/index.js",
+  "exports": {
+    "require": "./build/index.cjs",
+    "import": "./build/index.js"
+  },
+  "files": [
+    "build",
+    "src/index.ts"
+  ],
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Ivan Zakharchanka",
+    "email": "3axap4eHko@gmail.com",
+    "url": "https://linkedin.com/in/3axap4eHko"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.29.0",
+    "@swc/jest": "^0.2.38",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^24.0.1",
+    "@typescript-eslint/eslint-plugin": "^8.34.0",
+    "@typescript-eslint/parser": "^8.34.0",
+    "eslint": "^9.29.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-prettier": "^5.4.1",
+    "husky": "^9.1.7",
+    "inop": "^0.7.8",
+    "jest": "^30.0.0",
+    "prettier": "^3.5.3",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.34.0"
+  },
+  "scripts": {
+    "build": "rm -rf build && inop src build -i __tests__ -i *.tmp.ts && tsc --declaration --emitDeclarationOnly",
+    "lint": "eslint src",
+    "test": "jest"
+  }
+}

package/src/index.ts

@@ -0,0 +1,124 @@
+import { serialize, deserialize } from "node:v8";
+
+export const SEMAPHORE = 0;
+
+export enum Semaphore {
+  READY,
+  HANDSHAKE,
+  PAYLOAD,
+}
+
+export enum Handshake {
+  TOTAL_SIZE = 1,
+  TOTAL_CHUNKS,
+}
+
+export enum Header {
+  CHUNK_INDEX = 1,
+  CHUNK_OFFSET,
+  CHUNK_SIZE,
+}
+
+export const HEADER_VALUES =
+  1 +
+  Math.max(Object.values(Handshake).length, Object.values(Header).length) / 2;
+export const HEADER_SIZE = Uint32Array.BYTES_PER_ELEMENT * HEADER_VALUES;
+
+export const write = (
+  data: unknown,
+  buffer: SharedArrayBuffer,
+  timeout = 5000,
+) => {
+  const serialized = serialize(data);
+  const chunkSize = buffer.byteLength - HEADER_SIZE;
+  const totalSize = serialized.length;
+  const totalChunks = Math.ceil(totalSize / chunkSize);
+
+  const header = new Int32Array(buffer);
+  header[Handshake.TOTAL_SIZE] = totalSize;
+  header[Handshake.TOTAL_CHUNKS] = totalChunks;
+
+  Atomics.store(header, SEMAPHORE, Semaphore.HANDSHAKE);
+  Atomics.notify(header, SEMAPHORE);
+
+  try {
+    if (
+      Atomics.wait(header, SEMAPHORE, Semaphore.HANDSHAKE, timeout) ===
+      "timed-out"
+    ) {
+      throw new Error("Reader handshake timeout");
+    }
+
+    const payload = new Uint8Array(buffer, HEADER_SIZE);
+
+    for (let i = 0; i < totalChunks; i++) {
+      const start = i * chunkSize;
+      const end = Math.min(start + chunkSize, totalSize);
+      const size = end - start;
+
+      payload.set(serialized.subarray(start, end), 0);
+
+      header[Header.CHUNK_INDEX] = i;
+      header[Header.CHUNK_OFFSET] = start;
+      header[Header.CHUNK_SIZE] = size;
+
+      Atomics.store(header, SEMAPHORE, Semaphore.PAYLOAD);
+      Atomics.notify(header, SEMAPHORE);
+
+      if (
+        Atomics.wait(header, SEMAPHORE, Semaphore.PAYLOAD, timeout) ===
+        "timed-out"
+      ) {
+        throw new Error(`Reader timeout on chunk ${i}/${totalChunks - 1}`);
+      }
+    }
+  } finally {
+    Atomics.store(header, SEMAPHORE, Semaphore.READY);
+  }
+};
+
+export const read = (buffer: SharedArrayBuffer, timeout = 5000): unknown => {
+  const header = new Int32Array(buffer);
+  if (
+    Atomics.wait(header, SEMAPHORE, Semaphore.READY, timeout) === "timed-out"
+  ) {
+    throw new Error("Handshake timeout");
+  }
+  if (header[SEMAPHORE] !== Semaphore.HANDSHAKE) {
+    throw new Error("Invalid handshake state");
+  }
+
+  const totalSize = header[Handshake.TOTAL_SIZE];
+  const totalChunks = header[Handshake.TOTAL_CHUNKS];
+  const data = new Uint8Array(totalSize);
+
+  Atomics.store(header, SEMAPHORE, Semaphore.READY);
+  Atomics.notify(header, SEMAPHORE);
+
+  const payload = new Uint8Array(buffer, HEADER_SIZE);
+  for (let i = 0; i < totalChunks; i++) {
+    if (
+      Atomics.wait(header, SEMAPHORE, Semaphore.READY, timeout) === "timed-out"
+    ) {
+      throw new Error(`Writer timeout waiting for chunk ${i}`);
+    }
+    // @ts-expect-error does not infer number
+    if (header[SEMAPHORE] !== Semaphore.PAYLOAD) {
+      throw new Error(
+        `Expected payload header, received ${Semaphore[header[SEMAPHORE]]}`,
+      );
+    }
+    const chunkIndex = header[Header.CHUNK_INDEX];
+    if (i !== chunkIndex) {
+      throw new Error(
+        `Reader integrity failure for chunk ${chunkIndex} expected ${i}`,
+      );
+    }
+    const offset = header[Header.CHUNK_OFFSET];
+    const size = header[Header.CHUNK_SIZE];
+    data.set(payload.subarray(0, size), offset);
+    Atomics.store(header, SEMAPHORE, Semaphore.READY);
+    Atomics.notify(header, SEMAPHORE);
+  }
+  return deserialize(data);
+};