orez 0.2.26 → 0.2.29

package/src/worker/shims/stream-browser.ts

@@ -1,15 +0,0 @@
-/**
- * stream shim — re-exports readable-stream with missing Node.js stream functions.
- *
- * readable-stream/stream-browserify don't include getDefaultHighWaterMark
- * which zero-cache uses (added in Node.js 18+).
- */
-
-// @ts-expect-error — readable-stream is CJS
-export * from 'readable-stream'
-// @ts-expect-error — readable-stream is CJS
-export { default } from 'readable-stream'
-
-export function getDefaultHighWaterMark(objectMode: boolean): number {
-  return objectMode ? 16 : 16 * 1024
-}

package/src/worker/shims/ws-browser.test.ts

@@ -1,205 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-
-import { messagePortToWs, browserWsToWs, createInProcessPair } from './ws-browser.js'
-
-describe('messagePortToWs', () => {
-  // create a mock MessagePort pair
-  function createMockPorts() {
-    type Handler = (event: MessageEvent) => void
-    let handler1: Handler | null = null
-    let handler2: Handler | null = null
-    let closed1 = false
-    let closed2 = false
-
-    const port1 = {
-      set onmessage(h: Handler | null) {
-        handler1 = h
-      },
-      get onmessage() {
-        return handler1
-      },
-      onmessageerror: null as Handler | null,
-      postMessage(data: unknown) {
-        if (closed2) return
-        // deliver to port2's handler
-        handler2?.({ data } as MessageEvent)
-      },
-      close() {
-        closed1 = true
-      },
-    }
-
-    const port2 = {
-      set onmessage(h: Handler | null) {
-        handler2 = h
-      },
-      get onmessage() {
-        return handler2
-      },
-      onmessageerror: null as Handler | null,
-      postMessage(data: unknown) {
-        if (closed1) return
-        handler1?.({ data } as MessageEvent)
-      },
-      close() {
-        closed2 = true
-      },
-    }
-
-    return [port1, port2] as [typeof port1, typeof port2]
-  }
-
-  it('wraps a MessagePort as WebSocket-like', () => {
-    const [port1] = createMockPorts()
-    const ws = messagePortToWs(port1 as any)
-    expect(ws.readyState).toBe(1) // OPEN
-    expect(ws.send).toBeInstanceOf(Function)
-    expect(ws.close).toBeInstanceOf(Function)
-  })
-
-  it('send() calls port.postMessage', () => {
-    const [port1] = createMockPorts()
-    const spy = vi.spyOn(port1, 'postMessage')
-    const ws = messagePortToWs(port1 as any)
-
-    ws.send('hello')
-    expect(spy).toHaveBeenCalledWith('hello')
-  })
-
-  it('send() invokes the ws callback after posting', () => {
-    const [port1] = createMockPorts()
-    const ws = messagePortToWs(port1 as any)
-    const callback = vi.fn()
-
-    ws.send('hello', callback)
-
-    expect(callback).toHaveBeenCalledWith()
-  })
-
-  it('send() reports an error to the callback after close', () => {
-    const [port1] = createMockPorts()
-    const ws = messagePortToWs(port1 as any)
-    const callback = vi.fn()
-
-    ws.close()
-    ws.send('ignored', callback)
-
-    expect(callback).toHaveBeenCalledWith(expect.any(Error))
-  })
-
-  it('forwards port messages as ws message events', () => {
-    const [port1, port2] = createMockPorts()
-    const ws1 = messagePortToWs(port1 as any)
-
-    const handler = vi.fn()
-    ws1.addEventListener('message', handler)
-
-    // send from port2 → should arrive at ws1
-    port2.postMessage('world')
-    expect(handler).toHaveBeenCalledWith({ data: 'world' })
-  })
-
-  it('close() sets readyState to CLOSED and fires event', () => {
-    const [port1] = createMockPorts()
-    const ws = messagePortToWs(port1 as any)
-
-    const closeHandler = vi.fn()
-    ws.addEventListener('close', closeHandler)
-
-    ws.close(1000)
-    expect(ws.readyState).toBe(3) // CLOSED
-    expect(closeHandler).toHaveBeenCalledWith(
-      expect.objectContaining({ code: 1000, wasClean: true })
-    )
-  })
-
-  it('send() is no-op after close', () => {
-    const [port1] = createMockPorts()
-    const spy = vi.spyOn(port1, 'postMessage')
-    const ws = messagePortToWs(port1 as any)
-
-    ws.close()
-    ws.send('ignored')
-    // postMessage should not be called after close
-    expect(spy).not.toHaveBeenCalled()
-  })
-
-  it('removeEventListener works', () => {
-    const [port1] = createMockPorts()
-    const ws = messagePortToWs(port1 as any)
-
-    const handler = vi.fn()
-    ws.addEventListener('message', handler)
-    ws.removeEventListener('message', handler)
-
-    // simulate message — handler should not be called
-    ;(port1 as any).onmessage?.({ data: 'test' })
-    // the handler was removed from ws listeners but port.onmessage still fires
-    // however ws.addEventListener wraps the handler, so the original shouldn't fire
-    // ... actually the port.onmessage fires the ws internal handler which checks listeners
-    // this is an implementation detail. just verify no error is thrown.
-  })
-})
-
-describe('browserWsToWs', () => {
-  it('wraps a browser WebSocket', () => {
-    const mockWs = {
-      readyState: 1,
-      send: vi.fn(),
-      close: vi.fn(),
-      addEventListener: vi.fn(),
-      removeEventListener: vi.fn(),
-    }
-
-    const ws = browserWsToWs(mockWs as any)
-    expect(ws.readyState).toBe(1)
-
-    ws.send('test')
-    expect(mockWs.send).toHaveBeenCalledWith('test')
-
-    ws.close(1000, 'bye')
-    expect(mockWs.close).toHaveBeenCalledWith(1000, 'bye')
-  })
-})
-
-describe('createInProcessPair', () => {
-  it('creates a connected pair', () => {
-    const [client, server] = createInProcessPair()
-    expect(client.readyState).toBe(1)
-    expect(server.readyState).toBe(1)
-  })
-
-  it('messages flow between client and server', async () => {
-    const [client, server] = createInProcessPair()
-
-    // MessageChannel delivers messages asynchronously in Node.js
-    const serverReceived = new Promise<string>((resolve) => {
-      server.addEventListener('message', (event: any) => {
-        resolve(event.data)
-      })
-    })
-
-    client.send('hello from client')
-    expect(await serverReceived).toBe('hello from client')
-
-    const clientReceived = new Promise<string>((resolve) => {
-      client.addEventListener('message', (event: any) => {
-        resolve(event.data)
-      })
-    })
-
-    server.send('hello from server')
-    expect(await clientReceived).toBe('hello from server')
-  })
-
-  it('close sets readyState', () => {
-    const [client] = createInProcessPair()
-
-    const closeHandler = vi.fn()
-    client.addEventListener('close', closeHandler)
-
-    client.close(1000)
-    expect(client.readyState).toBe(3)
-    expect(closeHandler).toHaveBeenCalled()
-  })
-})

package/src/worker/shims/ws-browser.ts

@@ -1,248 +0,0 @@
-/**
- * browser WebSocket/MessagePort adapter for the ws shim.
- *
- * wraps a browser WebSocket or MessagePort to match the interface
- * that the existing ws shim (orez/worker/shims/ws) expects. this lets
- * zero-cache handle WebSocket connections in browser Web Workers.
- *
- * usage:
- *   import { messagePortToWs, browserWsToWs } from 'orez/worker/shims/ws-browser'
- *
- *   // from a MessageChannel (worker ↔ main thread)
- *   const channel = new MessageChannel()
- *   const serverWs = messagePortToWs(channel.port2)
- *
- *   // from a browser WebSocket
- *   const ws = new WebSocket('ws://...')
- *   const shimWs = browserWsToWs(ws)
- */
-
-// the interface that the ws shim expects (same as CF WebSocket)
-// on/off are needed because createWebSocketStream uses ws.on('message')
-interface WsCompatible {
-  // ws constants — zero-cache uses ws.OPEN / ws.CONNECTING in switch statements
-  CONNECTING: number
-  OPEN: number
-  CLOSING: number
-  CLOSED: number
-  readyState: number
-  send(
-    data: string | ArrayBuffer | ArrayBufferView,
-    callback?: (err?: Error) => void
-  ): void
-  close(code?: number, reason?: string): void
-  addEventListener(type: string, handler: (event: any) => void): void
-  removeEventListener(type: string, handler: (event: any) => void): void
-  on(type: string, handler: (event: any) => void): void
-  off(type: string, handler: (event: any) => void): void
-}
-
-/**
- * wrap a MessagePort to look like a WebSocket.
- *
- * MessagePort uses postMessage/onmessage, while the ws shim expects
- * send/addEventListener('message'). this bridges the two.
- *
- * messages that arrive before any listener is registered are buffered
- * and replayed when the first 'message' listener is added. this prevents
- * a race where the port starts receiving data before the connection
- * handler (e.g. createWebSocketStream / proxyInbound) has set up its
- * listener — which would silently drop messages.
- */
-export function messagePortToWs(port: MessagePort): WsCompatible {
-  // separate listener sets for on() vs addEventListener() to match real ws behavior.
-  // in the ws package, on() is EventEmitter-style and addEventListener() is DOM-style.
-  // createWebSocketStream uses ws.on('message') exclusively for inbound data.
-  // streamOut uses ws.addEventListener('message') for ack handling.
-  // if they share the same set, ack messages reach both handlers and
-  // handleMessage tries to parse acks as protocol messages, closing the connection.
-  const onListeners = new Map<string, Set<(event: any) => void>>()
-  const domListeners = new Map<string, Set<(event: any) => void>>()
-  let closed = false
-
-  // buffer messages until a 'message' listener is registered (either kind)
-  const pendingMessages: any[] = []
-
-  function addOnListener(type: string, handler: (event: any) => void) {
-    if (!onListeners.has(type)) onListeners.set(type, new Set())
-    onListeners.get(type)!.add(handler)
-    if (type === 'message' && pendingMessages.length > 0) {
-      const queued = pendingMessages.splice(0)
-      for (const event of queued) handler(event)
-    }
-  }
-
-  function removeOnListener(type: string, handler: (event: any) => void) {
-    onListeners.get(type)?.delete(handler)
-  }
-
-  function addDomListener(type: string, handler: (event: any) => void) {
-    if (!domListeners.has(type)) domListeners.set(type, new Set())
-    domListeners.get(type)!.add(handler)
-    if (type === 'message' && pendingMessages.length > 0) {
-      const queued = pendingMessages.splice(0)
-      for (const event of queued) handler(event)
-    }
-  }
-
-  function removeDomListener(type: string, handler: (event: any) => void) {
-    domListeners.get(type)?.delete(handler)
-  }
-
-  function emit(type: string, event: any) {
-    const onHandlers = onListeners.get(type)
-    const domHandlers = domListeners.get(type)
-    const hasAny =
-      (onHandlers && onHandlers.size > 0) || (domHandlers && domHandlers.size > 0)
-    if (!hasAny) {
-      if (type === 'message') pendingMessages.push(event)
-      return
-    }
-    if (onHandlers) for (const h of onHandlers) h(event)
-    if (domHandlers) for (const h of domHandlers) h(event)
-  }
-
-  // forward port messages → ws 'message' events
-  // filter out control messages from sync-ws-patch.js (__close, __open)
-  port.onmessage = (event: MessageEvent) => {
-    const data = event.data
-    // control messages from sync-ws-patch.js — handle as close/open events
-    if (
-      data &&
-      typeof data === 'object' &&
-      !ArrayBuffer.isView(data) &&
-      !(data instanceof ArrayBuffer)
-    ) {
-      if (data.__close) {
-        closed = true
-        port.close()
-        emit('close', {
-          code: data.code ?? 1000,
-          reason: data.reason ?? '',
-          wasClean: true,
-        })
-        return
-      }
-      if (data.__open) {
-        // already open, ignore
-        return
-      }
-    }
-    emit('message', { data })
-  }
-
-  port.onmessageerror = (event: MessageEvent) => {
-    emit('error', { message: 'MessagePort error', error: event })
-  }
-
-  return {
-    // ws constants — zero-cache uses ws.OPEN / ws.CONNECTING in switch statements
-    CONNECTING: 0,
-    OPEN: 1,
-    CLOSING: 2,
-    CLOSED: 3,
-
-    get readyState() {
-      return closed ? 3 : 1 // CLOSED or OPEN
-    },
-
-    send(data: string | ArrayBuffer | ArrayBufferView, callback?: (err?: Error) => void) {
-      if (closed) {
-        callback?.(new Error('WebSocket is closed'))
-        return
-      }
-
-      try {
-        port.postMessage(data)
-      } catch (error) {
-        const err = error instanceof Error ? error : new Error(String(error))
-        if (callback) {
-          callback(err)
-          return
-        }
-        throw err
-      }
-
-      callback?.()
-    },
-
-    close(code?: number, _reason?: string) {
-      if (closed) return
-      closed = true
-      port.close()
-      emit('close', { code: code ?? 1000, reason: '', wasClean: true })
-    },
-
-    addEventListener: addDomListener,
-    removeEventListener: removeDomListener,
-    on: addOnListener,
-    off: removeOnListener,
-  }
-}
-
-/**
- * wrap a browser WebSocket to match the ws shim's expected interface.
- *
- * browser WebSocket and the ws shim's CFWebSocket interface are very
- * similar but have subtle differences. this normalizes them.
- */
-export function browserWsToWs(ws: WebSocket): WsCompatible {
-  return {
-    CONNECTING: 0,
-    OPEN: 1,
-    CLOSING: 2,
-    CLOSED: 3,
-
-    get readyState() {
-      return ws.readyState
-    },
-
-    send(data: string | ArrayBuffer | ArrayBufferView, callback?: (err?: Error) => void) {
-      try {
-        ws.send(data)
-      } catch (error) {
-        const err = error instanceof Error ? error : new Error(String(error))
-        if (callback) {
-          callback(err)
-          return
-        }
-        throw err
-      }
-
-      callback?.()
-    },
-
-    close(code?: number, reason?: string) {
-      ws.close(code, reason)
-    },
-
-    addEventListener(type: string, handler: (event: any) => void) {
-      ws.addEventListener(type, handler)
-    },
-
-    removeEventListener(type: string, handler: (event: any) => void) {
-      ws.removeEventListener(type, handler)
-    },
-
-    on(type: string, handler: (event: any) => void) {
-      ws.addEventListener(type, handler)
-    },
-
-    off(type: string, handler: (event: any) => void) {
-      ws.removeEventListener(type, handler)
-    },
-  }
-}
-
-/**
- * create a connected pair of WebSocket-like objects for in-process
- * communication (e.g., when zero-cache and Zero client are in the
- * same browser context). uses MessageChannel internally.
- *
- * returns [client, server] — client goes to Zero client, server
- * goes to the browser embed's handleWebSocket().
- */
-export function createInProcessPair(): [WsCompatible, WsCompatible] {
-  const channel = new MessageChannel()
-  return [messagePortToWs(channel.port1), messagePortToWs(channel.port2)]
-}