open-index/open-npm huggingface dataset:
npm package: @gatex402/checkout
Description: x402 Payment Gateway SDK for Solana — one-line payment integration for dApps, AI agents, and marketplaces
Author: GATEX402
Latest version: 1.0.0

# @gatex402/checkout

**x402 Payment Gateway SDK for Solana**

One-line payment integration for dApps, AI agents, and marketplaces.

## Install

```bash
npm install @gatex402/checkout
```

## Quick Start

```javascript
import { GateCheckout } from '@gatex402/checkout'

const gate = new GateCheckout({
  merchant: 'YOUR_WALLET_ADDRESS',
  network: 'mainnet',
  accept: ['SOL', 'USDC', 'USDT'],
  theme: 'dark',
})

gate.open({ amount: 25, currency: 'USDC', memo: 'order-9281' })

gate.on('confirmed', (tx) => {
  console.log(tx.signature, tx.riskScore, tx.amount)
})
```

## Headless Mode (Agent-to-Agent)

```javascript
import { GateHeadless } from '@gatex402/checkout/headless'
import { Keypair } from '@solana/web3.js'

const gate = new GateHeadless({
  merchant: 'TARGET_WALLET',
  network: 'mainnet',
  signer: Keypair.fromSecretKey(agentSecret),
})

const tx = await gate.pay({
  amount: 2.5,
  currency: 'USDC',
  memo: 'agent-task-7712',
})
```

## Micropayments

```javascript
import { MicroStream } from '@gatex402/checkout/micro'

const stream = new MicroStream({
  merchant: 'API_PROVIDER_WALLET',
  signer: agentKeypair,
  ratePerCall: 0.001,
  settleEvery: 100,
  currency: 'USDC',
})

await stream.tick() // +0.001 USDC
await stream.settle() // force settle
```

## Escrow

```javascript
const escrow = await gate.escrow.create({
  amount: 100,
  currency: 'USDC',
  payee: 'WORKER_WALLET',
  expiry: 86400,
})

await escrow.release() // or escrow.refund()
```

## Payment Links

```javascript
const link = gate.createLink({
  amount: 50,
  currency: 'USDC',
  label: 'Invoice #42',
  expiry: '24h',
})
// → https://pay.gatex402.com/p/x7k9m2
```

## Links

- Website: [gatex402.com](https://gatex402.com)
- Twitter: [@GATEX402_](https://x.com/GATEX402_)
- Docs: [gatex402.com/docs](https://gatex402.com)

## License

MIT
npm package: @gather-research/react-gather
Description:  A simple front-end library designed with the experimenter in mind. 
Author: Derek Stoeckenius
Latest version: 0.1.1

[![Build Status](https://travis-ci.org/GatherResearch/Gatherer.svg?branch=master)](https://travis-ci.org/GatherResearch/Gatherer)
[![Coverage Status](https://coveralls.io/repos/github/GatherResearch/Gatherer/badge.svg?branch=master)](https://coveralls.io/github/GatherResearch/Gatherer?branch=master)
[![Maintainability](https://api.codeclimate.com/v1/badges/f64014c14f66761fcd65/maintainability)](https://codeclimate.com/github/GatherResearch/Gatherer/maintainability)
[![Documentation Status](https://readthedocs.org/projects/gatherer/badge/?version=latest)](http://gatherer.readthedocs.io/en/latest/?badge=latest)

GatherResearch/react-gatherer
=========

A simple front-end library designed with the experimenter in mind.

## Installation

  `npm install @gatherresearch/gatherer`
npm package: @gathertown/floating-ui-devtools
Description: This is the platform-agnostic devtools package of Floating UI, exposing mechanisms to be used together with [Chrome devtools extension](https://chromewebstore.google.com/detail/floating-ui-devtools/ninlhpbnkjidaokbmgebblaehpokdmgb?hl=en) to help debugging
Latest version: 0.2.2

# Floating UI Devtools

This is the platform-agnostic devtools package of Floating UI, exposing
mechanisms to be used together with
[Chrome devtools extension](https://chromewebstore.google.com/detail/floating-ui-devtools/ninlhpbnkjidaokbmgebblaehpokdmgb?hl=en)
to help debugging Floating UI

## How to use

This package exposes a [middleware](https://floating-ui.com/docs/middleware) to
be added at the end of the middleware chain, which will inject the data to be
consumed by the devtools extension.

> ⚠️ Do not forget to remove the middleware before shipping to production

### Install

```bash
npm install @floating-ui/devtools
```

### Usage

```js
// example with @floating-ui/react
import {devtools} from '@floating-ui/devtools';

export const Default = () => {
  const [isOpen, setIsOpen] = useState(false);

  const {refs, floatingStyles, context} = useFloating({
    open: isOpen,
    onOpenChange: setIsOpen,
    // add the middleware to the end of the middleware chain if in dev mode
    middleware: [import.meta.env.DEV && devtools(document)],
  });

  const click = useClick(context);

  const {getReferenceProps, getFloatingProps} = useInteractions([click]);

  return (
    <>
      <button ref={refs.setReference} {...getReferenceProps()}>
        Reference element
      </button>
      {isOpen && (
        <div
          ref={refs.setFloating}
          style={floatingStyles}
          {...getFloatingProps()}
        >
          Floating element
        </div>
      )}
    </>
  );
};
```

## Contribution

- run `pnpm --filter @floating-ui/devtools run build` from root folder
npm package: @gathertown/worklet-loader
Description: worklet loader module for webpack
Author: Gather Presence, Inc.
Latest version: 3.0.0

# Worklet Loader
This loader loads imported scripts as a URL pointing to (or containing) a compiled module. That URL can be used to add worklet modules.

**NOTE! At the moment, this is basically just a fork of [`worker-loader`](https://github.com/webpack-contrib/worker-loader) and *probably shouldn't be used*. It's possible that, at some point, `worker-loader` will support worklets and this loader will be obsolete. It's also possible that there are worker-specific things that this package does that breaks worklets for one reason or another. So be careful!**

## Install

```bash
npm i -D worklet-loader
```

## [Usage](https://webpack.js.org/concepts/loaders)

### `Inlined`

**App.js**
```js
import workletUrl from 'worklet-loader!./Worklet.js';
```

### `Config`

**webpack.config.js**
```js
{
  module: {
    rules: [
      {
        test: /\.worklet\.js$/,
        use: { loader: 'worklet-loader' }
      }
    ]
  }
}
```

**App.js**
```js
import workletUrl from './file.worklet.js';

const audioCtx = new AudioContext();

audioCtx.audioWorklet.addModule(workletUrl).then(() => {
  // Do stuff with the now-registered processor
});
```

## Options

|Name|Type|Default|Description|
|:--:|:--:|:-----:|:----------|
|[**`name`**](#name)|`{String}`|`[hash].worklet.js`|Set a custom name for the output script|
|[**`inline`**](#inline)|`{Boolean}`|`false`|Inline the worklet as a Blob|
|[**`publicPath`**](#publicPath)|`{String}`|`null`|Override the path from which worklet scripts are downloaded|

### `name`

To set a custom name for the output script, use the `name` parameter. The name may contain the string `[hash]`, which will be replaced with a content dependent hash for caching purposes. When using `name` alone `[hash]` is omitted.

*webpack.config.js**
```js
{
  loader: 'worklet-loader',
  options: { name: 'WorkerName.[hash].js' }
}
```

### `inline`

Inline the worklet as a `Blob` with the `inline` parameter

**webpack.config.js**
```js
{
  loader: 'worklet-loader',
  options: { inline: true }
}
```

### `publicPath`

Overrides the path from which worklet scripts are downloaded. If not specified, the same public path used for other
webpack assets is used

**webpack.config.js**
```js
{
  loader: 'worklet-loader'
  options: { publicPath: '/scripts/worklets/' }
}
```

## Examples

### Integrating with TypeScript

You will need to define a custom module for the exports of your worklet files

**typings/custom.d.ts**
```typescript
declare module "*.worklet.ts" {
  const exportString: string;
  export default exportString;
}
```

**App.ts**
```typescript
import fooBarWorkletUrl from 'worlet-loader!./fooBar.worklet.ts'

const audioCtx = new AudioContext();

// @ts-ignore: AudioContext.audioWorklet is not available as a type yet
audioCtx.audioWorklet.addModule(fooBarWorkletUrl).then(() => {
  // Do stuff with the now-registered processor
});
```
npm package: @gatherui/components
Description: A UI library made by GatherContent
Latest version: 0.0.58
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# GatherUI/Components
A work in progress UI library for GatherContent.

Check out our [storybook](https://main--61e047e66568fd003ab0074e.chromatic.com)!

## Using the library
Run: 
```bash
# npm
npm i @gatherui/components

# Yarn
yarn add @gatherui/components
```

Import the core css and optionally the font css.
```js
import '@gatherui/components/dist/index.css';
import '@gatherui/components/dist/font.css';
```

and then you're ready to import UI components!

```js
import { ButtonPrimary } from '@gatherui/components';
```

## Deploying the Library

The library will automatically deploy when a new tag is pushed to the master branch. The easiest way to do this is to run `git pull --tags`, followed by `npm version <major | minor | patch>` followed by `git push origin --tags` and `git push`.
npm package: @gati-framework/cloud-aws
Description: AWS cloud provider plugin for Gati framework
Author: Krishna Paul
Latest version: 1.0.1

# @gati-framework/cloud-aws

AWS cloud provider plugin for Gati framework, enabling seamless deployment to Amazon EKS.

## Features

- ✅ **EKS Cluster Management** - Automated cluster creation and management
- ✅ **Load Balancer Integration** - Application Load Balancer (ALB) configuration
- ✅ **Secrets Manager** - Secure secret storage and rotation
- ✅ **IAM Role Automation** - Automatic role and policy management
- ✅ **Multi-AZ Support** - High availability across availability zones

## Installation

```bash
pnpm add @gati-framework/cloud-aws
```

## Usage

### Initialize AWS Provider

```typescript
import { AWSCloudProvider } from '@gati-framework/cloud-aws';
import { CloudProviderFactory } from '@gati-framework/core/cloud-provider';

// Register the provider
CloudProviderFactory.register('aws', () => new AWSCloudProvider());

// Create and initialize
const provider = CloudProviderFactory.create('aws');
await provider.initialize({
  region: 'us-east-1',
  credentials: {
    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
  },
});
```

### Create EKS Cluster

```typescript
const result = await provider.createCluster({
  name: 'my-gati-cluster',
  version: '1.28',
  nodePools: [
    {
      name: 'default',
      instanceType: 't3.medium',
      minNodes: 2,
      maxNodes: 10,
      desiredNodes: 3,
      diskSizeGb: 20,
    },
  ],
  network: {
    privateNetworking: true,
  },
});

console.log('Cluster endpoint:', result.clusterEndpoint);
```

### Manage Secrets

```typescript
// Store secret
await provider.storeSecret({
  name: 'my-app-secret',
  values: {
    DATABASE_URL: 'postgresql://...',
    API_KEY: 'secret-key',
  },
  tags: {
    Environment: 'production',
  },
});

// Retrieve secret
const secrets = await provider.retrieveSecret('my-app-secret');
console.log(secrets.DATABASE_URL);
```

### Create Load Balancer

```typescript
const lb = await provider.createLoadBalancer({
  type: 'application',
  scheme: 'internet-facing',
  targetPort: 3000,
  healthCheck: {
    path: '/health',
    intervalSeconds: 30,
    healthyThreshold: 2,
    unhealthyThreshold: 3,
  },
  ssl: {
    certificateId: 'arn:aws:acm:...',
    redirectHttp: true,
  },
});

console.log('Load balancer endpoint:', lb.endpoint);
```

## Configuration

### Environment Variables

- `AWS_ACCESS_KEY_ID` - AWS access key
- `AWS_SECRET_ACCESS_KEY` - AWS secret key
- `AWS_SESSION_TOKEN` - Session token (optional)
- `AWS_REGION` - Default AWS region

### IAM Permissions Required

The AWS credentials must have permissions for:
- EKS cluster management
- EC2 instance management
- IAM role creation and management
- Secrets Manager access
- Elastic Load Balancing

## API Reference

See [TypeScript definitions](./src/index.ts) for complete API documentation.

## License

MIT © Krishna Paul
npm package: @gati-framework/core
Description: Gati core runtime types and base config
Latest version: 0.4.5

# @gati-framework/core

Core types & base configuration for the Gati framework.

This package is intentionally minimal right now (Milestone M1). It provides:

- Canonical TypeScript types used by handlers & contexts
- A sharable `tsconfig.base.json` for scaffolding new services
- Stable public package for downstream tooling & the CLI

Future milestones will move the runtime (execution engine, router, module system) into its own publishable package (e.g. `@gati-framework/runtime`).

## Install

```bash
pnpm add @gati-framework/core
# or
npm i @gati-framework/core
```

## Exports

Currently exported types (subject to expansion):

```ts
import type {
  Handler,
  Request,
  Response,
  GlobalContext,
  LocalContext,
  AppConfig,
  GatiApp // interface form (runtime class will live in runtime package later)
} from '@gati-framework/core';
```

### Tsconfig Base

Reference it in your project `tsconfig.json`:

```json
{
  "extends": "@gati-framework/core/tsconfig.base.json",
  "compilerOptions": {
    "outDir": "./dist",
    "rootDir": "./src"
  },
  "include": ["src/**/*"]
}
```

## Handler Type (Preview)

```ts
import type { Handler } from '@gati-framework/core';

export const handler: Handler = (req, res, gctx, lctx) => {
  res.json({ ok: true });
};
```

## Versioning Policy

- Minor versions: additive, non-breaking exports
- Patch versions: internal / doc changes
- Major versions: (not expected until runtime lands)

## Roadmap Alignment

| Milestone | Relevance |
|-----------|-----------|
| M1        | Types & base config (this package) |
| M2        | Deployment engines (separate packages) |
| M3        | Versioned routing (runtime package) |

## Contributing

Open an issue or PR at https://github.com/krishnapaul242/gati

## License

MIT © Krishna Paul
npm package: @gati/space-invaders
Description: A terminal-based Space Invaders game written in TypeScript
Latest version: 1.0.2

# Terminal Space Invaders

A classic Space Invaders game implemented in TypeScript that runs in your terminal!

## Features

- 🚀 Classic Space Invaders gameplay
- 🎮 Keyboard controls (WASD, arrow keys, or hjkl)
- 🎯 Multiple enemy types with different point values
- 📊 Score tracking and level progression
- 🎨 Colorful terminal graphics using ANSI colors
- ⏸️ Pause functionality
- 🔄 Restart capability

## Installation

1. Clone or download this project
2. Install dependencies:
   ```bash
   npm install
   ```

## How to Play

1. Build and run the game:
   ```bash
   npm run play
   ```

2. Or use the simple launcher:
   ```bash
   ./play.js
   ```

3. Or build and run separately:
   ```bash
   npm run build
   npm start
   ```

## Controls

- **A** or **H**: Move left
- **D** or **L**: Move right  
- **W**, **K**, or **Space**: Shoot
- **P**: Pause/unpause the game
- **ESC**: Pause the game
- **Q**: Quit the game
- **R**: Restart (when game over)

## Gameplay

- Destroy all enemies to advance to the next level
- Different enemy types give different points:
  - Red diamonds (♦): 30 points
  - Yellow spades (♠): 20 points  
  - Cyan clubs (♣): 10 points
- Enemies move faster as levels progress
- Game ends if enemies reach your position
- You have 3 lives (feature can be extended)

## Development

- **Build**: `npm run build`
- **Watch mode**: `npm run dev` (rebuilds on file changes)
- **Start**: `npm start` (runs the compiled JavaScript)

## Technical Details

This game is built with:
- TypeScript for type safety and modern JavaScript features
- Node.js for terminal I/O and process management
- Chalk for colorful terminal output
- Raw terminal input handling for responsive controls
- Object-oriented design with separate classes for rendering, input, and game logic

## File Structure

```
src/
├── index.ts      # Main entry point
├── game.ts       # Core game engine and logic
├── renderer.ts   # Terminal rendering system
├── input.ts      # Keyboard input handling
└── types.ts      # TypeScript type definitions
```

Enjoy playing Space Invaders in your terminal! 🚀👾