open-index/open-npm huggingface dataset:
npm package: @go-go-scope/persistence-cloudflare-do
Description: Cloudflare Durable Objects persistence adapter for go-go-scope
Author: thelinuxlich
Latest version: 2.9.1

# @go-go-scope/persistence-cloudflare-do

Cloudflare Durable Objects persistence adapter for go-go-scope.

## Installation

```bash
npm install @go-go-scope/persistence-cloudflare-do
```

## Usage

```typescript
import { DurableObjectAdapter } from '@go-go-scope/persistence-cloudflare-do';
import { scope } from 'go-go-scope';

// In your Durable Object
export class MyDurableObject extends DurableObject {
  private persistence: DurableObjectAdapter;

  constructor(state: DurableObjectState, env: Env) {
    super(state, env);
    this.persistence = new DurableObjectAdapter(state.storage);
  }

  async fetch(request: Request) {
    await using s = scope({ persistence: this.persistence });

    // Acquire a distributed lock
    const lock = await s.acquireLock("resource:123", 30000);
    if (!lock) {
      return new Response("Lock failed", { status: 423 });
    }

    // Process request
    return new Response("Success");
  }
}
```

## Features

- Distributed locks with TTL
- Circuit breaker state persistence
- Cache provider implementation
- Atomic operations via DurableObjectStorage
- Key prefixing for multi-tenant isolation

## License

MIT
npm package: @go-go-scope/persistence-deno-kv
Description: Deno KV persistence adapter for go-go-scope
Author: thelinuxlich
Latest version: 2.9.1

# @go-go-scope/persistence-deno-kv

Deno KV persistence adapter for go-go-scope. Provides distributed locks, circuit breaker state, and caching using Deno's native KV store.

## Installation

```bash
deno add @go-go-scope/persistence-deno-kv
```

## Usage

### Basic Setup

```typescript
import { scope } from "go-go-scope";
import { DenoKVAdapter } from "@go-go-scope/persistence-deno-kv";

// Open Deno KV
const kv = await Deno.openKv();

// Create adapter
const persistence = new DenoKVAdapter(kv, { 
  keyPrefix: "myapp:" 
});

// Use with scope
await using s = scope({ persistence });

// Acquire a lock
const lock = await s.acquireLock("resource:123", 30000);
if (!lock) {
  throw new Error("Could not acquire lock");
}

// Lock automatically expires after TTL
// Optional: release early with await lock.release()
```

### Distributed Locking

```typescript
const kv = await Deno.openKv();
const persistence = new DenoKVAdapter(kv);

await using s = scope({ persistence });

// Try to acquire lock
const lock = await s.acquireLock("payment:123", 10000);
if (lock) {
  try {
    // Process payment
    await processPayment(123);
  } finally {
    await lock.release();
  }
} else {
  console.log("Payment already being processed");
}
```

### Circuit Breaker State

```typescript
const kv = await Deno.openKv();
const persistence = new DenoKVAdapter(kv);

await using s = scope({ 
  persistence,
  circuitBreaker: {
    failureThreshold: 5,
    resetTimeout: 30000,
  }
});

// Circuit breaker state is persisted to Deno KV
// and shared across all instances using the same KV
```

### Caching

```typescript
const kv = await Deno.openKv();
const persistence = new DenoKVAdapter(kv);

await using s = scope({ persistence });

// Cache with TTL
await s.setCache("user:123", userData, 60000);

// Retrieve from cache
const cached = await s.getCache("user:123");
```

## Features

- **Distributed Locks**: Atomic lock acquisition with TTL
- **Circuit Breaker State**: Persisted state across instances
- **Caching**: TTL-based caching with automatic expiration
- **Atomic Operations**: Uses Deno KV atomic operations for consistency
- **Key Namespacing**: Prefix support for multi-tenant applications

## Requirements

- Deno >= 1.40.0
- `--unstable-kv` flag (Deno KV is currently unstable)

## Testing

```bash
deno test --allow-all --unstable-kv tests/
```

## License

MIT
npm package: @go-go-scope/persistence-mysql
Description: MySQL/MariaDB persistence adapter for go-go-scope - distributed locks and circuit breaker state
Author: thelinuxlich
Latest version: 2.9.1

# @go-go-scope/persistence-mysql

MySQL/MariaDB persistence adapter for go-go-scope - provides distributed locks and circuit breaker state persistence.

## Installation

```bash
npm install @go-go-scope/persistence-mysql mysql2
```

## Usage

```typescript
import { createPool } from 'mysql2/promise'
import { MySQLAdapter } from '@go-go-scope/persistence-mysql'
import { scope } from 'go-go-scope'

const pool = createPool({ uri: process.env.DATABASE_URL })
const persistence = new MySQLAdapter(pool, { keyPrefix: 'myapp:' })

await using s = scope({ persistence })

// Acquire a lock with 30 second TTL
const lock = await s.acquireLock('resource:123', 30000)
if (!lock) {
  throw new Error('Could not acquire lock')
}

// Use the lock
await lock.release()
```

## License

MIT
npm package: @go-go-scope/persistence-postgres
Description: PostgreSQL persistence adapter for go-go-scope - distributed locks and circuit breaker state
Author: thelinuxlich
Latest version: 2.9.1

# @go-go-scope/persistence-postgres

PostgreSQL persistence adapter for go-go-scope - provides distributed locks and circuit breaker state persistence.

## Installation

```bash
npm install @go-go-scope/persistence-postgres pg
```

## Usage

```typescript
import { Pool } from 'pg'
import { PostgresAdapter } from '@go-go-scope/persistence-postgres'
import { scope } from 'go-go-scope'

const pool = new Pool({ connectionString: process.env.DATABASE_URL })
const persistence = new PostgresAdapter(pool, { keyPrefix: 'myapp:' })

await using s = scope({ persistence })

// Acquire a lock with 30 second TTL
const lock = await s.acquireLock('resource:123', 30000)
if (!lock) {
  throw new Error('Could not acquire lock')
}

// Use the lock
await lock.release()
```

## License

MIT
npm package: @go-go-scope/persistence-redis
Description: Redis persistence adapter for go-go-scope - distributed locks and circuit breaker state
Author: thelinuxlich
Latest version: 2.9.1

# @go-go-scope/persistence-redis

Redis persistence adapter for go-go-scope - provides distributed locks and circuit breaker state persistence.

## Installation

```bash
npm install @go-go-scope/persistence-redis ioredis
```

## Usage

```typescript
import { Redis } from 'ioredis'
import { RedisAdapter } from '@go-go-scope/persistence-redis'
import { scope } from 'go-go-scope'

const redis = new Redis(process.env.REDIS_URL)
const persistence = new RedisAdapter(redis, { keyPrefix: 'myapp:' })

await using s = scope({ persistence })

// Acquire a lock with 30 second TTL
const lock = await s.acquireLock('resource:123', 30000)
if (!lock) {
  throw new Error('Could not acquire lock')
}

// Use the lock
await lock.release()
```

## License

MIT
npm package: @go-go-scope/persistence-sqlite
Description: SQLite persistence adapter for go-go-scope - distributed locks and circuit breaker state
Author: thelinuxlich
Latest version: 2.9.1

# @go-go-scope/persistence-sqlite

SQLite persistence adapter for go-go-scope - provides distributed locks and circuit breaker state persistence.

## Installation

```bash
npm install @go-go-scope/persistence-sqlite sqlite3
```

## Usage

```typescript
import sqlite3 from 'sqlite3'
import { SQLiteAdapter } from '@go-go-scope/persistence-sqlite'
import { scope } from 'go-go-scope'

const db = new sqlite3.Database('/tmp/app.db')
const persistence = new SQLiteAdapter(db, { keyPrefix: 'myapp:' })

await using s = scope({ persistence })

// Acquire a lock with 30 second TTL
const lock = await s.acquireLock('resource:123', 30000)
if (!lock) {
  throw new Error('Could not acquire lock')
}

// Use the lock
await lock.release()
```

## License

MIT
npm package: @go-go-scope/persistence-sqlite-bun
Description: Bun-native SQLite persistence adapter for go-go-scope - uses bun:sqlite for optimal performance
Author: thelinuxlich
Latest version: 2.9.1

# @go-go-scope/persistence-sqlite-bun

Bun-native SQLite persistence adapter for go-go-scope using `bun:sqlite`. This adapter provides optimal performance when running under Bun by leveraging its native SQLite implementation.

## Installation

```bash
# For Bun projects
bun add @go-go-scope/persistence-sqlite-bun
```

## Usage

```typescript
import { Database } from 'bun:sqlite'
import { scope } from 'go-go-scope'
import { BunSQLiteAdapter } from '@go-go-scope/persistence-sqlite-bun'

// Create a database (in-memory or file-based)
const db = new Database(':memory:')
// or: const db = new Database('/path/to/app.db')

// Create the adapter
const persistence = new BunSQLiteAdapter(db, { 
  keyPrefix: 'myapp:' // optional prefix for keys
})

// Use with scope
await using s = scope({ persistence })

// Acquire distributed lock
const lock = await s.acquireLock('resource:123', 30000)
if (!lock) {
  throw new Error('Could not acquire lock')
}

// Lock automatically expires after TTL
// Optional: release early
await lock.release()
```

## Features

- **Distributed Locks**: In-memory with TTL support
- **Circuit Breaker State**: Persistent state storage
- **Native Performance**: Uses Bun's `bun:sqlite` for maximum speed
- **API Compatibility**: Same interface as other persistence adapters

## Why Use This Adapter?

| Feature | `sqlite3` | `bun:sqlite` (this adapter) |
|---------|-----------|----------------------------|
| Performance | Good | **Excellent** |
| Bun-native | No | **Yes** |
| Bundle size | Larger | **Smaller** |
| Dependencies | Native bindings | **Built-in** |

## API

### Constructor

```typescript
new BunSQLiteAdapter(db: Database, options?: { keyPrefix?: string })
```

- `db`: Bun SQLite Database instance
- `options.keyPrefix`: Optional prefix for all keys

### Methods

See the main [go-go-scope documentation](../../docs) for full persistence API details.

## Testing

```bash
# Run Bun compatibility tests
cd packages/go-go-scope
bun test tests/bun-compatibility.test.ts
```

## License

MIT
npm package: @go-go-scope/plugin-opentelemetry
Description: OpenTelemetry plugin for go-go-scope
Author: thelinuxlich
Latest version: 2.9.1

# @go-go-scope/plugin-opentelemetry

OpenTelemetry plugin for go-go-scope with convenient exporter helpers.

## Installation

```bash
npm install @go-go-scope/plugin-opentelemetry
```

## Quick Start

```typescript
import { scope } from "go-go-scope";
import { opentelemetryPlugin } from "@go-go-scope/plugin-opentelemetry";
import { trace } from "@opentelemetry/api";

const tracer = trace.getTracer("my-service");

await using s = scope({
  name: "my-scope",
  plugins: [
    opentelemetryPlugin(tracer, {
      name: "my-operation",
      attributes: { "custom.attr": "value" }
    })
  ]
});

const [err, result] = await s.task(() => fetchData());
```

## Exporters

### Jaeger

```typescript
import { createJaegerExporter } from "@go-go-scope/plugin-opentelemetry/exporters";
import { NodeSDK } from "@opentelemetry/sdk-node";

const exporter = createJaegerExporter({
  serviceName: "my-service",
  endpoint: "http://localhost:14268/api/traces"
});

const sdk = new NodeSDK({
  traceExporter: exporter,
  // ... other config
});

await sdk.start();
```

### Zipkin

```typescript
import { createZipkinExporter } from "@go-go-scope/plugin-opentelemetry/exporters";

const exporter = createZipkinExporter({
  serviceName: "my-service",
  url: "http://localhost:9411/api/v2/spans"
});
```

### OTLP (Grafana Tempo, Honeycomb, etc.)

```typescript
import { createOTLPExporter } from "@go-go-scope/plugin-opentelemetry/exporters";

const exporter = createOTLPExporter({
  url: "https://api.honeycomb.io/v1/traces",
  headers: { "x-honeycomb-team": "your-api-key" }
});
```

### Console (for debugging)

```typescript
import { createConsoleExporter } from "@go-go-scope/plugin-opentelemetry/exporters";

const exporter = createConsoleExporter({ pretty: true });
```

### Multiple Exporters

```typescript
import { createCompositeExporter, createJaegerExporter, createZipkinExporter } from "@go-go-scope/plugin-opentelemetry/exporters";

const exporter = createCompositeExporter([
  createJaegerExporter({ serviceName: "my-service" }),
  createZipkinExporter({ serviceName: "my-service" })
]);
```

## Examples

See the `examples/` directory for complete working examples:

- `jaeger-tracing.ts` - Full Jaeger integration example
- `zipkin-tracing.ts` - Full Zipkin integration example

## Running Examples

### Jaeger

```bash
# Start Jaeger
docker run -d --name jaeger \
  -p 16686:16686 \
  -p 14268:14268 \
  jaegertracing/all-in-one:latest

# Run example
npx tsx node_modules/@go-go-scope/plugin-opentelemetry/examples/jaeger-tracing.ts

# Open http://localhost:16686
```

### Zipkin

```bash
# Start Zipkin
docker run -d --name zipkin -p 9411:9411 openzipkin/zipkin

# Run example
npx tsx node_modules/@go-go-scope/plugin-opentelemetry/examples/zipkin-tracing.ts

# Open http://localhost:9411
```

## License

MIT
npm package: @go-go-scope/plugin-visualizer
Description: Real-time scope visualization dashboard for go-go-scope
Author: thelinuxlich
Latest version: 2.9.1

# @go-go-scope/plugin-visualizer

Real-time WebSocket-based dashboard for visualizing go-go-scope operations.

## Installation

```bash
npm install @go-go-scope/plugin-visualizer
```

## Usage

```typescript
import { scope } from 'go-go-scope';
import { visualizerPlugin, VisualizerDashboard } from '@go-go-scope/plugin-visualizer';

// Create a scope with the visualizer plugin
const s = scope({
  plugins: [visualizerPlugin()]
});

// Or run a standalone dashboard
const dashboard = new VisualizerDashboard({
  port: 3333,
  updateInterval: 100,
  maxHistory: 1000
});

await dashboard.start();

// Open http://localhost:3333 in your browser
// to see real-time scope, task, and channel visualization
```

## Features

- Real-time WebSocket updates
- Visualize scope hierarchy and lifecycle
- Track task execution and performance
- Monitor channel operations
- HTML dashboard with live charts

## Options

```typescript
interface VisualizerOptions {
  port?: number;           // Default: 3333
  host?: string;           // Default: localhost
  updateInterval?: number; // Default: 100ms
  maxHistory?: number;     // Default: 1000 events
}
```

## License

MIT
npm package: @go-go-scope/plugin-worker-profiler
Description: Worker performance profiling plugin for go-go-scope
Author: thelinuxlich
Latest version: 2.9.1

# @go-go-scope/plugin-worker-profiler

Worker performance profiling plugin for go-go-scope. Track detailed metrics for worker tasks including CPU time, memory usage, and data transfer overhead.

## Installation

```bash
npm install @go-go-scope/plugin-worker-profiler
```

## Usage

```typescript
import { scope } from 'go-go-scope'
import { workerProfilerPlugin } from '@go-go-scope/plugin-worker-profiler'

await using s = scope({
  plugins: [workerProfilerPlugin()]
})

// Run worker tasks
const [err, result] = await s.task(
  { module: './heavy-computation.js', export: 'compute' },
  { worker: true, data: { n: 1000000 } }
)

// Get profiling report
const report = s.workerProfile?.()
console.log(`Tasks: ${report?.statistics.totalTasks}`)
console.log(`Avg duration: ${report?.statistics.avgDuration.toFixed(2)}ms`)
console.log(`Avg CPU time: ${report?.statistics.avgCpuTime.toFixed(2)}ms`)
```

## Configuration

```typescript
workerProfilerPlugin({
  trackCpuTime: true,    // Track CPU usage (default: true)
  trackMemory: true,     // Track memory usage (default: true)
  trackTransfers: true,  // Track data transfer overhead (default: true)
  maxProfiles: 1000      // Max profiles to keep (default: 1000)
})
```

## Metrics Collected

Per task:
- **duration**: Total execution time in milliseconds
- **cpuTime**: CPU time (user + system) in milliseconds
- **memoryPeakRss**: Peak memory RSS in MB
- **memoryPeakHeap**: Peak heap used in MB
- **transferTime**: Data transfer overhead in milliseconds
- **transferSize**: Size of data transferred in bytes

## Report Structure

```typescript
interface WorkerProfilerReport {
  tasks: WorkerTaskProfile[]
  statistics: {
    totalTasks: number
    successfulTasks: number
    failedTasks: number
    avgDuration: number
    avgCpuTime: number
    avgMemoryPeakRss: number
    totalTransferSize: number
  }
}
```

## Filtering Profiles

```typescript
// Get profiles for specific module
const mathProfiles = profiler.getModuleProfiles('./math.js')

// Get profiles for specific export
const addProfiles = profiler.getExportProfiles('./math.js', 'add')
```

## License

MIT
npm package: @go-go-scope/scheduler
Description: Distributed job scheduler for go-go-scope with unified instance API
Author: thelinuxlich
Latest version: 2.9.1

# @go-go-scope/scheduler

> Distributed job scheduler for go-go-scope with admin + workers architecture

## Features

- **Admin + Workers Pattern**: Enforced separation between schedule management and execution
- **Schedule Management**: Create, update, pause, resume, disable, and delete schedules
- **Schedule States**: Active, paused, or disabled states with automatic handling
- **Statistics**: Track job success rates, durations, and counts
- **Timezone Support**: Full IANA timezone support with DST handling
- **Distributed Locking**: Prevents duplicate execution across multiple workers
- **Persistent Storage**: Redis, PostgreSQL, MySQL, SQLite support

## Installation

```bash
npm install go-go-scope @go-go-scope/scheduler
```

## Architecture

The scheduler enforces a clear separation of concerns:

### Admin Instance
- **Creates and manages schedules** using `createSchedule()`
- Stores schedule metadata in persistent storage
- Typically only **one admin runs at a time**
- Handles schedule lifecycle (create, delete, update)

### Worker Instances
- **Load schedules** from storage using `loadSchedules()`
- Provide handler functions for each schedule
- Execute jobs with distributed locking
- Multiple workers can run for **high availability**

## Quick Start

### 1. Admin Instance

```typescript
import { scope } from "go-go-scope";
import { Scheduler, SchedulerRole, CronPresets } from "@go-go-scope/scheduler";
import { RedisJobStorage } from "@go-go-scope/scheduler";
import { RedisAdapter } from "go-go-scope/persistence/redis";
import Redis from "ioredis";

const redis = new Redis("redis://localhost:6379");
const redisAdapter = new RedisAdapter(redis);

await using s = scope({ persistence: redisAdapter });

const admin = new Scheduler({
  role: SchedulerRole.ADMIN,  // Required!
  scope: s,
  storage: new RedisJobStorage(redis, redisAdapter),
});

// Create schedules - no handler needed here
await admin.createSchedule("daily-report", {
  cron: CronPresets.DAILY,
  timezone: "America/New_York",
  maxRetries: 3,
  timeout: 30000,
});
```

### 2. Worker Instance

```typescript
const worker = new Scheduler({
  role: SchedulerRole.WORKER,  // Required!
  scope: s,
  storage: new RedisJobStorage(redis, redisAdapter),
});

// Load schedules from storage and provide handlers
await worker.loadSchedules({
  handlerFactory: (name, schedule) => {
    switch (name) {
      case "daily-report":
        return async (job, jobScope) => {
          const [err, data] = await jobScope.task(async () => {
            return fetchReportData();
          });
          if (err) throw err;
          await sendReport(data);
        };
      default:
        return null; // Skip unknown schedules
    }
  },
});

worker.start();
```

## API Reference

See the full [API documentation](../../docs/15-scheduler.md) for detailed usage.

## License

MIT © [thelinuxlich](https://github.com/thelinuxlich)
npm package: @go-go-scope/scheduler-tui
Description: Interactive TUI and CLI for go-go-scope scheduler
Author: thelinuxlich
Latest version: 2.9.1

# @go-go-scope/scheduler-tui

> Interactive TUI and CLI for go-go-scope scheduler

## Features

- **Interactive TUI**: Real-time monitoring with keyboard navigation
- **CLI Tool**: Scriptable command-line interface
- **Schedule Management**: List, create, update, pause, resume, disable, delete
- **Statistics**: View job success rates and execution times
- **Manual Trigger**: Run schedules on-demand

## Installation

```bash
# Global installation for CLI access
npm install -g @go-go-scope/scheduler-tui

# Or use with npx
npx @go-go-scope/scheduler-tui <command>
```

## CLI Usage

```bash
# List all schedules
npx go-go-scheduler list --storage redis --url redis://localhost:6379

# Create a schedule
npx go-go-scheduler create daily-report \
  --cron "0 9 * * *" \
  --timezone America/New_York

# Get schedule details
npx go-go-scheduler get daily-report

# Show statistics
npx go-go-scheduler stats daily-report
# or for all schedules
npx go-go-scheduler stats

# Update a schedule
npx go-go-scheduler update daily-report --cron "0 10 * * *"

# Pause/resume/disable
npx go-go-scheduler pause daily-report
npx go-go-scheduler resume daily-report
npx go-go-scheduler disable daily-report

# Trigger immediately
npx go-go-scheduler trigger daily-report

# Delete a schedule
npx go-go-scheduler delete daily-report

# List jobs for a schedule
npx go-go-scheduler jobs daily-report
```

## TUI Usage

```bash
# Start the interactive TUI
npx go-go-scheduler-tui

# With Redis storage
npx go-go-scheduler-tui -s redis -u redis://localhost:6379
```

### TUI Controls

| Key | Action |
|-----|--------|
| `↑/↓` | Navigate schedules |
| `Enter` | View schedule details |
| `p` | Pause/Resume schedule |
| `d` | Disable schedule |
| `t` | Trigger schedule (run now) |
| `r` | Refresh data |
| `q` or `Ctrl+C` | Quit |

### TUI Features

- Real-time schedule list with color-coded states (green=active, yellow=paused, red=disabled)
- Job statistics (total, pending, running, completed, failed)
- Success rate percentage
- Auto-refresh every 5 seconds
- Schedule details view with all metadata

## License

MIT © [thelinuxlich](https://github.com/thelinuxlich)
npm package: @go-go-scope/stream
Description: Lazy async iterable streams for go-go-scope - 50+ composable operations
Author: thelinuxlich
Latest version: 2.9.1

# @go-go-scope/stream

Lazy async iterable streams for go-go-scope with 50+ composable operations.

## Installation

```bash
npm install @go-go-scope/stream
```

## Usage

### Standalone

```typescript
import { Stream } from '@go-go-scope/stream'
import { scope } from 'go-go-scope'

await using s = scope()

const [err, results] = await new Stream(async function*() {
  yield 1; yield 2; yield 3
}, s)
  .map(x => x * 2)
  .filter(x => x > 2)
  .toArray()
```

### With Plugin (adds stream() method to Scope)

```typescript
import { scope } from 'go-go-scope'
import { streamPlugin } from '@go-go-scope/stream'

const s = scope({ plugins: [streamPlugin] })

const [err, results] = await s.stream([1, 2, 3, 4, 5])
  .map(x => x * 2)
  .filter(x => x > 4)
  .take(2)
  .toArray()
```

## Available Operations

- **Transform**: `map`, `flatMap`, `tap`
- **Filter**: `filter`, `take`, `drop`, `distinct`, `distinctBy`
- **Combine**: `zip`, `concat`, `merge`
- **Buffer**: `buffer`, `bufferTime`, `groupAdjacentBy`
- **Timing**: `debounce`, `throttle`, `delay`
- **Advanced**: `exhaustMap`, `concatMap`, `switchMap`, `pairwise`, `window`
- **Terminal**: `toArray`, `forEach`, `reduce`, `drain`

## License

MIT
npm package: @go-go-scope/testing
Description: Testing utilities for go-go-scope - mocks, spies, and time control
Author: thelinuxlich
Latest version: 2.9.1

# @go-go-scope/testing

Testing utilities for go-go-scope - mocks, spies, time control, and test helpers.

## Installation

```bash
npm install -D @go-go-scope/testing
```

## Usage

### Mock Scope

```typescript
import { createMockScope } from '@go-go-scope/testing'

const s = createMockScope({
  autoAdvanceTimers: true,
  deterministic: true
})

const [err, result] = await s.task(() => Promise.resolve('done'))
expect(result).toBe('done')
```

### Spies

```typescript
import { createSpy } from '@go-go-scope/testing'

const spy = createSpy().mockReturnValue('mocked')
const result = spy()
expect(result).toBe('mocked')
expect(spy.wasCalled()).toBe(true)
```

### Time Control

```typescript
import { createTimeTravelController } from '@go-go-scope/testing'

const time = createTimeTravelController()

// Schedule operations
const results: number[] = []
time.setTimeout(() => results.push(1), 100)
time.setTimeout(() => results.push(2), 200)

// Jump to specific time
time.jumpTo(150)
expect(results).toEqual([1]) // Only first timer fired
```

### Mock Channels

```typescript
import { createMockChannel } from '@go-go-scope/testing'

const mockCh = createMockChannel<number>()
mockCh.setReceiveValues([1, 2, 3])

const ch = mockCh.channel
const value = await ch.receive()
expect(value).toBe(1)
```

## License

MIT
npm package: @go-mailer/easy-email-editor
Description: Email editor
Author: noguntuberu
Latest version: 5.0.2

# Easy-email-editor

## Introduction

Email render and preview container.

## usage

```sh
$ npm install --save @go-mailer/easy-email-editor
```

or

```sh
$ yarn add @go-mailer/easy-email-editor
```

```js
import React from 'react';
import { BlockManager } from '@go-mailer/easy-email-core';
import { EmailEditor, EmailEditorProvider } from '@go-mailer/easy-email-editor';
import '@go-mailer/easy-email-editor/lib/style.css';

const initialValues = {
  subject: 'Welcome to Easy-email',
  subTitle: 'Nice to meet you!',
  content: BlockManager.getBlockByType(BasicType.PAGE).create({}),
};

export function App() {
  return (
    <EmailEditorProvider
      data={initialValues}
      height={'calc(100vh - 72px)'}
    >
      {({ values }) => {
        return <EmailEditor />;
      }}
    </EmailEditorProvider>
  );
}
```
npm package: @go-mailer/easy-email-extensions
Description: Email editor
Author: noguntuberu
Latest version: 5.0.3

# Easy-email-extensions

## usage

```sh
$ npm install --save easy-email-extensions
```

or

```sh
$ yarn add easy-email-extensions
```

```js
import React from 'react';
import { BlockManager, BasicType, AdvancedType } from 'easy-email-core';
import { EmailEditor, EmailEditorProvider } from 'easy-email-editor';
import { ExtensionProps, StandardLayout } from 'easy-email-extensions';

import 'easy-email-editor/lib/style.css';
import 'easy-email-extensions/lib/style.css';

const categories: ExtensionProps['categories'] = [
  {
    label: 'Content',
    active: true,
    blocks: [
      {
        type: AdvancedType.TEXT,
      },
      {
        type: AdvancedType.IMAGE,
        payload: { attributes: { padding: '0px 0px 0px 0px' } },
      },
      {
        type: AdvancedType.BUTTON,
      },
      {
        type: AdvancedType.SOCIAL,
      },
      {
        type: AdvancedType.DIVIDER,
      },
      {
        type: AdvancedType.SPACER,
      },
      {
        type: AdvancedType.HERO,
      },
      {
        type: AdvancedType.WRAPPER,
      },
    ],
  },
  {
    label: 'Layout',
    active: true,
    displayType: 'column',
    blocks: [
      {
        title: '2 columns',
        payload: [
          ['50%', '50%'],
          ['33%', '67%'],
          ['67%', '33%'],
          ['25%', '75%'],
          ['75%', '25%'],
        ],
      },
      {
        title: '3 columns',
        payload: [
          ['33.33%', '33.33%', '33.33%'],
          ['25%', '25%', '50%'],
          ['50%', '25%', '25%'],
        ],
      },
      {
        title: '4 columns',
        payload: [['25%', '25%', '25%', '25%']],
      },
    ],
  },
];

const initialValues = {
  subject: 'Welcome to Easy-email',
  subTitle: 'Nice to meet you!',
  content: BlockManager.getBlockByType(BasicType.PAGE)!.create({}),
};

export default function App() {

  return (
    <EmailEditorProvider
      data={initialValues}
      height={'calc(100vh - 72px)'}
      autoComplete
      dashed={false}
    >
      {({ values }) => {
        return (
          <StandardLayout
            categories={categories}
            showSourceCode={true}
          >
            <EmailEditor />
          </StandardLayout>
        );
      }}
    </EmailEditorProvider>
  );
}

```
npm package: @go-mental/mcp
Description: MCP server for Mental thought capture system - capture thoughts from Claude Code and Cursor
Author: Lucas Prieto
Latest version: 1.0.0

# @go-mental/mcp

MCP (Model Context Protocol) server for the Mental thought capture system. Capture thoughts, ideas, blockers, and questions directly from Claude Code or Cursor without leaving your workflow.

## What is Mental?

Mental is a personal "mind centralization" system for developers who context-switch constantly. It captures thoughts as you work, tracks their status (open/resolved), and helps you close the loop on ideas, blockers, and questions.

## Installation

```bash
# Run directly with npx (recommended)
npx @go-mental/mcp

# Or install globally
npm install -g @go-mental/mcp
```

## Configuration

### Environment Variables

| Variable | Description | Default |
|----------|-------------|---------|
| `MENTAL_API_URL` | URL of your Mental API server | `http://localhost:3000` |

### Claude Code (claude_desktop_config.json)

Add to your Claude Code configuration:

```json
{
  "mcpServers": {
    "mental": {
      "command": "npx",
      "args": ["@go-mental/mcp"],
      "env": {
        "MENTAL_API_URL": "https://your-mental-api.example.com"
      }
    }
  }
}
```

### Cursor

Add to your Cursor MCP settings:

```json
{
  "mcpServers": {
    "mental": {
      "command": "npx",
      "args": ["@go-mental/mcp"],
      "env": {
        "MENTAL_API_URL": "https://your-mental-api.example.com"
      }
    }
  }
}
```

## Available Tools

| Tool | Description |
|------|-------------|
| `ping` | Health check - returns pong to verify server is running |
| `capture_thought` | Capture a thought with title, content, optional project and theme |
| `list_thoughts` | List captured thoughts, optionally filtered by status |
| `get_thought` | Get details of a specific thought by ID |
| `resolve_thought` | Mark a thought as resolved with a resolution summary |
| `reopen_thought` | Reopen a previously resolved thought |
| `add_followup` | Add a follow-up update to an existing thought |
| `start_session` | Start a capture session to group related thoughts |
| `end_session` | End the current session and see summary |

### Themes

When capturing thoughts, you can specify a theme:
- `blocker` - Blocked, waiting on dependencies
- `concern` - Worried, risk, uncertain
- `question` - Asking how/why, unclear
- `idea` - Suggestion, alternative, maybe

## Example Usage

Once configured, you can ask Claude to:

- "Capture a thought: I need to refactor the auth module"
- "List my open thoughts"
- "Mark thought abc123 as resolved - decided to use JWT"
- "Start a session for the payments feature"

## Links

- [Mental Repository](https://github.com/lucasprieto/mental)
- [Model Context Protocol](https://modelcontextprotocol.io/)

## License

MIT
npm package: @go-mondo/app-connect-sdk
Description: A node SDK for Mondo App Connect
Latest version: 0.0.1-beta.14

# Mondo App Connect - Node SDK
App Connect is a unified identifier management solution aimed to solve the nuaunces and complexty in storing and retrieving related identifiers.  If your application integrates with other applications, App Connect helps you establish and maintain the related identifiers in your other applications.

For example, with your CRM as the record of truth.  You may also have a web site, events platform, community forum, etc.  Each of these auxillary apps also contain 'contacts' and 'companies' with their own application specific identifiers.  App Connect allows you establish relationships among your various app identifiers so you can easily find CRM contact '123' in your events platform, web site, etc. 

You can use the library in both TypeScript and JavaScript code bases.

## Features
- Enforce 1-to-1, 1-to-many or many-to-many relationships
- App agnostic