open-index/open-npm huggingface dataset:
npm package: @syntay/fastay
Description: Framework backend moderno baseado em Express.js, para criar APIs rapidamente
Author: Syntay team
Latest version: 1.0.1

# Fastay

<p align="center">
  <a href="https://www.npmjs.com/package/@syntay/fastay">
    <img src="https://img.shields.io/npm/v/@syntay/fastay.svg?style=flat-square" alt="npm version">
  </a>
  <a href="https://github.com/syntay-team/fastay">
    <img src="https://img.shields.io/badge/GitHub-Repository-blue?style=flat-square&logo=github" alt="GitHub">
  </a>
  <a href="https://www.npmjs.com/package/@syntay/fastay">
    <img src="https://img.shields.io/npm/dt/@syntay/fastay.svg?style=flat-square" alt="npm downloads">
  </a>
  <a href="https://github.com/syntay-team/fastay/blob/main/LICENSE">
    <img src="https://img.shields.io/npm/l/@syntay/fastay.svg?style=flat-square" alt="license">
  </a>
</p>

Fastay is a modern backend framework built on Express.js, designed for fast, predictable, and developer-friendly API development. It is TypeScript-first, file-based, and automatically discovers routes and middlewares.

The complete documentation is available at:

[https://fastay.syntay.site](https://fastay.syntay.site)

## Quick Start

```bash
npx fastay create-app my-app
cd my-app
npm run dev
```

## Why Fastay?

- File-based routing with auto-discovery
- Clean separation between routes and middlewares
- Minimal configuration, maximum productivity
- Ideal for REST APIs, microservices, and MVPs

## Contributing

1. Fork the repository
2. Create a branch (`git checkout -b my-feature`)
3. Commit your changes (`git commit -m "Add feature"`)
4. Push to your branch
5. Open a Pull Request

## License

MIT © Syntay Team
npm package: @syntect/wasm
Description: Syntect (Syntax highlighter in Rust) for WebAssembly
Author: Menci
Latest version: 0.0.4

# Syntect for Node.js and WASM

[Syntect (Syntax highlighter in Rust)](https://github.com/trishume/syntect) for Node.js and WebAssembly.

Syntect highlights code with TextMate's `.tmTheme` theme. And the highlighting result is independent of the theme (using CSS classes, unlike [Shiki](https://github.com/shikijs/shiki), which uses inline styles) so you can switch themes in your website by only switching CSS.


```bash
# Install the meta-package
yarn add syntect       # Auto choose --
                       # Native binding for Node.js
                       # WebAssembly for browser

# Or Install manually
yarn add @syntect/node # Node.js native binding
yarn add @syntect/wasm # WebAssembly
```

# Usage

**Note:** See [WASM Notes](#wasm-notes) if you encountered any error using the WASM version.

```typescript
import { getCSS, highlight } from "syntect" /* or "@syntect/node" / "@syntect/wasm" */;

// Generate CSS code from .tmTheme file
const result = getCSS(
  // The text content of .tmTheme file
  tmThemeText,
  // The prefix of CSS class name,
  "hl-"
);
console.log(result.css);
// Only needed once.
// You could save the CSS file for your website.
// See also [CLI]

// Highlight code
const highlightResult = highlight(
  // The code to highlight
  "#include <cstdio>",
  // The language name or file extension. Use "plain" or "plaintext" for plain text
  "cpp",
  // The prefix of CSS class name,
  "hl-"
);
console.log(result.html);
```

# CLI

There's a cli utility for `getCSS` function. You should install the Node.js version (`syntect` or `@syntect/node`) to use it.

```bash
# Install with `yarn add syntect` or `yarn add @syntect/node`

# yarn syntect-css <prefix>
cat my-theme.tmTheme | yarn syntect-css hl-

# e.g. the tomorrow theme
curl https://raw.githubusercontent.com/chriskempson/textmate-tomorrow-theme/master/Tomorrow.tmTheme | yarn syntect-css hl-
```

# WASM Notes

The WASM version has all code in ES Modules.

To use the WASM version with Node.js, please add `--experimental-wasm-modules` to your Node.js command line options to enable Node.js to load `.wasm` modules. For older version of Node.js you'll also need `--experimental-modules` to enable basic ES Modules support.

To use the WASM version in browser, you may need to configure your bundler:

* *Webpack 5*: enable `experiments.asyncWebAssembly`.
* *Vite*: not currently supported but related works are in progress.
npm package: @synth-coder/iflow-acp
Description: Thin ACP proxy adapter for iFlow CLI
Author: hicaosen
Latest version: 0.1.0

# iflow-acp

`iflow-acp` is a **thin ACP proxy adapter** for [iFlow CLI](https://www.npmjs.com/package/@iflow-ai/iflow-cli).

It exposes ACP over stdio and forwards all protocol traffic to:

```bash
iflow --experimental-acp
```

## Why this architecture

Instead of reimplementing ACP translation logic, this project delegates ACP behavior to iFlow's native ACP implementation and focuses on:

- robust process management
- compatible entrypoint for ACP clients
- clear error handling
- testable, low-maintenance adapter surface

## Prerequisites

- Node.js 20+
- iFlow CLI installed and available in `PATH`

```bash
npm install -g @iflow-ai/iflow-cli
```

## Install

```bash
npm install -g @synth-coder/iflow-acp
```

Then configure your ACP client (example with a custom command):

```json
{
  "agent_servers": {
    "iflow": {
      "type": "custom",
      "command": "iflow-acp",
      "args": [],
      "env": {}
    }
  }
}
```

## Runtime behavior

### Default mode

```bash
iflow-acp
```

Runs iFlow ACP mode:

```bash
iflow --experimental-acp
```

### Terminal login mode

```bash
iflow-acp --terminal-login
```

Passes through to iFlow interactive mode (without forcing `--experimental-acp`).

## Environment variables

- `IFLOW_ACP_IFLOW_COMMAND` – override executable (default: `iflow`)
- `IFLOW_ACP_IFLOW_ARGS` – extra args appended before CLI passthrough args

Example:

```bash
IFLOW_ACP_IFLOW_COMMAND=iflow.cmd IFLOW_ACP_IFLOW_ARGS="--model kimi-k2.5 --yolo" iflow-acp
```

## Migration notes

This repository is now **iflow-only**.

- Legacy RPC translation internals were removed.
- ACP behavior is delegated to iFlow native ACP mode.
- The adapter acts as a process-managed wrapper for ACP clients.

Treat `0.1.0` as a breaking migration baseline.

## Development

```bash
npm install
npm run quality
npm run smoke
```

Quality gate includes:

- lint
- strict typecheck
- coverage check (>= 80% lines/functions/branches/statements)
- build

## Release verification checklist

Before publishing:

```bash
npm run quality
npm run smoke
```

Then validate with an ACP client:

1. `initialize` succeeds
2. `session/new` returns a valid session id
3. `session/prompt` returns streamed output and ends normally

## Open-source attribution

This project is a derivative work based on a public MIT-licensed ACP adapter codebase.

- Historical upstream project: https://github.com/svkozak/pi-acp
- Current repository keeps visible git history and fork lineage.
- The original MIT license notice is preserved in [`LICENSE`](./LICENSE).
- This repository contains substantial refactoring and productization focused on an iflow-only thin proxy architecture.

## License

MIT
npm package: @synthels/node-media-server
Description: A Node.js implementation of RTMP Server
Author: Chen Mingliang
Latest version: 2.3.8

# NodeMediaServer (fork)
![License](https://img.shields.io/github/license/synthels/NodeMediaServer)

NodeMediaServer fork with my personal modifications

# Running
```
$ yarn add @synthels/node-media-server
$ node-media-server
```
npm package: @synthetixio/bfp-market
Description: L1 perp market implementation
Author: Synthetix
Latest version: 3.13.0

# BFP Market

### Intro

The _big ~~fucking~~ freaking perp market_ (or just BFP-Market) is a perpetual swap market, leveraging the capabilities of Synthetix v3 as its underlying infrastructure. bfp-market inherits core features from [v2x](https://github.com/Synthetixio/synthetix/tree/develop/contracts), such as dynamic funding rates, PD (Premium/Discount) adjusted market prices, and asynchronous hybrid oracle-based order executions through [Pyth](https://pyth.network/).

In addition to these features, it also introduces various enhancements, including native multi-collateral support, improved dynamic keeper fees, user-adjustable keeper fees on order commitments, settlement hooks, account splitting/merging, improved liquidations, a host of quality-of-life improvements, a strong emphasis on gas optimization, and obviously built on [Synthetix v3](https://github.com/Synthetixio/synthetix-v3).

bfp-market's primary use case is to allow stable coin issuers, vaults, and other DeFi protocols to create a delta neutral perp, utilizing ETH and ETH LSTs as collateral. The end result is a new defi primitive that's yield bearing (through positive funding) and hyper-stable. All of this done completely decentralised and onchain.

### Docs

To find more information on how to integrate BFP you can check out the docs here: [L1 Perp (BFP) docs](https://docs.synthetix.io/v3/for-perp-integrators/l1-perp-bfp)

## Development

```bash
# Ensure you're in the root of project.
cd synthetix-v3

# Install monorepo dependencies.
yarn

# Generate a testable artifacts.
yarn generate-testable
yarn build-testable

# Build and run bfp-market tests.
yarn workspace @synthetixio/bfp-market {build,test,test:stable}
```

### Architecture

<p align="center">
  <img src="./assets/overview.png" alt="Overview">
<img src="./assets/diagram.png" alt="Diagram">
</p>
npm package: @synthetixio/perps-market
Description: Perps Market implementation
Author: Synthetix
Latest version: 3.13.0

# Perpetual Futures Market

This system generates markets that allow traders to open positions (ERC-721 tokens) that are long or short with leverage after depositing collateral as margin.

## Developer Get Started

1. Ensure you have [IPFS Desktop](https://docs.ipfs.tech/install/ipfs-desktop/) running
2. Run `yarn` at the root directory: `/synthetix-v3`.
3. Run `yarn cannon setup` to configure cannon

- Run `cat ~/.local/share/cannon/settings.json` and ensure your `ipfsUrl` is configured to `http://localhost:5001`. If it's still unable to find your IPFS local node, try using `http://0.0.0.0:5001`.

4. Run `yarn build` at the root directory: `/synthetix-v3`.
5. Run `yarn test` in the synthetix protocol directory: `/protocol/synthetix`.

- This will create `synthetix-testable` version and throw it into your local IPFS cluster.

6. Run `yarn test` in the spot market directory: `/markets/spot-market`.

- This will create a `spot-market-testable` version and throw it into your local IPFS cluster.

7. Run `yarn test` in the perps market directory: `/markets/perps-market`.

- The perps market is composed of both the synthetix core and spot market contracts and uses the testable versions to create a testable perps market environment.

If you have passing tests at this point, **congrats**, you are all set for development.

## Troubleshooting

If you experience any unexpected errors try running:

- `yarn clean`