@semilayer/client 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,196 @@
+import { StreamSearchParams, SearchResult, StreamQueryParams, SubscribeParams, StreamEvent, SearchParams, SearchResponse, SimilarParams, SimilarResponse, QueryParams, QueryResponse } from '@semilayer/core';
+export { QueryParams, QueryResponse, SearchParams, SearchResponse, SearchResult, SimilarParams, SimilarResponse, StreamEvent, StreamEventKind, StreamQueryParams, StreamSearchParams, SubscribeParams } from '@semilayer/core';
+
+declare class BeamError extends Error {
+    readonly status: number;
+    readonly detail: string;
+    readonly path: string;
+    constructor(status: number, detail: string, path: string);
+}
+declare class BeamNotFoundError extends BeamError {
+    constructor(detail: string, path: string);
+}
+declare class BeamAuthError extends BeamError {
+    constructor(detail: string, path: string);
+}
+/**
+ * The server returned a stream `error` frame. Carries the frame's `code`
+ * field so callers can branch on `rate_limited`, `forbidden`, `not_found`,
+ * `bad_request`, `internal`.
+ */
+declare class BeamStreamError extends Error {
+    readonly code: string;
+    readonly detail: string;
+    readonly lens: string;
+    constructor(code: string, detail: string, lens: string);
+}
+/**
+ * The server rate-limited a control frame or row emission. Thrown through
+ * the AsyncIterable so the consumer can catch and back off.
+ */
+declare class BeamStreamRateLimitError extends BeamStreamError {
+    constructor(detail: string, lens: string);
+}
+/**
+ * The WebSocket closed with the connection-limit close code (4290) or the
+ * rows-per-hour close code (4291). Caller should back off and retry later.
+ */
+declare class BeamStreamClosedError extends Error {
+    readonly closeCode: number;
+    readonly reason: string;
+    constructor(closeCode: number, reason: string);
+}
+
+/**
+ * Minimal WebSocket interface so callers can inject a mock (or the Node `ws`
+ * library) without depending on DOM types. Uses `Uint8Array` (not `Buffer`)
+ * so the client stays runtime-agnostic — browsers, Node, and edge runtimes
+ * all have Uint8Array; only Node has Buffer.
+ */
+interface WebSocketLike {
+    readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: 'open', listener: () => void): void;
+    addEventListener(type: 'close', listener: (event: {
+        code: number;
+        reason: string;
+    }) => void): void;
+    addEventListener(type: 'message', listener: (event: {
+        data: string | ArrayBuffer | Uint8Array;
+    }) => void): void;
+    addEventListener(type: 'error', listener: (event: unknown) => void): void;
+    removeEventListener(type: string, listener: unknown): void;
+}
+type WebSocketConstructor = new (url: string) => WebSocketLike;
+
+interface BeamConfig {
+    /** Base URL of the SemiLayer API (e.g. http://localhost:3001) */
+    baseUrl: string;
+    /** Service key (sk_...) or publishable key (pk_...) */
+    apiKey: string;
+    /**
+     * End-user JWT passed through as the `X-User-Token` header on REST calls
+     * and the `userToken` query param on WebSocket handshakes. SemiLayer
+     * validates it against the environment's JWKS config and feeds the claims
+     * into per-lens access rules (row-level security via the `(claims) =>
+     * AccessRuleResult` function-rule form).
+     *
+     * This is the **customer's own end-user** identity, distinct from the
+     * `apiKey` (which identifies the tenant).
+     *
+     * Leave undefined for server-to-server calls or sk_ (service key) flows
+     * that bypass access rules.
+     */
+    userToken?: string;
+    /** Override fetch implementation (for testing, SSR) */
+    fetch?: typeof fetch;
+    /**
+     * Override the WebSocket base URL (e.g. `wss://ws.semilayer.com`). When
+     * omitted, the client derives it from `baseUrl` by swapping the scheme
+     * (`https://` → `wss://`, `http://` → `ws://`), with a special-case
+     * default to `wss://ws.semilayer.com` for the hosted SaaS URL.
+     */
+    wsUrl?: string;
+    /**
+     * Override the WebSocket constructor — used by tests and Node environments
+     * that need to inject the `ws` package. Defaults to `globalThis.WebSocket`
+     * which is available in browsers, Node 22+, and modern edge runtimes.
+     */
+    WebSocket?: WebSocketConstructor;
+}
+
+/**
+ * BeamClient — the canonical SemiLayer runtime client.
+ *
+ * HTTP methods (always available):
+ *   - search, similar, query
+ *
+ * Streaming namespace (opens WebSocket lazily on first call):
+ *   - stream.search(lens, params) → AsyncIterable<SearchResult>
+ *   - stream.query (lens, params) → AsyncIterable<row>
+ *   - stream.subscribe(lens, params) → AsyncIterable<StreamEvent>
+ *
+ * Single-record observe (top-level because it's semantically distinct):
+ *   - observe(lens, recordId) → AsyncIterable<record>  (current state + every delta)
+ *
+ * v0.1 behavior on WebSocket disconnect: pending ops throw
+ * `BeamStreamClosedError`. Callers that want transparent reconnect wrap the
+ * iteration in a retry loop. Transparent reconnect is a v0.2 feature.
+ */
+declare class BeamClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly userToken;
+    private readonly fetchFn;
+    private readonly wsUrl;
+    private readonly WsCtor;
+    /** Streaming ops grouped under a `.stream` sub-object for ergonomic chaining. */
+    readonly stream: {
+        search<M = Record<string, unknown>>(lens: string, params: StreamSearchParams): AsyncIterable<SearchResult<M>>;
+        query<M = Record<string, unknown>>(lens: string, params: StreamQueryParams): AsyncIterable<M>;
+        subscribe<M = Record<string, unknown>>(lens: string, params?: SubscribeParams): AsyncIterable<StreamEvent<M>>;
+    };
+    constructor(config: BeamConfig);
+    /**
+     * Return a new `BeamClient` bound to an end-user JWT. Cheap (no network,
+     * no new socket) — the clone shares the same baseUrl / apiKey / fetch /
+     * WebSocket config and only differs in the `userToken` it attaches.
+     *
+     * Typical SSR pattern:
+     *
+     * ```ts
+     * const beam = new BeamClient({ baseUrl, apiKey: PK })
+     *
+     * // Inside a request handler, per end user:
+     * const userBeam = beam.withUser(session.token)
+     * const results = await userBeam.search('products', { query })
+     * ```
+     *
+     * The returned client passes the token as `X-User-Token` on REST calls and
+     * as `?userToken=` on WebSocket handshakes.
+     */
+    withUser(userToken: string): BeamClient;
+    search<M = Record<string, unknown>>(lens: string, params: SearchParams): Promise<SearchResponse<M>>;
+    similar<M = Record<string, unknown>>(lens: string, params: SimilarParams): Promise<SimilarResponse<M>>;
+    query<M = Record<string, unknown>>(lens: string, params?: QueryParams): Promise<QueryResponse<M>>;
+    /**
+     * Observe a single record by id. First yield is the current record state;
+     * subsequent yields fire only when the record actually changes (server-side
+     * per-subscription hash dedup). Terminates when the consumer breaks, the
+     * abort signal fires, or the server closes the stream.
+     */
+    observe<M = Record<string, unknown>>(lens: string, recordId: string): AsyncIterable<M>;
+    private opCounter;
+    private nextOpId;
+    /**
+     * Run a chunked op (search.stream / query.stream). The transport yields
+     * `row` frames; we push each row into the queue as-is. Terminates on
+     * `done` / `error` / socket close.
+     */
+    private runChunkedOp;
+    /**
+     * Run a long-lived live op (subscribe). The transport yields `event`
+     * frames; we wrap each as a `StreamEvent` before pushing.
+     */
+    private runLiveOp;
+    /**
+     * Run an observe op. Like subscribe but yields the raw record (not
+     * wrapped in a StreamEvent) — first yield is current state, subsequent
+     * yields are deltas.
+     */
+    private runObserveOp;
+    /**
+     * Build the transport + register the PendingOp + kick off the send.
+     * Returns the transport so the iterator wrapper can close it on break.
+     */
+    private buildOpTransport;
+    /**
+     * Wrap an AsyncQueue so that a consumer breaking out of `for await` tears
+     * down the transport cleanly.
+     */
+    private wrapIterable;
+    private request;
+}
+
+export { BeamAuthError, BeamClient, type BeamConfig, BeamError, BeamNotFoundError, BeamStreamClosedError, BeamStreamError, BeamStreamRateLimitError, type WebSocketConstructor, type WebSocketLike };

package/dist/index.js

@@ -0,0 +1,529 @@
+// src/errors.ts
+var BeamError = class extends Error {
+  constructor(status, detail, path) {
+    super(`Beam ${status}: ${detail} (${path})`);
+    this.status = status;
+    this.detail = detail;
+    this.path = path;
+    this.name = "BeamError";
+  }
+  status;
+  detail;
+  path;
+};
+var BeamNotFoundError = class extends BeamError {
+  constructor(detail, path) {
+    super(404, detail, path);
+    this.name = "BeamNotFoundError";
+  }
+};
+var BeamAuthError = class extends BeamError {
+  constructor(detail, path) {
+    super(401, detail, path);
+    this.name = "BeamAuthError";
+  }
+};
+var BeamStreamError = class extends Error {
+  constructor(code, detail, lens) {
+    super(`Beam stream ${code}: ${detail} (${lens})`);
+    this.code = code;
+    this.detail = detail;
+    this.lens = lens;
+    this.name = "BeamStreamError";
+  }
+  code;
+  detail;
+  lens;
+};
+var BeamStreamRateLimitError = class extends BeamStreamError {
+  constructor(detail, lens) {
+    super("rate_limited", detail, lens);
+    this.name = "BeamStreamRateLimitError";
+  }
+};
+var BeamStreamClosedError = class extends Error {
+  constructor(closeCode, reason) {
+    super(`Beam stream closed: ${closeCode} ${reason}`);
+    this.closeCode = closeCode;
+    this.reason = reason;
+    this.name = "BeamStreamClosedError";
+  }
+  closeCode;
+  reason;
+};
+
+// src/async-queue.ts
+function createAsyncQueue() {
+  const items = [];
+  const waiters = [];
+  let closed = false;
+  let finalError = null;
+  function push(item) {
+    if (closed) return;
+    const waiter = waiters.shift();
+    if (waiter) {
+      waiter.resolve({ value: item, done: false });
+      return;
+    }
+    items.push(item);
+  }
+  function done() {
+    if (closed) return;
+    closed = true;
+    while (waiters.length > 0) {
+      const waiter = waiters.shift();
+      waiter.resolve({ value: void 0, done: true });
+    }
+  }
+  function error(err) {
+    if (closed) return;
+    closed = true;
+    finalError = err;
+    while (waiters.length > 0) {
+      const waiter = waiters.shift();
+      waiter.reject(err);
+    }
+  }
+  async function next() {
+    if (items.length > 0) {
+      return { value: items.shift(), done: false };
+    }
+    if (closed) {
+      if (finalError) throw finalError;
+      return { value: void 0, done: true };
+    }
+    return new Promise((resolve, reject) => {
+      waiters.push({ resolve, reject });
+    });
+  }
+  return {
+    push,
+    done,
+    error,
+    get closed() {
+      return closed;
+    },
+    [Symbol.asyncIterator]() {
+      return {
+        next,
+        async return() {
+          done();
+          return { value: void 0, done: true };
+        }
+      };
+    }
+  };
+}
+
+// src/ws-transport.ts
+import { STREAM_CLOSE_CODES } from "@semilayer/core";
+var WsTransport = class {
+  ws = null;
+  state = "idle";
+  ops = /* @__PURE__ */ new Map();
+  url;
+  WsCtor;
+  onStateChange;
+  openPromise = null;
+  constructor(opts) {
+    this.url = opts.url;
+    const ctor = opts.WebSocket ?? globalThis.WebSocket;
+    if (!ctor) {
+      throw new Error(
+        "WsTransport: no WebSocket constructor found. Pass `WebSocket` in options or run in a WS-capable environment (Node 22+, browser, edge runtime)."
+      );
+    }
+    this.WsCtor = ctor;
+    this.onStateChange = opts.onStateChange;
+  }
+  /** Open the socket and wait for it to be ready. Idempotent. */
+  connect() {
+    if (this.state === "open") return Promise.resolve();
+    if (this.state === "closed") {
+      return Promise.reject(new Error("WsTransport: cannot reconnect a closed transport"));
+    }
+    if (this.openPromise) return this.openPromise;
+    this.state = "connecting";
+    this.onStateChange?.("connecting");
+    const ws = new this.WsCtor(this.url);
+    this.ws = ws;
+    this.openPromise = new Promise((resolve, reject) => {
+      const onOpen = () => {
+        this.state = "open";
+        this.onStateChange?.("open");
+        ws.removeEventListener("open", onOpen);
+        ws.removeEventListener("error", onInitialError);
+        resolve();
+      };
+      const onInitialError = (ev) => {
+        ws.removeEventListener("open", onOpen);
+        ws.removeEventListener("error", onInitialError);
+        reject(new Error(`WsTransport: failed to open socket: ${String(ev)}`));
+      };
+      ws.addEventListener("open", onOpen);
+      ws.addEventListener("error", onInitialError);
+    });
+    ws.addEventListener("message", (event) => this.handleMessage(event.data));
+    ws.addEventListener("close", (event) => this.handleClose(event.code, event.reason));
+    return this.openPromise;
+  }
+  /** Register an op — idempotent, last writer wins. */
+  registerOp(op) {
+    this.ops.set(op.id, op);
+  }
+  /** Unregister an op (called by the AsyncIterable on early break). */
+  unregisterOp(id) {
+    this.ops.delete(id);
+  }
+  /**
+   * Send an op frame on the underlying socket. Waits for the connection to
+   * be open before sending. Errors if the transport is closed.
+   */
+  async send(frame) {
+    if (this.state === "closed") {
+      throw new Error("WsTransport: cannot send \u2014 transport is closed");
+    }
+    await this.connect();
+    if (!this.ws || this.ws.readyState !== 1) {
+      throw new Error("WsTransport: socket not open");
+    }
+    this.ws.send(JSON.stringify(frame));
+  }
+  /** Send a raw control frame without op semantics (e.g. pong). */
+  sendRaw(frame) {
+    if (!this.ws || this.ws.readyState !== 1) return;
+    this.ws.send(JSON.stringify(frame));
+  }
+  /**
+   * Close the socket. All registered ops get an `onClosed(1000, 'normal')`
+   * callback before we mark the transport closed.
+   */
+  close() {
+    if (this.state === "closed") return;
+    this.state = "closed";
+    this.onStateChange?.("closed");
+    for (const op of this.ops.values()) {
+      try {
+        op.onClosed(STREAM_CLOSE_CODES.normal, "client closed");
+      } catch {
+      }
+    }
+    this.ops.clear();
+    try {
+      this.ws?.close(STREAM_CLOSE_CODES.normal, "client closed");
+    } catch {
+    }
+    this.ws = null;
+  }
+  /** Number of active ops (for tests + debugging). */
+  activeOpCount() {
+    return this.ops.size;
+  }
+  // ── Internal ──────────────────────────────────────────────
+  handleMessage(raw) {
+    const text = typeof raw === "string" ? raw : raw instanceof ArrayBuffer ? new TextDecoder().decode(new Uint8Array(raw)) : new TextDecoder().decode(raw);
+    let frame;
+    try {
+      frame = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (frame.type === "ping") {
+      this.sendRaw({ type: "pong" });
+      return;
+    }
+    if (frame.type === "pong") {
+      return;
+    }
+    if ("id" in frame && frame.id) {
+      const op = this.ops.get(frame.id);
+      if (!op) return;
+      switch (frame.type) {
+        case "row":
+          op.onRow(frame.data);
+          return;
+        case "event":
+          op.onEvent(frame.kind ?? "update", frame.record);
+          return;
+        case "done":
+          op.onDone(frame.meta ?? { count: 0, durationMs: 0 });
+          this.ops.delete(frame.id);
+          return;
+        case "error":
+          op.onError(frame.code ?? "internal", frame.message ?? "stream error");
+          this.ops.delete(frame.id);
+          return;
+      }
+    }
+    if (frame.type === "error") {
+      for (const op of this.ops.values()) {
+        op.onError(frame.code ?? "internal", frame.message ?? "stream error");
+      }
+      this.ops.clear();
+    }
+  }
+  handleClose(code, reason) {
+    if (this.state === "closed") return;
+    this.state = "closed";
+    this.onStateChange?.("closed");
+    for (const op of this.ops.values()) {
+      try {
+        op.onClosed(code, reason);
+      } catch {
+      }
+    }
+    this.ops.clear();
+    this.ws = null;
+  }
+};
+function buildStreamUrl(baseUrl, wsUrl, lens, apiKey, userToken) {
+  const origin = wsUrl ?? defaultWsOrigin(baseUrl);
+  const clean = origin.replace(/\/$/, "");
+  const params = new URLSearchParams({ key: apiKey });
+  if (userToken) {
+    params.set("userToken", userToken);
+  }
+  return `${clean}/v1/stream/${encodeURIComponent(lens)}?${params.toString()}`;
+}
+function defaultWsOrigin(baseUrl) {
+  const stripped = baseUrl.replace(/\/$/, "");
+  if (/^https?:\/\/api\.semilayer\.com$/i.test(stripped)) {
+    return "wss://ws.semilayer.com";
+  }
+  return stripped.replace(/^http:\/\//, "ws://").replace(/^https:\/\//, "wss://");
+}
+function toStreamError(code, message, lens) {
+  if (code === "rate_limited") {
+    return new BeamStreamRateLimitError(message, lens);
+  }
+  return new BeamStreamError(code, message, lens);
+}
+function closeCodeToError(code, reason) {
+  return new BeamStreamClosedError(code, reason);
+}
+
+// src/client.ts
+var BeamClient = class _BeamClient {
+  baseUrl;
+  apiKey;
+  userToken;
+  fetchFn;
+  wsUrl;
+  WsCtor;
+  /** Streaming ops grouped under a `.stream` sub-object for ergonomic chaining. */
+  stream;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+    this.userToken = config.userToken;
+    this.fetchFn = config.fetch ?? globalThis.fetch;
+    this.wsUrl = config.wsUrl;
+    this.WsCtor = config.WebSocket;
+    this.stream = {
+      search: (lens, params) => this.runChunkedOp(lens, {
+        id: this.nextOpId(),
+        op: "search.stream",
+        params
+      }),
+      query: (lens, params) => this.runChunkedOp(lens, {
+        id: this.nextOpId(),
+        op: "query.stream",
+        params
+      }),
+      subscribe: (lens, params) => this.runLiveOp(lens, {
+        id: this.nextOpId(),
+        op: "subscribe",
+        params: params ?? {}
+      })
+    };
+  }
+  /**
+   * Return a new `BeamClient` bound to an end-user JWT. Cheap (no network,
+   * no new socket) — the clone shares the same baseUrl / apiKey / fetch /
+   * WebSocket config and only differs in the `userToken` it attaches.
+   *
+   * Typical SSR pattern:
+   *
+   * ```ts
+   * const beam = new BeamClient({ baseUrl, apiKey: PK })
+   *
+   * // Inside a request handler, per end user:
+   * const userBeam = beam.withUser(session.token)
+   * const results = await userBeam.search('products', { query })
+   * ```
+   *
+   * The returned client passes the token as `X-User-Token` on REST calls and
+   * as `?userToken=` on WebSocket handshakes.
+   */
+  withUser(userToken) {
+    return new _BeamClient({
+      baseUrl: this.baseUrl,
+      apiKey: this.apiKey,
+      userToken,
+      fetch: this.fetchFn,
+      wsUrl: this.wsUrl,
+      WebSocket: this.WsCtor
+    });
+  }
+  // ── HTTP ops (existing) ──────────────────────────────────
+  async search(lens, params) {
+    return this.request("POST", `/v1/search/${lens}`, params);
+  }
+  async similar(lens, params) {
+    return this.request("POST", `/v1/similar/${lens}`, params);
+  }
+  async query(lens, params) {
+    return this.request("POST", `/v1/query/${lens}`, params ?? {});
+  }
+  // ── Streaming ops — single-record observation ───────────
+  /**
+   * Observe a single record by id. First yield is the current record state;
+   * subsequent yields fire only when the record actually changes (server-side
+   * per-subscription hash dedup). Terminates when the consumer breaks, the
+   * abort signal fires, or the server closes the stream.
+   */
+  observe(lens, recordId) {
+    return this.runObserveOp(lens, {
+      id: this.nextOpId(),
+      op: "observe",
+      params: { recordId }
+    });
+  }
+  // ── Internal ─────────────────────────────────────────────
+  opCounter = 0;
+  nextOpId() {
+    this.opCounter += 1;
+    return `op_${Date.now().toString(36)}_${this.opCounter}`;
+  }
+  /**
+   * Run a chunked op (search.stream / query.stream). The transport yields
+   * `row` frames; we push each row into the queue as-is. Terminates on
+   * `done` / `error` / socket close.
+   */
+  runChunkedOp(lens, frame) {
+    const queue = createAsyncQueue();
+    const transport = this.buildOpTransport(lens, frame, queue, {
+      onRow: (data) => queue.push(data),
+      // `event` frames shouldn't arrive on chunked ops, but if they do we
+      // silently ignore rather than crash the iterator.
+      onEvent: () => {
+      }
+    });
+    return this.wrapIterable(queue, transport);
+  }
+  /**
+   * Run a long-lived live op (subscribe). The transport yields `event`
+   * frames; we wrap each as a `StreamEvent` before pushing.
+   */
+  runLiveOp(lens, frame) {
+    const queue = createAsyncQueue();
+    const transport = this.buildOpTransport(lens, frame, queue, {
+      onRow: () => {
+      },
+      onEvent: (kind, record) => queue.push({ kind, record })
+    });
+    return this.wrapIterable(queue, transport);
+  }
+  /**
+   * Run an observe op. Like subscribe but yields the raw record (not
+   * wrapped in a StreamEvent) — first yield is current state, subsequent
+   * yields are deltas.
+   */
+  runObserveOp(lens, frame) {
+    const queue = createAsyncQueue();
+    const transport = this.buildOpTransport(lens, frame, queue, {
+      onRow: () => {
+      },
+      onEvent: (_kind, record) => queue.push(record)
+    });
+    return this.wrapIterable(queue, transport);
+  }
+  /**
+   * Build the transport + register the PendingOp + kick off the send.
+   * Returns the transport so the iterator wrapper can close it on break.
+   */
+  buildOpTransport(lens, frame, queue, handlers) {
+    const url = buildStreamUrl(this.baseUrl, this.wsUrl, lens, this.apiKey, this.userToken);
+    const transport = new WsTransport({ url, WebSocket: this.WsCtor });
+    const op = {
+      id: frame.id,
+      kind: frame.op === "search.stream" || frame.op === "query.stream" ? "chunked" : frame.op === "observe" ? "observe" : "live",
+      onRow: handlers.onRow,
+      onEvent: handlers.onEvent,
+      onDone() {
+        queue.done();
+        transport.close();
+      },
+      onError(code, message) {
+        queue.error(toStreamError(code, message, lens));
+        transport.close();
+      },
+      onClosed(code, reason) {
+        if (!queue.closed) {
+          queue.error(closeCodeToError(code, reason));
+        }
+      }
+    };
+    transport.registerOp(op);
+    void transport.send(frame).catch((err) => {
+      queue.error(err instanceof Error ? err : new Error(String(err)));
+      transport.close();
+    });
+    return transport;
+  }
+  /**
+   * Wrap an AsyncQueue so that a consumer breaking out of `for await` tears
+   * down the transport cleanly.
+   */
+  wrapIterable(queue, transport) {
+    const base = queue[Symbol.asyncIterator].bind(queue);
+    return {
+      [Symbol.asyncIterator]() {
+        const inner = base();
+        return {
+          async next() {
+            return inner.next();
+          },
+          async return() {
+            if (inner.return) await inner.return(void 0);
+            transport.close();
+            return { value: void 0, done: true };
+          }
+        };
+      }
+    };
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`
+    };
+    if (this.userToken) {
+      headers["X-User-Token"] = this.userToken;
+    }
+    const res = await this.fetchFn(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const parsed = await res.json().catch(() => ({ error: res.statusText }));
+      const detail = parsed.error ?? res.statusText;
+      if (res.status === 401) throw new BeamAuthError(detail, path);
+      if (res.status === 404) throw new BeamNotFoundError(detail, path);
+      throw new BeamError(res.status, detail, path);
+    }
+    return res.json();
+  }
+};
+export {
+  BeamAuthError,
+  BeamClient,
+  BeamError,
+  BeamNotFoundError,
+  BeamStreamClosedError,
+  BeamStreamError,
+  BeamStreamRateLimitError
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/async-queue.ts","../src/ws-transport.ts","../src/client.ts"],"sourcesContent":["export class BeamError extends Error {\n  constructor(\n    public readonly status: number,\n    public readonly detail: string,\n    public readonly path: string,\n  ) {\n    super(`Beam ${status}: ${detail} (${path})`)\n    this.name = 'BeamError'\n  }\n}\n\nexport class BeamNotFoundError extends BeamError {\n  constructor(detail: string, path: string) {\n    super(404, detail, path)\n    this.name = 'BeamNotFoundError'\n  }\n}\n\nexport class BeamAuthError extends BeamError {\n  constructor(detail: string, path: string) {\n    super(401, detail, path)\n    this.name = 'BeamAuthError'\n  }\n}\n\n// ── Streaming errors ───────────────────────────────────────\n\n/**\n * The server returned a stream `error` frame. Carries the frame's `code`\n * field so callers can branch on `rate_limited`, `forbidden`, `not_found`,\n * `bad_request`, `internal`.\n */\nexport class BeamStreamError extends Error {\n  constructor(\n    public readonly code: string,\n    public readonly detail: string,\n    public readonly lens: string,\n  ) {\n    super(`Beam stream ${code}: ${detail} (${lens})`)\n    this.name = 'BeamStreamError'\n  }\n}\n\n/**\n * The server rate-limited a control frame or row emission. Thrown through\n * the AsyncIterable so the consumer can catch and back off.\n */\nexport class BeamStreamRateLimitError extends BeamStreamError {\n  constructor(detail: string, lens: string) {\n    super('rate_limited', detail, lens)\n    this.name = 'BeamStreamRateLimitError'\n  }\n}\n\n/**\n * The WebSocket closed with the connection-limit close code (4290) or the\n * rows-per-hour close code (4291). Caller should back off and retry later.\n */\nexport class BeamStreamClosedError extends Error {\n  constructor(\n    public readonly closeCode: number,\n    public readonly reason: string,\n  ) {\n    super(`Beam stream closed: ${closeCode} ${reason}`)\n    this.name = 'BeamStreamClosedError'\n  }\n}\n","/**\n * A bounded-by-backpressure async queue backing every streaming op's\n * AsyncIterable. Producers push items via `push(item)`; the consumer pulls\n * via `[Symbol.asyncIterator]().next()`.\n *\n * Signals:\n * - `push(item)` — enqueue (or hand directly to a waiting consumer)\n * - `done()`     — terminate cleanly; any further pushes are dropped\n * - `error(err)` — terminate with the given error; the next `next()` rejects\n *\n * Cancellation: the consumer can break out of `for await` and the queue\n * will simply stop being drained — push() calls become no-ops once done()\n * or error() has been invoked.\n */\nexport interface AsyncQueue<T> extends AsyncIterable<T> {\n  push(item: T): void\n  done(): void\n  error(err: Error): void\n  /** True once done() or error() has been called. */\n  readonly closed: boolean\n}\n\nexport function createAsyncQueue<T>(): AsyncQueue<T> {\n  const items: T[] = []\n  const waiters: Array<{\n    resolve: (result: IteratorResult<T>) => void\n    reject: (err: Error) => void\n  }> = []\n  let closed = false\n  let finalError: Error | null = null\n\n  function push(item: T): void {\n    if (closed) return\n    const waiter = waiters.shift()\n    if (waiter) {\n      waiter.resolve({ value: item, done: false })\n      return\n    }\n    items.push(item)\n  }\n\n  function done(): void {\n    if (closed) return\n    closed = true\n    while (waiters.length > 0) {\n      const waiter = waiters.shift()!\n      waiter.resolve({ value: undefined, done: true })\n    }\n  }\n\n  function error(err: Error): void {\n    if (closed) return\n    closed = true\n    finalError = err\n    while (waiters.length > 0) {\n      const waiter = waiters.shift()!\n      waiter.reject(err)\n    }\n  }\n\n  async function next(): Promise<IteratorResult<T>> {\n    if (items.length > 0) {\n      return { value: items.shift()!, done: false }\n    }\n    if (closed) {\n      if (finalError) throw finalError\n      return { value: undefined, done: true }\n    }\n    return new Promise<IteratorResult<T>>((resolve, reject) => {\n      waiters.push({ resolve, reject })\n    })\n  }\n\n  return {\n    push,\n    done,\n    error,\n    get closed() {\n      return closed\n    },\n    [Symbol.asyncIterator](): AsyncIterator<T> {\n      return {\n        next,\n        async return() {\n          done()\n          return { value: undefined, done: true }\n        },\n      }\n    },\n  }\n}\n","import type {\n  StreamOpFrame,\n  StreamFrame,\n  StreamOp,\n  StreamErrorCode,\n} from '@semilayer/core'\nimport { STREAM_CLOSE_CODES } from '@semilayer/core'\nimport {\n  BeamStreamClosedError,\n  BeamStreamError,\n  BeamStreamRateLimitError,\n} from './errors.js'\n\n/**\n * Minimal WebSocket interface so callers can inject a mock (or the Node `ws`\n * library) without depending on DOM types. Uses `Uint8Array` (not `Buffer`)\n * so the client stays runtime-agnostic — browsers, Node, and edge runtimes\n * all have Uint8Array; only Node has Buffer.\n */\nexport interface WebSocketLike {\n  readyState: number\n  send(data: string): void\n  close(code?: number, reason?: string): void\n  addEventListener(type: 'open', listener: () => void): void\n  addEventListener(type: 'close', listener: (event: { code: number; reason: string }) => void): void\n  addEventListener(type: 'message', listener: (event: { data: string | ArrayBuffer | Uint8Array }) => void): void\n  addEventListener(type: 'error', listener: (event: unknown) => void): void\n  removeEventListener(type: string, listener: unknown): void\n}\n\nexport type WebSocketConstructor = new (url: string) => WebSocketLike\n\n/**\n * Each active op on a single WS connection registers a `PendingOp` handle.\n * The transport routes frames matching the op id to these callbacks.\n */\nexport interface PendingOp {\n  id: string\n  kind: 'chunked' | 'live' | 'observe'\n  onRow(data: unknown): void\n  onEvent(kind: 'insert' | 'update' | 'delete', record: unknown): void\n  onDone(meta: { count: number; durationMs: number }): void\n  onError(code: StreamErrorCode, message: string): void\n  /** Called when the underlying socket closes with the given code. */\n  onClosed(code: number, reason: string): void\n}\n\nexport interface WsTransportOptions {\n  /** Full WS URL including `/v1/stream/:lens?key=...` query. */\n  url: string\n  /** Injected WebSocket constructor — defaults to `globalThis.WebSocket`. */\n  WebSocket?: WebSocketConstructor\n  /** Called on each state change (for logging / observability). */\n  onStateChange?: (state: 'connecting' | 'open' | 'closed') => void\n}\n\ntype TransportState = 'idle' | 'connecting' | 'open' | 'closed'\n\n/**\n * Transport for a single WebSocket connection to a lens stream endpoint.\n *\n * - Multiplexes N ops over one socket via the frame `id` field\n * - Fires heartbeat `pong` replies when the server sends `ping`\n * - On unexpected close: notifies every active op with `onClosed` — the\n *   AsyncIterable consumer sees a `BeamStreamClosedError`\n *\n * v0.1 does NOT automatically reconnect. A transport instance is scoped to\n * one op lifecycle for chunked streams, or to one subscribe/observe session.\n * Callers catch `BeamStreamClosedError` and re-run the op.\n */\nexport class WsTransport {\n  private ws: WebSocketLike | null = null\n  private state: TransportState = 'idle'\n  private readonly ops = new Map<string, PendingOp>()\n  private readonly url: string\n  private readonly WsCtor: WebSocketConstructor\n  private readonly onStateChange?: (state: 'connecting' | 'open' | 'closed') => void\n  private openPromise: Promise<void> | null = null\n\n  constructor(opts: WsTransportOptions) {\n    this.url = opts.url\n    const ctor = (opts.WebSocket ?? (globalThis as { WebSocket?: WebSocketConstructor }).WebSocket)\n    if (!ctor) {\n      throw new Error(\n        'WsTransport: no WebSocket constructor found. Pass `WebSocket` in options or run in a WS-capable environment (Node 22+, browser, edge runtime).',\n      )\n    }\n    this.WsCtor = ctor\n    this.onStateChange = opts.onStateChange\n  }\n\n  /** Open the socket and wait for it to be ready. Idempotent. */\n  connect(): Promise<void> {\n    if (this.state === 'open') return Promise.resolve()\n    if (this.state === 'closed') {\n      return Promise.reject(new Error('WsTransport: cannot reconnect a closed transport'))\n    }\n    if (this.openPromise) return this.openPromise\n\n    this.state = 'connecting'\n    this.onStateChange?.('connecting')\n    const ws = new this.WsCtor(this.url)\n    this.ws = ws\n\n    this.openPromise = new Promise<void>((resolve, reject) => {\n      const onOpen = () => {\n        this.state = 'open'\n        this.onStateChange?.('open')\n        ws.removeEventListener('open', onOpen)\n        ws.removeEventListener('error', onInitialError)\n        resolve()\n      }\n      const onInitialError = (ev: unknown) => {\n        ws.removeEventListener('open', onOpen)\n        ws.removeEventListener('error', onInitialError)\n        reject(new Error(`WsTransport: failed to open socket: ${String(ev)}`))\n      }\n      ws.addEventListener('open', onOpen)\n      ws.addEventListener('error', onInitialError)\n    })\n\n    ws.addEventListener('message', (event) => this.handleMessage(event.data))\n    ws.addEventListener('close', (event) => this.handleClose(event.code, event.reason))\n\n    return this.openPromise\n  }\n\n  /** Register an op — idempotent, last writer wins. */\n  registerOp(op: PendingOp): void {\n    this.ops.set(op.id, op)\n  }\n\n  /** Unregister an op (called by the AsyncIterable on early break). */\n  unregisterOp(id: string): void {\n    this.ops.delete(id)\n  }\n\n  /**\n   * Send an op frame on the underlying socket. Waits for the connection to\n   * be open before sending. Errors if the transport is closed.\n   */\n  async send(frame: StreamOpFrame): Promise<void> {\n    if (this.state === 'closed') {\n      throw new Error('WsTransport: cannot send — transport is closed')\n    }\n    await this.connect()\n    if (!this.ws || this.ws.readyState !== 1 /* OPEN */) {\n      throw new Error('WsTransport: socket not open')\n    }\n    this.ws.send(JSON.stringify(frame))\n  }\n\n  /** Send a raw control frame without op semantics (e.g. pong). */\n  sendRaw(frame: Record<string, unknown>): void {\n    if (!this.ws || this.ws.readyState !== 1) return\n    this.ws.send(JSON.stringify(frame))\n  }\n\n  /**\n   * Close the socket. All registered ops get an `onClosed(1000, 'normal')`\n   * callback before we mark the transport closed.\n   */\n  close(): void {\n    if (this.state === 'closed') return\n    this.state = 'closed'\n    this.onStateChange?.('closed')\n    for (const op of this.ops.values()) {\n      try {\n        op.onClosed(STREAM_CLOSE_CODES.normal, 'client closed')\n      } catch {\n        // ignore\n      }\n    }\n    this.ops.clear()\n    try {\n      this.ws?.close(STREAM_CLOSE_CODES.normal, 'client closed')\n    } catch {\n      // ignore\n    }\n    this.ws = null\n  }\n\n  /** Number of active ops (for tests + debugging). */\n  activeOpCount(): number {\n    return this.ops.size\n  }\n\n  // ── Internal ──────────────────────────────────────────────\n\n  private handleMessage(raw: string | ArrayBuffer | Uint8Array): void {\n    const text =\n      typeof raw === 'string'\n        ? raw\n        : raw instanceof ArrayBuffer\n          ? new TextDecoder().decode(new Uint8Array(raw))\n          : new TextDecoder().decode(raw)\n\n    let frame: StreamFrame\n    try {\n      frame = JSON.parse(text) as StreamFrame\n    } catch {\n      return // silently drop malformed frames\n    }\n\n    // Heartbeat\n    if (frame.type === 'ping') {\n      this.sendRaw({ type: 'pong' })\n      return\n    }\n    if (frame.type === 'pong') {\n      return\n    }\n\n    // Op-scoped frames\n    if ('id' in frame && frame.id) {\n      const op = this.ops.get(frame.id)\n      if (!op) return // unknown id — op was torn down\n\n      switch (frame.type) {\n        case 'row':\n          op.onRow(frame.data)\n          return\n        case 'event':\n          op.onEvent(frame.kind ?? 'update', frame.record)\n          return\n        case 'done':\n          op.onDone(frame.meta ?? { count: 0, durationMs: 0 })\n          this.ops.delete(frame.id)\n          return\n        case 'error':\n          op.onError(frame.code ?? 'internal', frame.message ?? 'stream error')\n          this.ops.delete(frame.id)\n          return\n      }\n    }\n\n    // Error frame without id — affects every active op\n    if (frame.type === 'error') {\n      for (const op of this.ops.values()) {\n        op.onError(frame.code ?? 'internal', frame.message ?? 'stream error')\n      }\n      this.ops.clear()\n    }\n  }\n\n  private handleClose(code: number, reason: string): void {\n    if (this.state === 'closed') return\n    this.state = 'closed'\n    this.onStateChange?.('closed')\n    for (const op of this.ops.values()) {\n      try {\n        op.onClosed(code, reason)\n      } catch {\n        // ignore\n      }\n    }\n    this.ops.clear()\n    this.ws = null\n  }\n}\n\n/**\n * Build the wss URL for a `/v1/stream/:lens` endpoint.\n *\n * Resolution order:\n * 1. Explicit `wsUrl` override (enterprise / self-hosted / dev override)\n * 2. SaaS canonical: if baseUrl is the hosted `api.semilayer.com`, default\n *    to `wss://ws.semilayer.com` — the dedicated streaming subdomain\n * 3. Otherwise, derive from `baseUrl` by swapping scheme (`https://` →\n *    `wss://`, `http://` → `ws://`) so self-hosted and localhost work\n *    without any config\n *\n * The end-user JWT (`userToken`) is passed as an additional query param when\n * provided. Browsers can't set arbitrary headers on WS upgrades, so query\n * params are the lowest-common-denominator path. TLS encrypts on wire;\n * servers should scrub `userToken` from access logs as an operational\n * practice.\n */\nexport function buildStreamUrl(\n  baseUrl: string,\n  wsUrl: string | undefined,\n  lens: string,\n  apiKey: string,\n  userToken?: string,\n): string {\n  const origin =\n    wsUrl ??\n    defaultWsOrigin(baseUrl)\n  const clean = origin.replace(/\\/$/, '')\n  const params = new URLSearchParams({ key: apiKey })\n  if (userToken) {\n    params.set('userToken', userToken)\n  }\n  return `${clean}/v1/stream/${encodeURIComponent(lens)}?${params.toString()}`\n}\n\n/**\n * Default WS origin when the caller hasn't set one explicitly. Special-cases\n * the hosted SaaS URL so `new BeamClient({baseUrl: 'https://api.semilayer.com', ...})`\n * opens streams against `wss://ws.semilayer.com` without any extra config.\n */\nfunction defaultWsOrigin(baseUrl: string): string {\n  const stripped = baseUrl.replace(/\\/$/, '')\n  // Hosted SaaS — route streams to the dedicated subdomain. Both www. and\n  // bare subdomain forms match for safety.\n  if (/^https?:\\/\\/api\\.semilayer\\.com$/i.test(stripped)) {\n    return 'wss://ws.semilayer.com'\n  }\n  // Everything else: derive from the REST base URL\n  return stripped.replace(/^http:\\/\\//, 'ws://').replace(/^https:\\/\\//, 'wss://')\n}\n\n/**\n * Map a server error frame to the typed BeamStream error subclass.\n * Centralized so the op handlers all raise consistent errors.\n */\nexport function toStreamError(\n  code: StreamErrorCode,\n  message: string,\n  lens: string,\n): BeamStreamError {\n  if (code === 'rate_limited') {\n    return new BeamStreamRateLimitError(message, lens)\n  }\n  return new BeamStreamError(code, message, lens)\n}\n\n/**\n * Map a close code to a typed error. 4290 = concurrent connection cap, 4291 =\n * rows/hr cap, 4401 = auth failed, 4403 = forbidden. Other codes pass through\n * as a generic closed error.\n */\nexport function closeCodeToError(code: number, reason: string): BeamStreamClosedError {\n  return new BeamStreamClosedError(code, reason)\n}\n\n/** Used for typed op discrimination in the client. */\nexport type StreamOpKind = StreamOp\n","import type {\n  BeamConfig,\n  SearchParams,\n  SearchResponse,\n  SearchResult,\n  SimilarParams,\n  SimilarResponse,\n  QueryParams,\n  QueryResponse,\n  StreamSearchParams,\n  StreamQueryParams,\n  SubscribeParams,\n  StreamEvent,\n} from './types.js'\nimport { BeamError, BeamAuthError, BeamNotFoundError } from './errors.js'\nimport { createAsyncQueue } from './async-queue.js'\nimport {\n  WsTransport,\n  buildStreamUrl,\n  toStreamError,\n  closeCodeToError,\n  type PendingOp,\n} from './ws-transport.js'\nimport type { StreamOpFrame } from '@semilayer/core'\n\n/**\n * BeamClient — the canonical SemiLayer runtime client.\n *\n * HTTP methods (always available):\n *   - search, similar, query\n *\n * Streaming namespace (opens WebSocket lazily on first call):\n *   - stream.search(lens, params) → AsyncIterable<SearchResult>\n *   - stream.query (lens, params) → AsyncIterable<row>\n *   - stream.subscribe(lens, params) → AsyncIterable<StreamEvent>\n *\n * Single-record observe (top-level because it's semantically distinct):\n *   - observe(lens, recordId) → AsyncIterable<record>  (current state + every delta)\n *\n * v0.1 behavior on WebSocket disconnect: pending ops throw\n * `BeamStreamClosedError`. Callers that want transparent reconnect wrap the\n * iteration in a retry loop. Transparent reconnect is a v0.2 feature.\n */\nexport class BeamClient {\n  private readonly baseUrl: string\n  private readonly apiKey: string\n  private readonly userToken: string | undefined\n  private readonly fetchFn: typeof fetch\n  private readonly wsUrl: string | undefined\n  private readonly WsCtor: BeamConfig['WebSocket']\n\n  /** Streaming ops grouped under a `.stream` sub-object for ergonomic chaining. */\n  readonly stream: {\n    search<M = Record<string, unknown>>(\n      lens: string,\n      params: StreamSearchParams,\n    ): AsyncIterable<SearchResult<M>>\n    query<M = Record<string, unknown>>(\n      lens: string,\n      params: StreamQueryParams,\n    ): AsyncIterable<M>\n    subscribe<M = Record<string, unknown>>(\n      lens: string,\n      params?: SubscribeParams,\n    ): AsyncIterable<StreamEvent<M>>\n  }\n\n  constructor(config: BeamConfig) {\n    this.baseUrl = config.baseUrl.replace(/\\/$/, '')\n    this.apiKey = config.apiKey\n    this.userToken = config.userToken\n    this.fetchFn = config.fetch ?? globalThis.fetch\n    this.wsUrl = config.wsUrl\n    this.WsCtor = config.WebSocket\n\n    this.stream = {\n      search: <M = Record<string, unknown>>(lens: string, params: StreamSearchParams) =>\n        this.runChunkedOp<SearchResult<M>>(lens, {\n          id: this.nextOpId(),\n          op: 'search.stream',\n          params: params as unknown as Record<string, unknown>,\n        }),\n      query: <M = Record<string, unknown>>(lens: string, params: StreamQueryParams) =>\n        this.runChunkedOp<M>(lens, {\n          id: this.nextOpId(),\n          op: 'query.stream',\n          params: params as unknown as Record<string, unknown>,\n        }),\n      subscribe: <M = Record<string, unknown>>(lens: string, params?: SubscribeParams) =>\n        this.runLiveOp<M>(lens, {\n          id: this.nextOpId(),\n          op: 'subscribe',\n          params: (params ?? {}) as Record<string, unknown>,\n        }),\n    }\n  }\n\n  /**\n   * Return a new `BeamClient` bound to an end-user JWT. Cheap (no network,\n   * no new socket) — the clone shares the same baseUrl / apiKey / fetch /\n   * WebSocket config and only differs in the `userToken` it attaches.\n   *\n   * Typical SSR pattern:\n   *\n   * ```ts\n   * const beam = new BeamClient({ baseUrl, apiKey: PK })\n   *\n   * // Inside a request handler, per end user:\n   * const userBeam = beam.withUser(session.token)\n   * const results = await userBeam.search('products', { query })\n   * ```\n   *\n   * The returned client passes the token as `X-User-Token` on REST calls and\n   * as `?userToken=` on WebSocket handshakes.\n   */\n  withUser(userToken: string): BeamClient {\n    return new BeamClient({\n      baseUrl: this.baseUrl,\n      apiKey: this.apiKey,\n      userToken,\n      fetch: this.fetchFn,\n      wsUrl: this.wsUrl,\n      WebSocket: this.WsCtor,\n    })\n  }\n\n  // ── HTTP ops (existing) ──────────────────────────────────\n\n  async search<M = Record<string, unknown>>(\n    lens: string,\n    params: SearchParams,\n  ): Promise<SearchResponse<M>> {\n    return this.request<SearchResponse<M>>('POST', `/v1/search/${lens}`, params)\n  }\n\n  async similar<M = Record<string, unknown>>(\n    lens: string,\n    params: SimilarParams,\n  ): Promise<SimilarResponse<M>> {\n    return this.request<SimilarResponse<M>>('POST', `/v1/similar/${lens}`, params)\n  }\n\n  async query<M = Record<string, unknown>>(\n    lens: string,\n    params?: QueryParams,\n  ): Promise<QueryResponse<M>> {\n    return this.request<QueryResponse<M>>('POST', `/v1/query/${lens}`, params ?? {})\n  }\n\n  // ── Streaming ops — single-record observation ───────────\n\n  /**\n   * Observe a single record by id. First yield is the current record state;\n   * subsequent yields fire only when the record actually changes (server-side\n   * per-subscription hash dedup). Terminates when the consumer breaks, the\n   * abort signal fires, or the server closes the stream.\n   */\n  observe<M = Record<string, unknown>>(\n    lens: string,\n    recordId: string,\n  ): AsyncIterable<M> {\n    return this.runObserveOp<M>(lens, {\n      id: this.nextOpId(),\n      op: 'observe',\n      params: { recordId },\n    })\n  }\n\n  // ── Internal ─────────────────────────────────────────────\n\n  private opCounter = 0\n  private nextOpId(): string {\n    this.opCounter += 1\n    return `op_${Date.now().toString(36)}_${this.opCounter}`\n  }\n\n  /**\n   * Run a chunked op (search.stream / query.stream). The transport yields\n   * `row` frames; we push each row into the queue as-is. Terminates on\n   * `done` / `error` / socket close.\n   */\n  private runChunkedOp<T>(lens: string, frame: StreamOpFrame): AsyncIterable<T> {\n    const queue = createAsyncQueue<T>()\n    const transport = this.buildOpTransport<T>(lens, frame, queue, {\n      onRow: (data) => queue.push(data as T),\n      // `event` frames shouldn't arrive on chunked ops, but if they do we\n      // silently ignore rather than crash the iterator.\n      onEvent: () => {},\n    })\n    return this.wrapIterable(queue, transport)\n  }\n\n  /**\n   * Run a long-lived live op (subscribe). The transport yields `event`\n   * frames; we wrap each as a `StreamEvent` before pushing.\n   */\n  private runLiveOp<M>(lens: string, frame: StreamOpFrame): AsyncIterable<StreamEvent<M>> {\n    const queue = createAsyncQueue<StreamEvent<M>>()\n    const transport = this.buildOpTransport<StreamEvent<M>>(lens, frame, queue, {\n      onRow: () => {},\n      onEvent: (kind, record) => queue.push({ kind, record: record as M }),\n    })\n    return this.wrapIterable(queue, transport)\n  }\n\n  /**\n   * Run an observe op. Like subscribe but yields the raw record (not\n   * wrapped in a StreamEvent) — first yield is current state, subsequent\n   * yields are deltas.\n   */\n  private runObserveOp<M>(lens: string, frame: StreamOpFrame): AsyncIterable<M> {\n    const queue = createAsyncQueue<M>()\n    const transport = this.buildOpTransport<M>(lens, frame, queue, {\n      onRow: () => {},\n      onEvent: (_kind, record) => queue.push(record as M),\n    })\n    return this.wrapIterable(queue, transport)\n  }\n\n  /**\n   * Build the transport + register the PendingOp + kick off the send.\n   * Returns the transport so the iterator wrapper can close it on break.\n   */\n  private buildOpTransport<T>(\n    lens: string,\n    frame: StreamOpFrame,\n    queue: ReturnType<typeof createAsyncQueue<T>>,\n    handlers: {\n      onRow: (data: unknown) => void\n      onEvent: (kind: 'insert' | 'update' | 'delete', record: unknown) => void\n    },\n  ): WsTransport {\n    const url = buildStreamUrl(this.baseUrl, this.wsUrl, lens, this.apiKey, this.userToken)\n    const transport = new WsTransport({ url, WebSocket: this.WsCtor })\n\n    const op: PendingOp = {\n      id: frame.id!,\n      kind:\n        frame.op === 'search.stream' || frame.op === 'query.stream'\n          ? 'chunked'\n          : frame.op === 'observe'\n            ? 'observe'\n            : 'live',\n      onRow: handlers.onRow,\n      onEvent: handlers.onEvent,\n      onDone() {\n        queue.done()\n        transport.close()\n      },\n      onError(code, message) {\n        queue.error(toStreamError(code, message, lens))\n        transport.close()\n      },\n      onClosed(code, reason) {\n        if (!queue.closed) {\n          queue.error(closeCodeToError(code, reason))\n        }\n      },\n    }\n    transport.registerOp(op)\n\n    // Kick off the op. Any error from send() surfaces to the first `next()`.\n    void transport.send(frame).catch((err) => {\n      queue.error(err instanceof Error ? err : new Error(String(err)))\n      transport.close()\n    })\n\n    return transport\n  }\n\n  /**\n   * Wrap an AsyncQueue so that a consumer breaking out of `for await` tears\n   * down the transport cleanly.\n   */\n  private wrapIterable<T>(\n    queue: ReturnType<typeof createAsyncQueue<T>>,\n    transport: WsTransport,\n  ): AsyncIterable<T> {\n    const base = queue[Symbol.asyncIterator].bind(queue)\n    return {\n      [Symbol.asyncIterator](): AsyncIterator<T> {\n        const inner = base()\n        return {\n          async next() {\n            return inner.next()\n          },\n          async return() {\n            if (inner.return) await inner.return(undefined as unknown as T)\n            transport.close()\n            return { value: undefined as unknown as T, done: true }\n          },\n        }\n      },\n    }\n  }\n\n  private async request<T>(method: string, path: string, body?: unknown): Promise<T> {\n    const url = `${this.baseUrl}${path}`\n\n    const headers: Record<string, string> = {\n      'Content-Type': 'application/json',\n      Authorization: `Bearer ${this.apiKey}`,\n    }\n    if (this.userToken) {\n      headers['X-User-Token'] = this.userToken\n    }\n\n    const res = await this.fetchFn(url, {\n      method,\n      headers,\n      body: body ? JSON.stringify(body) : undefined,\n    })\n\n    if (!res.ok) {\n      const parsed = await res.json().catch(() => ({ error: res.statusText }))\n      const detail = (parsed as { error?: string }).error ?? res.statusText\n\n      if (res.status === 401) throw new BeamAuthError(detail, path)\n      if (res.status === 404) throw new BeamNotFoundError(detail, path)\n      throw new BeamError(res.status, detail, path)\n    }\n\n    return res.json() as Promise<T>\n  }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@semilayer/client",
+  "version": "1.1.0",
+  "description": "SemiLayer Beam client runtime — fetch, auth, pagination",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@semilayer/core": "workspace:*"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}