open-index/open-npm huggingface dataset:
npm package: @streamroot/videojs-hlsjs-plugin
Description: Adds HLS playback support to [video.js 5.0+](https://github.com/videojs/video.js) using [hls.js library](https://github.com/video-dev/hls.js/).
Author: Streamroot
Latest version: 1.0.16
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
npm package: @streamspaceio/streamspace-sdk-js
Description: A js sdk for streamspace-io sfu
Author: streamspace
Latest version: 0.1.0

# streamspace-sdk-js

Frontend sdk for the StreamSpace backend.

## Installation

`npm install streamspace-sdk-js`

## Usage

```ts
import { Client, LocalStream, RemoteStream } from 'streamspace-sdk-js';
const client = new Client({ url: 'wss://endpoint' });

// Setup handlers
client.on('peer-join', (uid: string, info: any) => {});
client.on('peer-leave', (uid: string) => {});
client.on('transport-open', () => {});
client.on('transport-closed', () => {});
client.on('stream-add', (uid: string, info: any) => {});
client.on('stream-remove', (stream: RemoteStream) => {});
client.on('broadcast', (uid: string, info: any) => {});

// Join a room
client.join(rid, {
    name: "name"
});

// Leave current room
client.leave();

// Get a local stream
const local = await LocalStream.getUserMedia({
    audio: true,
    video: true
});

// Publish local stream
client.publish(local);

// Unpublish local stream
local.unpublish();

// Subscribe to a remote stream
const remote = client.subscribe(mid);

// Unsubscribe from a stream
remote.unsubscribe();

// Broadcast a payload to the room
client.broadcast(payload);

// Close client connection
client.close();
```
npm package: @streamsql/streamsql-js
Description: StreamSQL's javascript ingestion API
Author: StreamSQL
Latest version: 1.0.0

# StreamSQL Javascript Ingestion API

> Upload data on your StreamSQL event streams.

## Install

### npm

```sh
npm install @streamsql/streamsql-js
```

### CDN

If not using a bundler, the package is available via CDN. Include the script tag in all pages where `streamsql` is used.

```html
<script crossorigin src="https://unpkg.com/@streamsql/streamsql-js"></script>
```

## Usage

```javascript
import streamsql from '@streamsql/streamsql-js'

// Initialize the client
streamsql.init(process.env.APIKEY)

// Set custom user properties
streamsql.identify('USER_ID')

// Send data on your streams
streamsql.sendEvent(
  'mystream',
  { eventName: 'My Event' },
)
```

## API

### streamsql

#### `streamsql.init(APIKEY <string>)`

Initialize the streamsql client with your API key. If you are using the CDN script, this must be called first on every page streamsql is used.

#### `streamsql.identify(userId <string>)`

Set a user id to be tied with events. The user id is persisted throughout multiple sessions.Use `streamsql.unidentify()` to clear set user ids.

#### `streamsql.unidentify()`

Clears any stored user ids that were set by `streamsql.identify('userId')`.

#### `streamsql.sendEvent(streamName <string> [,data <object>, onSent <function>])`

Send data to `streamName`. The stream name must be valid and registered prior to sending. If data is not provided, default options will be sent including page context, any set user ids, timestamps, and so on. `onSent` is a an optional callback that is called with the response status code and response text when sending is complete.

## Related

> streamsql-pixel: Simple starter script to gather some general visitor data.
npm package: @streamster/core
Description: Streamster is a JavaScript library designed to make working with water resource related APIs simpler. Currently, Streamster supports querying the [USGS Daily Values](https://waterservices.usgs.gov/rest/DV-Test-Tool.html) and [USGS Instantaneous Values](ht
Author: Ben Tyler
Latest version: 0.0.1-alpha.2

# @Streamster/core

Streamster is a JavaScript library designed to make working with water resource related APIs simpler. Currently, Streamster supports querying the [USGS Daily Values](https://waterservices.usgs.gov/rest/DV-Test-Tool.html) and [USGS Instantaneous Values](https://waterservices.usgs.gov/rest/IV-Test-Tool.html) services. It is still very much a work in progress, but currently allows querying by a variety location, parameter, and time period arguments.

## Roadmap

I am hoping to add support for all of [USGS Water Services](https://waterservices.usgs.gov) as well as the some of the Colorado DWR web services.
npm package: @streamster/coyote
Description: A wiley, shapeshifting data transformation utility.
Author: Ben Tyler
Latest version: 0.0.1-alpha.2

# @streamster/coyote

> :warning: @streamster/coyote is still very much a work in progress. Features and implementations are likely to change.

A wiley, shapeshifting data transformation utility.

The aim of coyote is to make the process of programmatically transforming an input data set to match a desired output structure much simpler. The need for this package arose when I started working with the USGS Water Services. 

## Getting Started

To install the package

```bash
# yarn
yarn add @streamster/coyote

# npm
npm install @streamster/coyote
```

## Usage

Coyote currently only exports the `transform` function, but I am guessing this will change down the road. Usage is relatively straightforward. You just need to provide a `data` and `schema` argument like in the example below. Pass the data that you would like to transform to the `data` argument. This can be an object or array. The `schema` argument expects an object with the desired property names and mappings for each object that is output by `transform`. 

Using the `schema` in the example below, you can see that we want the `transform` function return an array of objects with the fields `date`, `siteId`, `siteName`, `parameter`...you get the idea. The value for each of these keys in the schema object represents where coyote needs to grab the associated value from in the source dataset. The string value follows the JavaScript Object Dot Notation with one very important exception. If the property you are accessing is an array and you need to iterate over it, you will need to place an `*` after the property name that will be iterated over. For example `results.*.location` will traverse the source data up until it hits the `results` property at which point it will loop through it and grab the value for the `location` property from each array item. This is difficult to explain but easier to show.

```js
import { transform } from '@streamster/coyote';

// some mock source data to transform
const sourceData = {
  meta: {
    datasetName: 'Some Imaginaray Dataset',
    organization: 'Streamster',
    resultCount: 2
  },
  results: [
    { id: 1, date: '2021-02-10T14:24:29.909Z', location: 'LL-1', resultValue: 12 },
    { id: 2, date: '2021-02-12T14:24:29.909Z', location: 'LL-1', resultValue: 14 }
  ]
};

// define our desired output format and map our fields
// to fields in the source data
const transformSchema = {
  id: 'results.*.id',
  date: 'results.*.date',
  siteName: 'results.*.location',
  value: 'results.*.resultValue',
  organization: 'meta.organization'
};

const data = transform({
  data: sourceData,
  schema: transformSchema,
});

// data will yield
//  [
//    { 
//      id: 1, 
//      date: '2021-02-10T14:24:29.909Z', 
//      siteName: 'LL-1', 
//      value: 12, 
//      organization: 'streamster'
//    },
//    { 
//      id: 1, 
//      date: '2021-02-12T14:24:29.909Z', 
//      siteName: 'LL-1', 
//      value: 14, 
//      organization: 'streamster'
//    }
//  ]
```
npm package: @streamstraight/client
Description: Browser client SDK for consuming Streamstraight streams.
Latest version: 0.3.4

# @streamstraight/client

Streamstraight improves long-running LLM streaming to your frontend by replacing server sent events with websockets. We ensure streams resume upon reconnection, enable LLM requests in async jobs, and provide reliability to user-facing AI loading states.

`@streamstraight/client` contains Streamstraight's browser client SDK. A LLM stream provided to `@streamstraight/server` can be fetched and tailed using this client SDK.

```bash
npm install --save @streamstraight/client
```

## Usage

In a React app:

```ts
import { connectStreamstraightClient } from "@streamstraight/client";
import type OpenAI from "openai";

async function fetchStreamstraightToken(): Promise<string> {
  const response = await fetch("/api/streamstraight-token", { method: "POST" });
  if (!response.ok) {
    throw new Error("Failed to fetch Streamstraight token");
  }
  const { jwtToken } = (await response.json()) as { jwtToken: string };
  return jwtToken;
}

export default function AiChatPage() {
  useEffect(() => {
    // Obtain your streamId from your backend here
    const streamId = "chat-123";
    handleLlmStream({ streamId });
  }, []);

  async function handleLlmStream({ streamId }: { streamId: string }) {
    const ssClient =
      await connectStreamstraightClient<OpenAI.Responses.ResponseStreamEvent>(
        { fetchToken: fetchStreamstraightToken },
        { streamId },
      );

    for await (const chunk of ssClient.toAsyncIterable()) {
      // Handle each chunk as it's streamed
    }
  }

  // Render your UI here
}
```

For more information, visit [docs.streamstraight.com](https://docs.streamstraight.com).
npm package: @streamstraight/protocol
Description: Shared protocol contracts for Streamstraight SDKs and API.
Latest version: 0.1.6

# @streamstraight/protocol

Shared protocol definitions used by the Streamstraight SDKs. The package provides Zod schemas, event maps, and constants that keep producers and consumers in sync.

## Usage

Do not install this package directly. It is a dependency of `@streamstraight/server` and `@streamstraight/client`.

Most users should interact with the higher-level SDKs. This package is available if you need to build custom integrations or validate events yourself.
npm package: @streamstraight/server
Description: TypeScript server SDK for streaming data into Streamstraight.
Latest version: 0.1.9

# @streamstraight/server

Streamstraight improves long-running LLM streaming to your frontend by replacing server sent events with websockets. We ensure streams resume upon reconnection, enable LLM requests in async jobs, and provide reliability to user-facing AI loading states.

`@streamstraight/server` contains Streamstraight's server-side SDK. Pass your LLM stream to this SDK, and it will be available in our browser client SDK `@streamstraight/client`.

```bash
npm install --save @streamstraight/server
```

## Usage

Using OpenAI as your LLM provider:

```ts
import { streamstraightServer } from "@streamstraight/server";
import OpenAI from "openai";

export async function POST(request: Request) {
  // Call your LLM provider
  const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
  const stream = await openai.responses.stream({
    // ... other options
  });

  // Create a Streamstraight server and pass the stream to it.
  // Make sure to set a unique streamId.
  const streamId = crypto.randomUUID();
  const server = await streamstraightServer(
    { apiKey: process.env.STREAMSTRAIGHT_API_KEY! },
    { streamId },
  );
  await server.stream(stream);

  return { streamId };
}
```

You can also use this SDK to obtain your Streamstraight client JWT:

```ts
import { fetchClientToken } from "@streamstraight/server";

// /api/streamstraight-jwt
export async function POST(request: Request) {
  const token = await fetchClientToken({ apiKey: process.env.STREAMSTRAIGHT_API_KEY! });

  return { token };
}
```

## Logging

The SDK defaults to logging only errors. To see more detailed logs (useful for debugging connection issues), you can adjust the log level:

```ts
import { setLogLevel, LogLevel } from "@streamstraight/server";

// Set to INFO to see connection attempts and stream lifecycle
setLogLevel(LogLevel.INFO);

// Set to DEBUG to see all internal operations
setLogLevel(LogLevel.DEBUG);

// Set to WARN to see only warnings and errors
setLogLevel(LogLevel.WARN);

// Disable SDK logging entirely
setLogLevel(LogLevel.SILENT);
```

For more information, visit [docs.streamstraight.com](https://docs.streamstraight.com).
npm package: @streamy-cn/auth-js
Description: streamy-cn auth js client
Author: byteplanet
Latest version: 0.0.1

# `gotrue-js`

An isomorphic JavaScript client library for the [GoTrue](https://github.com/supabase/gotrue) API.

## Docs

- Using `gotrue-js`: https://supabase.com/docs/reference/javascript/auth-signup
- TypeDoc: https://supabase.github.io/gotrue-js/

## Quick start

Install

```bash
npm install --save @supabase/gotrue-js
```

Usage

```js
import { GoTrueClient } from '@supabase/gotrue-js'

const GOTRUE_URL = 'http://localhost:9999'

const auth = new GoTrueClient({ url: GOTRUE_URL })
```

- `signUp()`: https://supabase.io/docs/reference/javascript/auth-signup
- `signIn()`: https://supabase.io/docs/reference/javascript/auth-signin
- `signOut()`: https://supabase.io/docs/reference/javascript/auth-signout

### Custom `fetch` implementation

`gotrue-js` uses the [`cross-fetch`](https://www.npmjs.com/package/cross-fetch) library to make HTTP requests, but an alternative `fetch` implementation can be provided as an option. This is most useful in environments where `cross-fetch` is not compatible, for instance Cloudflare Workers:

```js
import { GoTrueClient } from '@supabase/gotrue-js'

const GOTRUE_URL = 'http://localhost:9999'

const auth = new GoTrueClient({ url: GOTRUE_URL, fetch: fetch })
```

## Sponsors

We are building the features of Firebase using enterprise-grade, open source products. We support existing communities wherever possible, and if the products don’t exist we build them and open source them ourselves.

[![New Sponsor](https://user-images.githubusercontent.com/10214025/90518111-e74bbb00-e198-11ea-8f88-c9e3c1aa4b5b.png)](https://github.com/sponsors/supabase)

![Watch this repo](https://gitcdn.xyz/repo/supabase/monorepo/master/web/static/watch-repo.gif 'Watch this repo')
npm package: @streamy-cn/streamy-js
Description: Javascript client for Streamy
Author: byteplanet
Latest version: 0.0.2

# `supabase-js`

An isomorphic JavaScript client for Supabase.

- **Documentation:** https://supabase.com/docs/client/supabase-client
- TypeDoc: https://supabase.github.io/supabase-js

## Usage

First of all, you need to install the library:

```sh
npm install @supabase/supabase-js
```

Then you're able to import the library and establish the connection with the database:

```js
import { createClient } from '@supabase/supabase-js'

// Create a single supabase client for interacting with your database
const supabase = createClient('https://xyzcompany.supabase.co', 'public-anon-key')
```

### UMD

You can now use plain `<script>`s to import supabase-js from CDNs, like:

```html
<script src="https://cdn.jsdelivr.net/npm/@supabase/supabase-js"></script>
```

or even:

```html
<script src="https://unpkg.com/@supabase/supabase-js"></script>
```

Then you can use it from a global `supabase` variable:

```html
<script>
  const { createClient } = supabase
  const _supabase = createClient('https://xyzcompany.supabase.co', 'public-anon-key')

  console.log('Supabase Instance: ', _supabase)
  // ...
</script>
```

### ESM

You can now use type="module" `<script>`s to import supabase-js from CDNs, like:

```html
<script type="module">
  import { createClient } from 'https://cdn.jsdelivr.net/npm/@supabase/supabase-js/+esm'
  const supabase = createClient('https://xyzcompany.supabase.co', 'public-anon-key')

  console.log('Supabase Instance: ', supabase)
  // ...
</script>
```

### Custom `fetch` implementation

`supabase-js` uses the [`cross-fetch`](https://www.npmjs.com/package/cross-fetch) library to make HTTP requests, but an alternative `fetch` implementation can be provided as an option. This is most useful in environments where `cross-fetch` is not compatible, for instance Cloudflare Workers:

```js
import { createClient } from '@supabase/supabase-js'

// Provide a custom `fetch` implementation as an option
const supabase = createClient('https://xyzcompany.supabase.co', 'public-anon-key', {
  fetch: (...args) => fetch(...args),
})
```

## Sponsors

We are building the features of Firebase using enterprise-grade, open source products. We support existing communities wherever possible, and if the products don’t exist we build them and open source them ourselves. Thanks to these sponsors who are making the OSS ecosystem better for everyone.

[![New Sponsor](https://user-images.githubusercontent.com/10214025/90518111-e74bbb00-e198-11ea-8f88-c9e3c1aa4b5b.png)](https://github.com/sponsors/supabase)
npm package: @streamygg/kient
Description: TypeScript-First Client Library for Kick.com
Author: Soulweaver
Latest version: 1.0.1

<h1 align="center">
Kient
</h1>

<p align="center">
  <a href="https://github.com/zSoulweaver/kient/blob/master/LICENSE">
    <img src="https://img.shields.io/badge/license-MIT-blue.svg?style=for-the-badge&labelColor=181a1e&color=00e701&">
  </a>
  <a href="https://www.npmjs.com/package/kient">
    <img src="https://img.shields.io/npm/v/kient.svg?logo=npm&style=for-the-badge&labelColor=181a1e&color=00e701&logoColor=fff">
  </a>
  <a href="https://kient.pages.dev/">
    <img src="https://img.shields.io/badge/Documentation-fff?style=for-the-badge">
  </a>
</p>

## About

Kient (**K**ick-Cl**ient**) is a versatile TypeScript client designed to simplify interaction with Kick's API and WebSocket. With Kient, you can seamlessly integrate Kick's platform into your projects, making it easier than ever to leverage its capabilities.


## Documentation

Learn how to use Kient and find detailed information on the [website](https://kient.pages.dev/).

## Installation and Example Usage

Install Kient with your preferred package manager.

```bash
$ pnpm add kient
```

Import Kient, create a new instance, and interact with API endpoints or listen to WebSocket events.
```ts
import { Events, Kient } from 'kient'

// Create a new client instance
const client = await Kient.create()

// Get a channel and listen to its chatroom
const channel = await client.api.channel.getChannel('channel_slug')
await client.ws.chatroom.listen(channel.data.chatroom.id)

// Handle incoming messages
client.on(Events.Chatroom.Message, (message) => {
  console.log(message.data)
})
```

## License

Kient is licensed under the [MIT License](https://github.com/zSoulweaver/kient/blob/master/LICENSE).
npm package: @streamyy/cli
Description: CLI for scaffolding Streamyy backend and frontend apps.
Latest version: 0.1.1

# @streamyy/cli

CLI package for scaffolding Streamyy starters.

## Usage

```bash
npx @streamyy/cli init
npx @streamyy/cli init --backend
npx @streamyy/cli init --frontend
npx @streamyy/cli init --frontend --custom
```

## Output

- `streamyy-backend` for the backend starter
- `streamyy-frontend` for the frontend starter

Use `--custom` when you want the frontend starter to scaffold `StreamyyProvider` and `useStreamyy()` instead of the default widget.
npm package: @streamyy/client
Description: Frontend client, React hooks, UI components, and WebRTC helpers for Streamyy.
Latest version: 0.4.1

# @streamyy/client

Frontend client package for Streamyy.

It includes the Socket.IO signaling client, React hooks, install-ready UI components, ringtone helpers, and WebRTC utilities for browser calling flows.

## Install

```bash
npm install @streamyy/client react react-dom socket.io-client
```

## Usage

```tsx
import { StreamyyProvider, StreamyyCallWidget } from "@streamyy/client";

export function App() {
  return (
    <StreamyyProvider
      options={{
        url: "http://localhost:3000",
        userId: "user-1",
        token: "demo-token",
      }}
    >
      <StreamyyCallWidget defaultReceiverId="user-2" />
    </StreamyyProvider>
  );
}
```

## Includes

- signaling client
- React provider and hook
- default calling widget
- start-audio and start-video hook actions for custom buttons
- customizable incoming-call and active-call screens
- typed `error` event for transport and rate-limit failures
- ringtone helpers
- video layout helpers
- WebRTC peer session helpers

See the workspace root `README.md` for setup details and advanced usage.
npm package: @streamyy/core
Description: Core domain types, events, repositories, and call lifecycle services for Streamyy.
Latest version: 0.1.1

# @streamyy/core

Core domain package for Streamyy.

It contains the shared call types, signaling events, repository interfaces, in-memory persistence adapter, and the service that drives the call lifecycle.

## Install

```bash
npm install @streamyy/core
```

## Includes

- call session and presence types
- socket event names
- repository and notifier interfaces
- in-memory repositories
- call lifecycle service factory

## Usage

```ts
import { createInMemoryPersistenceAdapter, createStreammyService } from "@streamyy/core";

const persistence = createInMemoryPersistenceAdapter();

const service = createStreammyService({
  sessions: persistence.sessions,
  presence: persistence.presence,
  connections: persistence.connections,
  notifier: {
    async emitToUser() {},
    async emitToConnection() {},
  },
});
```

See the workspace root `README.md` for the full backend and frontend integration guide.
npm package: @streamyy/dynamodb
Description: DynamoDB persistence adapter for Streamyy call sessions, presence, and connections.
Latest version: 0.1.0

# @streamyy/dynamodb

DynamoDB persistence adapter for Streamyy.

## Install

```bash
npm install @streamyy/server @streamyy/dynamodb @aws-sdk/lib-dynamodb
```

## Usage

```ts
import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
import { createDynamoDbPersistenceAdapter } from "@streamyy/dynamodb";
import { createStreammyServer } from "@streamyy/server";

const dynamo = DynamoDBDocumentClient.from(baseClient);

const streammy = createStreammyServer({
  httpServer,
  persistence: createDynamoDbPersistenceAdapter({
    client: dynamo,
  }),
});
```

## Good fit

- AWS-native deployments
- serverless backends
- horizontally scalable metadata storage
npm package: @streamyy/mongoose
Description: Mongoose persistence adapter for Streamyy call sessions, presence, and connections.
Latest version: 0.1.0

# @streamyy/mongoose

MongoDB/Mongoose persistence adapter for Streamyy.

## Install

```bash
npm install @streamyy/server @streamyy/mongoose mongoose
```

## Usage

```ts
import mongoose from "mongoose";
import { createServer } from "node:http";
import { createMongoosePersistenceAdapter } from "@streamyy/mongoose";
import { createStreammyServer } from "@streamyy/server";

await mongoose.connect(process.env.MONGODB_URI!);

const httpServer = createServer();

const streammy = createStreammyServer({
  httpServer,
  persistence: createMongoosePersistenceAdapter(mongoose),
});
```

## What it provides

- Call session model
- User presence model
- Socket connection model
- Mongoose repository implementations
- `createMongoosePersistenceAdapter(...)`
npm package: @streamyy/postgres
Description: PostgreSQL persistence adapter for Streamyy call sessions, presence, and connections.
Latest version: 0.1.0

# @streamyy/postgres

PostgreSQL persistence adapter for Streamyy.

## Install

```bash
npm install @streamyy/server @streamyy/postgres pg
```

## Usage

```ts
import { Pool } from "pg";
import { createPostgresPersistenceAdapter } from "@streamyy/postgres";
import { createStreammyServer } from "@streamyy/server";

const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
});

const streammy = createStreammyServer({
  httpServer,
  persistence: createPostgresPersistenceAdapter({
    client: pool,
  }),
});
```

## SQL schema

See [schema.sql](C:/Users/USER/Desktop/programming/javascript/packages/streamyy/packages/postgres/examples/schema.sql).
npm package: @streamyy/prisma
Description: Prisma persistence adapter for Streamyy call sessions, presence, and connections.
Latest version: 0.1.0

# @streamyy/prisma

Prisma persistence adapter for Streamyy.

## Install

```bash
npm install @streamyy/server @streamyy/prisma
```

## Usage

```ts
import { createPrismaPersistenceAdapter } from "@streamyy/prisma";
import { createStreammyServer } from "@streamyy/server";

const streammy = createStreammyServer({
  httpServer,
  persistence: createPrismaPersistenceAdapter({
    callSession: prisma.callSession,
    userPresence: prisma.userPresence,
    socketConnection: prisma.socketConnection,
  }),
});
```

## Prisma schema example

See [schema.prisma](C:/Users/USER/Desktop/programming/javascript/packages/streamyy/packages/prisma/examples/schema.prisma).
npm package: @streamyy/redis
Description: Redis persistence adapter for Streamyy call sessions, presence, and connections.
Latest version: 0.1.0

# @streamyy/redis

Redis persistence adapter for Streamyy.

## Install

```bash
npm install @streamyy/server @streamyy/redis redis
```

## Usage

```ts
import { createClient } from "redis";
import { createRedisPersistenceAdapter } from "@streamyy/redis";
import { createStreammyServer } from "@streamyy/server";

const redis = createClient({ url: process.env.REDIS_URL });
await redis.connect();

const streammy = createStreammyServer({
  httpServer,
  persistence: createRedisPersistenceAdapter({
    client: redis,
  }),
});
```

## Good fit

- lightweight deployments
- fast presence and connection tracking
- short-lived call state
npm package: @streamyy/server
Description: Socket.IO runtime and framework adapters for Streamyy signaling backends.
Latest version: 0.1.1

# @streamyy/server

Backend runtime package for Streamyy.

It provides the Socket.IO signaling transport, runtime bootstrap helpers, and lightweight framework adapters for Express, Fastify, and Nest-style setups.

## Install

```bash
npm install @streamyy/server socket.io
```

## Usage

```ts
import { createServer } from "node:http";
import { createStreammyRuntime } from "@streamyy/server";

const httpServer = createServer();

const streammy = createStreammyRuntime({
  httpServer,
  rateLimit: {
    connectionAttempts: { max: 20, windowMs: 60_000 },
    callInitiation: { max: 8, windowMs: 60_000 },
  },
  auth: async () => ({ userId: "user-1", deviceId: "device-1" }),
});

streammy.bind();
httpServer.listen(3000);
```

## Includes

- Socket.IO signaling event binding
- runtime creation with in-memory persistence by default
- configurable in-memory rate limiting for connection attempts and call initiation
- Express adapter
- Fastify adapter
- Nest-style module helpers

See the workspace root `README.md` for end-to-end usage with persistence adapters.
npm package: @streamyy/supabase
Description: Supabase persistence adapter for Streamyy call sessions, presence, and connections.
Latest version: 0.1.0

# @streamyy/supabase

Supabase persistence adapter for Streamyy.

## Install

```bash
npm install @streamyy/server @streamyy/supabase @supabase/supabase-js
```

## Usage

```ts
import { createClient } from "@supabase/supabase-js";
import { createSupabasePersistenceAdapter } from "@streamyy/supabase";
import { createStreammyServer } from "@streamyy/server";

const supabase = createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_KEY!);

const streammy = createStreammyServer({
  httpServer,
  persistence: createSupabasePersistenceAdapter({
    callSession: supabase.from("streammy_call_sessions"),
    userPresence: supabase.from("streammy_user_presence"),
    socketConnection: supabase.from("streammy_socket_connections"),
  }),
});
```

## SQL schema

See [schema.sql](C:/Users/USER/Desktop/programming/javascript/packages/streamyy/packages/supabase/examples/schema.sql).