open-index/open-npm huggingface dataset:
npm package: @latch-wallet/core-types
Description: Biconomy Client SDK types
Author: Biconomy
Latest version: 0.0.1

# `@latch-wallet/core-types`

# Biconomy SDK Types

Common types in the [Biconomy SDK](https://github.com/bcnmy/biconomy-client-sdk)

### Usage

for example

```typescript
import { SmartAccountState, SmartAccountVersion, GasLimit, ChainId } from "@latch-wallet/core-types";
```
npm package: @latch-wallet/node-client
Description: Node Client that comminucates with indexer service to fetch necessary details for the Smart Account
Author: Biconomy
Latest version: 0.0.1

# `@latch-wallet/node-client`

# Biconomy SDK Node Client

Node Client is the api client package that communicate with [Biconomy SDK](https://github.com/bcnmy/biconomy-client-sdk) backend node to fetch needed smart contract wallet data i.e supported chains list, transaction history, balances e.t.c

## Installation

`yarn add @latch-wallet/node-client`

OR

`npm install @latch-wallet/node-client `

## Usage

```
// import package
import NodeClient from '@latch-wallet/node-client'

// initialisation

const nodeClient = new NodeClient({ txServiceUrl: 'https://sdk-backend.staging.biconomy.io/v1' })
```

# Fetch Supported Chains List

```
const supportedChainsList = await nodeClient.getAllSupportedChains()
console.log('supportedChainsList ', supportedChainsList)
```

# Fetch Transactions By Address

```
const chainId = 80001
const address = '0xabc......'
const trxHistory = await nodeClient.getTransactionByAddress(chainId, address)
console.log('trxHistory ', trxHistory)
```

# Get Transaction By Hash

```
const txHash = '0x........'
const trxDetail = await nodeClient.getTransactionByHash(txHash)
console.log('trxDetail ', trxDetail)
```

# Get Smart Contract Wallet Balances

```
import { BalancesDto } from '@latch-wallet/node-client'

import { ChainId } from '@latch-wallet/core-types'

const address = '0xabc......'

const balanceParams: BalancesDto =
      {
          // if no chainId is supplied, SDK will automatically pick active one that
         //  is being supplied for initialization

        chainId: ChainId.MAINNET, // chainId of your choice
        address: address,
        // If empty string you receive balances of all tokens watched by Indexer
        // you can only whitelist token addresses that are listed in token respository
        // specified above ^
        tokenAddresses: [],
      };

const balFromSdk = await nodeClient.getAllTokenBalances(balanceParams);
console.info("balFromSdk ", balFromSdk);

const usdBalFromSdk = await nodeClient.getTotalBalanceInUsd(balanceParams);
console.info("usdBalFromSdk ", usdBalFromSdk)
```
npm package: @latch-wallet/particle-auth
Description: Particle auth for Biconomy SDK
Author: livingrockrises
Latest version: 0.0.1

# `@latch-wallet/particle-auth`

> A library to import the particle-auth for web directly from [Biconomy SDK](https://github.com/bcnmy/biconomy-client-sdk)

## Usage

```ts
import { ParticleNetwork, WalletEntryPosition } from "@latch-wallet/particle-auth";
import { ParticleProvider } from "@latch-wallet/particle-auth";
import Web3 from "web3";

const particle = new ParticleNetwork({
  projectId: "xx",
  clientKey: "xx",
  appId: "xx",
  chainName: "Ethereum", //optional: current chain name, default Ethereum.
  chainId: 1, //optional: current chain id, default 1.
  wallet: {
    //optional: by default, the wallet entry is displayed in the bottom right corner of the webpage.
    displayWalletEntry: true, //show wallet entry when connect particle.
    defaultWalletEntryPosition: WalletEntryPosition.BR, //wallet entry position
    uiMode: "dark", //optional: light or dark, if not set, the default is the same as web auth.
    supportChains: [
      { id: 1, name: "Ethereum" },
      { id: 5, name: "Ethereum" },
    ], // optional: web wallet support chains.
    customStyle: {}, //optional: custom wallet style
  },
});

const particleProvider = new ParticleProvider(particle.auth);

//if you use web3.js
window.web3 = new Web3(particleProvider);
window.web3.currentProvider.isParticleNetwork; // => true

//if you use ethers.js
import { ethers } from "ethers";
const ethersProvider = new ethers.providers.Web3Provider(particleProvider, "any");
const ethersSigner = ethersProvider.getSigner();
```
npm package: @latch-wallet/transak
Description: transak for biconomy sdk
Author: livingrockrises
Latest version: 0.0.1

# `@latch-wallet/transak`

> A library to import the transak for web directly from [Biconomy SDK](https://github.com/bcnmy/biconomy-client-sdk)

## Usage

No need to create api key from transak dashboard.

```ts
import Transak from "@latch-wallet/transak";
const transak = new Transak("STAGING");
transak.init();
```
npm package: @latcha/react
Description: AI-proof CAPTCHA widget for React — drop-in reCAPTCHA replacement
Latest version: 0.1.1

# @latcha/react

AI-proof CAPTCHA for React. Drop-in replacement for reCAPTCHA v2 — no signup, no API key, no backend needed.

<!-- Replace with an actual screenshot -->
![Latcha widget screenshot](https://latcha.dev/captcha.png)

---

## Install

```bash
npm install @latcha/react
# or
pnpm add @latcha/react
```

## Usage

```tsx
import { LatchaWidget } from "@latcha/react";

function ContactForm() {
  const [verified, setVerified] = useState(false);

  return (
    <form onSubmit={...}>
      <input name="email" type="email" />
      <textarea name="message" />

      <LatchaWidget onVerify={() => setVerified(true)} />

      <button type="submit" disabled={!verified}>Send</button>
    </form>
  );
}
```

## How it works

1. User clicks "I'm not a robot"
2. A 3×3 grid of AI-generated images loads — human faces are hidden inside some cells
3. User selects all cells with a face and clicks Verify
4. Answer is checked server-side. `onVerify` fires on success.

No cookies. No tracking. No account required.

## Props

| Prop | Type | Default | Description |
|------|------|---------|-------------|
| `onVerify` | `(token: string) => void` | — | Called on success |
| `onError` | `(err: Error) => void` | — | Called on network/API failure |
| `apiBase` | `string` | `"https://latcha.dev/api/latcha"` | Override to self-host |
| `theme` | `"light" \| "dark"` | `"light"` | Color scheme |

## Links

- [Live demo](https://latcha.dev/dashboard)
- [GitHub](https://github.com/ekvanox/lacha)


Made with ❤️ for HackEurope Stockholm
npm package: @latchagent/cli
Description: Latch CLI - MCP Guard Proxy for AI Agents
Latest version: 0.1.2

# @latch/cli

Latch CLI is an MCP guard proxy that sits between your agent and an upstream MCP server, enforcing deterministic policies and requiring approval for risky actions.

## Install

```bash
npm install -g @latch/cli
```

## Setup

```bash
latch init
```

This stores defaults in `~/.latch/config.json`.

## Run (wrap an MCP server)

```bash
latch run --upstream-command "npx" --upstream-args "-y,@modelcontextprotocol/server-github"
```

## Repository

Source lives in the main repo at `packages/cli`.
npm package: @latchagent/latchctl
Description: Latch CLI bootstrap tool for OpenClaw and runtime configuration.
Latest version: 0.1.0

# @latchagent/latchctl

Bootstrap and operate Latch integrations from the terminal.

## Install

```bash
npm install -g @latchagent/latchctl
```

## OpenClaw Setup (One Command)

```bash
latchctl openclaw setup \
  --cloud-url https://your-latch-url.com \
  --workspace-id ws_xxx \
  --upstream-id upstream_xxx \
  --agent-key sk-latch-xxx
```

This command installs and enables `@latchagent/openclaw-latch-guard`, writes OpenClaw plugin config, and restarts gateway service.

## Print Manual Commands

```bash
latchctl openclaw print-config \
  --cloud-url https://your-latch-url.com \
  --workspace-id ws_xxx \
  --upstream-id upstream_xxx \
  --agent-key sk-latch-xxx
```

## Authorize Test

```bash
latchctl openclaw test \
  --cloud-url https://your-latch-url.com \
  --workspace-id ws_xxx \
  --upstream-id upstream_xxx \
  --agent-key sk-latch-xxx \
  --tool-name openclaw:read \
  --action-class read \
  --risk-level low
```
npm package: @latchagent/openclaw-latch-guard
Description: OpenClaw plugin that enforces Latch authorization before tool execution.
Latest version: 0.1.0

# @latchagent/openclaw-latch-guard

OpenClaw plugin that enforces Latch Cloud decisions before native tool execution.

## Install

```bash
openclaw plugins install @latchagent/openclaw-latch-guard
openclaw plugins enable openclaw-latch-guard
```

## Configure

```bash
openclaw config set plugins.entries.openclaw-latch-guard.config.baseUrl "https://your-latch-url.com"
openclaw config set plugins.entries.openclaw-latch-guard.config.workspaceId "ws_xxx"
openclaw config set plugins.entries.openclaw-latch-guard.config.upstreamId "upstream_xxx"
openclaw config set plugins.entries.openclaw-latch-guard.config.agentKey "sk-latch-xxx"
openclaw config set plugins.entries.openclaw-latch-guard.config.waitForApproval true --json
openclaw config set plugins.entries.openclaw-latch-guard.config.approvalTimeoutSeconds 600 --json
openclaw config set plugins.entries.openclaw-latch-guard.config.failClosed true --json
openclaw gateway restart
```

## Config Options

- `mode`: `monitor` or `enforce` (default `enforce`)
- `baseUrl`: Latch Cloud base URL
- `workspaceId`: Workspace ID
- `upstreamId`: Connector ID used as `upstream_id`
- `agentKey`: Agent key
- `waitForApproval`: poll approval status when needed
- `approvalTimeoutSeconds`: max wait when polling approvals
- `failClosed`: block if Latch is unreachable
- `logFile`: optional plugin log path
npm package: @latedream/ping
Description: just a simple ping utility to measure latency to a host.
Author: LateDream
Latest version: 0.1.0

# @latedream/ping

just a simple ping utility to measure latency to a host.

## usage

<details>
<summary>node.js</summary>

### installation

```sh
pnpm add @latedream/ping
# yarn add @latedream/ping
# npm install @latedream/ping
# bun install @latedream/ping
```

### esm
```js
import Ping from '@latedream/ping';

const ping = new Ping({
	hosts: ['github.com', 'https://latedream.cn', 'http://localhost:5173'],
	timeout: 1000
});

(async() => {
	const results = await ping.start();
	/** ... */
})();
```

### cjs
```js
const Ping = require('@latedream/ping');

const ping = new Ping({
	hosts: ['github.com', 'https://latedream.cn', 'http://localhost:5173'],
	timeout: 1000
});

(async() => {
	const results = await ping.start();
	/** ... */
})();
```

### results

```js
{
  'github.com': {
    valid: true,
    reachable: true,
    timeouted: false,
    latency: 569,
    status: 200,
    protocol: 'https:',
    url: 'https://github.com',
    message: 'OK',
    port: 443,
    ipType: false
  },
  'https://latedream.cn': {
    valid: true,
    reachable: true,
    timeouted: false,
    latency: 442,
    status: 200,
    protocol: 'https:',
    url: 'https://latedream.cn',
    message: 'OK',
    port: 443,
    ipType: false
  },
  'http://localhost:5173': {
    valid: true,
    reachable: true,
    timeouted: false,
    latency: 12,
    status: 200,
    protocol: 'http:',
    url: 'http://localhost:5173',
    message: 'OK',
    port: 5173,
    ipType: false
  }
}
```

</details>

<details>
<summary>browser</summary>

### umd
```html
<script src="https://cdn.jsdelivr.net/npm/@latedream/ping@0.1/dist/index.umd.js"></script>
<script>
const ping = new Ping({
	hosts: ['https://github.com', 'https://latedream.cn', 'http://localhost:5173'],
	timeout: 1000
});

(async() => {
	const results = await ping.start();
	/** ... */
})();
</script>
```

### results

```json
{
  "https://github.com": {
    "valid": true,
    "reachable": false,
    "timeouted": false,
    "latency": 679,
    "status": 0,
    "protocol": "https:",
    "url": "https://github.com",
    "message": "",
    "port": 443,
    "ipType": false
  },
  "https://latedream.cn": {
    "valid": true,
    "reachable": false,
    "timeouted": false,
    "latency": 137,
    "status": 0,
    "protocol": "https:",
    "url": "https://latedream.cn",
    "message": "",
    "port": 443,
    "ipType": false
  },
  "http://localhost:5173": {
    "valid": true,
    "reachable": false,
    "timeouted": false,
    "latency": 16,
    "status": 0,
    "protocol": "http:",
    "url": "http://localhost:5173",
    "message": "",
    "port": 5173,
    "ipType": false
  }
}
```

</details>


## license

MIT
Copyright (c) 2026 LateDream
npm package: @latel88/bedrock
Description: Game loop library.
Latest version: 1.1.15

# Bedrock
Game loop library.

## install
```shell
npm install @latel88/bedrock
```
- CJS
```javascript
const Bedrock = require( "@latel88/bedrock" ).default;
```
- ESM
```javascript
import Bedrock from "@latel88/bedrock";
```

## exsample
```javascript
const bedrock = new Bedrock(
{
	fps: 30

} );

bedrock.on( "update", ( event ) =>
{
	//game loop
	entity.x += addX * event.percent;
	entity.y += addY * event.percent;

} );

bedrock.on( "rendering", ( event ) =>
{
	//render loop
	draw_sprite( entity.x, entity.y );

} );
// start game loop
bedrock.run();

if (bedrock.hasRun())
{
	//stop game loop
	bedrock.stop();

}
```

```javascript
class GameLoop extends Bedrock
{
	constructor ( fps )
	{
		super( { fps } );

		this.run();

	}

	onupdate ( event )
	{

	}

	onrendering ( event )
	{

	}

}
```

```javascript
const gameloop = GameLoop.singleton( 30 );
//true;
gameloop === GameLoop.singleton();
```

```javascript
gameloop.setFPS( 60 );
gameloop.setSpeed( 0.5 );

gameloop.on( "update", ( event ) =>
{
	console.log( gameloop.getFPS() );
	
	//fix speed
	entity.x += addX * event.percent;
	entity.y += addY * event.percent;

} );
```
npm package: @latel88/gamepad
Description: ## install
Latest version: 1.2.10
Deprecated: false

# Gamepad

## install

```shell
npm install @latel88/gamepad
```
- cjs
```javascript
const { Gamepad, keycode } = require( "@latel88/gamepad" );
```
- mjs
```javascript
import { Gamepad, keycode } from "@latel88/gamepad";
```

## exsample
```javascript
const gamepad = new Gamepad( window,
{
	key: "body",//key event target element
	mouse: "body",//mouse event target element

	touchX: "#touch-x",//touch pad x target element
	touchY: "#touch-y",//touch pad y target element

	pointer_look: "body"//pointer look target element

},
{
	"forward": keycode.W,
	"back": keycode.S,
	"right": keycode.D,
	"left": keycode.A

	"fire": keycode.MOUSE_LEFT,
	"ads": keycode.MOUSE_RIGHT

},
{
	sensibilityX: 1,
	sensibilityY: 1,
	invertedX: false,
	invertedY: false,

	touch_max_x: 75

} );


setInterval( () =>
{
	gamepad.fire( "update" );
	
} );
```

```javascript
setInterval( () =>
{
	gamepad.fire( "update" );

	const force = gamepad.getButton( "forward" );

	if (force > 0)
	{
		entity.position.y += 1;

	}

} );
```

```javascript
setInterval( () =>
{
	gamepad.fire( "update" );
	
	entity.position.x += gamepad.movementX.x;
	entity.position.y += gamepad.movementX.y;

	entity.direction.x += gamepad.movementY.x;
	entity.direction.y += gamepad.movementY.y;

} );
```

```javascript
const touch_button = document.createElement( "div" );

touch_button.addEventListener( "touchstart", ( event ) =>
{
	gamepad.pressButton( "fire" );

} );

touch_button.addEventListener( "touchend", ( event ) =>
{
	gamepad.releaseButton( "fire" );

} );
```

```javascript
gamepad.setBind( "fire", keycode.GAMEPAD_RR );

gamepad.readyBind( "fire" ( keyCode, bind ) =>
{
	if (confim( `${ keyCode }` ))
	{
		bind( true );

	}
	else
	{
		bind( false );

	}

} );
```
npm package: @latel88/hotate
Description: UI library.
Latest version: 1.1.0

# Hotate

UI library.

## install
```shell
npm install @latel88/hotate
```

- CJS
```javascript
const Hotate = requrire( "@latel88/hotate" ).default;
```

- ESM
```javascript
import Hotate from "@latel88/hotate";
```

## exsample

```javascript
const $ = new Hotate( { window } );
```

```javascript
const elem = document.getElementById( "render" );

$.BOOT( elem ).
	OPEN( "div",
	{
		style: {
			"color": "#f00"
			
		}
		
	} ).
		TEXT( "HelloWorld!" ).

	CLOSE( "div" ).
EXIT();
```

## rendering list

```javascript
const list = [ "apple", "orange", "nuts" ];
const render = ( name ) ->
{
	$.OPEN( "li" ).
		TEXT( name ).

	CLOSE( "li" );

}

$.BOOT( elem );
	$.OPEN( "ul",
	{
		style: {
			"listStyleType": "number"
			
		}
		
	} );

	list.forEach( render );

	$.CLOSE( "ul" );
$.EXIT();

```

## append touch element

```javascript

const canvas = document.createElement( "canvas" );
const css = elem.style;

canvas.id = "game";
css.width = elem.width * 2 + "px";
css.height = elem.height * 2 + "px";

$.BOOT( elem ).
	ELEMENT( canvas ).
	
EXIT();

$.BOOT( elem ).
	VOID( "canvas" ).
	
EXIT();

console.log( canvas.parentNode ); //null

```
npm package: @latel88/job
Description: ## how to use - install ```shell npm install @latel88/job ``` ``` - CJS ```javascript const { Job, Child, Collection } = require( "@latel88/job" ).default; ``` - ESM ```javascript import { Job, Child, Collection } from "@latel88/job"; ```
Latest version: 1.2.13
Deprecated: false

# Job

## how to use
- install
```shell
npm install @latel88/job
```
```
- CJS
```javascript
const { Job, Child, Collection } = require( "@latel88/job" ).default;
```
- ESM
```javascript
import { Job, Child, Collection } from "@latel88/job";
```

## exsample
- extend
```javascript
class Entity extends Job
{
	constructor ()
	{
		super( "enemy" );

	}

};

const entity = new Entity();

entity.begin();
	
getFile( () =>
{
	entity.done();

} );

const id = setInterval( () =>
{
	if (entity.hasComplete())
	{
		callback();

		clearInterval( id );

	}
	else
	{
		if (hasError())
		{
			entity.skip();

		}
		else
		{
			sleep();

		}

	}

} );

```

```javascript
class Entity extends Child
{
	constructor ()
	{
		super( "child#enemy.entity" );//css query selector

	}

};

const collection = new Collection();
const entity = new Entity();

collection.set( entity );
collection.find( ".entity" );

```
npm package: @latel88/message
Description: ## how to use - install ```shell npm install @latel88/stream ``` - CJS ```javascript const { Stream, Pipe } = require( "@latel88/stream" ).default; ``` - ESM ```javascript import { Stream, Pipe } from "@latel88/stream"; ```
Latest version: 1.2.5

# Stream

## how to use
- install
```shell
npm install @latel88/stream
```
- CJS
```javascript
const { Stream, Pipe } = require( "@latel88/stream" ).default;
```
- ESM
```javascript
import { Stream, Pipe } from "@latel88/stream";
```

## exsample
- how to use stream class.
```javascript
class FileStream extends Stream
{
    constructor ( src, type = "text" )
    {
        super( ( resolve, reject ) =>
        {
            const xhr = new XMLHttpRequest();

            xhr.onreadystatechange = () =>
            {
                if (xhr.readyState === 4)
                {
                    if ((200 <= xhr.status && xhr.status < 300) || (xhr.status === 304))
                    {
                        const source = xhr.response;
                        
                        resolve( source );

                    }
                    else
                    {
                        reject( new Error( `File not found. ${ url }` ) );

                    }

                }

            };

            xhr.onerror = () =>
            {
                reject( new Error( `File not found. ${ url }` ) );

            };

            xhr.open( "GET", src, true );
            xhr.responseType = type;
            xhr.send( null );

        } );

    }

}
```
- how to use pipe class.
```javascript
class ToImagePipe extends Pipe
{
	constructor ()
	{
		super( ( data, resolve, reject ) =>
		{
			const source = new Image();
				
			source.onload = () => resolve( source );
			source.onerror = () => reject( new Error( "Can not process image." ) );

			switch (true)
			{
				case typeof( data.source ) === "string":
					source.src = `data:image/jpeg;base64,${ data.source }`;
					break;

				case data.source instanceof Blob:
					source.src = window.URL.createObjectURL( data.source );
					break;

				case data.source instanceof ArrayBuffer:
					const bytes = new Uint8Array( data.source );

					let binaryData = "";

					for (let i = 0, len = bytes.byteLength; i < len; i++)
					{
						binaryData += String.fromCharCode( bytes[ i ] );

					}

					source.src = `data:image/jpeg;base64,${ window.btoa( binaryData ) }`;
					break;

			}

		} );

	}

}
```
```javascript
new FileStream( "anonymous.png" ).pipe( new ToImagePipe() ).then( ( event ) =>
{
	const image = event.data;

}, ( event ) =>
{
	const error = event.data;

	throw error;

} );
```
npm package: @latel88/monokit
Description: Base class library.
Latest version: 1.1.0

# Monokit
Base class library.

## how to use
- install
```shell
npm install @latel88/monokit
```
- CJS
```javascript
const Monokit = require( "@latel88/monokit" ).default;
```
- ESM
```javascript
import Monokit from "@latel88/monokit";
```

## exsample
- extend
```javascript
class Entity extends Monokit
{
	constructor ()
	{
		super(
		{
			...initialized

		} );

	}

}
```

```javascript
const Entity = Monokit.extend(
{
	constructor ()
	{
		this._super( "constructor",
		{
			...initialized

		} );

	}

} );
```

```javascript
const Entity = Monokit.extend( {} );
const Enemy = Entity.extend( {} );
```

- create
```javascript
const entity = new Entity( ...arguments );
const entity = Entity.create( ...arguments );
```

```javascript
const entity = Entity.singleton( ...arguments );
//true
entity === Entity.singleton();
```

```javascript
const entity = Entity.singleton( ...arguments );
//delete static instance
entity.destroy();
//new instance
const other = Entity.singleton( ...arguments );
```

```javascript
//pop pool
const entity = Entity.pool( ...arguments );
//stack pool
entity.destroy();
```

```javascript
const entity = Entity.pool();

Object.defineProperty( entity, "life",
{
	value: 100,
	configurable: false
	
} );
//Not stack pool
if (entity.destroy() === false)
{
	throw "Can not stack instance.";

}
```

- listener
```javascript
const entity = new Entity();

function callback ( event )
{
	event.type;//listener name
	event.target;//call instance
	event.timestamp;//trigger time
	event[ ...parameters ];

}
//add
entity.on( "load", callback );
//remove
entity.off( "load", callback );
//trigger
entity.fire( "load", { ...parameters } );
```

```javascript
class Entity extends Monokit
{
	onload ( event )
	{

	}

}

const entity = new Entity();

entity.fire( "load", { ...parameters } );
```

```javascript
class Entity extends Monokit
{
	ondestroy ( event )
	{

	}

}

const entity = new Entity();

entity.on( "destroy", () => );

entity.destroy();
```
npm package: @latel88/pixel
Description: ## install
Latest version: 1.3.0

# Pixel

## install

```shell
npm install @latel88/pixel
```
- cjs
```javascript
const Pixel = require( "@latel88/pixel" ).default;
```
- mjs
```javascript
import Pixel from "@latel88/pixel";
```
## exsample
```javascript
const canvas = document.createElement( "canvas" );
const gl = canvas.getContext( "webgl2" );

const width = 200;
const height = 300;

const hour = 3.14;

const static_texture = new Uint8Array( width * height * 4 );
const animation_texture = new Float32Array( width * height );
const normal = new Uint8Array( width * height * 4);
const depth = new Uint8Array( width * height * 4);

const pixel = new Pixel(
{
	"geometory": `#version 300 es

		uniform ivec2: screen_size;
		uniform sampler2D static_texture_data;

		location (layout = 0) vec4 normal;

		void main ()
		{
			normal = vec4(vec3(1., 0., 0.), 1.);

		}

	`,

	"lighting": `#version 300 es

		uniform ivec2: screen_size;
		uniform sampler2D animation_texture_data;
		uniform sampler2D normal;

		location (layout = 0) vec4 screen;

		void main ()
		{
			screen = dot( normal, vec3(0.1, 0.5, 0.25) );

		}

	`,

	"color": `#version 300 es

		uniform ivec2: screen_size;
		uniform sampler2D screen;
		uniform float hour;

		out vec4 color;

		void main ()
		{
			color = vec4(1, 1, 1, 1) * (screen.r * 2. - 1.);

		}

	`
	
 }, `#version 300 es
	precision highp float;
	precision highp int;

	layout(location = 0) in vec2 pos;

	void main()
	{
		gl_Position = vec4(pos, 0.0, 1.0);
		
	}

` );

pixel.rendering( gl,
{
	0: {
		format: 4,
		data: static_texture.buffer,

		width,
		height,

		sync: false

	},

	1: {
		type: "32f",
		format: 1,
		data: animation_texture.buffer,

		width,
		height,

		sync: true

	},

	2: {
		attachment: { geometory: 0 },
		type: "32f",
		format: 4,
		data: depth.buffer,

		width,
		height,

	}

},
{
	screen_size: {
		type: "2i",
		value: [ canvas.width, canvas.height ]

	},

	hour: {
		type: "1f",
		value: [ hour ]

	},

	static_texture_data: {
		unit: 0

	},

	animation_texture_data: {
		unit: 1

	},

	normal: {
		unit 2

	}

} );
```
npm package: @latel88/stream
Description: ## how to use - install ```shell npm install @latel88/stream ``` - CJS ```javascript const { Stream, Pipe } = require( "@latel88/stream" ).default; ``` - ESM ```javascript import { Stream, Pipe } from "@latel88/stream"; ```
Latest version: 1.1.1

# Stream

## how to use
- install
```shell
npm install @latel88/stream
```
- CJS
```javascript
const { Stream, Pipe } = require( "@latel88/stream" ).default;
```
- ESM
```javascript
import { Stream, Pipe } from "@latel88/stream";
```

## exsample
- how to use stream class.
```javascript
class FileStream extends Stream
{
    constructor ( src, type = "text" )
    {
        super( ( resolve, reject ) =>
        {
            const xhr = new XMLHttpRequest();

            xhr.onreadystatechange = () =>
            {
                if (xhr.readyState === 4)
                {
                    if ((200 <= xhr.status && xhr.status < 300) || (xhr.status === 304))
                    {
                        const source = xhr.response;
                        
                        resolve( source );

                    }
                    else
                    {
                        reject( new Error( `File not found. ${ url }` ) );

                    }

                }

            };

            xhr.onerror = () =>
            {
                reject( new Error( `File not found. ${ url }` ) );

            };

            xhr.open( "GET", src, true );
            xhr.responseType = type;
            xhr.send( null );

        } );

    }

}
```
- how to use pipe class.
```javascript
class ToImagePipe extends Pipe
{
	constructor ()
	{
		super( ( data, resolve, reject ) =>
		{
			const source = new Image();
				
			source.onload = () => resolve( source );
			source.onerror = () => reject( new Error( "Can not process image." ) );

			switch (true)
			{
				case typeof( data.source ) === "string":
					source.src = `data:image/jpeg;base64,${ data.source }`;
					break;

				case data.source instanceof Blob:
					source.src = window.URL.createObjectURL( data.source );
					break;

				case data.source instanceof ArrayBuffer:
					const bytes = new Uint8Array( data.source );

					let binaryData = "";

					for (let i = 0, len = bytes.byteLength; i < len; i++)
					{
						binaryData += String.fromCharCode( bytes[ i ] );

					}

					source.src = `data:image/jpeg;base64,${ window.btoa( binaryData ) }`;
					break;

			}

		} );

	}

}
```
```javascript
new FileStream( "anonymous.png" ).pipe( new ToImagePipe() ).then( ( event ) =>
{
	const image = event.data;

}, ( event ) =>
{
	const error = event.data;

	throw error;

} );
```
npm package: @latelier/vue-application-insights
Author: L'Atelier
Latest version: 1.0.6

# vue-application-insights


## Installation


```console
$ npm install vue-application-insights --save
```

## Get started


```js
import Vue from 'vue'
import VueAppInsights from 'vue-application-insights'

Vue.use(VueAppInsights, {
  id: 'XXXXXXXX--XXXX-XXXX-XXXXXXXXXXXX'
})
```

With vue router


```js
import Vue from 'vue'
import router from './router'

import VueAppInsights from 'vue-application-insights'

Vue.use(VueAppInsights, {
  id: 'XXXXXXXX--XXXX-XXXX-XXXXXXXXXXXX',
  router
})
```

Example with custom track event

```js
Vue.extend({

  methods: {
    custom_action() {
      this.$appInsights.trackEvent("custom_action", { value: 'ok' });
    }   
  }
  
});
```

## Options

- **id** - The instrumentation key of your AppInsights resource on Azure.
- **router** - The router instance, which events should be tracked as page views _(optional)_.
**baseName** String that will prefix the name of the tracked page _(optional, default is '(Vue App)')_
**appInsights** Instance of the Application Insights client  _(optional)_.
- **trackInitialPageView** - Boolean that determines whether or not the initial page view should be tracked. _(optional, defaults to true)_

## Initializing AppInsights from outside the Vue application

Maybe you use server side code to include the javascript snippet that initializes AppInsights. In that case you want to provide the AppInsights instance to this Vue plugin and prevent it from tracking the initial page view.

```js
import Vue from 'vue'
import router from './router'

import VueAppInsights from 'vue-application-insights'

Vue.use(VueAppInsights, {
  appInsights: window.appInsights,
  trackInitialPageView: false,
  router
})
```
npm package: @latelier/vue-signalr
Description: Signalr client for vue js
Author: L'Atelier
Latest version: 2.0.4

# vue-signalr


## Installation


```console
$ npm install @latelier/vue-signalr --save
```

## Get started


```js
import Vue from 'vue'
import VueSignalR from 'vue-signalr'

Vue.use(VueSignalR, 'SOCKET_URL');

new Vue({
  el: '#app',
  render: h => h(App),
  
  created() {
    this.$socket.start({
      log: false // Active only in development for debugging.
    });
  },

});
```

## Example with component

```js
Vue.extend({

  ...
  
  methods: {
  
    someMethod() {
      this.$socket.invoke('socketName', payloadData)
        .then(response => {
          ...
        })
    }
    
    async someAsyncMethod() {
      const response = await this.$socket.invoke('socketName', payloadData)
      ...
    }
    
  },

  // Register your listener here. 
  sockets: {
  
    // Equivalent of
    // signalrHubConnection.on('someEvent', (data) => this.someActionWithData(data))
    someEvent(data) {
      this.someActionWithData(data)
    }
    
    otherSomeEvent(data) {
      this.otheSomeActionWithOtherSomeData(data)
    }
    
  }

});


```
npm package: @latelier22/artisans-strapi
Description: A Next.js project with reusable components and functions
Author: Cyrille LE CORRE
Latest version: 0.1.11

This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).

## Getting Started

First, run the development server:

```bash
npm run dev
# or
yarn dev
# or
pnpm dev
# or
bun dev
```

Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.

You can start editing the page by modifying `app/page.js`. The page auto-updates as you edit the file.

This project uses [`next/font`](https://nextjs.org/docs/basic-features/font-optimization) to automatically optimize and load Inter, a custom Google Font.

## Learn More

To learn more about Next.js, take a look at the following resources:

- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.

You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js/) - your feedback and contributions are welcome!

## Deploy on Vercel

The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.

Check out our [Next.js deployment documentation](https://nextjs.org/docs/deployment) for more details.
npm package: @latelier22/npm-next
Description: A Next.js project with reusable components and functions
Author: Cyrille LE CORRE
Latest version: 0.1.7

This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).

## Getting Started

First, run the development server:

```bash
npm run dev
# or
yarn dev
# or
pnpm dev
# or
bun dev
```

Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.

You can start editing the page by modifying `app/page.js`. The page auto-updates as you edit the file.

This project uses [`next/font`](https://nextjs.org/docs/basic-features/font-optimization) to automatically optimize and load Inter, a custom Google Font.

## Learn More

To learn more about Next.js, take a look at the following resources:

- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.

You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js/) - your feedback and contributions are welcome!

## Deploy on Vercel

The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.

Check out our [Next.js deployment documentation](https://nextjs.org/docs/deployment) for more details.
npm package: @latelier22/v8cadrebois
Description: This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).
Author: Cyrille LE CORRE
Latest version: 0.1.4

This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).

## Getting Started

First, run the development server:

```bash
npm run dev
# or
yarn dev
# or
pnpm dev
# or
bun dev
```

Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.

You can start editing the page by modifying `app/page.js`. The page auto-updates as you edit the file.

This project uses [`next/font`](https://nextjs.org/docs/basic-features/font-optimization) to automatically optimize and load Inter, a custom Google Font.

## Learn More

To learn more about Next.js, take a look at the following resources:

- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.

You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js/) - your feedback and contributions are welcome!

## Deploy on Vercel

The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.

Check out our [Next.js deployment documentation](https://nextjs.org/docs/deployment) for more details.
npm package: @latenode/js-node-bootstrap
Description: LateNode JS node extension
Author: Vitaliy V. Makeev
Latest version: 1.0.0

# @latenode/js-node-bootstrap

[![npm](https://img.shields.io/npm/v/simplex-lang.svg?cacheSeconds=1800&style=flat-square)](https://www.npmjs.com/package/@latenode/js-node-bootstrap)
[![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/wmakeev/latenode-js-node-bootstrap/main.yml?style=flat-square)](https://github.com/wmakeev/latenode-js-node-bootstrap/actions/workflows/main.yml)
![Coverage](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/wmakeev/latenode-js-node-bootstrap/main/badges/coverage.json)

> Latenode JS node extension

## Table of contents <!-- omit in toc -->

- [@latenode/js-node-bootstrap](#latenodejs-node-bootstrap)
  - [Quick start](#quick-start)

## Quick start

```ts
/** @CustomParams
{
  "obj": {
    "type": "string",
    "title": "JSON string parameter",
    "description": "**JSON**: Enter JSON string"
  }
}
*/

import { getRun } from '@latenode/js-node-bootstrap'

async function logic({execution_id, input, data, store, db}, { params, customParamsConfig }) {
  const { obj } = params

  return {
    // Parsed json parameter
    obj
  }
}

export default getRun(logic)
```

<img alt="In the process of development" src="under-construction.png"/>
npm package: @latent-network/sdk
Description: TypeScript SDK for the Latent Network — query blocks, inference, DEX, staking, and real-time WebSocket events
Latest version: 0.1.0

# @latent-network/sdk

TypeScript SDK for the [Latent Network](https://minelatent.xyz) — an AI-native blockchain with proof-of-useful-work consensus.

## Install

```bash
npm install @latent-network/sdk
```

## Quick Start

```typescript
import { LatentClient, LatentWs } from '@latent-network/sdk';

// HTTP client
const client = new LatentClient({ rpcUrl: 'https://testnet.minelatent.xyz' });

const info = await client.getChainInfo();
console.log(`Height: ${info.height}, Supply: ${info.total_supply}`);

const block = await client.getLatestBlock();
console.log(`Latest block miner: ${block.miner_id}`);

// Real-time WebSocket
const ws = new LatentWs({
  wsUrl: 'wss://testnet.minelatent.xyz/ws',
  subscribe: ['blocks', 'inference'],
});

ws.on((event) => {
  if (event.kind === 'blocks') {
    console.log('New block:', event.data);
  }
});

ws.connect();
```

## API

### `LatentClient`

| Method | Description |
|--------|-------------|
| `getChainInfo()` | Height, supply, difficulty |
| `getBlock(height)` | Block by height |
| `getLatestBlock()` | Latest block |
| `getTransaction(txId)` | Transaction by ID |
| `getBalance(address)` | Address balance |
| `getStakingInfo()` | Total staked, tiers |
| `stake(amount, address)` | Stake LAT |
| `getDexPools()` | All liquidity pools |
| `swap(poolId, ...)` | Submit a swap |
| `getInferenceRecords(...)` | Query inference dataset |
| `submitBounty(...)` | Post an inference bounty |
| `getGovernanceParams()` | Governance track config |
| `requestFaucet(address)` | Testnet faucet |

### `LatentWs`

Real-time event stream over WebSocket.

```typescript
const ws = new LatentWs({ wsUrl: 'wss://testnet.minelatent.xyz/ws' });
ws.on((event) => console.log(event.kind, event.data));
ws.connect();
ws.disconnect();
```

Event kinds: `blocks` | `txs` | `inference` | `dex` | `governance`

## Testnet

- RPC: `https://testnet.minelatent.xyz`
- WS: `wss://testnet.minelatent.xyz/ws`
- Explorer: `https://testnet.minelatent.xyz`
- Faucet: `POST https://testnet.minelatent.xyz/faucet`

## License

MIT