open-index/open-npm huggingface dataset:
npm package: @signal-fire/client
Description: Client for Signal-Fire Server
Author: Michiel van der Velde
Latest version: 1.4.0

# Signal-Fire Client

**Signal-Fire Client** is a **WebRTC** signaling client for
[Signal-Fire Server](https://github.com/Signal-Fire/server).

A WebRTC signaling server communicates between peers to set up
peer-to-peer audio/video and/or data channels. This allows your
clients to communicate directly with each other.

## Features

* Works __seamlessly__ with [Signal-Fire Server](https://github.com/Signal-Fire/server)
* __Abstracts away__ the hassles of setting up peer connections
* Uses a __simple__, JSON-based [protocol](https://github.com/Signal-Fire/server/blob/main/PROTOCOL.md)
* __No__ forest of dependencies

## Install

Install using npm:

```
npm i @signal-fire/client
```

## Documentation

[Click here to view the documentation](https://signal-fire.github.io/client/).

## Example

> __Note__: Is is assumed the server is running
> [Signal Fire Server](https://github.com/Signal-Fire/server)
> or a server which uses the same [protocol](https://github.com/Signal-Fire/server/blob/main/PROTOCOL.md).

> See the documentation for more examples!

This example shows how to start a session.

```ts
import connect, { SessionAcceptedEvent } from '@signal-fire/client'

async function run () {
  const client = await connect('ws://localhost:3003/socket')
  const session = await client.createSession('<target id>')

  session.addEventListener('accepted', (ev: SessionAcceptedEvent) => {
    console.log('Session accepted!')

    const connection = ev.detail
    const stream = await navigator.mediaDevices.getUserMedia({
      video: true,
      audio: true
    })

    stream.getTracks().forEach(track => {
      connection.addTrack(track, stream)
    })
  })

  session.addEventListener('rejected', () => {
    console.log('Session rejected')
  })

  session.addEventListener('timed-out', () => {
    console.log('Session timed out')
  })
}
```

This example shows how to accept a session.

```ts
import connect, { IncomingSessionEvent } from '@signal-fire/client'

async function run () {
  const client = await connect('ws://localhost:3003/socket')

  client.addEventListener('session', (ev: IncomingSessionEvent) => {
    const session = ev.detail
    const connection = await session.accept()
  })
}
```
npm package: @signal-fire/peer
Description: Wrapper for the native RTCPeerConnection to make life a little easier
Author: Michiel van der Velde
Latest version: 1.0.0

# Signal Fire Peer

Wrapper for the native `RTCPeerConnection` to make life a little easier.

## Install

```
> npm i @signal-fire/peer
```

## Example

```typescript
import Peer, {
  SessionDescriptionEvent
  IceCandidateEvent,
  DataChannelEvent
} from '@signal-fire/peer'

// Create a new RTCPeerConnection to wrap
const connection = new RTCPeerConnection()
// Create a new peer from the connection
const peer = new Peer(connection)

peer.addEventListener('description', ({ description }: SessionDescriptionEvent) => {
  // send the description to the remote peer through the signaling server
})

peer.addEventListener('icecandidate', ({ candidate }: ICECandidateEvent) => {
  if (candidate) {
    // send the ICE candidate to the remote peer through the signaling server
  }
})

// When we get a session description from the remote peer...
await peer.setSessionDescription(description)

// When we get an ICE candidate from the remote peer...
await peer.addIceCandidate(candidate)
```

## License

Copyright 2021 Michiel van der Velde.

This software is licensed under [the MIT License](LICENSE).
npm package: @signal-fire/server
Description: WebRTC signaling server for node.js
Author: Michiel van der Velde
Latest version: 0.5.0

# Signal-Fire Server

**Signal-Fire Server** is a **WebRTC** signaling server built for node.js.

A WebRTC signaling server communicates between peers to set up peer-to-peer
audio/video and/or data channels. This allows your clients to communicate
directly with each other.

## Features

* WebSockets powered __[WebRTC](https://en.wikipedia.org/wiki/WebRTC) signaling server__
  * Messages are passed using [simple JSON objects](https://github.com/Signal-Fire/server/blob/main/PROTOCOL.md)
* There is a __tailor-made [browser client](https://github.com/Signal-Fire/client)__
  available as well
* __Automatic__ peer ID generation (also possible to plug in your own)
* __Automatic__ routing of messages
* Supports __one-to-one__, __one-to-many__ and __many-to-many__ out of the box
* Horizontally __scalable__ by using [registries](https://github.com/lucets/registry)

## Install

> You can help by reporting bugs or unexpected behavior.
> If you encounter anything, please open an issue, or even
> better, a pull request.

Install the module through npm:

```
npm i @signal-fire/server
```

## Command Line Interface (CLI)

There is also a CLI available to start and manage multiple
workers simultaneously. The CLI is a work-in-progress,
but can already be used.

To install the CLI:

```
npm i -g @signal-fire/cli
```

To start a new worker on port 3003:

```
> signal-fire start -p 3003
```

[See the CLI documentation](https://github.com/Signal-Fire/cli)
to learn how to use the CLI.

## Documentation

[Click here to view the documentation](https://signal-fire.github.io/server/).

## Example

In this example we use the `LocalRegistry` in-memory
registry from the [@lucets/registry](https://github.com/lucets/registry) package.

The resulting app is in fact just a [Luce](https://github.com/lucets/luce) application,
which you can extend yourself. You'll also need to
use your own HTTP server, of course.


```ts
import { Server } from 'http'

import createApp from './index'
import { LocalRegistry } from '@lucets/registry'

const registry = new LocalRegistry()
const app = createApp(registry)
const server = new Server()

server.on('upgrade', app.onUpgrade())
server.listen(3003, () => {
  console.log('Server listening on port 3003')
})

```

## License

Copyright 2021 Michiel van der Velde.

This software is licensed under [the MIT License](LICENSE).
npm package: @signal-kernel/core
Description: A minimal, deterministic, fine-grained reactivity engine.
Author: Luciano Lee
Latest version: 0.1.1

# @signal-kernel/core

A minimal, deterministic, fine-grained reactivity engine.

Build reactive systems without frameworks — from UI adapters to async dataflow runtimes.

> Think of this as a **reactive runtime kernel**, not a framework.

---

## Installation

```bash
npm install @signal-kernel/core
```

---

## Quick Start

```ts
import { signal, computed, createEffect } from "@signal-kernel/core";

const count = signal(0);

const doubled = computed(() => count.get() * 2);

createEffect(() => {
  console.log("doubled =", doubled.get());
});

count.set(1);
count.set(2);
```

Output:

```
doubled = 2
doubled = 4
```

---

## What is this?

`@signal-kernel/core` is a **framework-agnostic reactive runtime**.

It provides the minimal primitives needed to build reactive systems:

* `signal()` — mutable state
* `computed()` — lazy derived values
* `createEffect()` — reactive side effects
* `batch()` — update coalescing
* deterministic scheduler

Unlike frameworks (React, Vue), this library:

* does **not render UI**
* does **not manage DOM**
* focuses purely on **reactive dataflow and execution order**

---

## When to use this

Use `@signal-kernel/core` if you need:

* Fine-grained reactivity (no VDOM diffing)
* Deterministic update ordering
* A foundation for building:

  * UI adapters (React/Vue/Solid)
  * async data pipelines
  * reactive state machines
  * server-side reactive graphs

This is **not a UI framework** — it is a **low-level reactive kernel**.

---

## Core Concepts

### signal()

```ts
const count = signal(0);

count.get();
count.peek();
count.set(1);
```

---

### computed()

```ts
const doubled = computed(() => count.get() * 2);
```

---

### createEffect()

```ts
createEffect(() => {
  console.log(count.get());
});
```

---

### batch()

```ts
batch(() => {
  count.set(1);
  count.set(2);
});
```

---

## Scheduler Model

![Two-phase scheduler](../../docs/scheduler.svg)

This runtime uses a **two-phase deterministic scheduler**:

1. Recompute all stale computed nodes
2. Execute all effects

→ Guarantees stable and predictable execution order.

---

## Architecture Overview

![Reactive Graph](../../docs/architecture.svg)

For full details, see:

👉 [Architecture Documentation](../../docs/architecture.md)

---

## Public API

```ts
export { signal } from "./signal.js";
export { computed } from "./computed.js";
export { createEffect, onCleanup } from "./effect.js";
export { batch } from "./scheduler.js";
```

---

## Design Goals

* Deterministic scheduling
* Lazy computation
* Explicit dependency graph
* Zero framework assumptions
* Adapter-friendly architecture

---

## Ecosystem

`@signal-kernel/core` is the foundation of the Signal Kernel ecosystem.

Future packages:

* async runtime
* framework adapters

---

## License

MIT © Luciano
npm package: @signal-web-ui/angular
Description: Angular wrappers for Signal UI web components.
Latest version: 0.1.12

# @signal-web-ui/angular

Angular wrappers for Signal UI web components.

## Install

```bash
pnpm add @signal-web-ui/angular @signal-web-ui/core
```

## Usage

```ts
import { defineCustomElements } from "@signal-web-ui/core/loader";
import { SignalWebUiModule } from "@signal-web-ui/angular";

defineCustomElements();
```

```ts
@NgModule({
  imports: [SignalWebUiModule]
})
export class AppModule {}
```

Notes:
- Add `CUSTOM_ELEMENTS_SCHEMA` if you do not import `SignalWebUiModule`.
- Use property bindings like `[options]` for arrays/objects.
- Listen to custom events like `(valueChange)` and `(openChange)`.
npm package: @signal-web-ui/ember
Description: Ember addon for Signal UI web components (Ember 3.17 → latest).
Latest version: 0.1.12

# @signal-web-ui/ember

Ember addon for Signal UI web components (Ember 3.17 → latest).

## Install

```bash
pnpm add @signal-web-ui/ember @signal-web-ui/core
```

## Usage

The addon registers custom elements at app startup.

```hbs
<SignalButton @onClick={{this.handleClick}}>Save</SignalButton>
<SignalInput @value={{this.name}} @onValueChange={{this.onValueChange}} />
```

### Custom elements

If you prefer using the elements directly, the initializer automatically runs:

```ts
import { applyPolyfills, defineCustomElements } from "@signal-web-ui/core/loader";

applyPolyfills().then(() => defineCustomElements());
```

### Glimmer wrappers

Wrappers forward attributes, set properties for non-string values, and map custom events:

- `SignalInput`: `@onValueInput`, `@onValueChange`
- `SignalFileUpload`: `@onSelect`, `@onUpload`, `@onRemove`
- `SignalCombobox`: `@onValueChange`, `@onOpenChange`, `@onQueryChange`, `@onClear`
- `SignalModal`: `@onOpenChange`, `@onClose`, `@onConfirm`
- `SignalTable`: `@onRowClick`, `@onReorder`, `@onSearchChange`, `@onFilterChange`
npm package: @signal-web-ui/react
Description: React wrappers for Signal UI web components.
Latest version: 0.1.12

# @signal-web-ui/react

React wrappers for Signal UI web components.

## Install

```bash
pnpm add @signal-web-ui/react @signal-web-ui/core
```

## Usage

```tsx
import { defineCustomElements } from "@signal-web-ui/core/loader";
import { SignalButton } from "@signal-web-ui/react";

defineCustomElements();

export function Example() {
  return <SignalButton onClick={() => console.log("clicked")}>Hello</SignalButton>;
}
```

Notes:
- Complex props (arrays/objects) are passed as properties.
- Custom events map to props like `onValueChange` and `onOpenChange`.
npm package: @signal-web-ui/vue
Description: Vue wrappers for Signal UI web components.
Latest version: 0.1.12

# @signal-web-ui/vue

Vue wrappers for Signal UI web components.

## Install

```bash
pnpm add @signal-web-ui/vue @signal-web-ui/core
```

## Usage

```ts
import { defineCustomElements } from "@signal-web-ui/core/loader";

defineCustomElements();
```

```vue
<template>
  <SignalButton @click="onClick">Hello</SignalButton>
</template>
```

Notes:
- Bind complex props with `:prop` to set properties.
- Listen to custom events like `@valueChange` and `@openChange`.
npm package: @signal24/devtool-otel
Description: One-liner to start/stop local OpenTelemetry tools for development
Author: Signal24
Latest version: 0.0.6
Deprecated: This package has moved to @zyno-io/devtool-otel

Quick launch tool to launch a local Grafana LGTM environment for use in local development.

Startup: `npx @signal24/devtool-otel`\
Shutdown: `npx @signal24/devtool-otel down`

Exposes:
- Grafana at http://localhost:3200/explore
- gRPC OpenTelemetry collector at http://localhost:4317
- HTTP OpenTelemetry collector at http://localhost:4318
npm package: @signal24/vue-foundation
Description: Common components, directives, and helpers for Vue 3 apps
Latest version: 4.32.0
Deprecated: This package has moved to @zyno-io/vue-foundation

# @signal24/vue-foundation

A Vue 3 component library providing common components, directives, helpers, and hooks for building applications. Distributed as an ES module with full TypeScript type definitions.

## Documentation

Full documentation and live interactive demos: **[signal24.github.io/vue-foundation](https://signal24.github.io/vue-foundation/)**

## Quick Start

```bash
yarn add @signal24/vue-foundation
# Peer dependencies
yarn add vue date-fns lodash
```

```typescript
import { createApp } from 'vue';
import { installVf, configureVf, OverlayContainer } from '@signal24/vue-foundation';
import '@signal24/vue-foundation/dist/vue-foundation.css';

import App from './App.vue';

const app = createApp(App);
installVf(app);
configureVf({});
app.mount('#app');
```

See the [Getting Started guide](https://signal24.github.io/vue-foundation/guide/getting-started) for full setup instructions.

## What's Included

- **Components** — Modal system, searchable selects, toast notifications, overlay management
- **Directives** — v-tooltip, v-hotkey, v-datetime, v-confirm-button, v-infinite-scroll, and more
- **Helpers** — Error handling, form masking, context menus, string/number/object utilities
- **Hooks** — useInfiniteScroll, useResizeWatcher
- **Filters** — Display formatting via createFilters()
- **Types** — Branded types, PickRequired, PickOptional, and more

## License

MIT