knitting 0.1.46

package/src/connections/process-shared-buffer.js

@@ -0,0 +1,267 @@
+import { getNodeBuiltinModule } from "../common/node-compat.js";
+import { FileDescriptor, } from "./file-descriptor.js";
+import { RUNTIME } from "../common/runtime.js";
+import { createBunConnectionPrimitives } from "./bun.js";
+import { createDenoConnectionPrimitives } from "./deno.js";
+import { loadNodeNativeAddon } from "./node-addons.js";
+import { assertPosixSharedMemoryPlatform } from "./posix.js";
+import { expectFd, expectPositiveSize, readCreateMode, readCreateName, readRequiredCreateName, readCreateSize, } from "./types.js";
+export const PROCESS_SHARED_BUFFER_BRAND = Symbol.for("knitting.processSharedBuffer");
+export const PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER = Symbol.for("knitting.processSharedBuffer.numericTransfer");
+const EXTERNAL_PAYLOAD_BRAND = Symbol.for("knitting.payloadCodec");
+const PROCESS_SHARED_BUFFER_CODEC_ID = "knitting.processSharedBuffer";
+const isRecord = (value) => typeof value === "object" && value !== null;
+const NUMERIC_SENTINEL = 0xffffffff;
+const RUNTIME_NODE = 1;
+const RUNTIME_DENO = 2;
+const RUNTIME_BUN = 3;
+const KIND_SHARED_ARRAY_BUFFER = 1;
+const KIND_EXTERNAL_ARRAY_BUFFER = 2;
+const decodeRuntime = (value) => {
+    switch (value) {
+        case RUNTIME_NODE:
+            return "node";
+        case RUNTIME_DENO:
+            return "deno";
+        case RUNTIME_BUN:
+            return "bun";
+        default:
+            return undefined;
+    }
+};
+const decodeKind = (value) => {
+    switch (value) {
+        case KIND_SHARED_ARRAY_BUFFER:
+            return "shared-array-buffer";
+        case KIND_EXTERNAL_ARRAY_BUFFER:
+            return "external-array-buffer";
+        default:
+            return undefined;
+    }
+};
+let defaultPrimitives;
+const fromDefaultNodeNativeMapping = (mapped) => ({
+    runtime: "node",
+    fd: mapped.fd,
+    size: mapped.size,
+    byteLength: mapped.sab.byteLength,
+    buffer: mapped.sab,
+    kind: "shared-array-buffer",
+    sab: mapped.sab,
+    baseAddressMod64: mapped.baseAddressMod64,
+});
+const createDefaultNodePrimitives = () => {
+    const nodeModule = getNodeBuiltinModule("node:module");
+    if (nodeModule === undefined) {
+        throw new TypeError("ProcessSharedBuffer needs connection primitives in this runtime");
+    }
+    const require = nodeModule.createRequire(import.meta.url);
+    const addon = loadNodeNativeAddon(require, "knitting_shared_memory");
+    return {
+        createSharedMemory: (options) => {
+            const size = expectPositiveSize(readCreateSize(options));
+            const mode = readCreateMode(options);
+            const name = mode === "anonymous"
+                ? readCreateName(options, "knitting_shared_memory")
+                : readRequiredCreateName(options);
+            return fromDefaultNodeNativeMapping(addon.createSharedMemory(size, name, mode));
+        },
+        mapSharedMemory: (options) => {
+            const fd = expectFd(options.fd);
+            const size = expectPositiveSize(options.size);
+            return fromDefaultNodeNativeMapping(addon.mapSharedMemory(fd, size));
+        },
+    };
+};
+const createDefaultPrimitives = () => {
+    assertPosixSharedMemoryPlatform("ProcessSharedBuffer");
+    if (RUNTIME === "bun")
+        return createBunConnectionPrimitives();
+    if (RUNTIME === "deno")
+        return createDenoConnectionPrimitives();
+    return createDefaultNodePrimitives();
+};
+export const setDefaultProcessSharedBufferPrimitives = (primitives) => {
+    defaultPrimitives = primitives;
+};
+export const getDefaultProcessSharedBufferPrimitives = () => {
+    defaultPrimitives ??= createDefaultPrimitives();
+    return defaultPrimitives;
+};
+const expectNonNegativeInteger = (value, label) => {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError(`${label} must be a non-negative integer`);
+    }
+    return value;
+};
+const readOptionalNonNegativeInteger = (value, label) => {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "number") {
+        throw new TypeError(`${label} must be a number`);
+    }
+    return expectNonNegativeInteger(value, label);
+};
+const expectRange = (byteOffset, byteLength, availableByteLength) => {
+    expectNonNegativeInteger(byteOffset, "process shared buffer byteOffset");
+    if (byteOffset > availableByteLength) {
+        throw new RangeError("process shared buffer byteOffset is out of bounds");
+    }
+    expectNonNegativeInteger(byteLength, "process shared buffer byteLength");
+    if (byteLength > availableByteLength - byteOffset) {
+        throw new RangeError("process shared buffer byteLength is out of bounds");
+    }
+};
+export class ProcessSharedBuffer {
+    [PROCESS_SHARED_BUFFER_BRAND] = true;
+    [EXTERNAL_PAYLOAD_BRAND] = PROCESS_SHARED_BUFFER_CODEC_ID;
+    descriptor;
+    byteOffset;
+    byteLength;
+    constructor(descriptor, range = {}) {
+        const byteOffset = range.byteOffset ?? 0;
+        const byteLength = range.byteLength ??
+            descriptor.byteLength - byteOffset;
+        expectRange(byteOffset, byteLength, descriptor.byteLength);
+        this.descriptor = descriptor;
+        this.byteOffset = byteOffset;
+        this.byteLength = byteLength;
+    }
+    static create(options, creator = getDefaultProcessSharedBufferPrimitives()) {
+        return ProcessSharedBuffer.fromMapping(creator.createSharedMemory(options));
+    }
+    static fromMapping(mapping) {
+        return new ProcessSharedBuffer(FileDescriptor.fromMapping(mapping));
+    }
+    static fromDescriptor(descriptor, range = {}) {
+        return new ProcessSharedBuffer(descriptor, range);
+    }
+    static fromMetadata(metadata) {
+        const parsed = parseProcessSharedBufferMetadata(metadata);
+        return new ProcessSharedBuffer(FileDescriptor.fromMetadata(parsed.descriptor), {
+            byteOffset: parsed.byteOffset,
+            byteLength: parsed.byteLength,
+        });
+    }
+    static parse(serialized) {
+        return ProcessSharedBuffer.fromMetadata(serialized);
+    }
+    static [PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER](metadata) {
+        const [fd, size, descriptorByteLength, byteOffset, byteLength, runtime, kind, baseAddressMod64,] = metadata;
+        return new ProcessSharedBuffer(new FileDescriptor({
+            version: 1,
+            fd,
+            size,
+            byteLength: descriptorByteLength,
+            runtime: decodeRuntime(runtime),
+            kind: decodeKind(kind),
+            baseAddressMod64: baseAddressMod64 === NUMERIC_SENTINEL
+                ? undefined
+                : baseAddressMod64,
+        }), {
+            byteOffset,
+            byteLength,
+        });
+    }
+    get fd() {
+        return this.descriptor.fd;
+    }
+    get size() {
+        return this.descriptor.size;
+    }
+    subbuffer(byteOffset, byteLength) {
+        const relativeByteOffset = expectNonNegativeInteger(byteOffset, "process shared buffer subbuffer byteOffset");
+        const relativeByteLength = byteLength === undefined
+            ? this.byteLength - relativeByteOffset
+            : expectNonNegativeInteger(byteLength, "process shared buffer subbuffer byteLength");
+        expectRange(relativeByteOffset, relativeByteLength, this.byteLength);
+        return new ProcessSharedBuffer(this.descriptor, {
+            byteOffset: this.byteOffset + relativeByteOffset,
+            byteLength: relativeByteLength,
+        });
+    }
+    getSharedArrayBuffer(mapper) {
+        return this.descriptor.getSAB(mapper ??
+            (this.descriptor.mapping?.sab === undefined
+                ? getDefaultProcessSharedBufferPrimitives()
+                : undefined));
+    }
+    getSAB(mapper) {
+        return this.getSharedArrayBuffer(mapper);
+    }
+    getBuffer(mapper) {
+        return this.descriptor.getBuffer(mapper ??
+            (this.descriptor.mapping?.buffer === undefined
+                ? getDefaultProcessSharedBufferPrimitives()
+                : undefined));
+    }
+    getRegion(mapper) {
+        return {
+            sab: this.getBuffer(mapper),
+            byteOffset: this.byteOffset,
+            byteLength: this.byteLength,
+        };
+    }
+    view(constructor, mapper) {
+        const bytesPerElement = constructor.BYTES_PER_ELEMENT;
+        if (this.byteOffset % bytesPerElement !== 0) {
+            throw new RangeError("process shared buffer byteOffset is not aligned for this view");
+        }
+        if (this.byteLength % bytesPerElement !== 0) {
+            throw new RangeError("process shared buffer byteLength is not aligned for this view");
+        }
+        return new constructor(this.getBuffer(mapper), this.byteOffset, this.byteLength / bytesPerElement);
+    }
+    bytes(mapper) {
+        return this.view(Uint8Array, mapper);
+    }
+    dataView(mapper) {
+        return new DataView(this.getBuffer(mapper), this.byteOffset, this.byteLength);
+    }
+    toMetadata() {
+        return {
+            version: 1,
+            descriptor: this.descriptor.toMetadata(),
+            byteOffset: this.byteOffset,
+            byteLength: this.byteLength,
+        };
+    }
+    toJSON() {
+        return this.toMetadata();
+    }
+    stringify() {
+        return JSON.stringify(this.toMetadata());
+    }
+    stringifyMetadata() {
+        return this.stringify();
+    }
+    toString() {
+        return this.stringify();
+    }
+}
+export const parseProcessSharedBufferMetadata = (input) => {
+    const value = typeof input === "string" ? JSON.parse(input) : input;
+    if (!isRecord(value)) {
+        throw new TypeError("process shared buffer metadata must be an object");
+    }
+    if (value.version !== 1) {
+        throw new TypeError("unsupported process shared buffer metadata version");
+    }
+    const descriptor = FileDescriptor.fromMetadata(value.descriptor);
+    const byteOffset = readOptionalNonNegativeInteger(value.byteOffset, "process shared buffer byteOffset") ?? 0;
+    const byteLength = readOptionalNonNegativeInteger(value.byteLength, "process shared buffer byteLength") ?? descriptor.byteLength - byteOffset;
+    expectRange(byteOffset, byteLength, descriptor.byteLength);
+    return {
+        version: 1,
+        descriptor: descriptor.toMetadata(),
+        byteOffset,
+        byteLength,
+    };
+};
+const processSharedBufferGlobal = globalThis;
+const codecs = processSharedBufferGlobal.__KNITTING_PAYLOAD_CODECS__ ??=
+    Object.create(null);
+codecs[PROCESS_SHARED_BUFFER_CODEC_ID] = {
+    decode: (metadata) => ProcessSharedBuffer.fromMetadata(metadata),
+    decodeNumeric: (metadata) => ProcessSharedBuffer[PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER](metadata),
+};

package/src/connections/types.d.ts

@@ -0,0 +1,48 @@
+export declare const CACHE_LINE_SIZE = 64;
+export type ConnectionRuntime = "node" | "deno" | "bun";
+export type SharedMemoryBuffer = ArrayBuffer | SharedArrayBuffer;
+export type SharedMemoryBufferKind = "shared-array-buffer" | "external-array-buffer";
+export type SharedMemoryCreateMode = "anonymous" | "create" | "open";
+export type SharedMemoryMapping<Buffer extends SharedMemoryBuffer = SharedMemoryBuffer> = {
+    runtime: ConnectionRuntime;
+    fd: number;
+    size: number;
+    byteLength: number;
+    buffer: Buffer;
+    kind: SharedMemoryBufferKind;
+    sab?: SharedArrayBuffer;
+    arrayBuffer?: ArrayBuffer;
+    baseAddressMod64?: number;
+    unsafePointer?: unknown;
+    close?: () => void;
+};
+export type CreateSharedMemoryOptions = {
+    size: number;
+    /**
+     * `anonymous` keeps the current fd-backed private mapping behavior.
+     * `create` and `open` use a named shared-memory object so independent
+     * processes can rendezvous by name.
+     */
+    mode?: SharedMemoryCreateMode;
+    name?: string;
+};
+export type MapSharedMemoryOptions = {
+    fd: number;
+    size: number;
+    duplicateFd?: boolean;
+};
+export type SharedMemoryConnectionPrimitives<Mapping extends SharedMemoryMapping = SharedMemoryMapping> = {
+    runtime: ConnectionRuntime;
+    createSharedMemory: (options: number | CreateSharedMemoryOptions) => Mapping;
+    mapSharedMemory: (options: MapSharedMemoryOptions) => Mapping;
+    unlinkSharedMemory?: (name: string) => boolean;
+};
+export declare const alignToCacheLine: (size: number) => number;
+export declare const readCreateSize: (options: number | CreateSharedMemoryOptions) => number;
+export declare const readCreateName: (options: number | CreateSharedMemoryOptions, fallback: string) => string;
+export declare const readCreateMode: (options: number | CreateSharedMemoryOptions) => SharedMemoryCreateMode;
+export declare const expectSharedMemoryName: (name: string) => string;
+export declare const readRequiredCreateName: (options: number | CreateSharedMemoryOptions) => string;
+export declare const expectPositiveSize: (size: number) => number;
+export declare const expectFd: (fd: number) => number;
+export declare const requireSharedArrayBuffer: (mapping: SharedMemoryMapping) => SharedArrayBuffer;

package/src/connections/types.js

@@ -0,0 +1,37 @@
+export const CACHE_LINE_SIZE = 64;
+export const alignToCacheLine = (size) => size + ((CACHE_LINE_SIZE - (size % CACHE_LINE_SIZE)) % CACHE_LINE_SIZE);
+export const readCreateSize = (options) => typeof options === "number" ? options : options.size;
+export const readCreateName = (options, fallback) => typeof options === "number" ? fallback : options.name ?? fallback;
+export const readCreateMode = (options) => typeof options === "number" ? "anonymous" : options.mode ?? "anonymous";
+export const expectSharedMemoryName = (name) => {
+    if (typeof name !== "string" || name.length === 0) {
+        throw new TypeError("shared memory name must be a non-empty string");
+    }
+    if (name.includes("\0")) {
+        throw new TypeError("shared memory name must not contain NUL bytes");
+    }
+    return name;
+};
+export const readRequiredCreateName = (options) => {
+    if (typeof options === "number" || options.name === undefined) {
+        throw new TypeError("named shared memory requires a name");
+    }
+    return expectSharedMemoryName(options.name);
+};
+export const expectPositiveSize = (size) => {
+    if (!Number.isFinite(size) || size <= 0) {
+        throw new RangeError("shared memory size must be positive");
+    }
+    return alignToCacheLine(Math.trunc(size));
+};
+export const expectFd = (fd) => {
+    if (!Number.isInteger(fd) || fd < 0) {
+        throw new RangeError("shared memory fd must be non-negative");
+    }
+    return fd;
+};
+export const requireSharedArrayBuffer = (mapping) => {
+    if (mapping.sab !== undefined)
+        return mapping.sab;
+    throw new TypeError(`${mapping.runtime} mapping is ${mapping.kind}; a native SAB wrapper is required`);
+};

package/src/error.d.ts

@@ -0,0 +1,13 @@
+import { type PromisePayloadHandler, type Task } from "./memory/lock.js";
+export declare enum ErrorKnitting {
+    Function = 0,
+    Symbol = 1,
+    Json = 2,
+    Serializable = 3
+}
+export declare const encoderError: ({ task, type, onPromise, detail, }: {
+    task: Task;
+    type: ErrorKnitting;
+    onPromise?: PromisePayloadHandler;
+    detail?: string;
+}) => false;

package/src/error.js

@@ -0,0 +1,49 @@
+import { beginPromisePayload, finishPromisePayload, TaskFlag, TaskIndex, } from "./memory/lock.js";
+import { RUNTIME_IS_MAIN_THREAD } from "./common/worker-runtime.js";
+export var ErrorKnitting;
+(function (ErrorKnitting) {
+    ErrorKnitting[ErrorKnitting["Function"] = 0] = "Function";
+    ErrorKnitting[ErrorKnitting["Symbol"] = 1] = "Symbol";
+    ErrorKnitting[ErrorKnitting["Json"] = 2] = "Json";
+    ErrorKnitting[ErrorKnitting["Serializable"] = 3] = "Serializable";
+})(ErrorKnitting || (ErrorKnitting = {}));
+const reasonFrom = (task, type, detail) => {
+    switch (type) {
+        case ErrorKnitting.Function: {
+            const name = typeof task.value === "function"
+                ? (task.value.name || "<anonymous>")
+                : "<unknown>";
+            return `KNT_ERROR_0: Function is not a valid type; name: ${name}`;
+        }
+        case ErrorKnitting.Symbol:
+            return "KNT_ERROR_1: Symbol must use Symbol.for(...) keys";
+        case ErrorKnitting.Json:
+            return detail == null || detail.length === 0
+                ? "KNT_ERROR_2: JSON stringify failed; payload must be JSON-safe"
+                : `KNT_ERROR_2: JSON stringify failed; ${detail}`;
+        case ErrorKnitting.Serializable:
+            return detail == null || detail.length === 0
+                ? "KNT_ERROR_3: Unsupported payload type; serialize it yourself"
+                : `KNT_ERROR_3: Unsupported payload type; ${detail}`;
+    }
+};
+export const encoderError = ({ task, type, onPromise, detail, }) => {
+    const reason = reasonFrom(task, type, detail);
+    if (!RUNTIME_IS_MAIN_THREAD) {
+        task.value = reason;
+        task[TaskIndex.FlagsToHost] = TaskFlag.Reject;
+        return false;
+    }
+    // Fallback for direct codec usage where no async settle callback is wired.
+    if (onPromise == null) {
+        throw new TypeError(reason);
+    }
+    if (!beginPromisePayload(task))
+        return false;
+    queueMicrotask(() => {
+        finishPromisePayload(task);
+        task.value = reason;
+        onPromise(task, true, reason);
+    });
+    return false;
+};

package/src/ipc/tools/ring-queue.d.ts

@@ -0,0 +1,33 @@
+export default class RingQueue<T> implements Iterable<T> {
+    #private;
+    constructor(capacity?: number);
+    get size(): number;
+    get isEmpty(): boolean;
+    get capacity(): number;
+    clear(): void;
+    peek(): T | undefined;
+    /** Ensure internal capacity >= requested (rounds up to next power of two). */
+    reserve(minCapacity: number): void;
+    /**
+     * Push to back
+     * Always succeeds (grows if full)
+     */
+    push(value: T): true;
+    /**
+     * Push to front (unshift)
+     * Always succeeds (grows if full)
+     */
+    unshift(value: T): true;
+    /**
+     * Pop from front (shift)
+     */
+    shift(): T | undefined;
+    /**
+     * Pop from front (shift) without clearing the slot.
+     * Use only for internal pooled-object queues where retaining references is acceptable.
+     */
+    shiftNoClear(): T | undefined;
+    [Symbol.iterator](): Generator<T, void, void>;
+    toArray(): T[];
+    get [Symbol.toStringTag](): string;
+}

package/src/ipc/tools/ring-queue.js

@@ -0,0 +1,159 @@
+;
+export default class RingQueue {
+    #buf;
+    #mask;
+    #head = 0;
+    #tail = 0;
+    #size = 0;
+    constructor(capacity = 512) {
+        let cap = 2;
+        while (cap < capacity)
+            cap <<= 1;
+        // Keep the array packed (avoid holey elements in hot queue paths).
+        this.#buf = new Array(cap).fill(null);
+        this.#mask = cap - 1;
+    }
+    get size() {
+        return this.#size;
+    }
+    get isEmpty() {
+        return this.#size === 0;
+    }
+    get capacity() {
+        return this.#mask + 1;
+    }
+    clear() {
+        // Keep buffer allocated; reset pointers (fast)
+        // (optional) also drop references to help GC if you want:
+        // for (let i = 0; i < this.#size; i++) this.#buf[(this.#head + i) & this.#mask] = null;
+        this.#head = 0;
+        this.#tail = 0;
+        this.#size = 0;
+    }
+    peek() {
+        return this.#size === 0 ? undefined : this.#buf[this.#head];
+    }
+    /** Ensure internal capacity >= requested (rounds up to next power of two). */
+    reserve(minCapacity) {
+        if (minCapacity <= this.capacity)
+            return;
+        let cap = this.capacity;
+        while (cap < minCapacity)
+            cap <<= 1;
+        this.#growTo(cap);
+    }
+    // --- hot path internal ---
+    #growIfFull() {
+        if (this.#size !== (this.#mask + 1))
+            return;
+        this.#growTo((this.#mask + 1) << 1);
+    }
+    #growTo(newCap) {
+        const oldBuf = this.#buf;
+        const oldCap = this.#mask + 1;
+        const n = this.#size;
+        const next = new Array(newCap).fill(null);
+        const head = this.#head;
+        const firstLen = Math.min(n, oldCap - head);
+        // copy [head..end)
+        for (let i = 0; i < firstLen; i++) {
+            next[i] = oldBuf[head + i];
+        }
+        // copy [0..remaining)
+        for (let i = firstLen; i < n; i++) {
+            next[i] = oldBuf[i - firstLen];
+        }
+        this.#buf = next;
+        this.#mask = newCap - 1;
+        this.#head = 0;
+        this.#tail = n;
+    }
+    /**
+     * Push to back
+     * Always succeeds (grows if full)
+     */
+    push(value) {
+        this.#growIfFull();
+        const buf = this.#buf;
+        const mask = this.#mask;
+        const tail = this.#tail;
+        buf[tail] = value;
+        this.#tail = (tail + 1) & mask;
+        this.#size++;
+        return true;
+    }
+    /**
+     * Push to front (unshift)
+     * Always succeeds (grows if full)
+     */
+    unshift(value) {
+        this.#growIfFull();
+        const buf = this.#buf;
+        const mask = this.#mask;
+        const head = (this.#head - 1) & mask;
+        this.#head = head;
+        buf[head] = value;
+        this.#size++;
+        return true;
+    }
+    /**
+     * Pop from front (shift)
+     */
+    shift() {
+        const size = this.#size;
+        if (size === 0)
+            return undefined;
+        const head = this.#head;
+        const buf = this.#buf;
+        const v = buf[head];
+        buf[head] = null; // help GC while keeping packed elements
+        this.#head = (head + 1) & this.#mask;
+        this.#size = size - 1;
+        return v;
+    }
+    /**
+     * Pop from front (shift) without clearing the slot.
+     * Use only for internal pooled-object queues where retaining references is acceptable.
+     */
+    shiftNoClear() {
+        const size = this.#size;
+        if (size === 0)
+            return undefined;
+        const head = this.#head;
+        const v = this.#buf[head];
+        this.#head = (head + 1) & this.#mask;
+        this.#size = size - 1;
+        return v;
+    }
+    *[Symbol.iterator]() {
+        const buf = this.#buf;
+        const mask = this.#mask;
+        let idx = this.#head;
+        let i = 0;
+        const n = this.#size;
+        while (i < n) {
+            // values should never be null inside active range, but keep it safe
+            const v = buf[idx];
+            if (v !== null)
+                yield v;
+            idx = (idx + 1) & mask;
+            i++;
+        }
+    }
+    toArray() {
+        // faster than Array.from(this) in some cases because it avoids iterator overhead,
+        // but keep iterator version if you prefer simplicity.
+        const out = new Array(this.#size);
+        const buf = this.#buf;
+        const mask = this.#mask;
+        let idx = this.#head;
+        for (let i = 0; i < out.length; i++) {
+            out[i] = buf[idx];
+            idx = (idx + 1) & mask;
+        }
+        return out;
+    }
+    get [Symbol.toStringTag]() {
+        return `RingQueue(size=${this.#size}, cap=${this.capacity})`;
+    }
+}

package/src/ipc/transport/shared-memory.d.ts

@@ -0,0 +1,25 @@
+export type SignalArguments = ReturnType<typeof createSharedMemoryTransport>;
+import { type SharedBufferSource } from "../../common/shared-buffer-region.js";
+import { type DebugOptions } from "../../types.js";
+export declare const TRANSPORT_SIGNAL_BYTES: number;
+export type Sab = {
+    size?: number;
+    sharedSab?: SharedBufferSource;
+};
+type SignalForWorker = {
+    sabObject?: Sab;
+    isMain: boolean;
+    thread: number;
+    debug?: DebugOptions;
+    startTime?: number;
+};
+export declare const createSharedMemoryTransport: ({ sabObject, isMain, startTime }: SignalForWorker) => {
+    sab: import("../../types.js").SharedBufferRegion;
+    op: Int32Array<import("../../common/shared-buffer-region.js").SharedBuffer>;
+    startAt: number;
+    opView: Int32Array<import("../../common/shared-buffer-region.js").SharedBuffer>;
+    rxStatus: Int32Array<import("../../common/shared-buffer-region.js").SharedBuffer>;
+    txStatus: Int32Array<import("../../common/shared-buffer-region.js").SharedBuffer>;
+};
+export type MainSignal = Pick<SignalArguments, "opView" | "startAt" | "rxStatus" | "txStatus">;
+export {};

package/src/ipc/transport/shared-memory.js

@@ -0,0 +1,35 @@
+import { createSharedArrayBuffer } from "../../common/runtime.js";
+import { toSharedBufferRegion, } from "../../common/shared-buffer-region.js";
+const page = 1024 * 4;
+const CACHE_LINE_BYTES = 64;
+// Keep hot signals on separate cache lines to avoid false sharing.
+const SIGNAL_OFFSETS = {
+    op: 0,
+    rxStatus: CACHE_LINE_BYTES,
+    txStatus: CACHE_LINE_BYTES * 2,
+};
+export const TRANSPORT_SIGNAL_BYTES = CACHE_LINE_BYTES * 3;
+const a_store = Atomics.store;
+export const createSharedMemoryTransport = ({ sabObject, isMain, startTime }) => {
+    const toGrow = sabObject?.size ?? page;
+    const roundedSize = toGrow + ((page - (toGrow % page)) % page);
+    const signalRegion = toSharedBufferRegion(sabObject?.sharedSab
+        ? sabObject.sharedSab
+        : createSharedArrayBuffer(roundedSize, page * page));
+    const sab = signalRegion.sab;
+    const baseByteOffset = signalRegion.byteOffset;
+    const startAt = startTime ?? performance.now();
+    const opView = new Int32Array(sab, baseByteOffset + SIGNAL_OFFSETS.op, 1);
+    if (isMain)
+        a_store(opView, 0, 0);
+    const rxStatus = new Int32Array(sab, baseByteOffset + SIGNAL_OFFSETS.rxStatus, 1);
+    a_store(rxStatus, 0, 1);
+    return {
+        sab: signalRegion,
+        op: opView,
+        startAt,
+        opView,
+        rxStatus,
+        txStatus: new Int32Array(sab, baseByteOffset + SIGNAL_OFFSETS.txStatus, 1),
+    };
+};