sabcom 0.1.140 → 0.1.141

package/build/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export 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 = 4;\n\n/**\n * Size in bytes reserved for protocol header in the SharedArrayBuffer.\n * The usable payload size is `buffer.byteLength - HEADER_SIZE`.\n */\nexport const HEADER_SIZE = Uint32Array.BYTES_PER_ELEMENT * HEADER_VALUES;\n\nexport interface Options {\n  /** Max wait time in milliseconds before timeout error. Default: 5000 */\n  timeout?: number;\n}\n\n/**\n * Request yielded by generator functions for Atomics.wait/waitAsync.\n * Pass to Atomics.wait() for sync or Atomics.waitAsync() for async waiting.\n */\nexport interface WaitRequest {\n  /** Int32Array view of the SharedArrayBuffer header */\n  target: Int32Array;\n  /** Index in the array to wait on (always SEMAPHORE = 0) */\n  index: number;\n  /** Value to compare against before waiting */\n  value: number;\n  /** Timeout in milliseconds */\n  timeout?: number;\n}\n\nexport type WaitResponse = ReturnType<typeof Atomics.wait>;\n\n/**\n * Low-level generator for writing data with custom flow control.\n * Use for progress tracking, cancellation, or custom scheduling.\n * @param data - Bytes to send (can be larger than buffer, will be chunked automatically)\n * @param buffer - SharedArrayBuffer shared with the reader thread (byteLength must be multiple of 4 and larger than HEADER_SIZE)\n * @param options - Optional configuration\n * @yields {WaitRequest} Request to wait for reader acknowledgment\n * @throws {Error} \"SharedArrayBuffer byteLength must be a multiple of 4\"\n * @throws {Error} \"SharedArrayBuffer too small for header\"\n * @throws {Error} \"Reader handshake timeout\" - reader didn't respond in time\n * @throws {Error} \"Reader timeout on chunk N/M\" - reader stopped responding mid-transfer\n * @example\n * ```typescript\n * import { writeGenerator } from 'sabcom';\n *\n * const gen = writeGenerator(data, buffer);\n * let chunks = 0;\n * for (const request of gen) {\n *   const result = Atomics.wait(request.target, request.index, request.value, request.timeout);\n *   if (result === 'timed-out') throw new Error('Timeout');\n *   console.log(`Chunk ${++chunks} sent`);\n * }\n * ```\n */\nexport function* writeGenerator(data: Uint8Array, buffer: SharedArrayBuffer, { timeout = 5000 }: Options = {}): Generator<WaitRequest, void, WaitResponse> {\n  if (buffer.byteLength % Int32Array.BYTES_PER_ELEMENT !== 0) {\n    throw new Error('SharedArrayBuffer byteLength must be a multiple of 4');\n  }\n  const chunkSize = buffer.byteLength - HEADER_SIZE;\n  if (chunkSize <= 0) {\n    throw new Error('SharedArrayBuffer too small for header');\n  }\n  const totalSize = data.length;\n  const totalChunks = Math.ceil(totalSize / chunkSize);\n  const header = new Int32Array(buffer);\n\n  header[Handshake.TOTAL_SIZE] = totalSize;\n  header[Handshake.TOTAL_CHUNKS] = totalChunks;\n  Atomics.store(header, SEMAPHORE, Semaphore.HANDSHAKE);\n  Atomics.notify(header, SEMAPHORE);\n\n  try {\n    const handshakeResult: WaitResponse = yield {\n      target: header,\n      index: SEMAPHORE,\n      value: Semaphore.HANDSHAKE,\n      timeout,\n    };\n    if (handshakeResult === 'timed-out') {\n      throw new Error('Reader handshake timeout');\n    }\n\n    const payload = new Uint8Array(buffer, HEADER_SIZE);\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      payload.set(data.subarray(start, end), 0);\n      header[Header.CHUNK_INDEX] = i;\n      header[Header.CHUNK_OFFSET] = start;\n      header[Header.CHUNK_SIZE] = size;\n      Atomics.store(header, SEMAPHORE, Semaphore.PAYLOAD);\n      Atomics.notify(header, SEMAPHORE);\n\n      const chunkResult: WaitResponse = yield {\n        target: header,\n        index: SEMAPHORE,\n        value: Semaphore.PAYLOAD,\n        timeout,\n      };\n      if (chunkResult === 'timed-out') {\n        throw new Error(`Reader timeout on chunk ${i}/${totalChunks - 1}`);\n      }\n    }\n  } finally {\n    Atomics.store(header, SEMAPHORE, Semaphore.READY);\n    Atomics.notify(header, SEMAPHORE);\n  }\n}\n\n/**\n * Low-level generator for reading data with custom flow control.\n * Use for progress tracking, cancellation, or custom scheduling.\n * @param buffer - SharedArrayBuffer shared with the writer thread (byteLength must be multiple of 4 and larger than HEADER_SIZE)\n * @param options - Optional configuration\n * @yields {WaitRequest} Request to wait for writer data\n * @returns Complete data as Uint8Array\n * @throws {Error} \"SharedArrayBuffer byteLength must be a multiple of 4\"\n * @throws {Error} \"SharedArrayBuffer too small for header\"\n * @throws {Error} \"Handshake timeout\" - writer didn't send data in time\n * @throws {Error} \"Invalid handshake state\" - protocol error\n * @throws {Error} \"Writer timeout waiting for chunk N\" - writer stopped responding mid-transfer\n * @example\n * ```typescript\n * import { readGenerator } from 'sabcom';\n *\n * const gen = readGenerator(buffer);\n * let result = gen.next();\n * while (!result.done) {\n *   const waitResult = Atomics.wait(result.value.target, result.value.index, result.value.value, result.value.timeout);\n *   result = gen.next(waitResult);\n * }\n * const data = result.value; // Uint8Array\n * ```\n */\nexport function* readGenerator(buffer: SharedArrayBuffer, { timeout = 5000 }: Options = {}): Generator<WaitRequest, Uint8Array, WaitResponse> {\n  if (buffer.byteLength % Int32Array.BYTES_PER_ELEMENT !== 0) {\n    throw new Error('SharedArrayBuffer byteLength must be a multiple of 4');\n  }\n  const chunkSize = buffer.byteLength - HEADER_SIZE;\n  if (chunkSize <= 0) {\n    throw new Error('SharedArrayBuffer too small for header');\n  }\n  const header = new Int32Array(buffer);\n\n  const handshakeResult: WaitResponse = yield {\n    target: header,\n    index: SEMAPHORE,\n    value: Semaphore.READY,\n    timeout,\n  };\n  if (handshakeResult === 'timed-out') {\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  if (totalSize < 0 || totalChunks < 0) {\n    throw new Error('Invalid handshake values');\n  }\n  if (totalSize === 0 && totalChunks !== 0) {\n    throw new Error('Invalid handshake values');\n  }\n  if (totalSize > totalChunks * chunkSize) {\n    throw new Error('Invalid handshake values');\n  }\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    const chunkResult: WaitResponse = yield {\n      target: header,\n      index: SEMAPHORE,\n      value: Semaphore.READY,\n      timeout,\n    };\n    if (chunkResult === 'timed-out') {\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(`Expected payload header, received ${Semaphore[header[SEMAPHORE]]}`);\n    }\n    const chunkIndex = header[Header.CHUNK_INDEX];\n    if (i !== chunkIndex) {\n      throw new Error(`Reader integrity failure for chunk ${chunkIndex} expected ${i}`);\n    }\n    const offset = header[Header.CHUNK_OFFSET];\n    const size = header[Header.CHUNK_SIZE];\n    if (offset < 0 || size <= 0 || size > chunkSize || offset + size > totalSize) {\n      throw new Error(`Invalid chunk metadata for chunk ${chunkIndex}`);\n    }\n    data.set(payload.subarray(0, size), offset);\n    Atomics.store(header, SEMAPHORE, Semaphore.READY);\n    Atomics.notify(header, SEMAPHORE);\n  }\n  return data;\n}\n\n/**\n * Synchronously writes data to a SharedArrayBuffer for cross-thread transfer.\n * Blocks until the reader receives all data. Use in workers where blocking is acceptable.\n * @param data - Bytes to send (can be larger than buffer, will be chunked automatically)\n * @param buffer - SharedArrayBuffer shared with the reader thread (byteLength must be multiple of 4 and larger than HEADER_SIZE)\n * @param options - Optional configuration\n * @throws {Error} \"SharedArrayBuffer byteLength must be a multiple of 4\"\n * @throws {Error} \"SharedArrayBuffer too small for header\"\n * @throws {Error} \"Reader handshake timeout\" - reader didn't respond in time\n * @throws {Error} \"Reader timeout on chunk N/M\" - reader stopped responding mid-transfer\n * @example\n * ```typescript\n * import { workerData } from 'worker_threads';\n * import { writeSync } from 'sabcom';\n *\n * const buffer = workerData as SharedArrayBuffer;\n * const data = new TextEncoder().encode('Hello from worker');\n * writeSync(data, buffer);\n * ```\n */\nexport const writeSync = (data: Uint8Array, buffer: SharedArrayBuffer, options?: Options): void => {\n  const gen = writeGenerator(data, buffer, options);\n  let result = gen.next();\n  while (!result.done) {\n    const waitResult = Atomics.wait(result.value.target, result.value.index, result.value.value, result.value.timeout);\n    result = gen.next(waitResult);\n  }\n};\n\n/**\n * Asynchronously writes data to a SharedArrayBuffer for cross-thread transfer.\n * Non-blocking, suitable for main thread. Resolves when the reader receives all data.\n * @param data - Bytes to send (can be larger than buffer, will be chunked automatically)\n * @param buffer - SharedArrayBuffer shared with the reader thread (byteLength must be multiple of 4 and larger than HEADER_SIZE)\n * @param options - Optional configuration\n * @throws {Error} \"SharedArrayBuffer byteLength must be a multiple of 4\"\n * @throws {Error} \"SharedArrayBuffer too small for header\"\n * @throws {Error} \"Reader handshake timeout\" - reader didn't respond in time\n * @throws {Error} \"Reader timeout on chunk N/M\" - reader stopped responding mid-transfer\n * @example\n * ```typescript\n * import { Worker } from 'worker_threads';\n * import { write } from 'sabcom';\n *\n * const buffer = new SharedArrayBuffer(4096);\n * const worker = new Worker('./worker.js', { workerData: buffer });\n * const data = new TextEncoder().encode('Hello from main');\n * await write(data, buffer);\n * ```\n */\nexport const write = async (data: Uint8Array, buffer: SharedArrayBuffer, options?: Options): Promise<void> => {\n  const gen = writeGenerator(data, buffer, options);\n  let result = gen.next();\n  while (!result.done) {\n    const request = result.value;\n    const waitResult = await Atomics.waitAsync(request.target, request.index, request.value, request.timeout).value;\n    result = gen.next(waitResult);\n  }\n};\n\n/**\n * Synchronously reads data from a SharedArrayBuffer written by another thread.\n * Blocks until all data is received. Use in workers where blocking is acceptable.\n * @param buffer - SharedArrayBuffer shared with the writer thread (byteLength must be multiple of 4 and larger than HEADER_SIZE)\n * @param options - Optional configuration\n * @returns Complete data as Uint8Array\n * @throws {Error} \"SharedArrayBuffer byteLength must be a multiple of 4\"\n * @throws {Error} \"SharedArrayBuffer too small for header\"\n * @throws {Error} \"Handshake timeout\" - writer didn't send data in time\n * @throws {Error} \"Invalid handshake state\" - protocol error\n * @throws {Error} \"Writer timeout waiting for chunk N\" - writer stopped responding mid-transfer\n * @example\n * ```typescript\n * import { workerData } from 'worker_threads';\n * import { readSync } from 'sabcom';\n *\n * const buffer = workerData as SharedArrayBuffer;\n * const data = readSync(buffer);\n * const message = new TextDecoder().decode(data);\n * ```\n */\nexport const readSync = (buffer: SharedArrayBuffer, options?: Options): Uint8Array => {\n  const gen = readGenerator(buffer, options);\n  let result = gen.next();\n  while (!result.done) {\n    const waitResult = Atomics.wait(result.value.target, result.value.index, result.value.value, result.value.timeout);\n    result = gen.next(waitResult);\n  }\n  return result.value;\n};\n\n/**\n * Asynchronously reads data from a SharedArrayBuffer written by another thread.\n * Non-blocking, suitable for main thread. Resolves when all data is received.\n * @param buffer - SharedArrayBuffer shared with the writer thread (byteLength must be multiple of 4 and larger than HEADER_SIZE)\n * @param options - Optional configuration\n * @returns Complete data as Uint8Array\n * @throws {Error} \"SharedArrayBuffer byteLength must be a multiple of 4\"\n * @throws {Error} \"SharedArrayBuffer too small for header\"\n * @throws {Error} \"Handshake timeout\" - writer didn't send data in time\n * @throws {Error} \"Invalid handshake state\" - protocol error\n * @throws {Error} \"Writer timeout waiting for chunk N\" - writer stopped responding mid-transfer\n * @example\n * ```typescript\n * import { Worker } from 'worker_threads';\n * import { read } from 'sabcom';\n *\n * const buffer = new SharedArrayBuffer(4096);\n * const worker = new Worker('./worker.js', { workerData: buffer });\n * // Worker writes data...\n * const data = await read(buffer);\n * const message = new TextDecoder().decode(data);\n * ```\n */\nexport const read = async (buffer: SharedArrayBuffer, options?: Options): Promise<Uint8Array> => {\n  const gen = readGenerator(buffer, options);\n  let result = gen.next();\n  while (!result.done) {\n    const request = result.value;\n    const waitResult = await Atomics.waitAsync(request.target, request.index, request.value, request.timeout).value;\n    result = gen.next(waitResult);\n  }\n  return result.value;\n};\n"],"names":["HEADER_SIZE","HEADER_VALUES","Handshake","Header","SEMAPHORE","Semaphore","read","readGenerator","readSync","write","writeGenerator","writeSync","Uint32Array","BYTES_PER_ELEMENT","data","buffer","timeout","byteLength","Int32Array","Error","chunkSize","totalSize","length","totalChunks","Math","ceil","header","Atomics","store","notify","handshakeResult","target","index","value","payload","Uint8Array","i","start","end","min","size","set","subarray","chunkResult","chunkIndex","offset","options","gen","result","next","done","waitResult","wait","request","waitAsync"],"mappings":"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"}
+{"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<void>;\n  read(options?: Options): Promise<Uint8Array>;\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<void>;\n  writeTail: Promise<void>;\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<number, Layout | null>();\nconst stateCache = new WeakMap<SharedArrayBuffer, State>();\nconst handleCache = new WeakMap<SharedArrayBuffer, Channel>();\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<void> => {\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<Uint8Array> => {\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 <T>(state: State, key: 'readTail' | 'writeTail', task: () => Promise<T>): Promise<T> => {\n  const previous = state[key];\n  let release!: () => void;\n  const next = new Promise<void>((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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"}

package/build/index.d.ts

@@ -1,180 +1,13 @@
-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 = 4;
-/**
- * Size in bytes reserved for protocol header in the SharedArrayBuffer.
- * The usable payload size is `buffer.byteLength - HEADER_SIZE`.
- */
-export declare const HEADER_SIZE: number;
 export interface Options {
-    /** Max wait time in milliseconds before timeout error. Default: 5000 */
     timeout?: number;
 }
-/**
- * Request yielded by generator functions for Atomics.wait/waitAsync.
- * Pass to Atomics.wait() for sync or Atomics.waitAsync() for async waiting.
- */
-export interface WaitRequest {
-    /** Int32Array view of the SharedArrayBuffer header */
-    target: Int32Array;
-    /** Index in the array to wait on (always SEMAPHORE = 0) */
-    index: number;
-    /** Value to compare against before waiting */
-    value: number;
-    /** Timeout in milliseconds */
-    timeout?: number;
+export interface Channel {
+    write(data: Uint8Array, options?: Options): Promise<void>;
+    read(options?: Options): Promise<Uint8Array>;
+    writeSync(data: Uint8Array, options?: Options): void;
+    readSync(options?: Options): Uint8Array;
+    close(): void;
 }
-export type WaitResponse = ReturnType<typeof Atomics.wait>;
-/**
- * Low-level generator for writing data with custom flow control.
- * Use for progress tracking, cancellation, or custom scheduling.
- * @param data - Bytes to send (can be larger than buffer, will be chunked automatically)
- * @param buffer - SharedArrayBuffer shared with the reader thread (byteLength must be multiple of 4 and larger than HEADER_SIZE)
- * @param options - Optional configuration
- * @yields {WaitRequest} Request to wait for reader acknowledgment
- * @throws {Error} "SharedArrayBuffer byteLength must be a multiple of 4"
- * @throws {Error} "SharedArrayBuffer too small for header"
- * @throws {Error} "Reader handshake timeout" - reader didn't respond in time
- * @throws {Error} "Reader timeout on chunk N/M" - reader stopped responding mid-transfer
- * @example
- * ```typescript
- * import { writeGenerator } from 'sabcom';
- *
- * const gen = writeGenerator(data, buffer);
- * let chunks = 0;
- * for (const request of gen) {
- *   const result = Atomics.wait(request.target, request.index, request.value, request.timeout);
- *   if (result === 'timed-out') throw new Error('Timeout');
- *   console.log(`Chunk ${++chunks} sent`);
- * }
- * ```
- */
-export declare function writeGenerator(data: Uint8Array, buffer: SharedArrayBuffer, { timeout }?: Options): Generator<WaitRequest, void, WaitResponse>;
-/**
- * Low-level generator for reading data with custom flow control.
- * Use for progress tracking, cancellation, or custom scheduling.
- * @param buffer - SharedArrayBuffer shared with the writer thread (byteLength must be multiple of 4 and larger than HEADER_SIZE)
- * @param options - Optional configuration
- * @yields {WaitRequest} Request to wait for writer data
- * @returns Complete data as Uint8Array
- * @throws {Error} "SharedArrayBuffer byteLength must be a multiple of 4"
- * @throws {Error} "SharedArrayBuffer too small for header"
- * @throws {Error} "Handshake timeout" - writer didn't send data in time
- * @throws {Error} "Invalid handshake state" - protocol error
- * @throws {Error} "Writer timeout waiting for chunk N" - writer stopped responding mid-transfer
- * @example
- * ```typescript
- * import { readGenerator } from 'sabcom';
- *
- * const gen = readGenerator(buffer);
- * let result = gen.next();
- * while (!result.done) {
- *   const waitResult = Atomics.wait(result.value.target, result.value.index, result.value.value, result.value.timeout);
- *   result = gen.next(waitResult);
- * }
- * const data = result.value; // Uint8Array
- * ```
- */
-export declare function readGenerator(buffer: SharedArrayBuffer, { timeout }?: Options): Generator<WaitRequest, Uint8Array, WaitResponse>;
-/**
- * Synchronously writes data to a SharedArrayBuffer for cross-thread transfer.
- * Blocks until the reader receives all data. Use in workers where blocking is acceptable.
- * @param data - Bytes to send (can be larger than buffer, will be chunked automatically)
- * @param buffer - SharedArrayBuffer shared with the reader thread (byteLength must be multiple of 4 and larger than HEADER_SIZE)
- * @param options - Optional configuration
- * @throws {Error} "SharedArrayBuffer byteLength must be a multiple of 4"
- * @throws {Error} "SharedArrayBuffer too small for header"
- * @throws {Error} "Reader handshake timeout" - reader didn't respond in time
- * @throws {Error} "Reader timeout on chunk N/M" - reader stopped responding mid-transfer
- * @example
- * ```typescript
- * import { workerData } from 'worker_threads';
- * import { writeSync } from 'sabcom';
- *
- * const buffer = workerData as SharedArrayBuffer;
- * const data = new TextEncoder().encode('Hello from worker');
- * writeSync(data, buffer);
- * ```
- */
-export declare const writeSync: (data: Uint8Array, buffer: SharedArrayBuffer, options?: Options) => void;
-/**
- * Asynchronously writes data to a SharedArrayBuffer for cross-thread transfer.
- * Non-blocking, suitable for main thread. Resolves when the reader receives all data.
- * @param data - Bytes to send (can be larger than buffer, will be chunked automatically)
- * @param buffer - SharedArrayBuffer shared with the reader thread (byteLength must be multiple of 4 and larger than HEADER_SIZE)
- * @param options - Optional configuration
- * @throws {Error} "SharedArrayBuffer byteLength must be a multiple of 4"
- * @throws {Error} "SharedArrayBuffer too small for header"
- * @throws {Error} "Reader handshake timeout" - reader didn't respond in time
- * @throws {Error} "Reader timeout on chunk N/M" - reader stopped responding mid-transfer
- * @example
- * ```typescript
- * import { Worker } from 'worker_threads';
- * import { write } from 'sabcom';
- *
- * const buffer = new SharedArrayBuffer(4096);
- * const worker = new Worker('./worker.js', { workerData: buffer });
- * const data = new TextEncoder().encode('Hello from main');
- * await write(data, buffer);
- * ```
- */
-export declare const write: (data: Uint8Array, buffer: SharedArrayBuffer, options?: Options) => Promise<void>;
-/**
- * Synchronously reads data from a SharedArrayBuffer written by another thread.
- * Blocks until all data is received. Use in workers where blocking is acceptable.
- * @param buffer - SharedArrayBuffer shared with the writer thread (byteLength must be multiple of 4 and larger than HEADER_SIZE)
- * @param options - Optional configuration
- * @returns Complete data as Uint8Array
- * @throws {Error} "SharedArrayBuffer byteLength must be a multiple of 4"
- * @throws {Error} "SharedArrayBuffer too small for header"
- * @throws {Error} "Handshake timeout" - writer didn't send data in time
- * @throws {Error} "Invalid handshake state" - protocol error
- * @throws {Error} "Writer timeout waiting for chunk N" - writer stopped responding mid-transfer
- * @example
- * ```typescript
- * import { workerData } from 'worker_threads';
- * import { readSync } from 'sabcom';
- *
- * const buffer = workerData as SharedArrayBuffer;
- * const data = readSync(buffer);
- * const message = new TextDecoder().decode(data);
- * ```
- */
-export declare const readSync: (buffer: SharedArrayBuffer, options?: Options) => Uint8Array;
-/**
- * Asynchronously reads data from a SharedArrayBuffer written by another thread.
- * Non-blocking, suitable for main thread. Resolves when all data is received.
- * @param buffer - SharedArrayBuffer shared with the writer thread (byteLength must be multiple of 4 and larger than HEADER_SIZE)
- * @param options - Optional configuration
- * @returns Complete data as Uint8Array
- * @throws {Error} "SharedArrayBuffer byteLength must be a multiple of 4"
- * @throws {Error} "SharedArrayBuffer too small for header"
- * @throws {Error} "Handshake timeout" - writer didn't send data in time
- * @throws {Error} "Invalid handshake state" - protocol error
- * @throws {Error} "Writer timeout waiting for chunk N" - writer stopped responding mid-transfer
- * @example
- * ```typescript
- * import { Worker } from 'worker_threads';
- * import { read } from 'sabcom';
- *
- * const buffer = new SharedArrayBuffer(4096);
- * const worker = new Worker('./worker.js', { workerData: buffer });
- * // Worker writes data...
- * const data = await read(buffer);
- * const message = new TextDecoder().decode(data);
- * ```
- */
-export declare const read: (buffer: SharedArrayBuffer, options?: Options) => Promise<Uint8Array>;
+export declare const createBuffer: (byteLength: number) => SharedArrayBuffer;
+export declare const open: (buffer: SharedArrayBuffer) => Channel;
+export declare const reset: (buffer: SharedArrayBuffer) => void;