Here is my solution to part one:

#!/usr/bin/env node

var fs = require('fs');

module.exports.lineToInt=lineToInt;
function lineToInt(line) {
 var prefix = line.slice(0,1);
 var magnitude = parseInt(line.slice(1));
 if(prefix==='R') return magnitude; 
 if(prefix==='L') return -magnitude;
 throw new Error('Improper prefix');
}

module.exports.readlinesSync=readlinesSync;
function readlinesSync(path) {
 return fs.readFileSync(path,'utf8').split('\n').filter(i=>i);
}

module.exports.circleMod=circleMod;
function circleMod(a,base=100) {
 if(a<0) return base-circleMod(-a,base);
 return a%base;
}


function main() {
 var path = process.argv[2]||'input.txt';
 var inputs = readlinesSync(path);
     //inputs = inputs.map(lineToInt);
 var start = 50;
 var pointer = start;
 var zerocount = 0;
 for(var input of inputs) {
  var numInput = circleMod(lineToInt(input));
  pointer=circleMod(pointer+numInput);
  console.log({input,numInput,pointer});
  if(pointer===0) ++zerocount;
 }
 console.log('Password:',zerocount);
}

if(!module.parent) main();

I've yet to figure it out but for some reason applying circleMod to the input in addition to pointer changed the output. In theory if the circleMod is working correctly it shouldn't make a difference. But this is the nature of advent of code. Get the solution and move on. I'm working on part 2 now.

Here is my code for part two. The big change was counting every time the dial crosses zero. I like doing things in functional ways even if I'm in a procedural language. This is why I did an extra step of input reduction at the start. Progressive mapping to equivalent more simple states is the heart of how to solve things with functional esoterics. I did fail at my first attempt at part two. The key thing was making a move function that allows isolating code that needs to consider edge cases away from a for loop. Loops should be tight with minimal logic in them. This function also manages a state update to the pointer. It has a dial position as an argument and also treats it as part of a multi-part return value. This is also a classically functional way to do things. It's also close to how it would be done in Elixir in case I feel like translating it.

#!/usr/bin/env node

var fs = require('fs');

module.exports.lineToInt = lineToInt;
function lineToInt(line) {
 var prefix = line.slice(0, 1);
 var magnitude = parseInt(line.slice(1));
 if(prefix === 'R') return magnitude;
 if(prefix === 'L') return -magnitude;
 throw new Error('Improper prefix');
}

module.exports.readlinesSync = readlinesSync;
function readlinesSync(path) {
 return fs.readFileSync(path, 'utf8').split('\n').filter(i => i);
}

module.exports.move = move;
function move(pointer, movement) {
 var base = 100;
 var newPointer = (pointer + movement) % base;
 if(newPointer < 0) newPointer += base;
 var crossCount = 0;
 if(movement > 0) {
  crossCount = Math.floor((pointer + movement) / base) - Math.floor(pointer / base);
 } else if(movement < 0) {
  crossCount = Math.floor((pointer - 1) / base) - Math.floor((pointer + movement - 1) / base);
 }
 return [newPointer, crossCount];
}

function sameSign(a, b) {
 return (a > 0 && b > 0) || (a < 0 && b < 0);
}

module.exports.combineMoves = combineMoves;
function combineMoves(moves) {
 if(moves.length === 0) return [];
 var out = [];
 var prev = moves[0];
 for(var i = 1; i < moves.length; ++i) {
  if(sameSign(prev, moves[i])) prev += moves[i];
  else {
   out.push(prev);
   prev = moves[i];
  }
 }
 out.push(prev);
 return out;
}

function main() {
 var path = process.argv[2] || 'input.txt';
 var inputs = readlinesSync(path);
 var movements = inputs.map(lineToInt);
 var reducedMovements = combineMoves(movements);

 var start = 50;
 var pointer = start;
 var zerocount = 0;

 for(var movement of reducedMovements) {
  var [newPointer, crosses] = move(pointer, movement);
  console.log({ movement, pointer, newPointer, crosses });
  pointer = newPointer;
  zerocount += crosses;
 }
 console.log('Password:', zerocount);
}

if(!module.parent) main();  

Bash version for part one:

#!/usr/bin/env bash
# Advent of Code 2025 Day 1 - Secret Entrance (Method 0x434C49434B)
# Counts how many clicks (including intermediate ones) land on 0.

MODULO=100        # numbers 0..99
start_pos=50      # initial dial position

pos=$start_pos
count_zero=0

# Count starting position if it is 0 (it is 50 here, but kept for generality)
if [ "$pos" -eq 0 ]; then
  count_zero=$((count_zero + 1))
fi

while IFS= read -r line; do
  [ -z "$line" ] && continue

  dir=${line:0:1}
  dist=${line:1}

  if ! [[ "$dist" =~ ^[0-9]+$ ]]; then
    echo "Invalid distance in line: $line" >&2
    exit 1
  fi

  # Normalize distance (doesn't change count, but keeps numbers small)
  dist=$(( dist % MODULO ))

  case "$dir" in
    L)
      # Move left one click at a time
      for ((i = 0; i < dist; i++)); do
        pos=$(( pos - 1 ))
        if [ $pos -lt 0 ]; then
          pos=$(( pos + MODULO ))
        fi
        if [ "$pos" -eq 0 ]; then
          count_zero=$((count_zero + 1))
        fi
      done
      ;;
    R)
      # Move right one click at a time
      for ((i = 0; i < dist; i++)); do
        pos=$(( pos + 1 ))
        pos=$(( pos % MODULO ))
        if [ "$pos" -eq 0 ]; then
          count_zero=$((count_zero + 1))
        fi
      done
      ;;
    *)
      echo "Invalid direction in line: $line" >&2
      exit 1
      ;;
  esac
done

echo "$count_zero"

I'm working on part 2. It keeps saying my solution is too low so figuring that out rn, could use some help.