@nanalogue/node 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sathish Thiyagarajan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,224 @@
+# `nanalogue-node`
+
+Node.js bindings for Nanalogue: single-molecule BAM/Mod-BAM analysis.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Nanalogue is a tool to parse and analyse BAM/Mod-BAM files with a single-molecule focus.
+This package exposes Nanalogue's functions through a Node.js/TypeScript interface using [NAPI-RS](https://napi.rs/).
+
+A common pain point in genomics analyses is that BAM files are information-dense,
+making it difficult to gain insight from them. Nanalogue-node helps extract and process
+this information, with a particular focus on single-molecule aspects and DNA/RNA modifications.
+
+We support any type of DNA/RNA modifications in any pattern (single/multiple mods,
+spatially-isolated/non-isolated, etc.). All we require is that the data is stored
+in a BAM file in the mod BAM format (using MM/ML tags as specified in the
+[SAM tags specification](https://samtools.github.io/hts-specs/SAMtags.pdf)).
+
+## Table of Contents
+
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Functions](#functions)
+  - [peek](#peek)
+  - [readInfo](#readinfo)
+  - [bamMods](#bammods)
+  - [windowReads](#windowreads)
+  - [seqTable](#seqtable)
+  - [simulateModBam](#simulatemodbam)
+- [TypeScript Support](#typescript-support)
+- [Filtering Options](#filtering-options)
+- [Further Documentation](#further-documentation)
+- [Versioning](#versioning)
+- [Acknowledgments](#acknowledgments)
+
+## Requirements
+
+- Node.js 22 or higher
+- For building from source: Rust toolchain
+
+## Installation
+
+```bash
+npm install @nanalogue/node
+```
+
+## Functions
+
+All functions return Promises and support extensive filtering options.
+
+### peek
+
+Quickly extract BAM file metadata without processing all records.
+
+```typescript
+import { peek } from '@nanalogue/node';
+
+const metadata = await peek({ bamPath: 'example.bam' });
+console.log(metadata);
+// {
+//   contigs: { chr1: 248956422, chr2: 242193529, ... },
+//   modifications: [['T', '+', 'T'], ['C', '+', 'm']]
+// }
+```
+
+### readInfo
+
+Get information about reads in the BAM file.
+
+```typescript
+import { readInfo } from '@nanalogue/node';
+
+const reads = await readInfo({ bamPath: 'example.bam' });
+// Returns array of read records with alignment info and modification counts
+```
+
+### bamMods
+
+Extract detailed modification data for each read.
+
+```typescript
+import { bamMods } from '@nanalogue/node';
+
+const mods = await bamMods({ bamPath: 'example.bam' });
+// Returns array of records with modification tables containing
+// position, reference position, and probability for each modification
+```
+
+### windowReads
+
+Compute windowed modification densities across reads.
+
+```typescript
+import { windowReads } from '@nanalogue/node';
+
+const tsv = await windowReads({
+  bamPath: 'example.bam',
+  win: 100,  // window size in bases
+  step: 50   // step size
+});
+// Returns TSV string with windowed modification densities
+```
+
+Supports `winOp: 'grad_density'` for gradient mode.
+
+### seqTable
+
+Extract sequences and qualities for a genomic region.
+
+```typescript
+import { seqTable } from '@nanalogue/node';
+
+const tsv = await seqTable({
+  bamPath: 'example.bam',
+  region: 'chr1:1000-2000'  // region is required
+});
+// Returns TSV with read_id, sequence, qualities columns
+// Sequence uses: . for deletion, lowercase for insertion, Z for modification
+```
+
+### simulateModBam
+
+Generate synthetic BAM files with defined modification patterns (useful for testing).
+
+```typescript
+import { simulateModBam } from '@nanalogue/node';
+
+const config = JSON.stringify({
+  contigs: { number: 2, len_range: [1000, 2000] },
+  reads: [{
+    number: 100,
+    len_range: [0.5, 0.9],
+    mods: [{
+      base: 'C',
+      is_strand_plus: true,
+      mod_code: 'm',
+      win: [5, 3],
+      mod_range: [[0.3, 0.7], [0.1, 0.5]]
+    }]
+  }]
+});
+
+await simulateModBam({
+  jsonConfig: config,
+  bamPath: 'output.bam',
+  fastaPath: 'output.fasta'
+});
+```
+
+## TypeScript Support
+
+Full TypeScript definitions are included. The package uses discriminated unions
+to enforce constraints at compile time (e.g., `fullRegion` can only be set when
+`region` is specified).
+
+```typescript
+import type { ReadOptions, BamModRecord, ReadInfoRecord } from '@nanalogue/node';
+```
+
+## Filtering Options
+
+All read functions support extensive filtering:
+
+| Option | Description |
+|--------|-------------|
+| `treatAsUrl` | Treat bamPath as URL instead of file path |
+| `region` | Genomic region filter (e.g., "chr1:1000-2000") |
+| `fullRegion` | Only include reads fully spanning the region |
+| `readFilter` | Filter by alignment type (e.g., "primary_forward,primary_reverse") |
+| `readIdSet` | Filter to specific read IDs |
+| `minSeqLen` | Minimum sequence length |
+| `minAlignLen` | Minimum alignment length |
+| `mapqFilter` | Minimum mapping quality |
+| `excludeMapqUnavail` | Exclude reads without mapping quality |
+| `sampleFraction` | Subsample reads (0.0 to 1.0) |
+| `threads` | Number of threads for BAM reading |
+| `tag` | Filter by modification type |
+| `modStrand` | Filter by modification strand ("bc" or "bc_comp") |
+| `minModQual` | Minimum modification quality threshold |
+| `rejectModQualNonInclusive` | Reject mods where low < prob < high |
+| `trimReadEndsMod` | Trim modification info from read ends |
+| `baseQualFilterMod` | Base quality filter for modifications |
+| `modRegion` | Genomic region for modification filtering |
+
+## Further Documentation
+
+- [Nanalogue Core Documentation](https://docs.rs/nanalogue)
+- [Nanalogue Cookbook](https://www.nanalogue.com)
+- [pynanalogue](https://github.com/DNAReplicationLab/pynanalogue) - Python bindings
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for version history.
+
+## Versioning
+
+We use [Semantic Versioning](https://semver.org/).
+
+**Current Status: Pre-1.0 (0.x.y)**
+
+While in 0.x.y versions:
+- The API may change without notice
+- Breaking changes can occur in minor version updates
+
+After 1.0.0, we will guarantee backwards compatibility in minor/patch releases.
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Acknowledgments
+
+This software was developed at the Earlham Institute in the UK.
+This work was supported by the Biotechnology and Biological Sciences
+Research Council (BBSRC), part of UK Research and Innovation,
+through the Core Capability Grant BB/CCG2220/1 at the Earlham Institute
+and the Earlham Institute Strategic Programme Grant Cellular Genomics
+BBX011070/1 and its constituent work packages BBS/E/ER/230001B
+(CellGen WP2 Consequences of somatic genome variation on traits).
+The work was also supported by the following response-mode project grants:
+BB/W006014/1 (Single molecule detection of DNA replication errors) and
+BB/Y00549X/1 (Single molecule analysis of Human DNA replication).
+This research was supported in part by NBI Research Computing
+through use of the High-Performance Computing system and Isilon storage.

package/index.d.ts

@@ -0,0 +1,239 @@
+// Node.js bindings for Nanalogue: single-molecule BAM/Mod-BAM analysis
+// This file provides TypeScript type definitions for the native module.
+
+export interface PeekResult {
+  contigs: Record<string, number>;
+  modifications: [string, string, string][];
+}
+
+export interface PeekOptions {
+  bamPath: string;
+  /** If true, treat bamPath as a URL. Otherwise treat as file path. */
+  treatAsUrl?: boolean;
+}
+
+export declare function peek(options: PeekOptions): Promise<PeekResult>;
+
+// Read info types
+export interface MappedReadInfo {
+  read_id: string;
+  sequence_length: number;
+  contig: string;
+  reference_start: number;
+  reference_end: number;
+  alignment_length: number;
+  alignment_type: 'primary_forward' | 'primary_reverse' | 'secondary_forward' | 'secondary_reverse' | 'supplementary_forward' | 'supplementary_reverse';
+  mod_count: string;
+}
+
+export interface UnmappedReadInfo {
+  read_id: string;
+  sequence_length: number;
+  alignment_type: 'unmapped';
+  mod_count: string;
+}
+
+export type ReadInfoRecord = MappedReadInfo | UnmappedReadInfo;
+
+// Base options shared by ReadOptions (excluding region/fullRegion)
+interface BaseReadOptionsCore {
+  /** Path to the BAM file (local path or URL). */
+  bamPath: string;
+  /** If true, treat bamPath as a URL. Otherwise treat as file path. */
+  treatAsUrl?: boolean;
+  /** Minimum sequence length filter. */
+  minSeqLen?: number;
+  /** Minimum alignment length filter. */
+  minAlignLen?: number;
+  /** Filter to a set of read IDs. */
+  readIdSet?: string[];
+  /** Number of threads for BAM reading. */
+  threads?: number;
+  /** Include zero-length sequences (may cause crashes). */
+  includeZeroLen?: boolean;
+  /** Comma-separated read filter (e.g., "primary_forward,primary_reverse"). */
+  readFilter?: string;
+  /** Subsample fraction (0.0 to 1.0). */
+  sampleFraction?: number;
+  /** Minimum mapping quality filter. */
+  mapqFilter?: number;
+  /** Exclude reads with unavailable mapping quality. */
+  excludeMapqUnavail?: boolean;
+  /** Filter to specific modification tag. */
+  tag?: string;
+  /** Filter by modification strand ("bc" or "bc_comp"). */
+  modStrand?: string;
+  /** Minimum modification quality threshold. */
+  minModQual?: number;
+  /**
+   * Reject modification calls where low < probability < high.
+   * Tuple of [low, high] where both are 0-255.
+   * If low > high, throws an error. If high - low <= 1, no rejection range is applied.
+   */
+  rejectModQualNonInclusive?: [number, number];
+  /** Trim modification info from read ends (bp). */
+  trimReadEndsMod?: number;
+  /** Base quality filter for modifications. */
+  baseQualFilterMod?: number;
+  /** Genomic region for modification filtering. */
+  modRegion?: string;
+}
+
+/**
+ * ReadOptions with a region filter specified.
+ * When `region` is set, `fullRegion` can optionally be used to require reads
+ * to fully span the region.
+ */
+interface ReadOptionsWithRegion extends BaseReadOptionsCore {
+  /** Genomic region filter (e.g., "chr1:1000-2000"). */
+  region: string;
+  /**
+   * Only include reads fully spanning the region.
+   * Can only be set when `region` is specified.
+   */
+  fullRegion?: boolean;
+}
+
+/**
+ * ReadOptions without a region filter.
+ * When `region` is not set, `fullRegion` cannot be used.
+ */
+interface ReadOptionsWithoutRegion extends BaseReadOptionsCore {
+  region?: undefined;
+  fullRegion?: undefined;
+}
+
+/**
+ * Options for read operations including BAM filtering and modification parameters.
+ *
+ * Note: `fullRegion` can only be set when `region` is specified.
+ */
+export type ReadOptions = ReadOptionsWithRegion | ReadOptionsWithoutRegion;
+
+export declare function readInfo(options: ReadOptions): Promise<ReadInfoRecord[]>;
+
+// Simulation types
+export interface SimulateOptions {
+  jsonConfig: string;
+  bamPath: string;
+  fastaPath: string;
+}
+
+export declare function simulateModBam(options: SimulateOptions): Promise<void>;
+
+// Detailed modification data types (bamMods)
+export interface ModTableEntry {
+  base: string;
+  is_strand_plus: boolean;
+  mod_code: string;
+  data: [number, number, number][]; // [read_pos, ref_pos, probability]
+}
+
+export interface MappedBamModRecord {
+  alignment_type: 'primary_forward' | 'primary_reverse' | 'secondary_forward' | 'secondary_reverse' | 'supplementary_forward' | 'supplementary_reverse';
+  alignment: {
+    start: number;
+    end: number;
+    contig: string;
+    contig_id: number;
+  };
+  mod_table: ModTableEntry[];
+  read_id: string;
+  seq_len: number;
+}
+
+export interface UnmappedBamModRecord {
+  alignment_type: 'unmapped';
+  mod_table: ModTableEntry[];
+  read_id: string;
+  seq_len: number;
+}
+
+export type BamModRecord = MappedBamModRecord | UnmappedBamModRecord;
+
+export declare function bamMods(options: ReadOptions): Promise<BamModRecord[]>;
+
+// Base options shared by WindowOptions (excluding region/fullRegion)
+interface BaseWindowOptionsCore {
+  /** Path to the BAM file (local path or URL). */
+  bamPath: string;
+  /** If true, treat bamPath as a URL. Otherwise treat as file path. */
+  treatAsUrl?: boolean;
+  /** Window size in number of bases. */
+  win: number;
+  /** Step size for sliding the window. */
+  step: number;
+  /** Type of windowing operation: "density" or "grad_density". */
+  winOp?: 'density' | 'grad_density';
+  /** Minimum sequence length filter. */
+  minSeqLen?: number;
+  /** Minimum alignment length filter. */
+  minAlignLen?: number;
+  /** Filter to a set of read IDs. */
+  readIdSet?: string[];
+  /** Number of threads for BAM reading. */
+  threads?: number;
+  /** Include zero-length sequences (may cause crashes). */
+  includeZeroLen?: boolean;
+  /** Comma-separated read filter. */
+  readFilter?: string;
+  /** Subsample fraction (0.0 to 1.0). */
+  sampleFraction?: number;
+  /** Minimum mapping quality filter. */
+  mapqFilter?: number;
+  /** Exclude reads with unavailable mapping quality. */
+  excludeMapqUnavail?: boolean;
+  /** Filter to specific modification tag. */
+  tag?: string;
+  /** Filter by modification strand. */
+  modStrand?: string;
+  /** Minimum modification quality threshold. */
+  minModQual?: number;
+  /**
+   * Reject modification calls where low < probability < high.
+   * Tuple of [low, high] where both are 0-255.
+   * If low > high, throws an error. If high - low <= 1, no rejection range is applied.
+   */
+  rejectModQualNonInclusive?: [number, number];
+  /** Trim modification info from read ends (bp). */
+  trimReadEndsMod?: number;
+  /** Base quality filter for modifications. */
+  baseQualFilterMod?: number;
+  /** Genomic region for modification filtering. */
+  modRegion?: string;
+}
+
+/**
+ * WindowOptions with a region filter specified.
+ * When `region` is set, `fullRegion` can optionally be used to require reads
+ * to fully span the region.
+ */
+interface WindowOptionsWithRegion extends BaseWindowOptionsCore {
+  /** Genomic region filter (e.g., "chr1:1000-2000"). */
+  region: string;
+  /**
+   * Only include reads fully spanning the region.
+   * Can only be set when `region` is specified.
+   */
+  fullRegion?: boolean;
+}
+
+/**
+ * WindowOptions without a region filter.
+ * When `region` is not set, `fullRegion` cannot be used.
+ */
+interface WindowOptionsWithoutRegion extends BaseWindowOptionsCore {
+  region?: undefined;
+  fullRegion?: undefined;
+}
+
+/**
+ * Options for windowed modification analysis.
+ *
+ * Note: `fullRegion` can only be set when `region` is specified.
+ */
+export type WindowOptions = WindowOptionsWithRegion | WindowOptionsWithoutRegion;
+
+export declare function windowReads(options: WindowOptions): Promise<string>;
+
+export declare function seqTable(options: ReadOptions): Promise<string>;

package/index.js

@@ -0,0 +1,320 @@
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+
+/* auto-generated by NAPI-RS */
+
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim()
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'nanalogue.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nanalogue.android-arm64.node')
+          } else {
+            nativeBinding = require('@nanalogue/node-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'nanalogue.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nanalogue.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('@nanalogue/node-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'nanalogue.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nanalogue.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('@nanalogue/node-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'nanalogue.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nanalogue.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('@nanalogue/node-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'nanalogue.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nanalogue.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('@nanalogue/node-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'nanalogue.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./nanalogue.darwin-universal.node')
+      } else {
+        nativeBinding = require('@nanalogue/node-darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'nanalogue.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nanalogue.darwin-x64.node')
+          } else {
+            nativeBinding = require('@nanalogue/node-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'nanalogue.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nanalogue.darwin-arm64.node')
+          } else {
+            nativeBinding = require('@nanalogue/node-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'nanalogue.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./nanalogue.freebsd-x64.node')
+      } else {
+        nativeBinding = require('@nanalogue/node-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'nanalogue.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nanalogue.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('@nanalogue/node-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'nanalogue.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nanalogue.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('@nanalogue/node-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'nanalogue.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nanalogue.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('@nanalogue/node-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'nanalogue.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nanalogue.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('@nanalogue/node-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'nanalogue.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nanalogue.linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('@nanalogue/node-linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'nanalogue.linux-arm-gnueabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nanalogue.linux-arm-gnueabihf.node')
+            } else {
+              nativeBinding = require('@nanalogue/node-linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'nanalogue.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nanalogue.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('@nanalogue/node-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'nanalogue.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nanalogue.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('@nanalogue/node-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
+        localFileExisted = existsSync(
+          join(__dirname, 'nanalogue.linux-s390x-gnu.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nanalogue.linux-s390x-gnu.node')
+          } else {
+            nativeBinding = require('@nanalogue/node-linux-s390x-gnu')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { peek, readInfo, simulateModBam, bamMods, windowReads, seqTable } = nativeBinding
+
+module.exports.peek = peek
+module.exports.readInfo = readInfo
+module.exports.simulateModBam = simulateModBam
+module.exports.bamMods = bamMods
+module.exports.windowReads = windowReads
+module.exports.seqTable = seqTable

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@nanalogue/node",
+  "version": "0.1.1",
+  "description": "Node.js bindings for Nanalogue: single-molecule BAM/Mod-BAM analysis",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "*.node"
+  ],
+  "napi": {
+    "name": "nanalogue",
+    "triples": {
+      "defaults": false,
+      "additional": [
+        "x86_64-apple-darwin",
+        "aarch64-apple-darwin",
+        "x86_64-unknown-linux-gnu",
+        "x86_64-unknown-linux-musl",
+        "aarch64-unknown-linux-gnu",
+        "aarch64-unknown-linux-musl"
+      ]
+    }
+  },
+  "engines": {
+    "node": ">= 22"
+  },
+  "scripts": {
+    "build": "napi build --platform --release --dts native.d.ts",
+    "build:debug": "napi build --platform",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "prepublishOnly": "napi pre-publish --npm-dir npm --no-gh-release"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.14",
+    "@napi-rs/cli": "^3.5.1",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^4.0.18"
+  },
+  "keywords": [
+    "bioinformatics",
+    "genomics",
+    "bam",
+    "modifications",
+    "nanopore",
+    "pacbio",
+    "illumina",
+    "napi-rs",
+    "rust"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sathish-t/nanalogue-node.git"
+  },
+  "author": "Sathish Thiyagarajan <mail@unintegrable.com>",
+  "optionalDependencies": {
+    "@nanalogue/node-darwin-x64": "0.1.1",
+    "@nanalogue/node-darwin-arm64": "0.1.1",
+    "@nanalogue/node-linux-x64-gnu": "0.1.1",
+    "@nanalogue/node-linux-x64-musl": "0.1.1",
+    "@nanalogue/node-linux-arm64-gnu": "0.1.1",
+    "@nanalogue/node-linux-arm64-musl": "0.1.1"
+  }
+}