open-index/open-npm huggingface dataset:
npm package: @hexaversia/fovea-sdk
Description: Foveated Streaming Engine: High-performance, bandwidth-efficient screen sharing using WASM and Dynamic ROI.
Author: Fovea Team
Latest version: 0.2.0

# Fovea SDK

**Foveated Streaming Engine** for High-Performance Screen Sharing.

![Fovea Banner](https://via.placeholder.com/800x200?text=Fovea+SDK)

## Overview
Fovea uses **WebAssembly (Rust)** to perform "Foveated Rendering" on video streams entirely on the client side. It detects changes in the screen and only sends high-resolution updates for the active region (ROI), while blurring the static background. This results in **massive bandwidth savings (up to 90%)** for screen sharing applications.

## Installation

```bash
npm install fovea-sdk
```

(Note: During private beta, install from local path or private registry)

## Usage

### 1. Electron (Node.js)

```javascript
const FoveaEngine = require('fovea-sdk');
const path = require('path');

async function start() {
    const engine = new FoveaEngine({ blurAmount: '12px' });
    
    // Initialize with local WASM file
    await engine.initialize({ 
        wasmPath: path.join(__dirname, 'node_modules/fovea-sdk/fovea_rs/pkg/fovea_wasm_bg.wasm') 
    });

    function loop() {
        // Process video frame -> canvas
        const result = engine.process(videoElement, outputCanvas);
        
        if (result && result.type === 'foveated') {
             console.log(`ROI: ${JSON.stringify(result.bbox)}`);
        }
        requestAnimationFrame(loop);
    }
}
```

### 2. Browser (React/Vue/Vanilla)

Copy the `.wasm` file to your public assets folder first.

```javascript
import FoveaEngine from 'fovea-sdk';

const engine = new FoveaEngine();

// Initialize by fetching WASM from public URL
await engine.initialize({ 
    wasmPath: '/assets/fovea_wasm_bg.wasm' 
});

// ... use engine.process() in your render loop
```

## Real-World Example
Using **Fovea** with an AI Video Analyzer to detect and describe drawings in real-time with minimal bandwidth usage:

![Real-World Demo](docs/assets/demo_robot.png)

## API

### `new FoveaEngine(config)`
- `config.blurAmount`: CSS blur string (default `'8px'`)
- `config.diffThreshold`: Sensitivity (0-255) for change detection (default `30`)

### `async initialize(options)`
- `options.wasmPath`: Path (Node) or URL (Browser) to the `.wasm` binary.
- `options.wasmBuffer`: ArrayBuffer of the WASM binary (optional alternative).

### `process(video, canvas)`
- `video`: Source HTMLVideoElement
- `canvas`: Target HTMLCanvasElement (where the foveated effect is drawn)
- Returns: `{ type, bbox, isKeyframe }`

## 🤝 Contributing
Want to improve the engine? We welcome optimizations!
Since the core is written in Rust, please see our [Contribution Guide](CONTRIBUTING.md) for build instructions.

## License
MIT
npm package: @hexcore/hcli
Description: CLI to help build hexcore based apps
Author: Mararok
Latest version: 0.9.4

# Hexcore CLI

## Description
Hexcore is advanced framework based on NestJS to build hexagonal architecture designed apps.
CLI package contains helper commands to faster create elements of Hexcore app like modules, commands, queries, entities.

## Usage:

In project folder execute:
```
hcli <command>
```

## Command list:
- **make:module \<name\>** - Creates new module with given name
- **make:module:command \<moduleName\> \<group\> \<name\>** - Creates new module command in selected command group with given name
npm package: @hexcore/mocker
Description: Simple and speed mock utils with typescript support
Author: Mararok
Latest version: 0.9.1
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# Hexcore Mocker

Package moved to https://www.npmjs.com/package/@hexancore/mocker


Mocker package is super simple wrapper for Jest mocks util with extra stuff :).

## Usage

```ts
import { Mocker } from '@hexcore/mocker';

interface TestMock {
  a(param1: string, param2: boolean): boolean;
  b(param1: string, param2: boolean): boolean;
}

// you can simply mock interface or class and give it descriptive name(used in errors)
const mock = Mocker.of<TestMock>("test_mock");

// define method call expectation(available methods list will be shows in VS)
mock.expects('a', 'test', true).andReturn(true);

// mock "i" attribute is object of mocked class, pass it where you need
mock.i.a('test', true);

// after execute your code, you can check sets expectations results with it(for many tests call it in jest "afterEach")
mock.checkExpections();
```

### Defining expectation

`Mocker::expects(method, ...args)` returns `MethodMock` object with you can define return value by:
*  `andReturnWith((implementation: (...args: any) => any)` - you can define your own method implementation
*  `andReturn(value: any)` - define returns passed value once
*  `andReturnResolved` - simple sugar function for andReturnWith((() => Promise.resolve(value))
npm package: @hexcuit/server
Description: [![npm version](https://img.shields.io/npm/v/@hexcuit/server)](https://www.npmjs.com/package/@hexcuit/server) [![CI](https://github.com/hexcuit/server/actions/workflows/ci.yml/badge.svg)](https://github.com/hexcuit/server/actions/workflows/ci.yml) [![code
Latest version: 0.13.0

# @hexcuit/server

[![npm version](https://img.shields.io/npm/v/@hexcuit/server)](https://www.npmjs.com/package/@hexcuit/server)
[![CI](https://github.com/hexcuit/server/actions/workflows/ci.yml/badge.svg)](https://github.com/hexcuit/server/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/hexcuit/server/graph/badge.svg)](https://codecov.io/gh/hexcuit/server)

Hono RPC type-safe client for Project LoL Server

## Installation

```bash
# Stable release
npm install @hexcuit/server

# Snapshot release (latest main branch)
npm install @hexcuit/server@snapshot
```

## Usage

```typescript
import { hcWithType, type Client } from '@hexcuit/server'

// Create type-safe client
const client = hcWithType('https://your-api.com')

// Type-safe API calls
const result = await client.rank.$get({
	query: { discordIds: ['123', '456'] },
})

// Type inference works automatically
const ranks = result.ranks // fully typed
```

## Development

### Server Development

```bash
npm install
npm run dev
```

### Deploy

```bash
npm run deploy
```

### Type Generation

[For generating/synchronizing types based on your Worker configuration](https://developers.cloudflare.com/workers/wrangler/commands/#types):

```bash
npm run cf-typegen
```

### Build for npm

```bash
npm run build
```

## Publishing

This package is automatically published to npm via GitHub Actions:

- **Stable release**: When a changeset PR is merged
- **Snapshot release**: When any PR is merged to main (`@snapshot` tag)

## License

MIT
npm package: @hexdeck/cli
Description: Real-time dashboard for Claude Code sessions — monitor agents, track plans, detect collisions
Latest version: 0.1.4

# Hexdeck

Real-time dashboard for your Claude Code and Codex sessions.

See what your agents are doing, track plans and progress, detect file collisions, and monitor costs — all locally.

```bash
npm install -g @hexdeck/cli
hex start
```

Opens a live dashboard at `http://localhost:7433`.

## What You Get

- **Live agent monitoring** — see every active session, what it's working on, files touched
- **Plan tracking** — watch agent plans from drafting through implementation to completion
- **Collision detection** — get alerted when multiple agents edit the same file
- **Risk analytics** — error rates, cost tracking, context usage, spinning detection
- **Intent mapping** — planned vs actual work, drift detection
- **Multi-operator support** — color-coded agents across operators

## Privacy

Hexdeck runs entirely on your machine. No data is sent externally.

| | Details |
|---|---|
| **Reads** | `~/.claude/projects/` and `~/.codex/sessions/` (session logs), `git status` (collision detection) |
| **Writes** | `~/.hexdeck/` (pid file, config, plan index) |
| **Network** | `localhost` only — zero outbound connections |
| **Telemetry** | None. No analytics, no tracking, no phone-home. |

Cloud relay is available for team use but is strictly opt-in, per-project, and shows exactly what data is being sent.

## Commands

```bash
hex start              # Start server + dashboard
hex start --foreground # Run in foreground
hex start --port 8080  # Custom port
hex status             # Show server info
hex stop               # Stop the server
hex restart            # Restart
hex open               # Open dashboard in browser
```

## Requirements

- Node.js >= 20
- Claude Code and/or Codex installed (`~/.claude/projects/` and/or `~/.codex/sessions/` must exist)

## Upgrade

```bash
npm install -g @hexdeck/cli@latest
```

## Hexcore

For teams running multiple operators on the same codebase, Hexcore adds multiplayer coordination — shared dashboards, cross-operator collision detection, and team presence.

## License

MIT