open-index/open-npm huggingface dataset:
npm package: @hexmon_tech/acccess-control-adapter-openfga
Description: @hexmon_tech OpenFGA adapter skeleton.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/acccess-control-adapter-openfga

OpenFGA adapter skeleton with mockable client interface; no runtime OpenFGA SDK dependency required.

## Install

```bash
pnpm add @hexmon_tech/acccess-control-adapter-openfga
```

## Minimal Usage

```ts
import { OpenFgaRebacAdapter } from '@hexmon_tech/acccess-control-adapter-openfga';

const adapter = new OpenFgaRebacAdapter(mockClient, {
  storeId: 'store-id',
  authorizationModelId: 'model-id',
});
```

## API Overview

- Adapter: `OpenFgaRebacAdapter`
- Client contract: `OpenFgaClient`
- Request/response shapes: `OpenFga*Request`, `OpenFga*Response`

## Compatibility

- Node `>=18`
- Offline test-friendly (mock client only)

## Verify

```bash
pnpm --filter @hexmon_tech/acccess-control-adapter-openfga typecheck
pnpm --filter @hexmon_tech/acccess-control-adapter-openfga test
pnpm --filter @hexmon_tech/acccess-control-adapter-openfga build
```
npm package: @hexmon_tech/acccess-control-audit
Description: @hexmon_tech audit package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/acccess-control-audit

Audit event contracts, sinks, batching logger, and role-assignment constraint checks.

## Install

```bash
pnpm add @hexmon_tech/acccess-control-audit
```

## Minimal Usage

```ts
import {
  ConsoleSink,
  BatchingSink,
  validateRoleAssignment,
} from '@hexmon_tech/acccess-control-audit';

const sink = new BatchingSink(new ConsoleSink(), { maxBatchSize: 50, flushIntervalMs: 250 });

const result = await validateRoleAssignment({
  tenantId: 'tenant-a',
  userId: 'u1',
  role: 'PaymentApprover',
  policyConstraints,
  roleDirectory,
});
```

## API Overview

- Events: `AuditEvent` union + typed event payloads
- Logging: `AuditSink`, `ConsoleSink`, `BatchingSink`
- Constraints: `RoleDirectory`, `validateRoleAssignment`

## Compatibility

- Node `>=18`
- Storage-agnostic interfaces (no DB implementation bundled)

## Verify

```bash
pnpm --filter @hexmon_tech/acccess-control-audit typecheck
pnpm --filter @hexmon_tech/acccess-control-audit test
pnpm --filter @hexmon_tech/acccess-control-audit build
```
npm package: @hexmon_tech/acccess-control-cli
Description: @hexmon_tech cli package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/acccess-control-cli

Developer CLI for policy validation, type generation, diffing, golden tests, and scaffolding.

## Install

```bash
pnpm add -D @hexmon_tech/acccess-control-cli
```

## Commands

```bash
hexmon_tech init --dir .
hexmon_tech validate examples/policies/basic.policy.json
hexmon_tech types examples/policies/basic.policy.json --out src/policy-types.ts
hexmon_tech test examples/policy-tests/basic --policy examples/policies/basic.policy.json
hexmon_tech diff examples/policies/basic.policy.json examples/policies/multi-tenant.policy.json
```

## API Overview

- Programmatic entry: `runCli(argv, options)`
- Command helpers: `runValidateCommand`, `runTypesCommand`, `runTestCommand`, `runDiffCommand`, `runInitCommand`

## Compatibility

- Node `>=18`
- Works offline; no external services required

## Verify

```bash
pnpm --filter @hexmon_tech/acccess-control-cli typecheck
pnpm --filter @hexmon_tech/acccess-control-cli test
pnpm --filter @hexmon_tech/acccess-control-cli build
node packages/cli/dist/bin.cjs --help
```
npm package: @hexmon_tech/acccess-control-compiler
Description: @hexmon_tech compiler package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/acccess-control-compiler

Compiles policy DSL into deterministic IR, performs semantic diagnostics, and computes stable hashes.

## Install

```bash
pnpm add @hexmon_tech/acccess-control-compiler
```

## Minimal Usage

```ts
import { compilePolicySet } from '@hexmon_tech/acccess-control-compiler';

const { ir, diagnostics } = compilePolicySet(policySet, { mode: 'multi-tenant' });
```

## API Overview

- Compile: `compilePolicySet(policy, options)`
- Diagnostics: conflict/unreachable/multi-tenant scoping/field selector checks
- Conditions: `evaluateCondition` + safe `resolveRef`
- Hashing: `stableStringify`, `sha256`, `hashObject`

## Compatibility

- Node `>=18`
- No dynamic code execution

## Verify

```bash
pnpm --filter @hexmon_tech/acccess-control-compiler typecheck
pnpm --filter @hexmon_tech/acccess-control-compiler test
pnpm --filter @hexmon_tech/acccess-control-compiler build
```
npm package: @hexmon_tech/acccess-control-core
Description: @hexmon_tech core package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/acccess-control-core

Core public contracts for authorization inputs/decisions, engine interfaces, stable error codes, and helper utilities.

## Install

```bash
pnpm add @hexmon_tech/acccess-control-core
```

## Minimal Usage

```ts
import { createTraceId, normalizeFields, assertTenant } from '@hexmon_tech/acccess-control-core';

const traceId = createTraceId();
const fields = normalizeFields(['title', 'title', 'meta']);
const tenantId = assertTenant({ principal: { tenantId: 'tenant-a' } }, 'required');
```

## API Overview

- Types: `AuthorizationInput`, `Decision`, `AuthorizationEngine`, `Context`, `Reason`, `Obligation`
- Errors: `AcxError`, `MissingTenantError`, `InvalidPolicyError`, `EngineError`
- Capabilities: `Capability`, `CapabilitySet`, `assertCapability`
- Helpers: `createTraceId`, `normalizeFields`, `assertTenant`

## Compatibility

- Node `>=18`
- ESM + CJS + `.d.ts`

## Verify

```bash
pnpm --filter @hexmon_tech/acccess-control-core typecheck
pnpm --filter @hexmon_tech/acccess-control-core test
pnpm --filter @hexmon_tech/acccess-control-core build
```
npm package: @hexmon_tech/acccess-control-engine-embedded
Description: @hexmon_tech engine-embedded package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/acccess-control-engine-embedded

In-process authorization engine for compiled policies with deny-by-default, deny-overrides-allow, tracing, and TTL cache.

## Install

```bash
pnpm add @hexmon_tech/acccess-control-engine-embedded
```

## Minimal Usage

```ts
import { compilePolicySet } from '@hexmon_tech/acccess-control-compiler';
import { EmbeddedEngine } from '@hexmon_tech/acccess-control-engine-embedded';

const { ir } = compilePolicySet(policySet);
const engine = new EmbeddedEngine({ mode: 'multi-tenant' });
engine.setPolicy(ir);

const decision = await engine.authorize(input);
```

## API Overview

- Class: `EmbeddedEngine`
- Methods: `setPolicy`, `authorize`, `batchAuthorize`, `explain`, `getMetrics`
- Options: `mode`, `fieldViolation`, cache config (`enabled`, `maxSize`, `ttlMs`)

## Compatibility

- Node `>=18`
- Deterministic candidate ordering and cache invalidation on `setPolicy`

## Verify

```bash
pnpm --filter @hexmon_tech/acccess-control-engine-embedded typecheck
pnpm --filter @hexmon_tech/acccess-control-engine-embedded test
pnpm --filter @hexmon_tech/acccess-control-engine-embedded build
node packages/engine-embedded/bench/run.mjs
```
npm package: @hexmon_tech/acccess-control-engine-hybrid
Description: @hexmon_tech hybrid engine package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/acccess-control-engine-hybrid

Hybrid engine that combines embedded decisions with ReBAC object checks.

## Install

```bash
pnpm add @hexmon_tech/acccess-control-engine-hybrid
```

## Minimal Usage

```ts
import { HybridEngine } from '@hexmon_tech/acccess-control-engine-hybrid';

const engine = new HybridEngine({
  embeddedEngine,
  rebacAdapter,
  config: {
    rebacEnabledActionsByResourceType: {
      post: ['post:*'],
      '*': ['file:read'],
    },
  },
});
```

## API Overview

- Class: `HybridEngine`
- Methods: `authorize`, `batchAuthorize`
- Match helpers: `matchesActionPattern`, `isRebacEnabledFor`

## Compatibility

- Node `>=18`
- Embedded engine remains authoritative for global constraints

## Verify

```bash
pnpm --filter @hexmon_tech/acccess-control-engine-hybrid typecheck
pnpm --filter @hexmon_tech/acccess-control-engine-hybrid test
pnpm --filter @hexmon_tech/acccess-control-engine-hybrid build
```
npm package: @hexmon_tech/acccess-control-engine-rebac
Description: @hexmon_tech ReBAC engine interfaces and adapters.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/acccess-control-engine-rebac

ReBAC adapter contract and in-memory adapter for direct tuple checks.

## Install

```bash
pnpm add @hexmon_tech/acccess-control-engine-rebac
```

## Minimal Usage

```ts
import { InMemoryRebacAdapter } from '@hexmon_tech/acccess-control-engine-rebac';

const adapter = new InMemoryRebacAdapter();
await adapter.writeTuples([
  {
    tenantId: 'tenant-a',
    object: { type: 'file', id: 'f1' },
    relation: 'viewer',
    subject: { type: 'user', id: 'u1' },
  },
]);

const result = await adapter.check({
  tenantId: 'tenant-a',
  object: { type: 'file', id: 'f1' },
  relation: 'viewer',
  subject: { type: 'user', id: 'u1' },
});
```

## API Overview

- Types: `RelationshipTuple`, `RebacCheckInput`, `RebacCheckResult`
- Interface: `RebacAdapter`
- Adapter: `InMemoryRebacAdapter`

## Compatibility

- Node `>=18`
- Direct tuple matching only (no graph traversal)

## Verify

```bash
pnpm --filter @hexmon_tech/acccess-control-engine-rebac typecheck
pnpm --filter @hexmon_tech/acccess-control-engine-rebac test
pnpm --filter @hexmon_tech/acccess-control-engine-rebac build
```
npm package: @hexmon_tech/acccess-control-integrations-express
Description: @hexmon_tech integrations-express package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/acccess-control-integrations-express

Express middleware and error handling helpers for authorization checks.

## Install

```bash
pnpm add @hexmon_tech/acccess-control-integrations-express
```

## Minimal Usage

```ts
import {
  requireAuthz,
  createAuthzErrorHandler,
} from '@hexmon_tech/acccess-control-integrations-express';

app.patch(
  '/posts/:id',
  requireAuthz({
    engine,
    action: 'post:update',
    principal: (req) => req.user,
    resource: (req) => ({ type: 'post', id: req.params.id }),
    context: (req) => ({ tenantId: req.headers['x-tenant-id'] as string }),
  }),
  handler,
);

app.use(createAuthzErrorHandler({ missingTenantStatus: 401 }));
```

## API Overview

- Middleware: `requireAuthz(config)`
- Error mapping: `createAuthzErrorHandler(options)`
- Request augmentation: `req.authzDecision?: Decision`

## Compatibility

- Node `>=18`
- Peer dependency: `express`

## Verify

```bash
pnpm --filter @hexmon_tech/acccess-control-integrations-express typecheck
pnpm --filter @hexmon_tech/acccess-control-integrations-express test
pnpm --filter @hexmon_tech/acccess-control-integrations-express build
```
npm package: @hexmon_tech/acccess-control-integrations-nest
Description: @hexmon_tech integrations-nest package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/acccess-control-integrations-nest

NestJS decorators, guard, and module wiring for authorization enforcement.

## Install

```bash
pnpm add @hexmon_tech/acccess-control-integrations-nest
```

## Minimal Usage

```ts
import { UseGuards } from '@nestjs/common';
import {
  AuthzAction,
  AuthzGuard,
  AuthzResource,
} from '@hexmon_tech/acccess-control-integrations-nest';

@UseGuards(AuthzGuard)
@AuthzAction('post:read')
@AuthzResource('post', (ctx) => ({ type: 'post', id: ctx.switchToHttp().getRequest().params.id }))
class PostController {}
```

## API Overview

- Decorators: `@AuthzAction`, `@AuthzResource`
- Guard: `AuthzGuard`
- Module: `AuthzModule.forRoot(...)`
- Tokens/interfaces: `AUTHZ_ENGINE`, `PrincipalResolver`, `AuthzConfig`

## Compatibility

- Node `>=18`
- Peer dependencies: NestJS core/common/platform-express + reflect-metadata

## Verify

```bash
pnpm --filter @hexmon_tech/acccess-control-integrations-nest typecheck
pnpm --filter @hexmon_tech/acccess-control-integrations-nest test
pnpm --filter @hexmon_tech/acccess-control-integrations-nest build
```
npm package: @hexmon_tech/acccess-control-integrations-next-node
Description: @hexmon_tech integrations-next-node package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/acccess-control-integrations-next-node

Authorization wrappers for Next.js Node runtime route handlers and server actions.

## Install

```bash
pnpm add @hexmon_tech/acccess-control-integrations-next-node
```

## Minimal Usage

```ts
import { withAuthz } from '@hexmon_tech/acccess-control-integrations-next-node';

export const POST = withAuthz(async (req: Request) => new Response(null, { status: 204 }), {
  engine,
  action: 'post:update',
  getPrincipal: async (req) => principalFromRequest(req),
  getResource: async () => ({ type: 'post', id: 'p1' }),
  getContext: async (req) => ({ tenantId: req.headers.get('x-tenant-id') ?? undefined }),
});
```

## API Overview

- Wrapper: `withAuthz(handler, config)`
- Errors: `AuthzDeniedError`, `NotImplementedError`
- Helper placeholder: `getPrincipalFromRequest`

## Compatibility

- Node `>=18`
- Next.js Node runtime only (not Edge runtime)

## Verify

```bash
pnpm --filter @hexmon_tech/acccess-control-integrations-next-node typecheck
pnpm --filter @hexmon_tech/acccess-control-integrations-next-node test
pnpm --filter @hexmon_tech/acccess-control-integrations-next-node build
```
npm package: @hexmon_tech/acccess-control-policy-dsl
Description: @hexmon_tech policy-dsl package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/acccess-control-policy-dsl

Policy DSL package for JSON schema validation and builder APIs.

## Install

```bash
pnpm add @hexmon_tech/acccess-control-policy-dsl
```

## Minimal Usage

```ts
import { policySet, validatePolicySet } from '@hexmon_tech/acccess-control-policy-dsl';

const policy = policySet('1.0.0')
  .rule({ id: 'allow-read', effect: 'allow', actions: ['post:read'], resourceTypes: ['post'] })
  .build();

const result = validatePolicySet(policy);
```

## API Overview

- Types: `PolicySet`, `PolicyRule`, `Condition`, `RoleDefinition`, `PolicyConstraints`
- Validation: `validatePolicySet(policy)`
- Builder: `policySet(version).rule(...).role(...).constraints(...).build()`
- Schema: `policySetSchema`

## Compatibility

- Node `>=18`
- Pure JSON AST condition language (no JS eval)

## Verify

```bash
pnpm --filter @hexmon_tech/acccess-control-policy-dsl typecheck
pnpm --filter @hexmon_tech/acccess-control-policy-dsl test
pnpm --filter @hexmon_tech/acccess-control-policy-dsl build
```
npm package: @hexmon_tech/adapter-openfga
Description: acx OpenFGA adapter skeleton.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/adapter-openfga

OpenFGA adapter skeleton with mockable client interface; no runtime OpenFGA SDK dependency required.

## Install

```bash
pnpm add @hexmon_tech/adapter-openfga
```

## Minimal Usage

```ts
import { OpenFgaRebacAdapter } from '@hexmon_tech/adapter-openfga';

const adapter = new OpenFgaRebacAdapter(mockClient, {
  storeId: 'store-id',
  authorizationModelId: 'model-id',
});
```

## API Overview

- Adapter: `OpenFgaRebacAdapter`
- Client contract: `OpenFgaClient`
- Request/response shapes: `OpenFga*Request`, `OpenFga*Response`

## Compatibility

- Node `>=18`
- Offline test-friendly (mock client only)

## Verify

```bash
pnpm --filter @hexmon_tech/adapter-openfga typecheck
pnpm --filter @hexmon_tech/adapter-openfga test
pnpm --filter @hexmon_tech/adapter-openfga build
```
npm package: @hexmon_tech/audit
Description: acx audit package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/audit

Audit event contracts, sinks, batching logger, and role-assignment constraint checks.

## Install

```bash
pnpm add @hexmon_tech/audit
```

## Minimal Usage

```ts
import { ConsoleSink, BatchingSink, validateRoleAssignment } from '@hexmon_tech/audit';

const sink = new BatchingSink(new ConsoleSink(), { maxBatchSize: 50, flushIntervalMs: 250 });

const result = await validateRoleAssignment({
  tenantId: 'tenant-a',
  userId: 'u1',
  role: 'PaymentApprover',
  policyConstraints,
  roleDirectory,
});
```

## API Overview

- Events: `AuditEvent` union + typed event payloads
- Logging: `AuditSink`, `ConsoleSink`, `BatchingSink`
- Constraints: `RoleDirectory`, `validateRoleAssignment`

## Compatibility

- Node `>=18`
- Storage-agnostic interfaces (no DB implementation bundled)

## Verify

```bash
pnpm --filter @hexmon_tech/audit typecheck
pnpm --filter @hexmon_tech/audit test
pnpm --filter @hexmon_tech/audit build
```
npm package: @hexmon_tech/audit-buffer-disk
Description: Disk-backed buffer for audit events with replay support.
Latest version: 2.0.0

# @hexmon_tech/audit-buffer-disk

Disk-backed buffer for audit events in Node.js. Use this sink to persist events
locally and replay them to another sink when it becomes available.

## Install

```bash
pnpm add @hexmon_tech/audit-buffer-disk
npm install @hexmon_tech/audit-buffer-disk
```

## Compatibility

- Node.js >= 18
- Optimized for Linux/Unix filesystems with durable writes

## Usage
```ts
import { createAuditLogger } from '@hexmon_tech/audit-core';
import { createDiskBuffer } from '@hexmon_tech/audit-buffer-disk';
import { createHttpAuditSink } from '@hexmon_tech/audit-sink-http';

const buffer = createDiskBuffer({
  filePath: './tmp/audit-buffer.jsonl',
  maxBufferBytes: 50 * 1024 * 1024,
});

const audit = createAuditLogger({
  sinks: [buffer],
});

// Later (cron/background job) flush to a primary sink
const httpSink = createHttpAuditSink({ endpoint: 'https://audit.example.com/batch' });
await buffer.drain(httpSink, { batchSize: 200 });
```

## Notes
- `createDiskBuffer` returns an `AuditSink` plus a `drain` method for replay.
- Draining is at-least-once; downstream sinks should de-duplicate by `eventId`.
- `maxBufferBytes` protects disk usage and rejects writes when exceeded.
npm package: @hexmon_tech/audit-cli
Description: CLI tools for audit integrity verification and exports.
Latest version: 2.0.0

# @hexmon_tech/audit-cli

Command-line verification tools for audit log integrity chains.

## Install

```bash
pnpm add @hexmon_tech/audit-cli
npm install @hexmon_tech/audit-cli
```

## Compatibility

- Node.js >= 18
- Depends on `@hexmon_tech/audit-export-postgres` / `pg` for Postgres commands
- Installs the `audit-cli` binary via the `bin` entry in `package.json`

## Commands

### verify-file

Verify a JSONL file produced by the file sink.

```bash
pnpm --filter @hexmon_tech/audit-cli exec audit-cli verify-file --path ./audit.jsonl
```

### verify-postgres

Verify audit records stored in Postgres.

```bash
pnpm --filter @hexmon_tech/audit-cli exec audit-cli verify-postgres \
  --connection "postgres://user:pass@localhost:5432/audit" \
  --from "2024-01-01" \
  --to "2024-01-31" \
  --tenantId "tenant-123"
```

Optional flags: `--table` (defaults to `audit_events`).

### export-postgres

Export audit records from Postgres (JSON or CSV).

```bash
pnpm --filter @hexmon_tech/audit-cli exec audit-cli export-postgres \
  --connection "postgres://user:pass@localhost:5432/audit" \
  --from "2024-01-01" \
  --to "2024-01-31" \
  --tenantId "tenant-123" \
  --format json
```

Optional flags: `--actorId`, `--action`, `--outcome`, `--pageSize`, `--cursor`,
`--table`, `--multiTenantStrict`.

### retention-postgres

Run a retention delete for records older than a timestamp.

```bash
pnpm --filter @hexmon_tech/audit-cli exec audit-cli retention-postgres \
  --connection "postgres://user:pass@localhost:5432/audit" \
  --before "2024-01-01" \
  --dry-run
```

Optional flags: `--table` (defaults to `audit_events`).

## Notes
- Verification uses the same hash chain algorithm as `@hexmon_tech/audit-core`.
- Hash chains are scoped per tenant when `tenantId` is present, otherwise per service.
- For distributed systems, see `docs/INTEGRITY.md` for ordering and coordination limits.
npm package: @hexmon_tech/audit-export-postgres
Description: Export helpers for audit logs stored in Postgres.
Latest version: 2.0.0

# @hexmon_tech/audit-export-postgres

Helpers to export audit logs from Postgres with safe, paginated queries.

## Install

```bash
pnpm add @hexmon_tech/audit-export-postgres
npm install @hexmon_tech/audit-export-postgres
```

## Compatibility

- Node.js >= 18
- Postgres 15+ (includes `migrations/*.sql` for the canonical audit table)

## Usage
```ts
import { exportAuditLogs } from '@hexmon_tech/audit-export-postgres';

const result = await exportAuditLogs({
  connectionString: process.env.DATABASE_URL,
  from: '2024-01-01',
  to: '2024-01-31',
  tenantId: 'tenant-123',
  format: 'json',
  pageSize: 1000,
});

if (result.ok) {
  console.log(result.data);
  console.log('next cursor', result.nextCursor);
}
```

## Options
- `from` / `to`: required time range (ISO or Postgres-compatible timestamps)
- `tenantId`: optional filter; required when `multiTenantStrict` is enabled
- `actorId`, `action`, `outcome`: optional filters
- `format`: `json` or `csv`
- `pageSize`: default 1000 (max 10,000)
- `cursor`: continue after a previous export page

## Notes
- Queries are keyset-paginated by `(occurred_at, event_id)`.
- `multiTenantStrict` helps prevent accidental cross-tenant export.
npm package: @hexmon_tech/audit-express
Description: Express middleware for audit logging with request context.
Latest version: 2.0.0

# @hexmon_tech/audit-express

Express middleware for audit logging. Attaches `req.audit` with request-scoped
context populated from headers and extractor functions.

## Install

```bash
pnpm add @hexmon_tech/audit-express
npm install @hexmon_tech/audit-express
```

## Compatibility

- Node.js >= 18
- Express 4.18+ required as a peer dependency
- Automatically extends `@hexmon_tech/audit-core` and `@hexmon_tech/audit-node`

## Usage

```ts
import express from 'express';
import { createAuditLogger } from '@hexmon_tech/audit-core';
import { createAuditMiddleware } from '@hexmon_tech/audit-express';

const app = express();
const audit = createAuditLogger({ service: 'api', environment: 'dev' });

app.use(
  createAuditMiddleware(audit, {
    getActor: (req) => req.user,
    getTenantId: (req) => req.headers['x-tenant-id'] as string | undefined,
    getOrgId: (req) => req.headers['x-org-id'] as string | undefined,
    getSessionId: (req) => req.session?.id,
  }),
);

app.post('/login', async (req, res) => {
  await req.audit.log({
    action: 'user.login',
    outcome: 'SUCCESS',
    actor: { type: 'user', id: req.user.id },
    metadata: { authMethod: 'password' },
  });
  res.json({ ok: true });
});
```

## Context Auto-Capture
The middleware captures:
- `requestId` from `x-request-id` (or a custom extractor)
- `ip` from `req.ip` or `x-forwarded-for`
- `userAgent` from `user-agent`
- `route` and `method` (added to event metadata under `metadata.http`)

## Type Augmentation
`req.audit` is typed via module augmentation so handlers can access the audit logger directly.

## Peer Dependencies
`express` is a peer dependency so the middleware does not bundle framework runtime code.
Install Express in your application or workspace root.
npm package: @hexmon_tech/audit-next
Description: Next.js App Router helpers for audit logging.
Latest version: 2.0.0

# @hexmon_tech/audit-next

Next.js App Router helpers for audit logging. Provides a `withAudit` wrapper that
attaches `req.audit` and captures request context.

## Install

```bash
pnpm add @hexmon_tech/audit-next
npm install @hexmon_tech/audit-next
```

## Compatibility

- Node.js >= 18
- Next.js >= 16, React 18+, and `@hexmon_tech/audit-node` (optional peer) for Node contexts
- Edge runtimes supported through manual context plus HTTP sink writes

## Usage

```ts
import { createAuditLogger } from '@hexmon_tech/audit-core';
import { withAudit } from '@hexmon_tech/audit-next';

const audit = createAuditLogger({ service: 'api', environment: 'dev' });

export const POST = withAudit(audit, async (req) => {
  await req.audit.log({
    action: 'user.login',
    outcome: 'SUCCESS',
    actor: { type: 'user', id: 'user-123' },
  });

  return new Response('ok');
});
```

## Context Auto-Capture
The wrapper captures:
- `requestId` from `x-request-id` (or a custom extractor)
- `ip` from `req.ip` or `x-forwarded-for`
- `userAgent` from `user-agent`
- `route` and `method` (added to event metadata under `metadata.http`)

## Node vs Edge
`withAudit` uses `@hexmon_tech/audit-node` (AsyncLocalStorage) when running in
Node.js. Edge runtimes do not support `AsyncLocalStorage`.
Install `@hexmon_tech/audit-node` in Node.js deployments to enable context propagation.

If you use the Edge runtime:
- Set `runtime: 'edge'` in the options.
- Provide manual context and send events via the HTTP sink.

```ts
export const runtime = 'edge';

export const POST = withAudit(audit, handler, { runtime: 'edge' });
```

## Peer Dependencies
`next`, `react`, and `react-dom` are peer dependencies to avoid bundling framework
runtime code into the library. Install compatible versions in your Next.js app.
npm package: @hexmon_tech/audit-node
Description: Node.js context helpers for audit logging.
Latest version: 2.0.0

# @hexmon_tech/audit-node

Node-only helpers for audit logging integrations. Provides an AsyncLocalStorage-backed
context store so request metadata can flow through async calls without manual threading.

## Install

```bash
pnpm add @hexmon_tech/audit-node
npm install @hexmon_tech/audit-node
```

## Compatibility

- Node.js >= 18 (requires `AsyncLocalStorage`)
- Intended to pair with `@hexmon_tech/audit-core` for context propagation

## Usage

```ts
import { runWithAuditContext, getAuditContext, setAuditContextPartial } from '@hexmon_tech/audit-node';

runWithAuditContext({ requestId: 'req-123', tenantId: 'tenant-1' }, async () => {
  // Access anywhere in the async call tree
  console.log(getAuditContext().requestId);

  // Update once you know more (e.g. after auth)
  setAuditContextPartial({ tenantId: 'tenant-2', orgId: 'org-1' });
});
```

## API
- `runWithAuditContext(ctx, fn)`: run a function with the provided context bound.
- `getAuditContext()`: read the current context (returns an empty object if none).
- `setAuditContextPartial(partial)`: merge new fields into the current context.

This package is Node-only because it depends on `AsyncLocalStorage`.
npm package: @hexmon_tech/audit-sink-file-jsonl
Description: JSONL file sink for audit events in Node.js.
Latest version: 2.0.0

# @hexmon_tech/audit-sink-file-jsonl

Append-only JSONL file sink for Node.js environments.

## Install

```bash
pnpm add @hexmon_tech/audit-sink-file-jsonl
npm install @hexmon_tech/audit-sink-file-jsonl
```

## Compatibility

- Node.js >= 18
- Requires local writable filesystem for JSONL durability

## Usage
```ts
import { createFileJsonlSink } from '@hexmon_tech/audit-sink-file-jsonl';

const sink = createFileJsonlSink({
  filePath: '/var/log/audit.jsonl',
  dedupeCacheSize: 10_000,
});
```

## Notes
- Best-effort in-memory dedupe avoids duplicate `eventId` entries during a process lifetime.
- Serverless filesystems are often ephemeral; prefer remote sinks in serverless environments.
npm package: @hexmon_tech/audit-sink-http
Description: HTTP sink for batching audit events to a remote endpoint.
Latest version: 2.0.0

# @hexmon_tech/audit-sink-http

Edge-friendly HTTP sink that POSTs audit event batches to a remote endpoint.

## Install

```bash
pnpm add @hexmon_tech/audit-sink-http
npm install @hexmon_tech/audit-sink-http
```

## Compatibility

- Node.js >= 18 or any runtime that provides `fetch`
- Works well in Edge, Deno, or Cloudflare Workers when paired with the core

## Usage
```ts
import { createHttpAuditSink } from '@hexmon_tech/audit-sink-http';

const sink = createHttpAuditSink({
  endpoint: 'https://audit.example.com/batch',
  headers: { Authorization: 'Bearer token' },
  timeoutMs: 5000,
});
```

## Behavior
- Uses `fetch` to POST `{ events: AuditEvent[] }` to the endpoint.
- 5xx, 408, 429, and timeouts are classified as `TRANSIENT` failures.
- 4xx (except 429) are classified as `PERMANENT` failures.
- Idempotency is expected to be enforced by the server using `eventId`.
npm package: @hexmon_tech/audit-sink-mongodb
Description: MongoDB sink for audit event storage with idempotent inserts.
Latest version: 2.0.0

# @hexmon_tech/audit-sink-mongodb

MongoDB sink using the official driver with a unique index on `eventId`.

## Install

```bash
pnpm add @hexmon_tech/audit-sink-mongodb
npm install @hexmon_tech/audit-sink-mongodb
```

## Compatibility

- Node.js >= 18
- MongoDB 6.x+ via the official `mongodb` driver

## Usage
```ts
import { createMongoAuditSink } from '@hexmon_tech/audit-sink-mongodb';

const sink = createMongoAuditSink({
  uri: process.env.MONGO_URL,
  dbName: 'audit_logs',
  collectionName: 'audit_events',
});
```

## Behavior
- Ensures a unique index on `eventId` by default.
- Duplicate key errors are treated as successful writes (idempotent).
npm package: @hexmon_tech/audit-sink-postgres
Description: Postgres sink for audit event storage with idempotent inserts.
Latest version: 2.0.0

# @hexmon_tech/audit-sink-postgres

Postgres sink using the `pg` driver with idempotent inserts via `event_id`.

## Install

```bash
pnpm add @hexmon_tech/audit-sink-postgres
npm install @hexmon_tech/audit-sink-postgres
```

## Compatibility

- Node.js >= 18
- Postgres 15+ (migrations shipped under `migrations/*.sql`)

## Usage
```ts
import { createPostgresAuditSink } from '@hexmon_tech/audit-sink-postgres';

const sink = createPostgresAuditSink({
  connectionString: process.env.DATABASE_URL,
  tableName: 'audit_events',
});
```

## Migrations
Run the migration in `migrations/001_create_audit_logs.sql`:
```sql
-- From your migration tool
\i migrations/001_create_audit_logs.sql
```

The table enforces `event_id` uniqueness and indexes `occurred_at`.

### Optional partitioning
For large installs, see the monthly partition template in
`migrations/002_partition_by_month.sql` and `docs/RETENTION.md`.
npm package: @hexmon_tech/cli
Description: acx cli package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/cli

Developer CLI for policy validation, type generation, diffing, golden tests, and scaffolding.

## Install

```bash
pnpm add -D @hexmon_tech/cli
```

## Commands

```bash
acx init --dir .
acx validate examples/policies/basic.policy.json
acx types examples/policies/basic.policy.json --out src/policy-types.ts
acx test examples/policy-tests/basic --policy examples/policies/basic.policy.json
acx diff examples/policies/basic.policy.json examples/policies/multi-tenant.policy.json
```

## API Overview

- Programmatic entry: `runCli(argv, options)`
- Command helpers: `runValidateCommand`, `runTypesCommand`, `runTestCommand`, `runDiffCommand`, `runInitCommand`

## Compatibility

- Node `>=18`
- Works offline; no external services required

## Verify

```bash
pnpm --filter @hexmon_tech/cli typecheck
pnpm --filter @hexmon_tech/cli test
pnpm --filter @hexmon_tech/cli build
node packages/cli/dist/bin.cjs --help
```
npm package: @hexmon_tech/compiler
Description: acx compiler package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/compiler

Compiles policy DSL into deterministic IR, performs semantic diagnostics, and computes stable hashes.

## Install

```bash
pnpm add @hexmon_tech/compiler
```

## Minimal Usage

```ts
import { compilePolicySet } from '@hexmon_tech/compiler';

const { ir, diagnostics } = compilePolicySet(policySet, { mode: 'multi-tenant' });
```

## API Overview

- Compile: `compilePolicySet(policy, options)`
- Diagnostics: conflict/unreachable/multi-tenant scoping/field selector checks
- Conditions: `evaluateCondition` + safe `resolveRef`
- Hashing: `stableStringify`, `sha256`, `hashObject`

## Compatibility

- Node `>=18`
- No dynamic code execution

## Verify

```bash
pnpm --filter @hexmon_tech/compiler typecheck
pnpm --filter @hexmon_tech/compiler test
pnpm --filter @hexmon_tech/compiler build
```
npm package: @hexmon_tech/core
Description: acx core package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/core

Core public contracts for authorization inputs/decisions, engine interfaces, stable error codes, and helper utilities.

## Install

```bash
pnpm add @hexmon_tech/core
```

## Minimal Usage

```ts
import { createTraceId, normalizeFields, assertTenant } from '@hexmon_tech/core';

const traceId = createTraceId();
const fields = normalizeFields(['title', 'title', 'meta']);
const tenantId = assertTenant({ principal: { tenantId: 'tenant-a' } }, 'required');
```

## API Overview

- Types: `AuthorizationInput`, `Decision`, `AuthorizationEngine`, `Context`, `Reason`, `Obligation`
- Errors: `AcxError`, `MissingTenantError`, `InvalidPolicyError`, `EngineError`
- Capabilities: `Capability`, `CapabilitySet`, `assertCapability`
- Helpers: `createTraceId`, `normalizeFields`, `assertTenant`

## Compatibility

- Node `>=18`
- ESM + CJS + `.d.ts`

## Verify

```bash
pnpm --filter @hexmon_tech/core typecheck
pnpm --filter @hexmon_tech/core test
pnpm --filter @hexmon_tech/core build
```
npm package: @hexmon_tech/engine-embedded
Description: acx engine-embedded package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/engine-embedded

In-process authorization engine for compiled policies with deny-by-default, deny-overrides-allow, tracing, and TTL cache.

## Install

```bash
pnpm add @hexmon_tech/engine-embedded
```

## Minimal Usage

```ts
import { compilePolicySet } from '@hexmon_tech/compiler';
import { EmbeddedEngine } from '@hexmon_tech/engine-embedded';

const { ir } = compilePolicySet(policySet);
const engine = new EmbeddedEngine({ mode: 'multi-tenant' });
engine.setPolicy(ir);

const decision = await engine.authorize(input);
```

## API Overview

- Class: `EmbeddedEngine`
- Methods: `setPolicy`, `authorize`, `batchAuthorize`, `explain`, `getMetrics`
- Options: `mode`, `fieldViolation`, cache config (`enabled`, `maxSize`, `ttlMs`)

## Compatibility

- Node `>=18`
- Deterministic candidate ordering and cache invalidation on `setPolicy`

## Verify

```bash
pnpm --filter @hexmon_tech/engine-embedded typecheck
pnpm --filter @hexmon_tech/engine-embedded test
pnpm --filter @hexmon_tech/engine-embedded build
node packages/engine-embedded/bench/run.mjs
```
npm package: @hexmon_tech/engine-hybrid
Description: acx hybrid engine package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/engine-hybrid

Hybrid engine that combines embedded decisions with ReBAC object checks.

## Install

```bash
pnpm add @hexmon_tech/engine-hybrid
```

## Minimal Usage

```ts
import { HybridEngine } from '@hexmon_tech/engine-hybrid';

const engine = new HybridEngine({
  embeddedEngine,
  rebacAdapter,
  config: {
    rebacEnabledActionsByResourceType: {
      post: ['post:*'],
      '*': ['file:read'],
    },
  },
});
```

## API Overview

- Class: `HybridEngine`
- Methods: `authorize`, `batchAuthorize`
- Match helpers: `matchesActionPattern`, `isRebacEnabledFor`

## Compatibility

- Node `>=18`
- Embedded engine remains authoritative for global constraints

## Verify

```bash
pnpm --filter @hexmon_tech/engine-hybrid typecheck
pnpm --filter @hexmon_tech/engine-hybrid test
pnpm --filter @hexmon_tech/engine-hybrid build
```
npm package: @hexmon_tech/engine-rebac
Description: acx ReBAC engine interfaces and adapters.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/engine-rebac

ReBAC adapter contract and in-memory adapter for direct tuple checks.

## Install

```bash
pnpm add @hexmon_tech/engine-rebac
```

## Minimal Usage

```ts
import { InMemoryRebacAdapter } from '@hexmon_tech/engine-rebac';

const adapter = new InMemoryRebacAdapter();
await adapter.writeTuples([
  {
    tenantId: 'tenant-a',
    object: { type: 'file', id: 'f1' },
    relation: 'viewer',
    subject: { type: 'user', id: 'u1' },
  },
]);

const result = await adapter.check({
  tenantId: 'tenant-a',
  object: { type: 'file', id: 'f1' },
  relation: 'viewer',
  subject: { type: 'user', id: 'u1' },
});
```

## API Overview

- Types: `RelationshipTuple`, `RebacCheckInput`, `RebacCheckResult`
- Interface: `RebacAdapter`
- Adapter: `InMemoryRebacAdapter`

## Compatibility

- Node `>=18`
- Direct tuple matching only (no graph traversal)

## Verify

```bash
pnpm --filter @hexmon_tech/engine-rebac typecheck
pnpm --filter @hexmon_tech/engine-rebac test
pnpm --filter @hexmon_tech/engine-rebac build
```
npm package: @hexmon_tech/integrations-express
Description: acx integrations-express package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/integrations-express

Express middleware and error handling helpers for authorization checks.

## Install

```bash
pnpm add @hexmon_tech/integrations-express
```

## Minimal Usage

```ts
import { requireAuthz, createAuthzErrorHandler } from '@hexmon_tech/integrations-express';

app.patch(
  '/posts/:id',
  requireAuthz({
    engine,
    action: 'post:update',
    principal: (req) => req.user,
    resource: (req) => ({ type: 'post', id: req.params.id }),
    context: (req) => ({ tenantId: req.headers['x-tenant-id'] as string }),
  }),
  handler,
);

app.use(createAuthzErrorHandler({ missingTenantStatus: 401 }));
```

## API Overview

- Middleware: `requireAuthz(config)`
- Error mapping: `createAuthzErrorHandler(options)`
- Request augmentation: `req.authzDecision?: Decision`

## Compatibility

- Node `>=18`
- Peer dependency: `express`

## Verify

```bash
pnpm --filter @hexmon_tech/integrations-express typecheck
pnpm --filter @hexmon_tech/integrations-express test
pnpm --filter @hexmon_tech/integrations-express build
```
npm package: @hexmon_tech/integrations-nest
Description: acx integrations-nest package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/integrations-nest

NestJS decorators, guard, and module wiring for authorization enforcement.

## Install

```bash
pnpm add @hexmon_tech/integrations-nest
```

## Minimal Usage

```ts
import { UseGuards } from '@nestjs/common';
import { AuthzAction, AuthzGuard, AuthzResource } from '@hexmon_tech/integrations-nest';

@UseGuards(AuthzGuard)
@AuthzAction('post:read')
@AuthzResource('post', (ctx) => ({ type: 'post', id: ctx.switchToHttp().getRequest().params.id }))
class PostController {}
```

## API Overview

- Decorators: `@AuthzAction`, `@AuthzResource`
- Guard: `AuthzGuard`
- Module: `AuthzModule.forRoot(...)`
- Tokens/interfaces: `AUTHZ_ENGINE`, `PrincipalResolver`, `AuthzConfig`

## Compatibility

- Node `>=18`
- Peer dependencies: NestJS core/common/platform-express + reflect-metadata

## Verify

```bash
pnpm --filter @hexmon_tech/integrations-nest typecheck
pnpm --filter @hexmon_tech/integrations-nest test
pnpm --filter @hexmon_tech/integrations-nest build
```
npm package: @hexmon_tech/integrations-next-node
Description: acx integrations-next-node package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/integrations-next-node

Authorization wrappers for Next.js Node runtime route handlers and server actions.

## Install

```bash
pnpm add @hexmon_tech/integrations-next-node
```

## Minimal Usage

```ts
import { withAuthz } from '@hexmon_tech/integrations-next-node';

export const POST = withAuthz(async (req: Request) => new Response(null, { status: 204 }), {
  engine,
  action: 'post:update',
  getPrincipal: async (req) => principalFromRequest(req),
  getResource: async () => ({ type: 'post', id: 'p1' }),
  getContext: async (req) => ({ tenantId: req.headers.get('x-tenant-id') ?? undefined }),
});
```

## API Overview

- Wrapper: `withAuthz(handler, config)`
- Errors: `AuthzDeniedError`, `NotImplementedError`
- Helper placeholder: `getPrincipalFromRequest`

## Compatibility

- Node `>=18`
- Next.js Node runtime only (not Edge runtime)

## Verify

```bash
pnpm --filter @hexmon_tech/integrations-next-node typecheck
pnpm --filter @hexmon_tech/integrations-next-node test
pnpm --filter @hexmon_tech/integrations-next-node build
```
npm package: @hexmon_tech/policy-dsl
Description: acx policy-dsl package.
Author: Hexmon Technology
Latest version: 0.1.0

# @hexmon_tech/policy-dsl

Policy DSL package for JSON schema validation and builder APIs.

## Install

```bash
pnpm add @hexmon_tech/policy-dsl
```

## Minimal Usage

```ts
import { policySet, validatePolicySet } from '@hexmon_tech/policy-dsl';

const policy = policySet('1.0.0')
  .rule({ id: 'allow-read', effect: 'allow', actions: ['post:read'], resourceTypes: ['post'] })
  .build();

const result = validatePolicySet(policy);
```

## API Overview

- Types: `PolicySet`, `PolicyRule`, `Condition`, `RoleDefinition`, `PolicyConstraints`
- Validation: `validatePolicySet(policy)`
- Builder: `policySet(version).rule(...).role(...).constraints(...).build()`
- Schema: `policySetSchema`

## Compatibility

- Node `>=18`
- Pure JSON AST condition language (no JS eval)

## Verify

```bash
pnpm --filter @hexmon_tech/policy-dsl typecheck
pnpm --filter @hexmon_tech/policy-dsl test
pnpm --filter @hexmon_tech/policy-dsl build
```
npm package: @hexonet/ispapi-apiconnector
Description: Node.js SDK for the insanely fast HEXONET API
Author: Kai Schwarz
Latest version: 9.0.8

# node-sdk

[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](code_of_conduct.md)
[![npm version](https://img.shields.io/npm/v/@hexonet/ispapi-apiconnector.svg?style=flat)](https://www.npmjs.com/package/@hexonet/ispapi-apiconnector)
[![node](https://img.shields.io/node/v/@hexonet/ispapi-apiconnector.svg)](https://www.npmjs.com/package/@hexonet/ispapi-apiconnector)
[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
[![Build Status](https://github.com/centralnicgroup-opensource/rtldev-middleware-node-sdk/workflows/Release/badge.svg?branch=master)](https://github.com/centralnicgroup-opensource/rtldev-middleware-node-sdk/workflows/Release/badge.svg?branch=master)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
[![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/centralnicgroup-opensource/rtldev-middleware-node-sdk/blob/master/CONTRIBUTING.md)

This module is a connector library for the insanely fast HEXONET Backend API. For further informations visit our [homepage](https://www.hexonet.net) and do not hesitate to [contact us](https://www.hexonet.net/contact).

## Resources

- [Documentation](https://www.hexonet.support/hc/en-gb/articles/13652150237981-Self-Development-Kit-for-NodeJS)
- [Release Notes](https://github.com/centralnicgroup-opensource/rtldev-middleware-node-sdk/releases)

## Authors

- **Kai Schwarz** - [KaiSchwarz-cnic](https://github.com/kaischwarz-cnic)
- **Asif Nawaz** - [AsifNawaz-cnic](https://github.com/asifnawaz-cnic)

## FAQ / Notes

ESM/CJS Support: We followed the [ESM-NODE Guide](https://www.typescriptlang.org/docs/handbook/esm-node.html) of TypeScript.

## License

MIT
npm package: @hexonet/semantic-release-github-whmcs-config
Description: semantic-release shareable configuration for GitHub + WHMCS Marketplace
Author: Kai Schwarz
Latest version: 3.0.2
Deprecated: This shared configuration is no longer actively maintained.

# @hexonet/semantic-release-github-whmcs-config

[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
[![Build Status](https://github.com/hexonet/semantic-release-github-whmcs-config/workflows/Release/badge.svg?branch=master)](https://github.com/hexonet/semantic-release-github-whmcs-config/workflows/Release/badge.svg?branch=master)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
[![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/hexonet/semantic-release-github-whmcs-config/blob/master/CONTRIBUTING.md)
[![npm version](https://img.shields.io/npm/v/@hexonet/semantic-release-github-whmcs-config/latest.svg?style=popout-square&logo=npm)](https://www.npmjs.com/package/@hexonet/semantic-release-github-whmcs-config)

[**semantic-release**](https://github.com/semantic-release/semantic-release) shareable config to publish WHMCS Marketplace Products with [GitHub](https://github.com).

## Plugins

This [shareable configuration](https://github.com/hexonet/semantic-release-github-whmcs-config/blob/master/.sharedreleaserc.js) interhits from a basic [shareable configuration](https://github.com/hexonet/semantic-release-github-whmcsbase-config/blob/master/.sharedreleaserc.json) and uses the following plugins:

- [`@hexonet/semantic-release-whmcs`](https://github.com/hexonet/semantic-release-whmcs)

## Summary

On top of the summary of [@hexonet/semantic-release-github-whmcsbase-config](https://github.com/hexonet/semantic-release-github-whmcsbase-config#summary), this module also

- Publishs a new product/module version to the [WHMCS Marketplace](https://marketplace.whmcs.com) including notes.

## Install

```bash
$ npm i -D semantic-release @hexonet/semantic-release-github-whmcs-config
```

## Usage

The shareable config can be configured in the [**semantic-release** configuration file](https://github.com/semantic-release/semantic-release/blob/master/docs/usage/configuration.md#configuration):

```json
{
  "extends": "@hexonet/semantic-release-github-whmcs-config",
  "branch": "master"
}
```

## Configuration

Ensure that your CI configuration has the following **_secret_** environment variables set:

- [`GH_TOKEN`](https://github.com/settings/tokens) with [`public_repo`](https://developer.github.com/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/#available-scopes) access.
- [`WHMCSMP_LOGIN, WHMCSMP_PASSWORD, WHMCSMP_PRODUCTID`](https://github.com/hexonet/semantic-release-whmcs#readme)

See each [plugin](#plugins) documentation for required installation and configuration steps.
npm package: @hexorialstudio/color-blinder
Description: Color Blinder Simulate color blindness of the given valid color hex code
Author: Manthankumar Satani
Latest version: 1.0.3

# Color Blinder

Color Blinder is the Color Blinder Functions to convert the any valid color hex to a color blindness hex color.

## Getting Started

Install the module with: `npm install @hexorialstudio/color-blinder`

## Documentation

```javascript
const blinder = require('@hexorialstudio/color-blinder');

```

All the blinder functions accept 1 parameter:

- **ColorHexString** - any valid color hex string

### blinder.protanomaly(hexCode)

Part of the "Anomalous Trichromat" family of color blindness. The viewer sees low amounts of red.

```javascript
blinder.protanomaly("#ff00f7");
// result: "#9058fc"
```

#### blinder.protanopia(hexCode)

Part of the "Dichromat" family of color blindness. The viewer sees no red.

```javascript
blinder.protanopia("#ff00f7");
// result: "#518bff"
```

#### blinder.deuteranomaly(hexCode)

Part of the "Anomalous Trichromat" family of color blindness. The viewer sees low amounts of green.

```javascript
blinder.deuteranomaly("#ff00f7");
// result: "#9c5ae6"
```

#### blinder.deuteranopia(hexCode)

Part of the "Dichromat" family of color blindness. The viewer sees no green.

```javascript
blinder.deuteranopia("#ff00f7");
// result: "#638edd"
```

#### blinder.tritanomaly(hexCode)

Part of the "Anomalous Trichromat" family of color blindness. The viewer sees low amounts of blue.

```javascript
blinder.tritanomaly("#ff00f7");
// result: "#f43e9c"
```

#### blinder.tritanopia(hexCode)

Part of the "Dichromat" family of color blindness. The viewer sees no blue.

```javascript
blinder.tritanopia("#ff00f7");
// result: "#ee6168"
```

#### blinder.achromatomaly(hexCode)

Part of the "Monochromat" family of color blindness. The viewer sees the absence of most color.

```javascript
blinder.achromatomaly("#ff00f7");
// result: "#8a2d87"
```

#### blinder.achromatopsia(hexCode)

Part of the "Monochromat" family of color blindness. The viewer sees no color at all.

```javascript
blinder.achromatopsia("#ff00f7");
// result: "#484848"
```
npm package: @hexpayday/gigacommunis
Description: This project demonstrates a basic Hardhat use case. It comes with a sample contract, a test for that contract, and a script that deploys that contract.
Latest version: 0.0.2

# Sample Hardhat Project

This project demonstrates a basic Hardhat use case. It comes with a sample contract, a test for that contract, and a script that deploys that contract.

Try running some of the following tasks:

```shell
npx hardhat help
npx hardhat test
REPORT_GAS=true npx hardhat test
npx hardhat node
npx hardhat run scripts/deploy.ts
```

install deps
```bash
yarn
```

compile
```bash
yarn run compile
```

deploy contract
```bash
npx hardhat --network hardhat deploy
```