{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export interface Options {\n timeout?: number;\n}\n\nexport interface Channel {\n write(data: Uint8Array, options?: Options): Promise;\n read(options?: Options): Promise;\n writeSync(data: Uint8Array, options?: Options): void;\n readSync(options?: Options): Uint8Array;\n close(): void;\n}\n\nconst MAGIC = 0x53424332;\nconst INIT_SENTINEL = -1;\nconst MIN_BUFFER_BYTES = 4096;\nconst VERSION = 2;\nconst HEADER_WORDS = 5;\nconst RING_CONTROL_WORDS = 4;\nconst DESCRIPTOR_WORDS = 3;\nconst CONTINUATION = -1;\nconst SLOT_OPTIONS = [256, 128, 64, 32, 16, 8];\nconst MIN_DATA_BYTES = 256;\nconst FLAG_CLOSED_A = 1;\nconst FLAG_CLOSED_B = 2;\n\nconst IDX_MAGIC = 0;\nconst IDX_VERSION = 1;\nconst IDX_OWNER_A = 2;\nconst IDX_OWNER_B = 3;\nconst IDX_FLAGS = 4;\n\nconst IDX_WRITE_MSG = 0;\nconst IDX_READ_MSG = 1;\nconst IDX_READ_BYTE = 3;\n\nconst IDX_DESC_OFFSET = 0;\nconst IDX_DESC_SIZE = 1;\nconst IDX_DESC_TOTAL = 2;\n\ninterface Layout {\n controlBytes: number;\n descriptorBytes: number;\n dataBytes: number;\n perDirectionBytes: number;\n ringSlots: number;\n}\n\ninterface RingViews {\n control: Int32Array;\n descriptors: Int32Array;\n bytes: Uint8Array;\n dataBytes: number;\n ringSlots: number;\n ringMask: number;\n}\n\ninterface State {\n header: Int32Array;\n inbound: RingViews;\n outbound: RingViews;\n ownerIndex: number;\n localClosedMask: number;\n peerClosedMask: number;\n localClosed: boolean;\n writeLocked: boolean;\n readLocked: boolean;\n readTail: Promise;\n writeTail: Promise;\n wMsg: number;\n wByte: number;\n rMsg: number;\n rByte: number;\n pendingAckMsg: number;\n pendingAckByte: number;\n pendingAckSize: number;\n}\n\nconst layoutCache = new Map();\nconst stateCache = new WeakMap();\nconst handleCache = new WeakMap();\nconst resolvedTail = Promise.resolve();\n\nconst roundDownToWord = (value: number): number => value & ~3;\n\nconst computeLayout = (byteLength: number): Layout | null => {\n const cached = layoutCache.get(byteLength);\n if (cached !== undefined) return cached;\n\n if (byteLength % Int32Array.BYTES_PER_ELEMENT !== 0 || byteLength < MIN_BUFFER_BYTES) {\n layoutCache.set(byteLength, null);\n return null;\n }\n\n const headerBytes = HEADER_WORDS * Int32Array.BYTES_PER_ELEMENT;\n const perDirectionBytes = roundDownToWord((byteLength - headerBytes) >> 1);\n const controlBytes = RING_CONTROL_WORDS * Int32Array.BYTES_PER_ELEMENT;\n\n for (const ringSlots of SLOT_OPTIONS) {\n const descriptorBytes = ringSlots * DESCRIPTOR_WORDS * Int32Array.BYTES_PER_ELEMENT;\n const dataBytes = perDirectionBytes - controlBytes - descriptorBytes;\n if (dataBytes >= MIN_DATA_BYTES) {\n const layout = { controlBytes, descriptorBytes, dataBytes, perDirectionBytes, ringSlots };\n layoutCache.set(byteLength, layout);\n return layout;\n }\n }\n\n layoutCache.set(byteLength, null);\n return null;\n};\n\nconst createRingViews = (buffer: SharedArrayBuffer, byteOffset: number, layout: Layout): RingViews => {\n const descriptorOffset = byteOffset + layout.controlBytes;\n const dataOffset = descriptorOffset + layout.descriptorBytes;\n return {\n control: new Int32Array(buffer, byteOffset, RING_CONTROL_WORDS),\n descriptors: new Int32Array(buffer, descriptorOffset, layout.ringSlots * DESCRIPTOR_WORDS),\n bytes: new Uint8Array(buffer, dataOffset, layout.dataBytes),\n dataBytes: layout.dataBytes,\n ringSlots: layout.ringSlots,\n ringMask: layout.ringSlots - 1,\n };\n};\n\nconst createEndpointToken = (): number => {\n if (typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function') {\n const buf = new Int32Array(1);\n do {\n crypto.getRandomValues(buf);\n } while (buf[0] === 0 || buf[0] === INIT_SENTINEL || buf[0] === MAGIC);\n return buf[0];\n }\n let token = 0;\n while (token === 0 || token === INIT_SENTINEL || token === MAGIC) {\n token = (Math.random() * 0x7fffffff) | 0;\n }\n return token;\n};\n\nconst ENDPOINT_TOKEN = createEndpointToken();\n\nconst finalizeHeader = (buffer: SharedArrayBuffer, header: Int32Array): void => {\n const bodyOffset = HEADER_WORDS * Int32Array.BYTES_PER_ELEMENT;\n if (bodyOffset < buffer.byteLength) {\n new Int32Array(buffer, bodyOffset, (buffer.byteLength - bodyOffset) / Int32Array.BYTES_PER_ELEMENT).fill(0);\n }\n Atomics.store(header, IDX_VERSION, VERSION);\n Atomics.store(header, IDX_OWNER_A, 0);\n Atomics.store(header, IDX_OWNER_B, 0);\n Atomics.store(header, IDX_FLAGS, 0);\n Atomics.store(header, IDX_MAGIC, MAGIC);\n Atomics.notify(header, IDX_MAGIC);\n};\n\nconst initializeHeaderSync = (buffer: SharedArrayBuffer, header: Int32Array): void => {\n for (;;) {\n const magic = Atomics.load(header, IDX_MAGIC);\n if (magic === MAGIC) {\n const version = Atomics.load(header, IDX_VERSION);\n if (version !== VERSION) throw new Error(`Unsupported channel version ${version}`);\n return;\n }\n if (magic === INIT_SENTINEL) {\n Atomics.wait(header, IDX_MAGIC, INIT_SENTINEL);\n continue;\n }\n if (magic !== 0) throw new Error('SharedArrayBuffer does not contain a supported channel');\n if (Atomics.compareExchange(header, IDX_MAGIC, 0, INIT_SENTINEL) !== 0) continue;\n finalizeHeader(buffer, header);\n return;\n }\n};\n\nconst resetClosedHeaderSync = (buffer: SharedArrayBuffer, header: Int32Array): void => {\n for (;;) {\n const magic = Atomics.load(header, IDX_MAGIC);\n if (magic === INIT_SENTINEL) {\n Atomics.wait(header, IDX_MAGIC, INIT_SENTINEL);\n continue;\n }\n if (magic !== MAGIC) return;\n const version = Atomics.load(header, IDX_VERSION);\n if (version !== VERSION) throw new Error(`Unsupported channel version ${version}`);\n if (Atomics.load(header, IDX_OWNER_A) !== 0 || Atomics.load(header, IDX_OWNER_B) !== 0 || Atomics.load(header, IDX_FLAGS) === 0) return;\n if (Atomics.compareExchange(header, IDX_MAGIC, MAGIC, INIT_SENTINEL) !== MAGIC) continue;\n finalizeHeader(buffer, header);\n return;\n }\n};\n\nconst resetHeaderSync = (buffer: SharedArrayBuffer, header: Int32Array): void => {\n initializeHeaderSync(buffer, header);\n for (;;) {\n if (Atomics.load(header, IDX_OWNER_A) !== 0 || Atomics.load(header, IDX_OWNER_B) !== 0) {\n throw new Error('Channel is still open');\n }\n if (Atomics.compareExchange(header, IDX_MAGIC, MAGIC, INIT_SENTINEL) !== MAGIC) {\n initializeHeaderSync(buffer, header);\n continue;\n }\n finalizeHeader(buffer, header);\n return;\n }\n};\n\nconst claimEndpoint = (header: Int32Array): 0 | 1 => {\n const ownerA = Atomics.load(header, IDX_OWNER_A);\n if (ownerA === ENDPOINT_TOKEN) {\n Atomics.and(header, IDX_FLAGS, ~FLAG_CLOSED_A);\n return 0;\n }\n if (ownerA === 0 && Atomics.compareExchange(header, IDX_OWNER_A, 0, ENDPOINT_TOKEN) === 0) {\n Atomics.and(header, IDX_FLAGS, ~FLAG_CLOSED_A);\n return 0;\n }\n const ownerB = Atomics.load(header, IDX_OWNER_B);\n if (ownerB === ENDPOINT_TOKEN) {\n Atomics.and(header, IDX_FLAGS, ~FLAG_CLOSED_B);\n return 1;\n }\n if (ownerB === 0 && Atomics.compareExchange(header, IDX_OWNER_B, 0, ENDPOINT_TOKEN) === 0) {\n Atomics.and(header, IDX_FLAGS, ~FLAG_CLOSED_B);\n return 1;\n }\n throw new Error('SharedArrayBuffer channel already claimed by two endpoints');\n};\n\nconst createState = (buffer: SharedArrayBuffer, layout: Layout): State => {\n const cached = stateCache.get(buffer);\n if (cached !== undefined) return cached;\n\n const byteOffset = HEADER_WORDS * Int32Array.BYTES_PER_ELEMENT;\n const directionA = createRingViews(buffer, byteOffset, layout);\n const directionB = createRingViews(buffer, byteOffset + layout.perDirectionBytes, layout);\n const header = new Int32Array(buffer, 0, HEADER_WORDS);\n const endpoint = claimEndpoint(header);\n\n const outbound = endpoint === 0 ? directionA : directionB;\n const inbound = endpoint === 0 ? directionB : directionA;\n\n const state: State = {\n header,\n inbound,\n outbound,\n ownerIndex: endpoint === 0 ? IDX_OWNER_A : IDX_OWNER_B,\n localClosedMask: endpoint === 0 ? FLAG_CLOSED_A : FLAG_CLOSED_B,\n peerClosedMask: endpoint === 0 ? FLAG_CLOSED_B : FLAG_CLOSED_A,\n localClosed: false,\n writeLocked: false,\n readLocked: false,\n readTail: resolvedTail,\n writeTail: resolvedTail,\n wMsg: Atomics.load(outbound.control, IDX_WRITE_MSG),\n wByte: 0,\n rMsg: Atomics.load(inbound.control, IDX_READ_MSG),\n rByte: 0,\n pendingAckMsg: 0,\n pendingAckByte: 0,\n pendingAckSize: 0,\n };\n\n stateCache.set(buffer, state);\n return state;\n};\n\nconst getStateSync = (buffer: SharedArrayBuffer): State => {\n const cached = stateCache.get(buffer);\n if (cached !== undefined) return cached;\n\n const layout = computeLayout(buffer.byteLength);\n if (layout === null) throw new Error(`SharedArrayBuffer too small for channel (minimum ${MIN_BUFFER_BYTES} bytes)`);\n\n const header = new Int32Array(buffer, 0, HEADER_WORDS);\n initializeHeaderSync(buffer, header);\n resetClosedHeaderSync(buffer, header);\n return createState(buffer, layout);\n};\n\nconst copyToRing = (ring: Uint8Array, ringOffset: number, source: Uint8Array, sourceOffset: number, size: number): void => {\n const first = Math.min(size, ring.byteLength - ringOffset);\n ring.set(source.subarray(sourceOffset, sourceOffset + first), ringOffset);\n if (first < size) ring.set(source.subarray(sourceOffset + first, sourceOffset + size), 0);\n};\n\nconst copyFromRing = (target: Uint8Array, targetOffset: number, ring: Uint8Array, ringOffset: number, size: number): void => {\n const first = Math.min(size, ring.byteLength - ringOffset);\n target.set(ring.subarray(ringOffset, ringOffset + first), targetOffset);\n if (first < size) target.set(ring.subarray(0, size - first), targetOffset + first);\n};\n\nconst freeWriteSpace = (ring: RingViews, writeMsg: number, writeByte: number): number => {\n const readMsg = Atomics.load(ring.control, IDX_READ_MSG);\n const pending = (writeMsg - readMsg) | 0;\n if (pending >= ring.ringSlots) return 0;\n if (pending === 0) return ring.dataBytes;\n const readByte = Atomics.load(ring.control, IDX_READ_BYTE);\n const free = ring.dataBytes - ((writeByte - readByte) | 0);\n return free > 0 ? free : 0;\n};\n\nconst publishSegment = (ring: RingViews, offset: number, size: number, total: number, writeMsg: number): void => {\n const di = (writeMsg & ring.ringMask) * DESCRIPTOR_WORDS;\n ring.descriptors[di + IDX_DESC_OFFSET] = offset;\n ring.descriptors[di + IDX_DESC_SIZE] = size;\n ring.descriptors[di + IDX_DESC_TOTAL] = total;\n Atomics.store(ring.control, IDX_WRITE_MSG, (writeMsg + 1) | 0);\n Atomics.notify(ring.control, IDX_WRITE_MSG, 1);\n};\n\nconst ackSegment = (ring: RingViews, readMsg: number, readByte: number, size: number): void => {\n Atomics.store(ring.control, IDX_READ_BYTE, (readByte + size) | 0);\n Atomics.store(ring.control, IDX_READ_MSG, (readMsg + 1) | 0);\n Atomics.notify(ring.control, IDX_READ_MSG, 1);\n};\n\nconst flushPendingAck = (state: State): void => {\n if (state.pendingAckSize > 0) {\n ackSegment(state.inbound, state.pendingAckMsg, state.pendingAckByte, state.pendingAckSize);\n state.pendingAckSize = 0;\n }\n};\n\nconst isPeerClosed = (state: State): boolean => (Atomics.load(state.header, IDX_FLAGS) & state.peerClosedMask) !== 0;\n\nconst assertOpen = (state: State): void => {\n if (state.localClosed) throw new Error('Channel is closed');\n};\n\nconst assertWritable = (state: State): void => {\n assertOpen(state);\n if (isPeerClosed(state)) throw new Error('Peer channel is closed');\n};\n\nconst assertReadable = (state: State, receiving: boolean): void => {\n assertOpen(state);\n if (isPeerClosed(state)) throw new Error(receiving ? 'Peer channel closed while receiving message' : 'Peer channel is closed');\n};\n\nconst notifyWaiters = (state: State): void => {\n Atomics.notify(state.inbound.control, IDX_WRITE_MSG);\n Atomics.notify(state.inbound.control, IDX_READ_MSG);\n Atomics.notify(state.outbound.control, IDX_WRITE_MSG);\n Atomics.notify(state.outbound.control, IDX_READ_MSG);\n};\n\nconst writeChannelSync = (data: Uint8Array, state: State, timeout: number): void => {\n if (state.writeLocked) throw new Error('Cannot writeSync while an async write is in progress');\n flushPendingAck(state);\n const ring = state.outbound;\n assertWritable(state);\n let writeMsg = state.wMsg;\n let writeByte = state.wByte;\n\n if (data.length === 0) {\n while (freeWriteSpace(ring, writeMsg, writeByte) === 0) {\n assertWritable(state);\n const readMsg = Atomics.load(ring.control, IDX_READ_MSG);\n if (Atomics.wait(ring.control, IDX_READ_MSG, readMsg, timeout) === 'timed-out') throw new Error('Write timeout waiting for channel space');\n }\n publishSegment(ring, (writeByte >>> 0) % ring.dataBytes, 0, 0, writeMsg);\n state.wMsg = (writeMsg + 1) | 0;\n return;\n }\n\n let sourceOffset = 0;\n let firstSegment = true;\n while (sourceOffset < data.length) {\n let free = freeWriteSpace(ring, writeMsg, writeByte);\n while (free === 0) {\n assertWritable(state);\n const readMsg = Atomics.load(ring.control, IDX_READ_MSG);\n if (Atomics.wait(ring.control, IDX_READ_MSG, readMsg, timeout) === 'timed-out') throw new Error('Write timeout waiting for channel space');\n free = freeWriteSpace(ring, writeMsg, writeByte);\n }\n const size = Math.min(data.length - sourceOffset, free);\n const ringOffset = (writeByte >>> 0) % ring.dataBytes;\n copyToRing(ring.bytes, ringOffset, data, sourceOffset, size);\n publishSegment(ring, ringOffset, size, firstSegment ? data.length : CONTINUATION, writeMsg);\n writeMsg = (writeMsg + 1) | 0;\n writeByte = (writeByte + size) | 0;\n state.wMsg = writeMsg;\n state.wByte = writeByte;\n sourceOffset += size;\n firstSegment = false;\n }\n};\n\nconst writeChannel = async (data: Uint8Array, state: State, timeout: number): Promise => {\n flushPendingAck(state);\n const ring = state.outbound;\n assertWritable(state);\n let writeMsg = state.wMsg;\n let writeByte = state.wByte;\n\n if (data.length === 0) {\n while (freeWriteSpace(ring, writeMsg, writeByte) === 0) {\n assertWritable(state);\n const readMsg = Atomics.load(ring.control, IDX_READ_MSG);\n if ((await Atomics.waitAsync(ring.control, IDX_READ_MSG, readMsg, timeout).value) === 'timed-out')\n throw new Error('Write timeout waiting for channel space');\n }\n publishSegment(ring, (writeByte >>> 0) % ring.dataBytes, 0, 0, writeMsg);\n state.wMsg = (writeMsg + 1) | 0;\n return;\n }\n\n let sourceOffset = 0;\n let firstSegment = true;\n while (sourceOffset < data.length) {\n let free = freeWriteSpace(ring, writeMsg, writeByte);\n while (free === 0) {\n assertWritable(state);\n const readMsg = Atomics.load(ring.control, IDX_READ_MSG);\n if ((await Atomics.waitAsync(ring.control, IDX_READ_MSG, readMsg, timeout).value) === 'timed-out')\n throw new Error('Write timeout waiting for channel space');\n free = freeWriteSpace(ring, writeMsg, writeByte);\n }\n const size = Math.min(data.length - sourceOffset, free);\n const ringOffset = (writeByte >>> 0) % ring.dataBytes;\n copyToRing(ring.bytes, ringOffset, data, sourceOffset, size);\n publishSegment(ring, ringOffset, size, firstSegment ? data.length : CONTINUATION, writeMsg);\n writeMsg = (writeMsg + 1) | 0;\n writeByte = (writeByte + size) | 0;\n state.wMsg = writeMsg;\n state.wByte = writeByte;\n sourceOffset += size;\n firstSegment = false;\n }\n};\n\nconst readChannelSync = (state: State, timeout: number): Uint8Array => {\n if (state.readLocked) throw new Error('Cannot readSync while an async read is in progress');\n const ring = state.inbound;\n\n flushPendingAck(state);\n\n let readMsg = state.rMsg;\n let readByte = state.rByte;\n\n while (readMsg === Atomics.load(ring.control, IDX_WRITE_MSG)) {\n assertReadable(state, false);\n if (Atomics.wait(ring.control, IDX_WRITE_MSG, readMsg, timeout) === 'timed-out') throw new Error('Read timeout');\n }\n\n const di = (readMsg & ring.ringMask) * DESCRIPTOR_WORDS;\n const offset = ring.descriptors[di + IDX_DESC_OFFSET];\n const size = ring.descriptors[di + IDX_DESC_SIZE];\n const total = ring.descriptors[di + IDX_DESC_TOTAL];\n\n if (offset < 0 || offset >= ring.dataBytes || size < 0 || size > ring.dataBytes) throw new Error('Invalid descriptor');\n if (total < 0) throw new Error('Invalid descriptor');\n\n // Single-segment, contiguous in ring: zero-copy with deferred ack\n if (size === total && offset + size <= ring.dataBytes) {\n state.pendingAckMsg = readMsg;\n state.pendingAckByte = readByte;\n state.pendingAckSize = size;\n state.rMsg = (readMsg + 1) | 0;\n state.rByte = (readByte + size) | 0;\n if (size === 0) return new Uint8Array(0);\n return new Uint8Array(ring.bytes.buffer, ring.bytes.byteOffset + offset, size);\n }\n\n // Multi-segment or wrapping: allocate + copy + immediate ack\n const data = new Uint8Array(total);\n const targetSize = total;\n let targetOffset = 0;\n\n if (targetOffset + size > targetSize) throw new Error('Invalid descriptor');\n if (size > 0) copyFromRing(data, targetOffset, ring.bytes, offset, size);\n targetOffset += size;\n ackSegment(ring, readMsg, readByte, size);\n readMsg = (readMsg + 1) | 0;\n readByte = (readByte + size) | 0;\n state.rMsg = readMsg;\n state.rByte = readByte;\n\n while (targetOffset < targetSize) {\n while (readMsg === Atomics.load(ring.control, IDX_WRITE_MSG)) {\n assertReadable(state, true);\n if (Atomics.wait(ring.control, IDX_WRITE_MSG, readMsg, timeout) === 'timed-out') throw new Error('Read timeout waiting for segment');\n }\n\n const di2 = (readMsg & ring.ringMask) * DESCRIPTOR_WORDS;\n const off2 = ring.descriptors[di2 + IDX_DESC_OFFSET];\n const sz2 = ring.descriptors[di2 + IDX_DESC_SIZE];\n const tot2 = ring.descriptors[di2 + IDX_DESC_TOTAL];\n\n if (off2 < 0 || off2 >= ring.dataBytes || sz2 < 0 || sz2 > ring.dataBytes) throw new Error('Invalid descriptor');\n if (tot2 !== CONTINUATION) throw new Error('Invalid descriptor');\n if (targetOffset + sz2 > targetSize) throw new Error('Invalid descriptor');\n\n if (sz2 > 0) copyFromRing(data, targetOffset, ring.bytes, off2, sz2);\n targetOffset += sz2;\n ackSegment(ring, readMsg, readByte, sz2);\n readMsg = (readMsg + 1) | 0;\n readByte = (readByte + sz2) | 0;\n state.rMsg = readMsg;\n state.rByte = readByte;\n }\n\n return data;\n};\n\nconst readChannel = async (state: State, timeout: number): Promise => {\n const ring = state.inbound;\n\n flushPendingAck(state);\n\n let readMsg = state.rMsg;\n let readByte = state.rByte;\n\n while (readMsg === Atomics.load(ring.control, IDX_WRITE_MSG)) {\n assertReadable(state, false);\n if ((await Atomics.waitAsync(ring.control, IDX_WRITE_MSG, readMsg, timeout).value) === 'timed-out') throw new Error('Read timeout');\n }\n\n const di = (readMsg & ring.ringMask) * DESCRIPTOR_WORDS;\n const offset = ring.descriptors[di + IDX_DESC_OFFSET];\n const size = ring.descriptors[di + IDX_DESC_SIZE];\n const total = ring.descriptors[di + IDX_DESC_TOTAL];\n\n if (offset < 0 || offset >= ring.dataBytes || size < 0 || size > ring.dataBytes) throw new Error('Invalid descriptor');\n if (total < 0) throw new Error('Invalid descriptor');\n\n if (size === total && offset + size <= ring.dataBytes) {\n state.pendingAckMsg = readMsg;\n state.pendingAckByte = readByte;\n state.pendingAckSize = size;\n state.rMsg = (readMsg + 1) | 0;\n state.rByte = (readByte + size) | 0;\n if (size === 0) return new Uint8Array(0);\n return new Uint8Array(ring.bytes.buffer, ring.bytes.byteOffset + offset, size);\n }\n\n const data = new Uint8Array(total);\n const targetSize = total;\n let targetOffset = 0;\n\n if (targetOffset + size > targetSize) throw new Error('Invalid descriptor');\n if (size > 0) copyFromRing(data, targetOffset, ring.bytes, offset, size);\n targetOffset += size;\n ackSegment(ring, readMsg, readByte, size);\n readMsg = (readMsg + 1) | 0;\n readByte = (readByte + size) | 0;\n state.rMsg = readMsg;\n state.rByte = readByte;\n\n while (targetOffset < targetSize) {\n while (readMsg === Atomics.load(ring.control, IDX_WRITE_MSG)) {\n assertReadable(state, true);\n if ((await Atomics.waitAsync(ring.control, IDX_WRITE_MSG, readMsg, timeout).value) === 'timed-out') throw new Error('Read timeout waiting for segment');\n }\n\n const di2 = (readMsg & ring.ringMask) * DESCRIPTOR_WORDS;\n const off2 = ring.descriptors[di2 + IDX_DESC_OFFSET];\n const sz2 = ring.descriptors[di2 + IDX_DESC_SIZE];\n const tot2 = ring.descriptors[di2 + IDX_DESC_TOTAL];\n\n if (off2 < 0 || off2 >= ring.dataBytes || sz2 < 0 || sz2 > ring.dataBytes) throw new Error('Invalid descriptor');\n if (tot2 !== CONTINUATION) throw new Error('Invalid descriptor');\n if (targetOffset + sz2 > targetSize) throw new Error('Invalid descriptor');\n\n if (sz2 > 0) copyFromRing(data, targetOffset, ring.bytes, off2, sz2);\n targetOffset += sz2;\n ackSegment(ring, readMsg, readByte, sz2);\n readMsg = (readMsg + 1) | 0;\n readByte = (readByte + sz2) | 0;\n state.rMsg = readMsg;\n state.rByte = readByte;\n }\n\n return data;\n};\n\nconst runExclusive = async (state: State, key: 'readTail' | 'writeTail', task: () => Promise): Promise => {\n const previous = state[key];\n let release!: () => void;\n const next = new Promise((resolve) => {\n release = resolve;\n });\n state[key] = previous.then(\n () => next,\n () => next,\n );\n await previous;\n try {\n return await task();\n } finally {\n release();\n }\n};\n\nconst closeState = (buffer: SharedArrayBuffer, state: State): void => {\n if (state.localClosed) return;\n flushPendingAck(state);\n state.localClosed = true;\n Atomics.or(state.header, IDX_FLAGS, state.localClosedMask);\n Atomics.compareExchange(state.header, state.ownerIndex, ENDPOINT_TOKEN, 0);\n notifyWaiters(state);\n handleCache.delete(buffer);\n stateCache.delete(buffer);\n};\n\nexport const createBuffer = (byteLength: number): SharedArrayBuffer => {\n if (byteLength % Int32Array.BYTES_PER_ELEMENT !== 0) throw new Error('SharedArrayBuffer byteLength must be a multiple of 4');\n const buffer = new SharedArrayBuffer(byteLength);\n if (computeLayout(buffer.byteLength) === null) throw new Error(`SharedArrayBuffer too small for channel (minimum ${MIN_BUFFER_BYTES} bytes)`);\n initializeHeaderSync(buffer, new Int32Array(buffer, 0, HEADER_WORDS));\n return buffer;\n};\n\nexport const open = (buffer: SharedArrayBuffer): Channel => {\n const cached = handleCache.get(buffer);\n if (cached !== undefined) return cached;\n\n if (buffer.byteLength % Int32Array.BYTES_PER_ELEMENT !== 0) throw new Error('SharedArrayBuffer byteLength must be a multiple of 4');\n\n const state = getStateSync(buffer);\n\n const channel: Channel = {\n write: (data, options) =>\n runExclusive(state, 'writeTail', async () => {\n state.writeLocked = true;\n try {\n await writeChannel(data, state, options?.timeout ?? 5000);\n } finally {\n state.writeLocked = false;\n }\n }),\n read: (options) =>\n runExclusive(state, 'readTail', async () => {\n state.readLocked = true;\n try {\n return await readChannel(state, options?.timeout ?? 5000);\n } finally {\n state.readLocked = false;\n }\n }),\n writeSync: (data, options) => writeChannelSync(data, state, options?.timeout ?? 5000),\n readSync: (options) => readChannelSync(state, options?.timeout ?? 5000),\n close: () => closeState(buffer, state),\n };\n\n handleCache.set(buffer, channel);\n return channel;\n};\n\nexport const reset = (buffer: SharedArrayBuffer): void => {\n if (buffer.byteLength % Int32Array.BYTES_PER_ELEMENT !== 0) throw new Error('SharedArrayBuffer byteLength must be a multiple of 4');\n if (computeLayout(buffer.byteLength) === null) throw new Error(`SharedArrayBuffer too small for channel (minimum ${MIN_BUFFER_BYTES} bytes)`);\n const cached = stateCache.get(buffer);\n if (cached !== undefined && !cached.localClosed) throw new Error('Channel is still open in this runtime');\n resetHeaderSync(buffer, new Int32Array(buffer, 0, HEADER_WORDS));\n handleCache.delete(buffer);\n stateCache.delete(buffer);\n};\n"],"names":["createBuffer","open","reset","MAGIC","INIT_SENTINEL","MIN_BUFFER_BYTES","VERSION","HEADER_WORDS","RING_CONTROL_WORDS","DESCRIPTOR_WORDS","CONTINUATION","SLOT_OPTIONS","MIN_DATA_BYTES","FLAG_CLOSED_A","FLAG_CLOSED_B","IDX_MAGIC","IDX_VERSION","IDX_OWNER_A","IDX_OWNER_B","IDX_FLAGS","IDX_WRITE_MSG","IDX_READ_MSG","IDX_READ_BYTE","IDX_DESC_OFFSET","IDX_DESC_SIZE","IDX_DESC_TOTAL","layoutCache","Map","stateCache","WeakMap","handleCache","resolvedTail","Promise","resolve","roundDownToWord","value","computeLayout","byteLength","cached","get","undefined","Int32Array","BYTES_PER_ELEMENT","set","headerBytes","perDirectionBytes","controlBytes","ringSlots","descriptorBytes","dataBytes","layout","createRingViews","buffer","byteOffset","descriptorOffset","dataOffset","control","descriptors","bytes","Uint8Array","ringMask","createEndpointToken","crypto","getRandomValues","buf","token","Math","random","ENDPOINT_TOKEN","finalizeHeader","header","bodyOffset","fill","Atomics","store","notify","initializeHeaderSync","magic","load","version","Error","wait","compareExchange","resetClosedHeaderSync","resetHeaderSync","claimEndpoint","ownerA","and","ownerB","createState","directionA","directionB","endpoint","outbound","inbound","state","ownerIndex","localClosedMask","peerClosedMask","localClosed","writeLocked","readLocked","readTail","writeTail","wMsg","wByte","rMsg","rByte","pendingAckMsg","pendingAckByte","pendingAckSize","getStateSync","copyToRing","ring","ringOffset","source","sourceOffset","size","first","min","subarray","copyFromRing","target","targetOffset","freeWriteSpace","writeMsg","writeByte","readMsg","pending","readByte","free","publishSegment","offset","total","di","ackSegment","flushPendingAck","isPeerClosed","assertOpen","assertWritable","assertReadable","receiving","notifyWaiters","writeChannelSync","data","timeout","length","firstSegment","writeChannel","waitAsync","readChannelSync","targetSize","di2","off2","sz2","tot2","readChannel","runExclusive","key","task","previous","release","next","then","closeState","or","delete","SharedArrayBuffer","channel","write","options","read","writeSync","readSync","close"],"mappings":"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"}