open-index/open-npm huggingface dataset:
npm package: 1to2
Description: NAN 1 -> 2 Migration Script
Latest version: 1.0.0

1to2 naively converts source code files from NAN 1 to NAN 2. There will be erroneous conversions,
false positives and missed opportunities. The input files are rewritten in place. Make sure that
you have backups. You will have to manually review the changes afterwards and do some touchups.

```sh
$ tools/1to2.js

  Usage: 1to2 [options] <file ...>

  Options:

    -h, --help     output usage information
    -V, --version  output the version number
```
npm package: 1tp-registrar
Description: Temporary service to route handshake messages between 1tp peers -- if needed.
Author: Nico Janssens
Latest version: 0.1.2

[![CircleCI](https://circleci.com/gh/MicroMinion/1tp-registrar.svg?style=svg)](https://circleci.com/gh/MicroMinion/1tp-registrar)

# 1tp-registrar
Temporary service to route handshake messages between 1tp peers -- if needed
npm package: 1tree-factory
Description: Factory that facilitates creating 1tree instances
Author: Nik Coughlin
Latest version: 0.1.15
Deprecated: Moved to @mojule/tree-factory

# 1tree-factory

Basically just a thin facade over 1tree to make the use case of creating a new
1tree instance easier when you have your own adapter/plugins etc.

1tree exports a default tree that's ready to start using provided that you want
to use 1tree's default underlying data structures, and also exposes some methods
for creating trees that use your own adapter and/or plugins.

Most people just want to start using a tree, 1tree's default export assumes
this.

However, if you want to use your own adapter, or use your own plugins but also
use 1tree's base plugins, there's a bit of fiddling around. It's not difficult
but doing it often gets old fast.

This module also inserts the plugins specified *before* 1tree's base plugins -
this is to ensure that the various 1tree plugins that do things like wrap other
plugins or extend them in some way will play nicely with your plugins. If you
want to add your plugins **after** the base plugins have been added, you can
always call the `plugin` method on the tree instance.

## usage

```javascript
/*
  we use the name Mtree (mojule tree) internally but the npm package name was
  taken
*/
const Mtree = require( '1tree-factory' )

/*
 create a tree using the default adapter but with some extra plugins that are
 added before the base plugins
*/
const tree1 = Mtree( plugin1, plugin2, plugin3 )

// same, but array instead of multiple args
const tree2 = Mtree( [ plugin1, plugin2, plugin3 ] )

// same, but with a custom adapter
const tree3 = Mtree( adapter, plugin1, plugin2, plugin3 )

// pass a boolean with true to exclude the base plugins
const tree4 = Mtree( plugin1, plugin2, plugin3, true )
const tree5 = Mtree( adapter, plugin1, plugin2, plugin3, true )

// add plugins after the fact, for example to wrap or extend existing plugins
tree5.plugin( plugin4 )

// same as just using 1tree
const tree6 = Mtree()
```
npm package: 1tree-json
Description: Convert JSON objects to and from 1tree instances
Author: Nik Coughlin
Latest version: 0.2.6
Deprecated: Moved to @mojule/json-tree

# 1tree-json

Allows conversion between JSON objects and 1tree instances

```javascript
const JsonTree = require( '1tree-json' )

const jsonData = require( './test-data.json' )

const tree = JsonTree( jsonData )

const numbers = tree.findAll( node => node.isNumber() )

numbers.forEach( numberNode => {
  const value = node.value()

  value.nodeValue *= 2

  node.value( value )
})

const newData = tree.toJson()

console.log( JSON.stringify( newData, null, 2 ) )
```
npm package: 1tree-schema
Description: Convert JSON schema to and from 1tree instances
Author: Nik Coughlin
Latest version: 0.2.5
Deprecated: Moved to @mojule/schema-tree

# 1tree-schema

Converts JSON schema to and from 1tree instances

```javascript
const SchemaTree = require( '1tree-schema' )
const jsonSchema = require( './test.schema.json' )

const tree = SchemaTree( jsonSchema )

const integerNodes = tree.findAll( n => n.nodeType() === 'integer' )

integerNodes.forEach( n => {
  const value = n.value()

  value.minimum = 1

  n.value( value )
})

const newSchema = tree.toSchema()

console.log( JSON.stringify( newSchema, null, 2 ) )
```
npm package: 1tube
Description: Self-hosted Supabase Edge Functions gateway for Deno, plus an ESLint plugin for consumers
Latest version: 0.1.3

![NPM Version](https://img.shields.io/npm/v/1tube)

# 1tube

Self-hosted Supabase Edge Functions gateway. Runs your Deno edge functions locally or behind a .NET host with zero-copy YARP proxying — no cold starts, no version lock, no Supabase compute dependency.

## How it works

1tube discovers edge function modules from a `supabase/functions/` directory and hosts them in a single Deno HTTP server. Each function's `serve()` call registers a handler in a global registry instead of starting a separate `Deno.serve()`. The gateway then routes requests, handles JWT auth, CORS, rate limiting, and structured logging.

Individual edge functions require **zero changes** — only the shared `_shared/handler.ts` wrapper needs a small shim (4 lines) to detect the 1tube registry.

## Quick start (local dev)

```bash
# Install dependencies
bun install

# Copy and fill in env vars
cp .env.example .env

# Start with auto-restart on file changes
bun run dev -- --functions ../sciobot-next/supabase/functions
```

The gateway starts on `http://localhost:3100`. Functions are available at `http://localhost:3100/functions/v1/<name>`.

In dev mode, 1tube also watches the functions directory and reloads handlers in-process on filesystem changes (including newly created function folders).

### Deno npm lifecycle scripts

Deno does not run npm `postinstall` / build scripts unless you allow them. `deno.lock` may still list transitive packages such as `protobufjs`; the `check` script uses `--allow-scripts=npm:protobufjs` so `bun run check` / `npm publish` (via `prepublishOnly`) stays warning-free. That script is only needed for dependency install — **1tube’s runtime graph is just Hono + JSR std**.

## Endpoints

| Path | Description |
|---|---|
| `POST /functions/v1/:name` | Invoke an edge function |
| `GET /health` | Health check + loaded function list |
| `GET /metrics` | Prometheus-compatible metrics |

## .NET integration

Add the `OneTube` NuGet package to your ASP.NET project:

```csharp
services.AddOneTube(options =>
{
    options.ProjectPath = "/path/to/1tube";
    options.FunctionsPath = "/path/to/supabase/functions";
    options.Port = 3100;
    options.EnvVars = new()
    {
        ["SUPABASE_URL"] = "...",
        ["JWT_SECRET"] = "...",
    };
});

// In the pipeline, after UseRouting:
app.MapOneTube(port: 3100);
```

This spawns the Deno gateway as a managed child process with health monitoring and auto-restart, and forwards `/functions/v1/*` via YARP zero-copy proxying.