open-index/open-npm huggingface dataset:
npm package: @nexirift/plugin-better-auth
Description: An experimental plugin for GraphQL Yoga that adds Better Auth functionality.
Author: Nexirift
Latest version: 1.0.3

![NPM Version](https://img.shields.io/npm/v/%40nexirift%2Fplugin-better-auth)
![NPM License](https://img.shields.io/npm/l/%40nexirift%2Fplugin-better-auth)
![NPM Downloads](https://img.shields.io/npm/dt/%40nexirift%2Fplugin-better-auth)

# plugin-better-auth

**Requires the Bearer plugin to be enabled in the authentication server.**

A GraphQL Yoga plugin that provides seamless user authorization using the Better Auth solution.

## How does it work?

This plugin implements the official Better Auth client to handle session and user authentication. It:

1. Extracts the auth token from the request header
2. Creates a new client instance with the token
3. Retrieves session and user data via getSession()
4. Returns an authenticated class instance with the user context

## Features

- Integrated Better Auth client methods
- Role-based access control via allowedRoles configuration
- Optional authentication requirements with requireAuth flag
- Automatic session handling and user context management
- Optional Redis caching support for improved performance

## Redis Configuration

Redis can be optionally used for token caching, which improves performance by reducing the number of API calls to the Better Auth server.

```typescript
import { createClient } from 'redis';
import { useBetterAuth } from '@nexirift/plugin-better-auth';

// With Redis (for improved performance)
const redis = createClient({ url: 'redis://localhost:6379' });
await redis.connect();

const yogaServer = createYoga({
  plugins: [
    useBetterAuth({
      redis,                  // Optional: Redis client for caching
      cachePrefix: 'tokens',  // Optional: Prefix for cache keys (default: 'tokens')
      cacheExpiration: 5,     // Optional: Cache TTL in seconds (default: 5)
      // Other configuration...
    })
  ]
});

// Without Redis (simpler setup)
const yogaServer = createYoga({
  plugins: [
    useBetterAuth({
      // Redis client is not provided, so no caching is used
      // Other configuration...
    })
  ]
});
```

## Example

For a complete implementation example, see the [demo repository](https://github.com/Nexirift/plugin-better-auth-example).

## Credits

- [GraphQL Yoga](https://github.com/dotansimha/graphql-yoga)
- [plugin-oidc](https://github.com/Nexirift/plugin-oidc)
npm package: @nexirift/plugin-keycloak
Description: Plugin for GraphQL Yoga that adds Keycloak authentication and authorization.
Author: Nexirift
Latest version: 1.1.6
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

![NPM Version](https://img.shields.io/npm/v/%40nexirift%2Fplugin-keycloak)
![NPM License](https://img.shields.io/npm/l/%40nexirift%2Fplugin-keycloak)
![NPM Downloads](https://img.shields.io/npm/dt/%40nexirift%2Fplugin-keycloak)

# plugin-keycloak

A basic [GraphQL Yoga](https://github.com/dotansimha/graphql-yoga) plugin that
adds functionality to authenticate users using the
[Keycloak](https://www.keycloak.org/) service.

## Deprecation Notice

As of the 9th of April 2024,
[plugin-keycloak](https://github.com/Nexirift/plugin-keycloak) has been
deprecated, effective immediately. If you wish to use this package, please
switch to [plugin-oidc](https://github.com/Nexirift/plugin-oidc) as that will be
our new maintained version. The new plugin will have support for OpenID Connect
compatible clients meaning that you can use other services like
[Authentik](https://goauthentik.io).

## How does it work?

This plugin checks an access token which is a `Bearer` token on the
`Authentication` header with the Keycloak server to verify if it's valid.
Additionally, it passes back the response info, which includes information like
the `preferred_username`, this can then be used in the GraphQL Yoga server to
identify users.

## BREAKING CHANGES

Starting from
[v1.1.5](https://github.com/Nexirift/plugin-keycloak/releases/tag/1.1.5), we
have removed the dependency of `keycloak-backend`. In addition, we have changed
`ITokenContent` to `KeycloakToken`, please update these in your code. You can
also see this
[commit](https://github.com/Nexirift/plugin-keycloak-example/commit/6dcf3c9dc93351006b63005f7e398cc72fa84522)
for changes.

## Example

Please see [here](https://github.com/Nexirift/plugin-keycloak-example) for an
example of how to use the project.

## Disclaimer

We are working on trying to stop depending on so many dependencies. As part of
this, we have copied some code from the keycloak-backend library. This project,
at the time of writing, is using the MIT license. The files that were took were:

-   `Token.ts` -> `token.ts`
-   `Keycloak.ts` -> `keycloak.ts`
-   `Jwt.ts` -> `jwt.ts`

We plan to adapt these files more as we change around our codebase. For example,
the new scopes feature that was mentioned in issue
[#2](https://github.com/Nexirift/plugin-keycloak/issues/2).

## Credits

Disclaimer: This plugin was based off of the plugin-jwt source code.

-   [GraphQL Yoga](https://github.com/dotansimha/graphql-yoga)
-   [Keycloak](https://www.keycloak.org/)
-   [plugin-jwt](https://github.com/dotansimha/graphql-yoga/tree/main/packages/plugins/jwt)
npm package: @nexirift/plugin-oidc
Description: Plugin for GraphQL Yoga that adds OpenID Connect authorization.
Author: Nexirift
Latest version: 1.0.3

![NPM Version](https://img.shields.io/npm/v/%40nexirift%2Fplugin-oidc)
![NPM License](https://img.shields.io/npm/l/%40nexirift%2Fplugin-oidc)
![NPM Downloads](https://img.shields.io/npm/dt/%40nexirift%2Fplugin-oidc)

# plugin-oidc

A basic [GraphQL Yoga](https://github.com/dotansimha/graphql-yoga) plugin that
adds functionality to authorize users using an OpenID Connect compatible
service.

## How does it work?

This plugin checks an access token from the `Authentication` header with an
OpenID Connect compatible server to verify if it's valid using the `introspect`
endpoint. Additionally, it passes back the response info, which includes
information like the `preferred_username`, `scope`, `email`, etc. The provided
information can then be used in the GraphQL Yoga server to identify users, such
as storing them in a database based on ID.

## Example

Please see [here](https://github.com/Nexirift/plugin-oidc-example) for an
example of how to use the project.

## Credits

Disclaimer: This plugin was based off of the plugin-jwt source code.

-   [GraphQL Yoga](https://github.com/dotansimha/graphql-yoga)
-   [keycloak-backend](https://github.com/BackendStack21/keycloak-backend)
-   [plugin-jwt](https://github.com/dotansimha/graphql-yoga/tree/main/packages/plugins/jwt)
npm package: @nexiswap/sdk
Description: 🛠 An SDK for building applications on top of Nexiswap.
Latest version: 1.0.11


> **Notice**
>
> Moved to https://github.com/pancakeswap/pancake-frontend/tree/develop/packages/swap-sdk

# Pancakeswap SDK

Forked from the [Uniswap SDK](https://github.com/Uniswap/uniswap-v2-sdk/commit/a88048e9c4198a5bdaea00883ca00c8c8e582605).

You can refer to the Uniswap SDK documentation [uniswap.org](https://docs.uniswap.org/sdk/2.0.0/).

## Running tests

To run the tests, follow these steps. You must have at least node v10 and [yarn](https://yarnpkg.com/) installed.

First clone the repository:

```sh
git clone https://github.com/pancakeswap/pancake-swap-sdk.git
```

Move into the pancakeswap-sdk working directory

```sh
cd pancakeswap-sdk/
```

Install dependencies

```sh
yarn install
```

Run tests

```sh
yarn test
```

You should see output like the following:

```sh
yarn run v1.22.4
$ tsdx test
 PASS  test/constants.test.ts
 PASS  test/pair.test.ts
 PASS  test/fraction.test.ts
 PASS  test/miscellaneous.test.ts
 PASS  test/entities.test.ts
 PASS  test/trade.test.ts

Test Suites: 1 skipped, 6 passed, 6 of 7 total
Tests:       3 skipped, 82 passed, 85 total
Snapshots:   0 total
Time:        5.091s
Ran all test suites.
✨  Done in 6.61s.
```
npm package: @nexiteamorg/sdk
Description: 🛠 An SDK for building applications on top of Nexiswap.
Latest version: 1.0.2


> **Notice**
>
> Moved to https://github.com/pancakeswap/pancake-frontend/tree/develop/packages/swap-sdk

# Pancakeswap SDK

Forked from the [Uniswap SDK](https://github.com/Uniswap/uniswap-v2-sdk/commit/a88048e9c4198a5bdaea00883ca00c8c8e582605).

You can refer to the Uniswap SDK documentation [uniswap.org](https://docs.uniswap.org/sdk/2.0.0/).

## Running tests

To run the tests, follow these steps. You must have at least node v10 and [yarn](https://yarnpkg.com/) installed.

First clone the repository:

```sh
git clone https://github.com/pancakeswap/pancake-swap-sdk.git
```

Move into the pancakeswap-sdk working directory

```sh
cd pancakeswap-sdk/
```

Install dependencies

```sh
yarn install
```

Run tests

```sh
yarn test
```

You should see output like the following:

```sh
yarn run v1.22.4
$ tsdx test
 PASS  test/constants.test.ts
 PASS  test/pair.test.ts
 PASS  test/fraction.test.ts
 PASS  test/miscellaneous.test.ts
 PASS  test/entities.test.ts
 PASS  test/trade.test.ts

Test Suites: 1 skipped, 6 passed, 6 of 7 total
Tests:       3 skipped, 82 passed, 85 total
Snapshots:   0 total
Time:        5.091s
Ran all test suites.
✨  Done in 6.61s.
```
npm package: @nexla/sdk
Description: TypeScript SDK for Nexla
Author: Nexla, Inc.
Latest version: 0.1.0

# Nexla TypeScript SDK

TypeScript SDK for interacting with the Nexla API.

## Installation

```bash
npm install @nexla/sdk
```

## Authentication

### Service key (recommended)

```ts
import { NexlaClient } from "@nexla/sdk";

const client = new NexlaClient({ serviceKey: process.env.NEXLA_SERVICE_KEY });
```

### Access token

```ts
import { NexlaClient } from "@nexla/sdk";

const client = new NexlaClient({ accessToken: process.env.NEXLA_ACCESS_TOKEN });
```

Supported env vars:

- `NEXLA_SERVICE_KEY`
- `NEXLA_ACCESS_TOKEN`
- `NEXLA_API_URL`

## Quick Start

```ts
import { NexlaClient } from "@nexla/sdk";

const client = new NexlaClient({ serviceKey: process.env.NEXLA_SERVICE_KEY });

const flows = await client.flows.list();
const activated = await client.flows.flow_activate_with_flow_id({
  params: { path: { flow_id: 123 } }
});
```

## Raw OpenAPI Access

Use the raw client when you need direct path-level access:

```ts
const { data } = await client.raw.GET("/flows", {
  params: { query: { page: 1 } }
});
```

## Webhooks

```ts
import { WebhooksClient } from "@nexla/sdk";

const webhooks = new WebhooksClient({ apiKey: process.env.NEXLA_WEBHOOK_API_KEY });
await webhooks.sendOneRecord("https://api.nexla.com/webhook/abc", { id: 1 });
```

## SDK Configuration

```ts
const client = new NexlaClient({
  serviceKey: process.env.NEXLA_SERVICE_KEY,
  baseUrl: "https://dataops.nexla.io/nexla-api",
  apiVersion: "v1",
  retry: { maxRetries: 3 },
  userAgent: "my-app/1.2.3"
});
```

## Documentation Map

- [Architecture](../../docs/ts-sdk/architecture.md)
- [API coverage process](../../docs/ts-sdk/api-coverage.md)
- [Python to TS migration guide](../../docs/ts-sdk/migration-guide.md)
- [Generated parity matrix](../../docs/ts-sdk/parity-matrix.md)
- [Integration test policy (non-blocking)](../../docs/ts-sdk/integration-tests.md)

## Refreshing Generated Coverage Docs

From repository root:

```bash
pnpm -C packages/ts-sdk gen
node packages/ts-sdk/scripts/generate-parity-matrix.mjs
```

This regenerates TS OpenAPI artifacts and refreshes `docs/ts-sdk/parity-matrix.md`.

## License

MIT
npm package: @nexlayer/mcp-install
Description: One command to install the Nexlayer MCP for all your AI coding tools
Latest version: 0.1.14

# @nexlayer/mcp-install

One command to install the Nexlayer MCP server for all your AI coding tools.

## Usage

```bash
npx @nexlayer/mcp-install
```

Or with flags:

```bash
npx @nexlayer/mcp-install --project   # Install for current project only
npx @nexlayer/mcp-install --restore   # Restore configs from backup (undo install)
npx @nexlayer/mcp-install --dev       # Use local dev servers
npx @nexlayer/mcp-install --help      # Show help
```

## Supported AI Tools

The installer auto-detects which tools are installed by checking their config directories:

| Tool | Config Location |
|---|---|
| Claude Code | `~/.claude/` |
| Cursor | `~/.cursor/` |
| VS Code | `~/Library/Application Support/Code/User/` (macOS) |
| Windsurf | `~/.codeium/windsurf/` |
| Antigravity | `~/Library/Application Support/Antigravity/User/` (macOS) |
| Zed | `~/.config/zed/` |
| Amazon Q | `~/.aws/amazonq/` |

Cross-platform support: macOS, Windows, and Linux paths are all handled.

## How It Works

1. **Detect** — Scans for installed AI coding tools
2. **Authenticate** — Opens browser for sign in (if auth server is available)
3. **Configure** — Writes MCP server config to each tool's config file

If the auth server is unavailable, the installer skips authentication and you can authenticate from within your coding tool later.

### Config Formats

Different tools use different config formats:

- **Claude Code / Cursor / Windsurf / Antigravity**: `mcpServers` in JSON config
- **VS Code**: `mcp.servers` in `mcp.json`
- **Zed**: `context_servers` in `settings.json`
- **Amazon Q**: `mcpServers` with `commandLine` format

## Architecture

```
├── bin.js          # CLI entry point (ASCII banner, flag parsing, main flow)
├── lib/
│   ├── detect.js   # AI tool detection (7 tools, cross-platform)
│   ├── auth.js     # Device auth flow (browser-based)
│   ├── config.js   # Per-tool config writers (read/merge/write JSON)
│   └── env.js      # Environment config (MCP URL, auth URL)
```

## Environment

- **MCP Server**: `https://mcp.nexlayer.ai/api/mcp`
- **Server Name**: `nexlayer-mcp`
- **Node.js**: >= 18 required
npm package: @nexload-sdk/env
Description: Type-safe, modern, and extensible environment variable manager for JS/TS applications — with built-in validation, composable presets, and advanced logging. Perfect for Next.js, Node.js, and API/CMS stacks.
Author: S. MohammadMahdi Zamanian
Latest version: 3.0.0

# @nexload-sdk/env

Type-safe environment variable reader with schema definitions, presets, and a small merge utility.

## Install

```bash
pnpm add @nexload-sdk/env
```

## Exports

- `EnvManager`
- `merge`
- presets from `@nexload-sdk/env/presets`

## Quick Start

```ts
import { EnvManager } from "@nexload-sdk/env";

const env = new EnvManager({
  PORT: { type: "number", default: 3000 },
  NODE_ENV: { type: "string", default: "development" },
  DEBUG: { type: "boolean", default: false },
  JWT_SECRET: { type: "string" }
});

const port = env.$("PORT");
const debug = env.$("DEBUG");
const secret = env.$("JWT_SECRET");
```

## Presets

```ts
import { EnvManager, merge } from "@nexload-sdk/env";
import { $ApiServicePreset, $NodePreset } from "@nexload-sdk/env/presets";

const env = new EnvManager(
  merge($NodePreset, $ApiServicePreset, {
    FEATURE_FLAG: { type: "boolean", default: true }
  })
);
```

Built-in presets:

- `$NodePreset`
- `$WebServicePreset`
- `$ApiServicePreset`
- `$CmsServicePreset`

## API

### `new EnvManager(schema)`

Creates an env manager and immediately:

- validates the declared keys against `process.env`
- loads all declared values into an internal cache

### `env.$(key, cache = true)`

Returns a cached typed value (`string | number | boolean`) based on the field definition.

### `merge(...schemas)`

Merges multiple env schemas while preserving TypeScript inference.

## Notes / Caveats

- Validation logs warnings/errors but does not throw.
- Values are read from `process.env` and coerced by the declared `type`.
- Logging is guarded by a global flag (`globalThis.envFirstLogging`), which is `false` by default in this package.
npm package: @nexload-sdk/eslint-config
Description: Shared flat ESLint configurations used across the Nexload SDK monorepo.
Latest version: 4.0.0

# @nexload-sdk/eslint-config

Shared flat ESLint configurations used across the Nexload SDK monorepo.

## Exports

- `@nexload-sdk/eslint-config/base.js`
- `@nexload-sdk/eslint-config/nextjs.js`

## Usage (Flat Config)

```js
import { baseConfig } from "@nexload-sdk/eslint-config/base.js";

export default baseConfig;
```

Next.js projects:

```js
import nextJsConfig from "@nexload-sdk/eslint-config/nextjs.js";

export default nextJsConfig;
```

## What is included

- ESLint core recommended rules
- TypeScript ESLint recommended config
- Stylistic rules (`@stylistic`)
- import ordering rules
- turbo env var checks (`turbo/no-undeclared-env-vars`)
- React/Hooks/Next.js rules in the Next config
- Prettier compatibility via `eslint-config-prettier`

## Notes

- The base config expects a local `tsconfig.json` (`parserOptions.project`)
- The base config enforces `no-console` by default
npm package: @nexload-sdk/healthcheck
Description: Lightweight, framework-agnostic health check system for Node.js and Kubernetes.
Author: GecutWeb
Latest version: 3.0.0

# @nexload-sdk/healthcheck

Framework-agnostic health check manager for Node.js services with built-in liveness/readiness checks.

## Install

```bash
pnpm add @nexload-sdk/healthcheck
```

## Exports

Root exports (`@nexload-sdk/healthcheck`):

- `HealthManager`
- `HealthCheck` (base class)
- `MemoryHealthCheck`
- `ProcessorHealthCheck`
- `UptimeHealthCheck`
- `NetworkHealthCheck`
- core types (`HealthCheckResult`, `HealthStatus`, `HealthCheckType`, ...)

Database extension exports (`@nexload-sdk/healthcheck/database`):

- `DatabaseHealthCheck`
- `PayloadAdapter`
- `DatabaseClientAdapter`

## Quick Start

```ts
import {
  HealthManager,
  MemoryHealthCheck,
  ProcessorHealthCheck,
  UptimeHealthCheck,
  NetworkHealthCheck
} from "@nexload-sdk/healthcheck";
import { DatabaseHealthCheck, PayloadAdapter } from "@nexload-sdk/healthcheck/database";

const health = new HealthManager({
  checks: [
    new MemoryHealthCheck(),
    new ProcessorHealthCheck(),
    new UptimeHealthCheck(),
    new NetworkHealthCheck("8.8.8.8")
    // new DatabaseHealthCheck(new PayloadAdapter(payload, { collection: "users", limit: 1 }))
  ],
  security: { token: process.env.HEALTH_TOKEN }
});

health.setShutdownSignal(["SIGTERM", "SIGINT"]);

const readiness = await health.run("readiness");
```

## HealthManager API

### `new HealthManager(options?)`

Options:

- `checks?: HealthCheck[]`
- `security?: { token?: string; ipWhitelist?: string[] }`

### Methods

- `addCheck(check)`
- `run("liveness" | "readiness")`
- `setShutdownSignal(signals?)`
- `isShuttingDown()`
- `authorize(token?, ip?)`

## Built-in Checks

- `MemoryHealthCheck`: liveness + readiness (memory pressure)
- `ProcessorHealthCheck`: liveness (CPU load)
- `UptimeHealthCheck`: liveness
- `NetworkHealthCheck(host)`: readiness (ping latency)
- `DatabaseHealthCheck(adapter)`: readiness (subpath export)

## Notes

- The package does not expose an HTTP server; wire it into your framework route/controller.
- `HealthManager.run()` returns a summary object plus per-check `details`.
npm package: @nexload-sdk/iconcraft
Description: A powerful CLI tool for effortlessly managing and generating type-safe icon components from Iconify in your projects.
Author: S. MohammadMahdi Zamanian
Latest version: 2.0.0

# @nexload-sdk/iconcraft

CLI for managing Iconify icons as local generated React-compatible TSX components.

## Install

```bash
pnpm add -D @nexload-sdk/iconcraft
```

## CLI Commands

Global option for all commands:

- `--out-dir`, `-o` (default: `icons`)

### Add

```bash
pnpm iconcraft add mdi:home
pnpm iconcraft add mdi:home --out-dir src/icons
```

### Remove

```bash
pnpm iconcraft remove mdi:home
```

### List

```bash
pnpm iconcraft list
```

### Sync

```bash
pnpm iconcraft sync
```

## Generated Files

Inside the output directory (default `icons/`), IconCraft manages:

- `*.tsx` icon component files
- `index.ts` barrel file exporting `Icon`
- `.ic-meta.json` registry (internal manifest)

Example generated usage:

```tsx
import { MdiHome } from "./icons/mdi-home";
import { Icon } from "./icons";

export function Example() {
  return (
    <div>
      <MdiHome className="size-5" />
      <Icon.MdiHome className="size-5" />
    </div>
  );
}
```

## Library API

The package also exports the engine/types for programmatic usage:

- `IconCraftEngine`
- `IconCraftOptions`
- `IconMeta`
- `Registry`

## Notes

- Icons are fetched from `https://api.iconify.design/...` at generation time.
- Generated component files are TSX and include `"use client"`.
- The registry file is `.ic-meta.json` (not `iconcraft.json`).
npm package: @nexload-sdk/jwt
Description: A lightweight, policy-driven, and adapter-based JWT factory for creating and verifying tokens in Node.js backend services. Enforces security best practices through a decoupled, testable architecture.
Author: S. MohammadMahdi Zamanian
Latest version: 1.0.0

# @nexload-sdk/jwt

Policy-driven JWT factory for Node.js/Bun services.

## Install

```bash
pnpm add @nexload-sdk/jwt
```

## Exports

- `createJwt`
- `JwtExpiredError`
- `JwtInvalidError`
- `JwtMalformedError`
- types: `JwtPolicy`, `SecretProvider`

## Quick Start

```ts
import { createJwt, JwtExpiredError, JwtMalformedError } from "@nexload-sdk/jwt";

type AuthPayload = {
  userId: string;
  roles: string[];
};

const authJwt = createJwt<AuthPayload>({
  secret: process.env.JWT_SECRET!,
  policy: {
    expiresIn: 60 * 60,
    issuer: "auth-service",
    audience: "api"
  }
});

const token = authJwt.sign({ userId: "u1", roles: ["admin"] });

try {
  const payload = authJwt.verify(token);
  console.log(payload.userId);
} catch (error) {
  if (error instanceof JwtExpiredError) {
    // token expired
  }
  if (error instanceof JwtMalformedError) {
    // invalid / malformed token input
  }
}
```

## API

### `createJwt<T>({ secret, policy })`

- `secret`: `string | SecretProvider`
- `policy`: `JwtPolicy`

Returns:

- `sign(payload: T): string`
- `verify(token: string): T`

## `JwtPolicy`

```ts
type JwtPolicy = {
  expiresIn: number;
  issuer?: string;
  audience?: string;
};
```

## Secret Providers

You may pass a custom object implementing:

```ts
type SecretProvider = {
  derive(): string;
};
```

If you pass a raw string, the package derives a hashed secret internally before signing/verifying.

## Runtime Notes

- Uses Node crypto (default provider) and `jsonwebtoken` adapter internally.
- Intended for Node.js/Bun server runtimes, not browser/edge runtimes.
npm package: @nexload-sdk/logger
Description: High-performance, structured, and type-safe logging for JS/TS apps — powered by pino, with pretty output, env-integration, security redaction, and Next.js-friendly wrappers.
Author: S. MohammadMahdi Zamanian
Latest version: 4.0.0

# @nexload-sdk/logger

Small structured logger for Node.js and browser environments with pluggable renderers.

## Install

```bash
pnpm add @nexload-sdk/logger
```

## Exports

- default export: global logger instance
- `NexloadLogger`
- logger types (`LogLevel`, renderer types, helpers)
- `test` helper from `@nexload-sdk/logger/log-test`

## Quick Start

```ts
import logger from "@nexload-sdk/logger";

logger.info({ service: "api" }, "Service started");
logger.warn({ userId: "u1" }, "Potential issue");
logger.error({ error: "Boom" }, "Request failed");
```

## Child Logger

```ts
const httpLogger = logger.child({ module: "http" });
httpLogger.debug({ route: "/health" }, "Incoming request");
```

## API

### `NexloadLogger`

Methods (all object-first):

- `trace(obj, msg?)`
- `debug(obj, msg?)`
- `info(obj, msg?)`
- `success(obj, msg?)`
- `warn(obj, msg?)`
- `error(obj, msg?)`
- `fatal(obj, msg?)`
- `child(obj)`

## Environment Variables (global logger)

The default logger instance reads from env/localStorage depending on runtime:

- `SERVICE_NAME` (or `$SERVICE_NAME` in browser localStorage)
- `LOG_LEVEL` (or `$LOG_LEVEL`)
- `NODE_ENV`
- `DEBUG`

Production mode uses compact renderers; non-production uses pretty renderers.

## Runtime Notes

- Works in Node.js and browsers.
- This is a custom logger implementation (not `pino`).