open-index/open-npm huggingface dataset:
npm package: @posprint/previewer-react
Description: Previewer of hyrdated DOM for POS Print.
Latest version: 0.0.41

# POS Print Previewer React

Previewer of template for POS Print in React

## Usage

```javascript
import { hydrate } from 'pos-print-template-jsx';
import Previewer from 'pos-print-previewer-react';

function render(props) {
  const { template, style, data, printer } = props;
  const dom = hydrate(template, style, data, printer);
  return <Previewer dom={dom} />;
}
```
npm package: @posquit0/omega
Description: An expressive framework to write serverless application
Author: Byungjin Park
Latest version: 0.0.3

<div align="center">
  <a href="https://github.com/posquit0/omega" title="Omega">
    <img alt="Omega" src="https://adc3ef35f321fe6e725a-fb8aac3b3bf42afe824f73b606f0aa4c.ssl.cf1.rackcdn.com/tenantlogos/19935.png" width="220px" />
  </a>
  <br />
  <h1>Omega</h1>
</div>

<p align="center">
  :fire: Make serverless application expressive
</p>

<div align="center">
  <a href="https://circleci.com/gh/posquit0/omega">
    <img alt="CircleCI" src="https://circleci.com/gh/posquit0/omega.svg?style=shield" />
  </a>
  <a href="https://coveralls.io/github/posquit0/omega">
    <img src="https://coveralls.io/repos/github/posquit0/omega/badge.svg" alt='Coverage Status' />
  </a>
  <a href="https://badge.fury.io/js/%40posquit0%2Fomega">
    <img alt="npm version" src="https://badge.fury.io/js/%40posquit0%2Fomega.svg" />
  </a>
  <a href="https://www.npmjs.com/package/%40posquit0%2Fomega">
    <img alt="npm" src="https://img.shields.io/npm/dt/%40posquit0%2Fomega.svg" />
  </a>
  <a href="https://david-dm.org/posquit0/omega">
    <img alt="npm" src="https://img.shields.io/david/posquit0/omega.svg?style=flat-square" />
  </a>
  <a href="https://opensource.org/licenses/mit-license.php">
    <img alt="MIT License" src="https://badges.frapsoft.com/os/mit/mit.svg?v=103" />
  </a>
  <a href="https://github.com/ellerbrock/open-source-badge/">
    <img alt="Open Source Love" src="https://badges.frapsoft.com/os/v1/open-source.svg?v=103" />
  </a>
</div>

<br />

**Omega** is an expressive framework to write serverless application with the layered architecture.


## Installation

```bash
# NPM
$ npm install --save @posquit0/omega
# Yarn
$ yarn add @posquit0/omega
```


## Example

```node
const Omega = require('@posquit0/omega');
const AwsProxyTranslator = require('@posquit0/omega/translators/aws-proxy-translator');


const app = new Omega();

// Set middlewares
app.use(new AwsProxyTranslator());


// Write your serverless functions here
const handler = app.createLambda(async ctx => {

});
```


## API

To be updated


## Contributing

This project follows the [**Contributor Covenant**](http://contributor-covenant.org/version/1/4/) Code of Conduct.

#### Bug Reports & Feature Requests

Please use the [issue tracker](https://github.com/posquit0/omega/issues) to report any bugs or ask feature requests.


## Self Promotion

Like omega? Follow the repository on [GitHub](https://github.com/posquit0/omega). And if you're feeling especially charitable, follow [posquit0](https://posquit0.com) on [GitHub](https://github.com/posquit0).


## Contact

If you have any questions, feel free to join me at [`#posquit0` on Freenode](irc://irc.freenode.net/posquit0) and ask away. Click [here](https://kiwiirc.com/client/irc.freenode.net/posquit0) to connect.


## License

Provided under the terms of the [MIT License](https://github.com/posquit0/omega/blob/master/LICENSE).

Copyright © 2018, [Byungjin Park](http://www.posquit0.com).
npm package: @possibilities/next-apollo-appsync
Description: Fork of next-apollo to enable AWS AppSync SSR Appsy
Author: Manuel Iglesias
Latest version: 0.0.9

# Next Apollo AppSync
A fork of [next-apollo](https://github.com/adamsoffer/next-apollo) to work with AWS AppSync for SSR React Applications

_a temp for, for context see https://github.com/dabit3/next-apollo-appsync/issues/12_

![](https://s3.amazonaws.com/aws-mobile-hub-images/nextjs.jpg)

## Installation

```bash
yarn add next-apollo-appsync
```

## Documentation
Create an Apollo configuration object (check out the Apollo Client API for more configuration options). Pass the configuration object to the withAppSyncData higher-order component and export the returned component.

```js
// withData.js

import { withAppSyncData } from 'next-apollo-appsync'

const config = {
  url: "https://<YOURAPI>.us-east-2.amazonaws.com/graphql",
  region: "us-east-2", // or whatever your region is
  auth: {
    type: "API_KEY", 
    apiKey: "<YOURAPIKEY>",

    // Other auth use cases
    // Amazon Cognito Federated Identities using AWS Amplify
    //credentials: () => Auth.currentCredentials(),

    // Amazon Cognito user pools using AWS Amplify
    // type: AUTH_TYPE.AMAZON_COGNITO_USER_POOLS,
    // jwtToken: async () => (await Auth.currentSession()).getIdToken().getJwtToken(),
  },
}

export default withAppSyncData(config)
```

Inside your Next.js page, wrap your component with your exported higher order component.

```js
import gql from 'graphql-tag'
import { graphql } from 'react-apollo'
import withData from '../withData'

const query = gql`
  query listTodos {
    listTodos {
      items {
        id
        name
        completed
      }
    }
  }
`

class Todos extends React.Component {
  render() {
    return <div>
      <p>Hello World</p>
    </div>
  }
}

const TodosWithData = graphql(query, {
  options: {
    fetchPolicy: 'cache-and-network'
  },
  props: props => ({ todos: props.data.listTodos ? props.data.listTodos.items : [] })
})(Todos)

export default withData(TodosWithData)
```

## License

MIT
npm package: @possumtech/rummy
Description: Relational Unknowns Memory Management Yoke
Author: @wikitopian
Latest version: 0.3.0

# RUMMY: Relational Unknowns Memory Management Yoke

Rummy is the only LLM agent service inspired by and dedicated to the memory of former Secretary of State Donald "Rummy" Rumsfeld. Our unique fusion of apophatic and hedbergian engineering strategies yields more accurate and efficient results than any other agent. Our client/server and plugin architecture integrates it into more workflows than any other agent. It's also more flexible and lean than any other agent. Our dynamic cache management, model hot-swapping, and flexible router interface make it more affordable than any other agent.

## Key Features

- **The Rumsfeld Loop:** Forcing models to catalog what they don't know is a powerful weapon against hallucination and laziness. Every turn, the model calls `<known>`, `<unknown>`, and `<update>` — externalizing its reasoning into a persistent K/V store that survives across turns without message history.

- **One K/V Store:** Files, knowledge, tool results, unknowns, user prompts — everything is a keyed entry in one SQLite table. No message history. No separate file listings. The model's entire context is assembled from the store each turn.

- **Hedberg:** The interpretation boundary between stochastic model output and deterministic system operations. Models speak in whatever syntax they were trained on — sed regex, SEARCH/REPLACE blocks, escaped characters. Hedberg normalizes all of it. Available to all plugins via `core.hooks.hedberg`.

- **Plugin Architecture:** Every `<tag>` the model sees is a plugin. Every scheme is registered by its owner. The prompt itself is assembled from plugins. Drop a directory into `~/.rummy/plugins/` or install via npm. See [PLUGINS.md](PLUGINS.md) for the complete plugin API.

- **Symbols Done Right:** Designed with universal language support in mind. Powered by [@possumtech/antlrmap](https://github.com/possumtech/antlrmap).

- **SQLite Done Right:** Async, compiled WAL-mode SQL engine in worker threads. Powered by [@possumtech/sqlrite](https://github.com/possumtech/sqlrite).

## Installation

```bash
npm i -g @possumtech/rummy
cd ~/.rummy
cp .env.example .env
vim .env # set up at least one model alias
npm start
```

## Usage

Rummy is just the service. You'll need to get (or vibe) yourself a client interface. We're partial the our Neovim plugin: [@possumtech/rummy.nvim](https://github.com/possumtech/rummy.nvim)

## Documentation

| Document | Contents |
|----------|----------|
| [SPEC.md](SPEC.md) | System design: K/V store, dispatch, packet structure, RPC |
| [PLUGINS.md](PLUGINS.md) | Plugin development: registration, events, filters, hedberg |
| [AGENTS.md](AGENTS.md) | Planning and progress |

Each plugin has its own README at `src/plugins/{name}/README.md`.
The `discover` RPC method returns the live protocol reference at runtime.
npm package: @possumtech/rummy.repo
Description: Rummy plugin for symbol extraction via antlrmap and ctags
Author: @wikitopian
Latest version: 0.0.11

# rummy.repo

File scanning and symbol extraction plugin for [Rummy](https://github.com/possumtech/rummy). Discovers project files via git, syncs them into the known store, detects changes, and extracts symbols using [antlrmap](https://github.com/possumtech/antlrmap) (formal ANTLR4 grammars) with [Universal Ctags](https://ctags.io/) as a fallback.

Antlrmap relies on ANTLR4's Grammar Zoo, mapping the symbol extraction process from formal EBNF grammars. More academically rigorous than tree-sitter heuristics, more accurate than ctags regex patterns, and more amenable to obscure and domain-specific languages. Don't like it? This is why symbol extraction is a plugin -- swap it out.

## What It Does

Every turn, this plugin:

1. Enumerates project files from git (via isomorphic-git or CLI fallback)
2. Stats and hashes files to detect changes since the last scan
3. Syncs file entries into the known store (upsert changed, remove deleted)
4. Emits `entry.changed` with the list of modified paths
5. Reacts to `entry.changed` by extracting symbols from changed files
6. Writes formatted symbol trees into each file entry's `attributes.symbols`

The model gets a compact structural overview of the codebase -- function names, class hierarchies, method signatures, line numbers -- without reading every file in full.

## Supported Languages

Antlrmap provides grammar-based parsing for 36+ languages: JavaScript, TypeScript, Python, Rust, Go, Java, C, C++, Kotlin, PHP, Lua, SQL, Dart, Scala, Clojure, Elixir, Zig, R, Objective-C, Verilog, VHDL, Terraform, Fortran, Erlang, Thrift, GraphQL, AWK, JSON, TOML, Dockerfile, and more.

Files with unsupported extensions fall back to Universal Ctags (if installed).

## Installation

Configure via environment variable in your `.env`:

```env
RUMMY_PLUGIN_REPO=@possumtech/rummy.repo
```

Install the package:

```bash
npm install @possumtech/rummy.repo
```

Rummy loads external plugins from `RUMMY_PLUGIN_*` env vars on startup. No other configuration required.

## Usage

The plugin registers automatically via the Rummy v0.2 plugin contract. No manual setup needed.

```js
import RummyRepo from "@possumtech/rummy.repo";
new RummyRepo(core);
```

## Optional Dependencies

- **isomorphic-git** -- Pure JS git implementation. Used for file enumeration and HEAD detection. Falls back to CLI `git` commands if not installed.
- **Universal Ctags** -- Fallback symbol extractor for languages not supported by antlrmap. Not required.

## Development

```bash
npm test          # lint + unit tests (80% coverage threshold)
npm run lint      # biome check
```

Requires Node.js >= 25.

## License

MIT -- PossumTech Laboratories
npm package: @possumtech/rummy.web
Description: Web search and fetch plugin for rummy — Playwright browser automation and SearXNG search integration
Author: @wikitopian
Latest version: 0.0.13

# @possumtech/rummy.web

Web search and fetch plugin for [rummy](https://github.com/possumtech/rummy). Adds `<search>` and URL-aware `<get>` tools powered by Playwright, Mozilla Readability, and SearXNG.

## Install

```sh
npm install @possumtech/rummy.web
npx playwright install chromium
```

## Setup

Load via environment variable:

```env
RUMMY_PLUGIN_WEB=@possumtech/rummy.web
```

The plugin loader imports the package, derives the name `"web"`, and calls `new RummyWeb(core)` with a `PluginContext`. Graceful failure if not installed.

### SearXNG

The `<search>` tool requires a running [SearXNG](https://github.com/searxng/searxng) instance:

```sh
docker run -d -p 8888:8080 searxng/searxng
```

### Environment Variables

| Variable | Required | Default | Description |
|---|---|---|---|
| `RUMMY_PLUGIN_WEB` | Yes | — | Set to `@possumtech/rummy.web` to load the plugin |
| `RUMMY_SEARXNG_URL` | Yes (for search) | — | SearXNG base URL (e.g. `http://127.0.0.1:8888`) |
| `RUMMY_FETCH_TIMEOUT` | No | `15000` | Timeout in ms for page loads and search requests |

## Tools

### `<search>` — Web Search

Queries SearXNG and creates URL entries from results.

```xml
<search>node.js streams backpressure</search>
<search results="5">SQLite WAL mode</search>
```

- Results default to 12; set the `results` attribute to limit.
- Each result is stored as an `https://` entry at `summary` state with `title + snippet` body.
- A `search://` result entry is created at `info` state with the URL listing.
- Use `<get>` on a result URL to fetch the full page.

### `<get>` — URL Fetch

When `<get>` targets an `http://` or `https://` URL, this plugin intercepts at priority 5 (before the core get handler at 10), fetches the page with headless Chromium, extracts readable content via Mozilla Readability, and converts it to markdown via Turndown.

```xml
<get>https://docs.example.com/api</get>
```

- Content is stored as a `full` entry with `title`, `excerpt`, `byline`, and `siteName` attributes.
- Already-fetched URLs are skipped (deduplication by path).
- If Readability fails to parse, falls back to the first 5000 chars of raw HTML.

## Programmatic Access

`WebFetcher` is available as a standalone export for use outside the plugin system:

```javascript
import WebFetcher from "@possumtech/rummy.web/fetcher";

const fetcher = new WebFetcher();

const page = await fetcher.fetch("https://example.com");
console.log(page.title, page.content);

const results = await fetcher.search("query");
console.log(results);

await fetcher.close();
```

### `WebFetcher.fetch(url)` Response

```javascript
{ url, title, content, excerpt, byline, siteName }
// or on failure:
{ url, title: null, content: null, error: "message" }
```

### `WebFetcher.search(query, opts)` Response

```javascript
[{ title, url, snippet, engine }]
```

### `WebFetcher.cleanUrl(raw)`

Static method. Strips query params, hash fragments, and trailing slashes for path canonicalization and cache deduplication.

## License

MIT
npm package: @post-cards/core
Description: @post-cards/core is a small node library for generating OpenGraph images for social media sharing.
Author: dev-warner
Latest version: 1.0.0

# post-cards 📬

[![Coverage Status](https://coveralls.io/repos/github/dev-warner/post-card/badge.svg?branch=main)](https://coveralls.io/github/dev-warner/post-card?branch=main)
[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg)](code_of_conduct.md)

`@post-cards/core` is a small node library for generating OpenGraph images for social media sharing. 📬

- [Templates](https://github.com/dev-warner/post-card-templates)
- [Documentation](https://dev-warner.github.io/post-card/)

<br>

## What is OpenGraph?

---

<br>

Simply as [opengraph.xyz](https://www.opengraph.xyz/) describes:

> Social networks and messaging apps use the Open Graph meta tags to display your website.

- [Open Graph documentation](https://ogp.me/)
- [Open Graph card validator](https://www.opengraph.xyz/)

## Getting Started

```bash
npm i @post-cards/core -D
```

```typescript
import generate from '@post-cards/core'
import BasicTemplate from '@post-cards/basic-template'

await generate(
  new BasicTemplate({
    text: '#fff',
    background: '#000',
    accent: 'orange',
  }),
  [
    {
      output: 'media/home-page.png',
      data: {
        title: 'My great Home Page',
      },
    },
    {
      output: 'media/about-page.png',
      data: {
        title: 'My great About Page',
      },
    },
  ],
  {
    concurrency: 10,
    ...options,
  }
)
```

### Template override

Sometimes you might not want the same template for each item but still want to batch them together.

```typescript
await generate(Template, [
  { output: 'media/first-image.jpg', data: {} },
  {
    output: 'media/second-image.jpg',
    data: {},
    options: { templateOveride: FancyTemplate },
  },
])
```

## Creating Templates

Creating template is an easy process, if you've ever worked with html canvas, creating templates should be a breeze, and we provide some utils to smooth out the process.

For more information: [Templates](https://github.com/dev-warner/post-card-templates)

## Contributting Guide

Some resources:

- Our [CONTRIBUTING.md](CONTRIBUTING.md) to get started with setting up the repo.

- Our [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) if you contribute i'd appreciate sticking to our code of conduct.

## License

[MIT](LICENSE)
npm package: @post-me/mpi
Description: MPI-like concurrency for a pool of web workers
Author: Alessandro Genova
Latest version: 0.1.2

<h1 align="center">@post-me/mpi</h1>

<p align="center">Write parallel algorithms in JavaScript using a MPI-like API.</p>

![diagram](./diagram.png)

__@post-me/mpi__ is a library to write parallel algorithms that can run on a pool of web workers, using an API similar to [MPI](https://en.wikipedia.org/wiki/Message_Passing_Interface).

A worker pool is a set of workers that are mutually interconnected. Each worker can communicate directly with any other worker in the pool.

The low level communication between workers and the parent application is managed by __post-me__.

## Usage

Below is a small example of using __@post-me/mpi__ in practice. In this example we will be sorting an array in parallel.

Worker code:
```javascript
import { joinPool } from '@post-me/mpi';

const connection = await joinPool(self);

// The parallel sort method
const sort = (communicator) => async (array) => {
  const root = 0;
  let subArray = await communicator.scatter(array, root);
  subArray.sort((a, b) => a - b);
  const sorted = await communicator.reduce(subArray, merge, root);

  return sorted;
}

// Expose parallel methods to the application
connection.registerMethods({ sort });

// Merge two sorted arrays into a single sorted array
function merge(a0, a1) {/* ... */}
```

Parent code:
```javascript
import { createPool } from '@post-me/mpi';

const array = new Float32Array(1024);
const N_WORKERS = 4;

// Create the workers
const workers: Worker[] = [];
for (let i = 0; i < N_WORKERS; ++i) {
  workers.push(new Worker('./worker.js'));
}

// Create a pool of mutually interconnected workers
const workerPool = await createPool(workers);

// Pass different parameter to the parallel method based on the rank of the worker
const root = 0;
const args = (rank) => rank === root ? array : null;
const transfer = (rank, [arr]) => rank === root ? [arr.buffer] : [];

// Call the parallel method 'sort'
const result = await workerPool.call('sort', args, transfer);

// The sorted array is returned by the root worker
const sortedArray = result[root];
```

## MPI Operations

The following MPI operations are already implemented in __@post-me/mpi__:
- `send`
- `recv`
- `bcast`
- `scatter`
- `gather`
- `reduce`
- `barrier`
- `allGather`
- `allReduce`

## Typescript

The library has extensive typescript support, all arguments, methods, return types, etc., are all type checked so that most coding mistakes can be caught at compile tim.

## Benchmark
Below is a quick non-scientific benchmark that shows that indeed running a parallel algorithm is faster than serial. In the plot I'm showing the speedup obtained when sorting arrays of various length as a function of the number of workers.

![benchmark](./benchmark.png)

## Demo
I created a small [demo page](https://alesgenova.github.io/post-me-demo/mpi/) where you can run a couple of test algorithms yourself ([source](https://github.com/alesgenova/post-me-demo/tree/main/examples/mpi)).
npm package: @postact/core
Description: Simple, fast, lightweight web dev.
Author: AWeirdDev
Latest version: 0.0.15-rc0

# @postact/core
Simple, fast, lightweight web dev.

[GitHub](https://github.com/AWeirdDev/postact)

```html
<div id="app"></div>
```

```ts
import { 
  select,
  state
  html,
} from "@postact/core";


const $count = state(0);

function onClick() {
  $count.update(v => v + 1)
}

return html`
  <button onclick=${onClick}>${$count}</button>
`

select("#app").render(createApp())
```
npm package: @postact/jsx
Description: JSX support for Postact.
Author: AWeirdDev
Latest version: 0.0.10

# @postact/jsx
This adds JSX support to [Postact](https://github.com/AWeirdDev/postact), if you'd like.

It took me forever, so please enjoy this.

You can just add `@postact/jsx` as the JSX input source in your `tsconfig.json`:

```jsonc
{
  "compilerOptions": {
    "jsx": "react-jsx",
    "jsxImportSource": "@postact/jsx",
  }
}
```

Then you should be good to go. Maybe. I don't fucking know.
npm package: @postact/serde
Description: Serialization/deserialization and typing system crafted to align with Postact and other workflows.
Author: AWeirdDev
Latest version: 0.0.2

# @postact/serde
Serialization/deserialization and typing system crafted to align with [Postact](https://github.com/AWeirdDev/postact) and other workflows.

## At a glance
serde provides a clean API that's similar to Zod, but you can take more control over how the data is structured.

```ts
import { t, serialize, deserialize } from "@postact/serde";

// Create a schema
const Product = t.object({
  name: t.field(t.string()).order(0),
  description: t.field(t.string()).order(1),
  price: t.field(t.int()).order(2),
});

// Extract the type from the schema
type Product = t.infer<typeof Product>;

const product = {
  name: "Ice cream",
  description: "Creamy and nice.",
  price: 3,
} satisfies Product;

// Serialize it into a buffer
const buf = serialize(Product, product);
console.log(buf); // ArrayBuffer(37) [ 9, 0, 0, 0, 73, 99, ... ]

// Deserialize the serialized data
const deserialized = deserialize(Product, buf);
console.log(deserialized); // { name: "Ice cream", (...) }
```

## Drawbacks
You cannot write documentation for each field or type, as it's not a TypeScript `interface`. Therefore, the field names & type names **must** be implicit. They can be as long as you wish, as they're just labels and will not be serialized.